/*

 * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.

 *             2005 Lars Knoll & Zack Rusin, Trolltech

 *             2008 Aaron Plattner, NVIDIA Corporation

 * Copyright © 2000 SuSE, Inc.

 * Copyright © 2007, 2009 Red Hat, Inc.

 * Copyright © 2008 André Tupinambá <andrelrt@gmail.com>

 *

 * Permission to use, copy, modify, distribute, and sell this software and its

 * documentation for any purpose is hereby granted without fee, provided that

 * the above copyright notice appear in all copies and that both that

 * copyright notice and this permission notice appear in supporting

 * documentation, and that the name of Keith Packard not be used in

 * advertising or publicity pertaining to distribution of the software without

 * specific, written prior permission.  Keith Packard makes no

 * representations about the suitability of this software for any purpose.  It

 * is provided "as is" without express or implied warranty.

 *

 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS

 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY

 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN

 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING

 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

 * SOFTWARE.

 */

#ifdef HAVE_CONFIG_H

#include <pixman-config.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "pixman-private.h"

#include "pixman-combine32.h"

#include "pixman-inlines.h"

#include "dither/blue-noise-64x64.h"

/* Fetch functions */

static force_inline void

fetch_pixel_no_alpha_32 (bits_image_t *image,

       int x, int y, pixman_bool_t check_bounds,

       void *out)

{

    uint32_t *ret = out;

    if (check_bounds &&

  (x < 0 || x >= image->width || y < 0 || y >= image->height))

  *ret = 0;

    else

  *ret = image->fetch_pixel_32 (image, x, y);

}

static force_inline void

fetch_pixel_no_alpha_float (bits_image_t *image,

          int x, int y, pixman_bool_t check_bounds,

          void *out)

{

    argb_t *ret = out;

    if (check_bounds &&

  (x < 0 || x >= image->width || y < 0 || y >= image->height))

  ret->a = ret->r = ret->g = ret->b = 0.f;

    else

  *ret = image->fetch_pixel_float (image, x, y);

}

typedef void (* get_pixel_t) (bits_image_t *image,

            int x, int y, pixman_bool_t check_bounds, void *out);

static force_inline void

bits_image_fetch_pixel_nearest (bits_image_t   *image,

        pixman_fixed_t  x,

        pixman_fixed_t  y,

        get_pixel_t get_pixel,

        void         *out)

{

    int x0 = pixman_fixed_to_int (x - pixman_fixed_e);

    int y0 = pixman_fixed_to_int (y - pixman_fixed_e);

    if (image->common.repeat != PIXMAN_REPEAT_NONE)

    {

  repeat (image->common.repeat, &x0, image->width);

  repeat (image->common.repeat, &y0, image->height);

  get_pixel (image, x0, y0, FALSE, out);

    }

    else

    {

  get_pixel (image, x0, y0, TRUE, out);

    }

}

static force_inline void

bits_image_fetch_pixel_bilinear_32 (bits_image_t   *image,

            pixman_fixed_t  x,

            pixman_fixed_t  y,

            get_pixel_t     get_pixel,

            void     *out)

{

    pixman_repeat_t repeat_mode = image->common.repeat;

    int width = image->width;

    int height = image->height;

    int x1, y1, x2, y2;

    uint32_t tl, tr, bl, br;

    int32_t distx, disty;

    uint32_t *ret = out;

    x1 = x - pixman_fixed_1 / 2;

    y1 = y - pixman_fixed_1 / 2;

    distx = pixman_fixed_to_bilinear_weight (x1);

    disty = pixman_fixed_to_bilinear_weight (y1);

    x1 = pixman_fixed_to_int (x1);

    y1 = pixman_fixed_to_int (y1);

    x2 = x1 + 1;

    y2 = y1 + 1;

    if (repeat_mode != PIXMAN_REPEAT_NONE)

    {

  repeat (repeat_mode, &x1, width);

  repeat (repeat_mode, &y1, height);

  repeat (repeat_mode, &x2, width);

  repeat (repeat_mode, &y2, height);

  get_pixel (image, x1, y1, FALSE, &tl);

  get_pixel (image, x2, y1, FALSE, &tr);

  get_pixel (image, x1, y2, FALSE, &bl);

  get_pixel (image, x2, y2, FALSE, &br);

    }

    else

    {

  get_pixel (image, x1, y1, TRUE, &tl);

  get_pixel (image, x2, y1, TRUE, &tr);

  get_pixel (image, x1, y2, TRUE, &bl);

  get_pixel (image, x2, y2, TRUE, &br);

    }

    *ret = bilinear_interpolation (tl, tr, bl, br, distx, disty);

}

static force_inline void

bits_image_fetch_pixel_bilinear_float (bits_image_t   *image,

               pixman_fixed_t  x,

               pixman_fixed_t  y,

               get_pixel_t     get_pixel,

               void       *out)

{

    pixman_repeat_t repeat_mode = image->common.repeat;

    int width = image->width;

    int height = image->height;

    int x1, y1, x2, y2;

    argb_t tl, tr, bl, br;

    float distx, disty;

    argb_t *ret = out;

    x1 = x - pixman_fixed_1 / 2;

    y1 = y - pixman_fixed_1 / 2;

    distx = ((float)pixman_fixed_fraction(x1)) / 65536.f;

    disty = ((float)pixman_fixed_fraction(y1)) / 65536.f;

    x1 = pixman_fixed_to_int (x1);

    y1 = pixman_fixed_to_int (y1);

    x2 = x1 + 1;

    y2 = y1 + 1;

    if (repeat_mode != PIXMAN_REPEAT_NONE)

    {

  repeat (repeat_mode, &x1, width);

  repeat (repeat_mode, &y1, height);

  repeat (repeat_mode, &x2, width);

  repeat (repeat_mode, &y2, height);

  get_pixel (image, x1, y1, FALSE, &tl);

  get_pixel (image, x2, y1, FALSE, &tr);

  get_pixel (image, x1, y2, FALSE, &bl);

  get_pixel (image, x2, y2, FALSE, &br);

    }

    else

    {

  get_pixel (image, x1, y1, TRUE, &tl);

  get_pixel (image, x2, y1, TRUE, &tr);

  get_pixel (image, x1, y2, TRUE, &bl);

  get_pixel (image, x2, y2, TRUE, &br);

    }

    *ret = bilinear_interpolation_float (tl, tr, bl, br, distx, disty);

}

static force_inline void accum_32(unsigned int *satot, unsigned int *srtot,

          unsigned int *sgtot, unsigned int *sbtot,

          const void *p, pixman_fixed_t f)

{

    uint32_t pixel = *(uint32_t *)p;

    *srtot += (int)RED_8 (pixel) * f;

    *sgtot += (int)GREEN_8 (pixel) * f;

    *sbtot += (int)BLUE_8 (pixel) * f;

    *satot += (int)ALPHA_8 (pixel) * f;

}

static force_inline void reduce_32(unsigned int satot, unsigned int srtot,

           unsigned int sgtot, unsigned int sbtot,

                                   void *p)

{

    uint32_t *ret = p;

    satot = (int32_t)(satot + 0x8000) / 65536;

    srtot = (int32_t)(srtot + 0x8000) / 65536;

    sgtot = (int32_t)(sgtot + 0x8000) / 65536;

    sbtot = (int32_t)(sbtot + 0x8000) / 65536;

    satot = CLIP ((int32_t)satot, 0, 0xff);

    srtot = CLIP ((int32_t)srtot, 0, 0xff);

    sgtot = CLIP ((int32_t)sgtot, 0, 0xff);

    sbtot = CLIP ((int32_t)sbtot, 0, 0xff);

    *ret = ((satot << 24) | (srtot << 16) | (sgtot <<  8) | (sbtot));

}

static force_inline void accum_float(unsigned int *satot, unsigned int *srtot,

             unsigned int *sgtot, unsigned int *sbtot,

             const void *p, pixman_fixed_t f)

{

    const argb_t *pixel = p;

    *satot += pixel->a * f;

    *srtot += pixel->r * f;

    *sgtot += pixel->g * f;

    *sbtot += pixel->b * f;

}

static force_inline void reduce_float(unsigned int satot, unsigned int srtot,

              unsigned int sgtot, unsigned int sbtot,

              void *p)

{

    argb_t *ret = p;

    ret->a = CLIP ((int32_t)satot / 65536.f, 0.f, 1.f);

    ret->r = CLIP ((int32_t)srtot / 65536.f, 0.f, 1.f);

    ret->g = CLIP ((int32_t)sgtot / 65536.f, 0.f, 1.f);

    ret->b = CLIP ((int32_t)sbtot / 65536.f, 0.f, 1.f);

}

typedef void (* accumulate_pixel_t) (unsigned int *satot, unsigned int *srtot,

             unsigned int *sgtot, unsigned int *sbtot,

             const void *pixel, pixman_fixed_t f);

typedef void (* reduce_pixel_t) (unsigned int satot, unsigned int srtot,

         unsigned int sgtot, unsigned int sbtot,

                                 void *out);

static force_inline void

bits_image_fetch_pixel_convolution (bits_image_t   *image,

            pixman_fixed_t  x,

            pixman_fixed_t  y,

            get_pixel_t     get_pixel,

            void        *out,

            accumulate_pixel_t accum,

            reduce_pixel_t reduce)

{

    pixman_fixed_t *params = image->common.filter_params;

    int x_off = (params[0] - pixman_fixed_1) >> 1;

    int y_off = (params[1] - pixman_fixed_1) >> 1;

    int32_t cwidth = pixman_fixed_to_int (params[0]);

    int32_t cheight = pixman_fixed_to_int (params[1]);

    int32_t i, j, x1, x2, y1, y2;

    pixman_repeat_t repeat_mode = image->common.repeat;

    int width = image->width;

    int height = image->height;

    unsigned int srtot, sgtot, sbtot, satot;

    params += 2;

    x1 = pixman_fixed_to_int (x - pixman_fixed_e - x_off);

    y1 = pixman_fixed_to_int (y - pixman_fixed_e - y_off);

    x2 = x1 + cwidth;

    y2 = y1 + cheight;

    srtot = sgtot = sbtot = satot = 0;

    for (i = y1; i < y2; ++i)

    {

  for (j = x1; j < x2; ++j)

  {

      int rx = j;

      int ry = i;

      pixman_fixed_t f = *params;

      if (f)

      {

    /* Must be big enough to hold a argb_t */

    argb_t pixel;

    if (repeat_mode != PIXMAN_REPEAT_NONE)

    {

        repeat (repeat_mode, &rx, width);

        repeat (repeat_mode, &ry, height);

        get_pixel (image, rx, ry, FALSE, &pixel);

    }

    else

    {

        get_pixel (image, rx, ry, TRUE, &pixel);

    }

    accum (&satot, &srtot, &sgtot, &sbtot, &pixel, f);

      }

      params++;

  }

    }

    reduce (satot, srtot, sgtot, sbtot, out);

}

static void

bits_image_fetch_pixel_separable_convolution (bits_image_t  *image,

                pixman_fixed_t x,

                pixman_fixed_t y,

                get_pixel_t    get_pixel,

                void      *out,

                accumulate_pixel_t accum,

                reduce_pixel_t     reduce)

{

    pixman_fixed_t *params = image->common.filter_params;

    pixman_repeat_t repeat_mode = image->common.repeat;

    int width = image->width;

    int height = image->height;

    int cwidth = pixman_fixed_to_int (params[0]);

    int cheight = pixman_fixed_to_int (params[1]);

    int x_phase_bits = pixman_fixed_to_int (params[2]);

    int y_phase_bits = pixman_fixed_to_int (params[3]);

    int x_phase_shift = 16 - x_phase_bits;

    int y_phase_shift = 16 - y_phase_bits;

    int x_off = ((cwidth << 16) - pixman_fixed_1) >> 1;

    int y_off = ((cheight << 16) - pixman_fixed_1) >> 1;

    pixman_fixed_t *y_params;

    unsigned int srtot, sgtot, sbtot, satot;

    int32_t x1, x2, y1, y2;

    int32_t px, py;

    int i, j;

    /* Round x and y to the middle of the closest phase before continuing. This

     * ensures that the convolution matrix is aligned right, since it was

     * positioned relative to a particular phase (and not relative to whatever

     * exact fraction we happen to get here).

     */

    x = ((x >> x_phase_shift) << x_phase_shift) + ((1 << x_phase_shift) >> 1);

    y = ((y >> y_phase_shift) << y_phase_shift) + ((1 << y_phase_shift) >> 1);

    px = (x & 0xffff) >> x_phase_shift;

    py = (y & 0xffff) >> y_phase_shift;

    y_params = params + 4 + (1 << x_phase_bits) * cwidth + py * cheight;

    x1 = pixman_fixed_to_int (x - pixman_fixed_e - x_off);

    y1 = pixman_fixed_to_int (y - pixman_fixed_e - y_off);

    x2 = x1 + cwidth;

    y2 = y1 + cheight;

    srtot = sgtot = sbtot = satot = 0;

    for (i = y1; i < y2; ++i)

    {

        pixman_fixed_48_16_t fy = *y_params++;

        pixman_fixed_t *x_params = params + 4 + px * cwidth;

        if (fy)

        {

            for (j = x1; j < x2; ++j)

            {

                pixman_fixed_t fx = *x_params++;

    int rx = j;

    int ry = i;

                if (fx)

                {

                    /* Must be big enough to hold a argb_t */

                    argb_t pixel;

                    pixman_fixed_t f;

                    if (repeat_mode != PIXMAN_REPEAT_NONE)

                    {

                        repeat (repeat_mode, &rx, width);

                        repeat (repeat_mode, &ry, height);

                        get_pixel (image, rx, ry, FALSE, &pixel);

                    }

                    else

                    {

                        get_pixel (image, rx, ry, TRUE, &pixel);

        }

                    f = (fy * fx + 0x8000) >> 16;

        accum(&satot, &srtot, &sgtot, &sbtot, &pixel, f);

                }

            }

  }

    }

    reduce(satot, srtot, sgtot, sbtot, out);

}

static force_inline void

bits_image_fetch_pixel_filtered (bits_image_t  *image,

         pixman_bool_t  wide,

         pixman_fixed_t x,

         pixman_fixed_t y,

         get_pixel_t    get_pixel,

         void          *out)

{

    switch (image->common.filter)

    {

    case PIXMAN_FILTER_NEAREST:

    case PIXMAN_FILTER_FAST:

  bits_image_fetch_pixel_nearest (image, x, y, get_pixel, out);

  break;

    case PIXMAN_FILTER_BILINEAR:

    case PIXMAN_FILTER_GOOD:

    case PIXMAN_FILTER_BEST:

  if (wide)

      bits_image_fetch_pixel_bilinear_float (image, x, y, get_pixel, out);

  else

      bits_image_fetch_pixel_bilinear_32 (image, x, y, get_pixel, out);

  break;

    case PIXMAN_FILTER_CONVOLUTION:

  if (wide)

  {

      bits_image_fetch_pixel_convolution (image, x, y,

            get_pixel, out,

            accum_float,

            reduce_float);

  }

  else

  {

      bits_image_fetch_pixel_convolution (image, x, y,

            get_pixel, out,

            accum_32, reduce_32);

  }

  break;

    case PIXMAN_FILTER_SEPARABLE_CONVOLUTION:

  if (wide)

  {

      bits_image_fetch_pixel_separable_convolution (image, x, y,

                get_pixel, out,

                accum_float,

                reduce_float);

  }

  else

  {

      bits_image_fetch_pixel_separable_convolution (image, x, y,

                get_pixel, out,

                accum_32, reduce_32);

  }

        break;

    default:

  assert (0);

        break;

    }

}

static uint32_t *

__bits_image_fetch_affine_no_alpha (pixman_iter_t *  iter,

            pixman_bool_t    wide,

            const uint32_t * mask)

{

    pixman_image_t *image  = iter->image;

    int             offset = iter->x;

    int             line   = iter->y++;

    int             width  = iter->width;

    uint32_t *      buffer = iter->buffer;

    const uint32_t wide_zero[4] = {0};

    pixman_fixed_t x, y;

    pixman_fixed_t ux, uy;

    pixman_vector_t v;

    int i;

    get_pixel_t get_pixel =

  wide ? fetch_pixel_no_alpha_float : fetch_pixel_no_alpha_32;

    /* reference point is the center of the pixel */

    v.vector[0] = pixman_int_to_fixed (offset) + pixman_fixed_1 / 2;

    v.vector[1] = pixman_int_to_fixed (line) + pixman_fixed_1 / 2;

    v.vector[2] = pixman_fixed_1;

    if (image->common.transform)

    {

  if (!pixman_transform_point_3d (image->common.transform, &v))

      return iter->buffer;

  ux = image->common.transform->matrix[0][0];

  uy = image->common.transform->matrix[1][0];

    }

    else

    {

  ux = pixman_fixed_1;

  uy = 0;

    }

    x = v.vector[0];

    y = v.vector[1];

    for (i = 0; i < width; ++i)

    {

  if (!mask || (!wide && mask[i]) ||

      (wide && memcmp(&mask[4 * i], wide_zero, 16) != 0))

  {

      bits_image_fetch_pixel_filtered (

    &image->bits, wide, x, y, get_pixel, buffer);

  }

  x += ux;

  y += uy;

  buffer += wide ? 4 : 1;

    }

    return iter->buffer;

}

static uint32_t *

bits_image_fetch_affine_no_alpha_32 (pixman_iter_t  *iter,

             const uint32_t *mask)

{

    return __bits_image_fetch_affine_no_alpha(iter, FALSE, mask);

}

static uint32_t *

bits_image_fetch_affine_no_alpha_float (pixman_iter_t  *iter,

          const uint32_t *mask)

{

    return __bits_image_fetch_affine_no_alpha(iter, TRUE, mask);

}

/* General fetcher */

static force_inline void

fetch_pixel_general_32 (bits_image_t *image,

      int x, int y, pixman_bool_t check_bounds,

      void *out)

{

    uint32_t pixel, *ret = out;

    if (check_bounds &&

  (x < 0 || x >= image->width || y < 0 || y >= image->height))

    {

  *ret = 0;

  return;

    }

    pixel = image->fetch_pixel_32 (image, x, y);

    if (image->common.alpha_map)

    {

  uint32_t pixel_a;

  x -= image->common.alpha_origin_x;

  y -= image->common.alpha_origin_y;

  if (x < 0 || x >= image->common.alpha_map->width ||

      y < 0 || y >= image->common.alpha_map->height)

  {

      pixel_a = 0;

  }

  else

  {

      pixel_a = image->common.alpha_map->fetch_pixel_32 (

    image->common.alpha_map, x, y);

      pixel_a = ALPHA_8 (pixel_a);

  }

  pixel &= 0x00ffffff;

  pixel |= (pixel_a << 24);

    }

    *ret = pixel;

}

static force_inline void

fetch_pixel_general_float (bits_image_t *image,

      int x, int y, pixman_bool_t check_bounds,

      void *out)

{

    argb_t *ret = out;

    if (check_bounds &&

  (x < 0 || x >= image->width || y < 0 || y >= image->height))

    {

  ret->a = ret->r = ret->g = ret->b = 0;

  return;

    }

    *ret = image->fetch_pixel_float (image, x, y);

    if (image->common.alpha_map)

    {

  x -= image->common.alpha_origin_x;

  y -= image->common.alpha_origin_y;

  if (x < 0 || x >= image->common.alpha_map->width ||

      y < 0 || y >= image->common.alpha_map->height)

  {

      ret->a = 0.f;

  }

  else

  {

      argb_t alpha;

      alpha = image->common.alpha_map->fetch_pixel_float (

        image->common.alpha_map, x, y);

      ret->a = alpha.a;

  }

    }

}

static uint32_t *

__bits_image_fetch_general (pixman_iter_t  *iter,

          pixman_bool_t wide,

          const uint32_t *mask)

{

    pixman_image_t *image  = iter->image;

    int             offset = iter->x;

    int             line   = iter->y++;

    int             width  = iter->width;

    uint32_t *      buffer = iter->buffer;

    get_pixel_t     get_pixel =

  wide ? fetch_pixel_general_float : fetch_pixel_general_32;

    const uint32_t wide_zero[4] = {0};

    pixman_fixed_t x, y, w;

    pixman_fixed_t ux, uy, uw;

    pixman_vector_t v;

    int i;

    /* reference point is the center of the pixel */

    v.vector[0] = pixman_int_to_fixed (offset) + pixman_fixed_1 / 2;

    v.vector[1] = pixman_int_to_fixed (line) + pixman_fixed_1 / 2;

    v.vector[2] = pixman_fixed_1;

    if (image->common.transform)

    {

  if (!pixman_transform_point_3d (image->common.transform, &v))

      return buffer;

  ux = image->common.transform->matrix[0][0];

  uy = image->common.transform->matrix[1][0];

  uw = image->common.transform->matrix[2][0];

    }

    else

    {

  ux = pixman_fixed_1;

  uy = 0;

  uw = 0;

    }

    x = v.vector[0];

    y = v.vector[1];

    w = v.vector[2];

    for (i = 0; i < width; ++i)

    {

  pixman_fixed_t x0, y0;

  if (!mask || (!wide && mask[i]) ||

      (wide && memcmp(&mask[4 * i], wide_zero, 16) != 0))

  {

      if (w != 0)

      {

    x0 = ((uint64_t)x << 16) / w;

    y0 = ((uint64_t)y << 16) / w;

      }

      else

      {

    x0 = 0;

    y0 = 0;

      }

      bits_image_fetch_pixel_filtered (

    &image->bits, wide, x0, y0, get_pixel, buffer);

  }

  x += ux;

  y += uy;

  w += uw;

  buffer += wide ? 4 : 1;

    }

    return iter->buffer;

}

static uint32_t *

bits_image_fetch_general_32 (pixman_iter_t  *iter,

           const uint32_t *mask)

{

    return __bits_image_fetch_general(iter, FALSE, mask);

}

static uint32_t *

bits_image_fetch_general_float (pixman_iter_t  *iter,

        const uint32_t *mask)

{

    return __bits_image_fetch_general(iter, TRUE, mask);

}

static void

replicate_pixel_32 (bits_image_t *   bits,

        int              x,

        int              y,

        int              width,

        uint32_t *       buffer)

{

    uint32_t color;

    uint32_t *end;

    color = bits->fetch_pixel_32 (bits, x, y);

    end = buffer + width;

    while (buffer < end)

  *(buffer++) = color;

}

static void

replicate_pixel_float (bits_image_t *   bits,

           int              x,

           int              y,

           int              width,

           uint32_t *       b)

{

    argb_t color;

    argb_t *buffer = (argb_t *)b;

    argb_t *end;

    color = bits->fetch_pixel_float (bits, x, y);

    end = buffer + width;

    while (buffer < end)

  *(buffer++) = color;

}

static void

bits_image_fetch_untransformed_repeat_none (bits_image_t *image,

                                            pixman_bool_t wide,

                                            int           x,

                                            int           y,

                                            int           width,

                                            uint32_t *    buffer)

{

    uint32_t w;

    if (y < 0 || y >= image->height)

    {

  memset (buffer, 0, width * (wide? sizeof (argb_t) : 4));

  return;

    }

    if (x < 0)

    {

  w = MIN (width, -x);

  memset (buffer, 0, w * (wide ? sizeof (argb_t) : 4));

  width -= w;

  buffer += w * (wide? 4 : 1);

  x += w;

    }

    if (x < image->width)

    {

  w = MIN (width, image->width - x);

  if (wide)

      image->fetch_scanline_float (image, x, y, w, buffer, NULL);

  else

      image->fetch_scanline_32 (image, x, y, w, buffer, NULL);

  width -= w;

  buffer += w * (wide? 4 : 1);

  x += w;

    }

    memset (buffer, 0, width * (wide ? sizeof (argb_t) : 4));

}

static void

bits_image_fetch_untransformed_repeat_normal (bits_image_t *image,

                                              pixman_bool_t wide,

                                              int           x,

                                              int           y,

                                              int           width,

                                              uint32_t *    buffer)

{

    uint32_t w;

    while (y < 0)

  y += image->height;

    while (y >= image->height)

  y -= image->height;

    if (image->width == 1)

    {

  if (wide)

      replicate_pixel_float (image, 0, y, width, buffer);

  else

      replicate_pixel_32 (image, 0, y, width, buffer);

  return;

    }

    while (width)

    {

  while (x < 0)

      x += image->width;

  while (x >= image->width)

      x -= image->width;

  w = MIN (width, image->width - x);

  if (wide)

      image->fetch_scanline_float (image, x, y, w, buffer, NULL);

  else

      image->fetch_scanline_32 (image, x, y, w, buffer, NULL);

  buffer += w * (wide? 4 : 1);

  x += w;

  width -= w;

    }

}

static uint32_t *

bits_image_fetch_untransformed_32 (pixman_iter_t * iter,

           const uint32_t *mask)

{

    pixman_image_t *image  = iter->image;

    int             x      = iter->x;

    int             y      = iter->y;

    int             width  = iter->width;

    uint32_t *      buffer = iter->buffer;

    if (image->common.repeat == PIXMAN_REPEAT_NONE)

    {

  bits_image_fetch_untransformed_repeat_none (

      &image->bits, FALSE, x, y, width, buffer);

    }

    else

    {

  bits_image_fetch_untransformed_repeat_normal (

      &image->bits, FALSE, x, y, width, buffer);

    }

    iter->y++;

    return buffer;

}

static uint32_t *

bits_image_fetch_untransformed_float (pixman_iter_t * iter,

              const uint32_t *mask)

{

    pixman_image_t *image  = iter->image;

    int             x      = iter->x;

    int             y      = iter->y;

    int             width  = iter->width;

    uint32_t *      buffer = iter->buffer;

    if (image->common.repeat == PIXMAN_REPEAT_NONE)

    {

  bits_image_fetch_untransformed_repeat_none (

      &image->bits, TRUE, x, y, width, buffer);

    }

    else

    {

  bits_image_fetch_untransformed_repeat_normal (

      &image->bits, TRUE, x, y, width, buffer);

    }

    iter->y++;

    return buffer;

}