../cdk-pixbuf/pixops/pixops.c

Bug Summary

File:	_build/../cdk-pixbuf/pixops/pixops.c
Warning:	line 1210, column 23 The left operand of '+' is a garbage value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -O2 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name pixops.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/rootdir/_build -fcoverage-compilation-dir=/rootdir/_build -resource-dir /usr/lib/llvm-21/lib/clang/21 -I cdk-pixbuf/pixops/libpixops.a.p -I cdk-pixbuf/pixops -I ../cdk-pixbuf/pixops -I . -I .. -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -I /usr/include/libmount -I /usr/include/blkid -D _FILE_OFFSET_BITS=64 -D _POSIX_C_SOURCE=200809L -D _DEFAULT_SOURCE -D _XOPEN_SOURCE=700 -D HAVE_CONFIG_H=1 -internal-isystem /usr/lib/llvm-21/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/15/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -std=gnu99 -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-checker deadcode.DeadStores -analyzer-checker security.ArrayBound -analyzer-checker unix.cstring.NotNullTerminated -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2026-06-05-220802-8580-1 -x c ../cdk-pixbuf/pixops/pixops.c
1/*
* Copyright (C) 2000 Red Hat, Inc
* mediaLib integration Copyright (c) 2001-2007 Sun Microsystems, Inc.
* All rights reserved.  (Brian Cameron, Dmitriy Demin, James Cheng,
* Padraig O'Briain)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
20#include "config.h"
21#include <math.h>
22#include <glib.h>

24#include "../fallback-c89.c"
25#include "pixops.h"

27#define SUBSAMPLE_BITS4 4
28#define SUBSAMPLE(1 << 4) (1 << SUBSAMPLE_BITS4)
29#define SUBSAMPLE_MASK((1 << 4)-1) ((1 << SUBSAMPLE_BITS4)-1)
30#define SCALE_SHIFT16 16

32static void
33_pixops_scale_real (guchar        *dest_buf,
                  int            render_x0,
                  int            render_y0,
                  int            render_x1,
                  int            render_y1,
                  int            dest_rowstride,
                  int            dest_channels,
                  gboolean       dest_has_alpha,
                  const guchar  *src_buf,
                  int            src_width,
                  int            src_height,
                  int            src_rowstride,
                  int            src_channels,
                  gboolean       src_has_alpha,
                  double         scale_x,
                  double         scale_y,
                  PixopsInterpType  interp_type);

51typedef struct _PixopsFilter PixopsFilter;
52typedef struct _PixopsFilterDimension PixopsFilterDimension;

54struct _PixopsFilterDimension
55{
int n;
double offset;
double *weights;
59};

61struct _PixopsFilter
62{
PixopsFilterDimension x;
PixopsFilterDimension y;
double overall_alpha;
66}; 

68typedef guchar *(*PixopsLineFunc) (int *weights, int n_x, int n_y,
		   guchar *dest, int dest_x, guchar *dest_end,
		   int dest_channels, int dest_has_alpha,
		   guchar **src, int src_channels,
		   gboolean src_has_alpha, int x_init,
		   int x_step, int src_width, int check_size,
		   guint32 color1, guint32 color2);
75typedef void (*PixopsPixelFunc)   (guchar *dest, int dest_x, int dest_channels,
		   int dest_has_alpha, int src_has_alpha,
		   int check_size, guint32 color1,
		   guint32 color2,
		   guint r, guint g, guint b, guint a);

81#ifdef USE_MEDIALIB
82#include <stdlib.h>
83#include <dlfcn.h>
84#include <mlib_image.h>

86#ifdef HAVE_STRINGS_H
87#include <strings.h>
88#endif

90#ifdef HAVE_STRING_H
91#include <string.h>
92#endif

94#if defined(HAVE_SYS_SYSTEMINFO_H)
95#include <sys/systeminfo.h>
96#elif defined(HAVE_SYS_SYSINFO_H)
97#include <sys/sysinfo.h>
98#endif

100static void pixops_medialib_composite    (guchar          *dest_buf,
                                        int              dest_width,
                                        int              dest_height,
                                        int              dest_rowstride,
                                        int              dest_channels,
                                        int              dest_has_alpha,
                                        const guchar    *src_buf,
                                        int              src_width,
                                        int              src_height,
                                        int              src_rowstride,
                                        int              src_channels,
                                        int              src_has_alpha,
                                        int              dest_x,
                                        int              dest_y,
                                        int              dest_region_width,
                                        int              dest_region_height,
                                        double           offset_x,
                                        double           offset_y,
                                        double           scale_x,
                                        double           scale_y,
                                        PixopsInterpType interp_type,
                                        int              overall_alpha);

123static void pixops_medialib_scale        (guchar          *dest_buf,
                                        int              dest_width,
                                        int              dest_height,
                                        int              dest_rowstride,
                                        int              dest_channels,
                                        int              dest_has_alpha,
                                        const guchar    *src_buf,
                                        int              src_width,
                                        int              src_height,
                                        int              src_rowstride,
                                        int              src_channels,
                                        int              src_has_alpha,
                                        int              dest_x,
                                        int              dest_y,
                                        int              dest_region_width,
                                        int              dest_region_height,
                                        double           offset_x,
                                        double           offset_y,
                                        double           scale_x,
                                        double           scale_y,
                                        PixopsInterpType interp_type);

145typedef struct _mlInterp mlInterp;

147struct _mlInterp
148{
double       tx;
double       ty;
PixopsFilter po_filter;
void         *interp_table;
153};

155static gboolean medialib_initialized = FALSE(0);
156static gboolean use_medialib         = TRUE(!(0));

158/*
* Sun mediaLib(tm) support.
*
*   http://www.sun.com/processors/vis/mlib.html
*
*/
164static void
165_pixops_use_medialib ()
166{
char *mlib_version_string;
char  sys_info[257];
long  count;

medialib_initialized = TRUE(!(0)); 

if (getenv ("CDK_DISABLE_MEDIALIB"))
  {
    use_medialib = FALSE(0);
    return;
  }

/*
 * The imaging functions we want to use were added in mediaLib version 2.
 * So turn off mediaLib support if the user has an older version.
 * mlib_version returns a string in this format:
 *
 * mediaLib:0210:20011101:v8plusa
 * ^^^^^^^^ ^^^^ ^^^^^^^^ ^^^^^^^
 * libname  vers  build   ISALIST identifier
 *                date    (in this case sparcv8plus+vis)
 * 
 * The first 2 digits of the version are the major version.  The 3rd digit
 * is the minor version, and the 4th digit is the micro version.  So the
 * above string corresponds to version 2.1.0.  In the following test we only
 * care about the major version.
 */
mlib_version_string = mlib_version ();

count = sysinfo (SI_ARCHITECTURE, &sys_info[0], 257);

if (count != -1)
  {
    if (strcmp (sys_info, "i386") == 0)
      {
        char *mlib_target_isa = &mlib_version_string[23];

        /*
         * For x86 processors mediaLib generic C implementation
         * does not give any performance advantage so disable it
         */
        if (strncmp (mlib_target_isa, "sse", 3) != 0)
          {
            use_medialib = FALSE(0);
            return;
          }

        /*
         * For x86 processors use of libumem conflicts with
         * mediaLib, so avoid using it.
         */
        if (dlsym (RTLD_PROBE,   "umem_alloc") != NULL((void*)0))
          {
            use_medialib = FALSE(0);
            return;
          }
      }
  }
else
  {
    /* Failed to get system architecture, disable mediaLib anyway */
    use_medialib = FALSE(0);
    return;
  }
231}
232#endif

234static int
235get_check_shift (int check_size)
236{
int check_shift = 0;
g_return_val_if_fail (check_size >= 0, 4)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_19
 = 0; if (check_size >= 0) _g_boolean_var_19 = 1; _g_boolean_var_19
; }), 1))) { } else { g_return_if_fail_warning (((gchar*) 0),
 ((const char*) (__func__)), "check_size >= 0"); return (4
); } } while (0);

while (!(check_size & 1))
  {
    check_shift++;
    check_size >>= 1;
  }

return check_shift;
247}

249static void
250pixops_scale_nearest (guchar        *dest_buf,
      int            render_x0,
      int            render_y0,
      int            render_x1,
      int            render_y1,
      int            dest_rowstride,
      int            dest_channels,
      gboolean       dest_has_alpha,
      const guchar  *src_buf,
      int            src_width,
      int            src_height,
      int            src_rowstride,
      int            src_channels,
      gboolean       src_has_alpha,
      double         scale_x,
      double         scale_y)
266{
gint64 i;
gint64 x;
gint64 x_step = (1 << SCALE_SHIFT16) / scale_x;
gint64 y_step = (1 << SCALE_SHIFT16) / scale_y;
gint64 xmax, xstart, xstop, x_pos, y_pos;
const guchar *p;

274#define INNER_LOOP(SRC_CHANNELS,DEST_CHANNELS,ASSIGN_PIXEL)     \
    xmax = x + (render_x1 - render_x0) * x_step;              \
    xstart = MIN (0, xmax)(((0) < (xmax)) ? (0) : (xmax));                                   \
    xstop = MIN (src_width << SCALE_SHIFT, xmax)(((src_width << 16) < (xmax)) ? (src_width << 16
) : (xmax));             \
    p = src + (CLAMP (x, xstart, xstop)(((x) > (xstop)) ? (xstop) : (((x) < (xstart)) ? (xstart
) : (x))) >> SCALE_SHIFT16) * SRC_CHANNELS; \
    while (x < xstart)                                        \
      {                                                       \
        ASSIGN_PIXEL;                                         \
        dest += DEST_CHANNELS;                                \
        x += x_step;                                          \
      }                                                       \
    while (x < xstop)                                         \
      {                                                       \
        p = src + (x >> SCALE_SHIFT16) * SRC_CHANNELS;          \
        ASSIGN_PIXEL;                                         \
        dest += DEST_CHANNELS;                                \
        x += x_step;                                          \
      }                                                       \
    x_pos = x >> SCALE_SHIFT16;                                 \
    p = src + CLAMP (x_pos, 0, src_width - 1)(((x_pos) > (src_width - 1)) ? (src_width - 1) : (((x_pos)
 < (0)) ? (0) : (x_pos))) * SRC_CHANNELS; \
    while (x < xmax)                                          \
      {                                                       \
        ASSIGN_PIXEL;                                         \
        dest += DEST_CHANNELS;                                \
        x += x_step;                                          \
      }

for (i = 0; i < (render_y1 - render_y0); i++)
  {
    const guchar *src;
    guchar       *dest;
    y_pos = ((i + render_y0) * y_step + y_step / 2) >> SCALE_SHIFT16;
    y_pos = CLAMP (y_pos, 0, src_height - 1)(((y_pos) > (src_height - 1)) ? (src_height - 1) : (((y_pos
) < (0)) ? (0) : (y_pos)));
    src  = src_buf + (gsize)y_pos * src_rowstride;
    dest = dest_buf + (gsize)i * dest_rowstride;

    x = render_x0 * x_step + x_step / 2;

    if (src_channels == 3)
{
 if (dest_channels == 3)
   {
     INNER_LOOP (3, 3, dest[0]=p[0];dest[1]=p[1];dest[2]=p[2]);
   }
 else
   {
     INNER_LOOP (3, 4, dest[0]=p[0];dest[1]=p[1];dest[2]=p[2];dest[3]=0xff);
   }
}
    else if (src_channels == 4)
{
 if (dest_channels == 3)
   {
     INNER_LOOP (4, 3, dest[0]=p[0];dest[1]=p[1];dest[2]=p[2]);
   }
 else
   {
     guint32 *p32;
     INNER_LOOP(4, 4, p32=(guint32*)dest;*p32=*((guint32*)p));
   }
}
  }
336}

338static void
339pixops_composite_nearest (guchar        *dest_buf,
	  int            render_x0,
	  int            render_y0,
	  int            render_x1,
	  int            render_y1,
	  int            dest_rowstride,
	  int            dest_channels,
	  gboolean       dest_has_alpha,
	  const guchar  *src_buf,
	  int            src_width,
	  int            src_height,
	  int            src_rowstride,
	  int            src_channels,
	  gboolean       src_has_alpha,
	  double         scale_x,
	  double         scale_y,
	  int            overall_alpha)
356{
gint64 i;
gint64 x;
gint64 x_step = (1 << SCALE_SHIFT16) / scale_x;
gint64 y_step = (1 << SCALE_SHIFT16) / scale_y;
gint64 xmax, xstart, xstop, x_pos, y_pos;
const guchar *p;
unsigned int  a0;

for (i = 0; i < (render_y1 - render_y0); i++)
  {
    const guchar *src;
    guchar       *dest;
    y_pos = ((i + render_y0) * y_step + y_step / 2) >> SCALE_SHIFT16;
    y_pos = CLAMP (y_pos, 0, src_height - 1)(((y_pos) > (src_height - 1)) ? (src_height - 1) : (((y_pos
) < (0)) ? (0) : (y_pos)));
    src  = src_buf + (gsize)y_pos * src_rowstride;
    dest = dest_buf + (gsize)i * dest_rowstride;

    x = render_x0 * x_step + x_step / 2;
    
    INNER_LOOP(src_channels, dest_channels,
 if (src_has_alpha)
   a0 = (p[3] * overall_alpha) / 0xff;
 else
   a0 = overall_alpha;

        switch (a0)
          {
          case 0:
            break;
          case 255:
            dest[0] = p[0];
            dest[1] = p[1];
            dest[2] = p[2];
            if (dest_has_alpha)
              dest[3] = 0xff;
            break;
          default:
            if (dest_has_alpha)
              {
                unsigned int w0 = 0xff * a0;
                unsigned int w1 = (0xff - a0) * dest[3];
                unsigned int w = w0 + w1;

  dest[0] = (w0 * p[0] + w1 * dest[0]) / w;
  dest[1] = (w0 * p[1] + w1 * dest[1]) / w;
  dest[2] = (w0 * p[2] + w1 * dest[2]) / w;
  dest[3] = w / 0xff;
              }
            else
              {
                unsigned int a1 = 0xff - a0;
  unsigned int tmp;

  tmp = a0 * p[0] + a1 * dest[0] + 0x80;
                dest[0] = (tmp + (tmp >> 8)) >> 8;
  tmp = a0 * p[1] + a1 * dest[1] + 0x80;
                dest[1] = (tmp + (tmp >> 8)) >> 8;
  tmp = a0 * p[2] + a1 * dest[2] + 0x80;
                dest[2] = (tmp + (tmp >> 8)) >> 8;
              }
            break;
          }
);
  }
421}

423static void
424pixops_composite_nearest_noscale (guchar        *dest_buf,
		  int            render_x0,
		  int            render_y0,
		  int            render_x1,
		  int            render_y1,
		  int            dest_rowstride,
		  int            dest_channels,
		  gboolean       dest_has_alpha,
		  const guchar  *src_buf,
		  int            src_width,
		  int            src_height,
		  int            src_rowstride,
		  int            src_channels,
		  gboolean       src_has_alpha,
		  int            overall_alpha)
439{
gint64 i;
gint64 x;
gint64 xmax, xstart, xstop, y_pos;
const guchar *p;
unsigned int  a0;

446#define INNER_LOOP_NOSCALE(SRC_CHANNELS,DEST_CHANNELS,ASSIGN_PIXEL) \
    xmax = x + (render_x1 - render_x0);                       \
    xstart = MIN (0, xmax)(((0) < (xmax)) ? (0) : (xmax));                                   \
    xstop = MIN (src_width, xmax)(((src_width) < (xmax)) ? (src_width) : (xmax));                            \
    p = src + CLAMP (x, xstart, xstop)(((x) > (xstop)) ? (xstop) : (((x) < (xstart)) ? (xstart
) : (x))) * SRC_CHANNELS;        \
    while (x < xstart)                                        \
      {                                                       \
        ASSIGN_PIXEL;                                         \
        dest += DEST_CHANNELS;                                \
        x++;                                                  \
      }                                                       \
    p = src + x * SRC_CHANNELS;                               \
    while (x < xstop)                                         \
      {                                                       \
        ASSIGN_PIXEL;                                         \
        dest += DEST_CHANNELS;                                \
        x++;                                                  \
        p += SRC_CHANNELS;                                    \
      }                                                       \
    p = src + CLAMP (x, 0, src_width - 1)(((x) > (src_width - 1)) ? (src_width - 1) : (((x) < (0
)) ? (0) : (x))) * SRC_CHANNELS;     \
    while (x < xmax)                                          \
      {                                                       \
        ASSIGN_PIXEL;                                         \
        dest += DEST_CHANNELS;                                \
        x++;                                                  \
      }

for (i = 0; i < (render_y1 - render_y0); i++)
  {
    const guchar *src;
    guchar       *dest;
    y_pos = i + render_y0;
    y_pos = CLAMP (y_pos, 0, src_height - 1)(((y_pos) > (src_height - 1)) ? (src_height - 1) : (((y_pos
) < (0)) ? (0) : (y_pos)));
    src  = src_buf + (gsize)y_pos * src_rowstride;
    dest = dest_buf + (gsize)i * dest_rowstride;

    x = render_x0;

    INNER_LOOP_NOSCALE(src_channels, dest_channels,
 if (src_has_alpha)
   a0 = (p[3] * overall_alpha) / 0xff;
 else
   a0 = overall_alpha;

 switch (a0)
   {
   case 0:
     break;
   case 255:
     dest[0] = p[0];
     dest[1] = p[1];
     dest[2] = p[2];
     if (dest_has_alpha)
dest[3] = 0xff;
     break;
   default:
     if (dest_has_alpha)
       {
  unsigned int w0 = 0xff * a0;
  unsigned int w1 = (0xff - a0) * dest[3];
  unsigned int w = w0 + w1;

  dest[0] = (w0 * p[0] + w1 * dest[0]) / w;
  dest[1] = (w0 * p[1] + w1 * dest[1]) / w;
  dest[2] = (w0 * p[2] + w1 * dest[2]) / w;
  dest[3] = w / 0xff;
       }
     else
       {
  unsigned int a1 = 0xff - a0;
  unsigned int tmp;

  tmp = a0 * p[0] + a1 * dest[0] + 0x80;
  dest[0] = (tmp + (tmp >> 8)) >> 8;
  tmp = a0 * p[1] + a1 * dest[1] + 0x80;
  dest[1] = (tmp + (tmp >> 8)) >> 8;
  tmp = a0 * p[2] + a1 * dest[2] + 0x80;
  dest[2] = (tmp + (tmp >> 8)) >> 8;
       }
     break;
   }
);
  }
529}
530#undef INNER_LOOP_NOSCALE

532static void
533pixops_composite_color_nearest (guchar        *dest_buf,
		int            render_x0,
		int            render_y0,
		int            render_x1,
		int            render_y1,
		int            dest_rowstride,
		int            dest_channels,
		gboolean       dest_has_alpha,
		const guchar  *src_buf,
		int            src_width,
		int            src_height,
		int            src_rowstride,
		int            src_channels,
		gboolean       src_has_alpha,
		double         scale_x,
		double         scale_y,
		int            overall_alpha,
		int            check_x,
		int            check_y,
		int            check_size,
		guint32        color1,
		guint32        color2)
555{
gint64 i, j;
gint64 x;
gint64 x_step = (1 << SCALE_SHIFT16) / scale_x;
gint64 y_step = (1 << SCALE_SHIFT16) / scale_y;
int r1, g1, b1, r2, g2, b2;
int check_shift = get_check_shift (check_size);
gint64 xmax, xstart, xstop, x_pos, y_pos;
const guchar *p;
unsigned int  a0;

for (i = 0; i < (render_y1 - render_y0); i++)
  {
    const guchar *src;
    guchar       *dest;
    y_pos = ((i + render_y0) * y_step + y_step / 2) >> SCALE_SHIFT16;
    y_pos = CLAMP (y_pos, 0, src_height - 1)(((y_pos) > (src_height - 1)) ? (src_height - 1) : (((y_pos
) < (0)) ? (0) : (y_pos)));
    src  = src_buf + (gsize)y_pos * src_rowstride;
    dest = dest_buf + (gsize)i * dest_rowstride;

    x = render_x0 * x_step + x_step / 2;
    
    
    if (((i + check_y) >> check_shift) & 1)
{
 r1 = (color2 & 0xff0000) >> 16;
 g1 = (color2 & 0xff00) >> 8;
 b1 = color2 & 0xff;

 r2 = (color1 & 0xff0000) >> 16;
 g2 = (color1 & 0xff00) >> 8;
 b2 = color1 & 0xff;
}
    else
{
 r1 = (color1 & 0xff0000) >> 16;
 g1 = (color1 & 0xff00) >> 8;
 b1 = color1 & 0xff;

 r2 = (color2 & 0xff0000) >> 16;
 g2 = (color2 & 0xff00) >> 8;
 b2 = color2 & 0xff;
}

    j = 0;
    INNER_LOOP(src_channels, dest_channels,
 if (src_has_alpha)
   a0 = (p[3] * overall_alpha + 0xff) >> 8;
 else
   a0 = overall_alpha;

        switch (a0)
          {
          case 0:
            if (((j + check_x) >> check_shift) & 1)
              {
                dest[0] = r2; 
                dest[1] = g2; 
                dest[2] = b2;
              }
            else
              {
                dest[0] = r1; 
                dest[1] = g1; 
                dest[2] = b1;
              }
          break;
          case 255:
     dest[0] = p[0];
     dest[1] = p[1];
     dest[2] = p[2];
            break;
          default:
     {
       unsigned int tmp;
            if (((j + check_x) >> check_shift) & 1)
              {
                tmp = ((int) p[0] - r2) * a0;
                dest[0] = r2 + ((tmp + (tmp >> 8) + 0x80) >> 8);
                tmp = ((int) p[1] - g2) * a0;
                dest[1] = g2 + ((tmp + (tmp >> 8) + 0x80) >> 8);
                tmp = ((int) p[2] - b2) * a0;
                dest[2] = b2 + ((tmp + (tmp >> 8) + 0x80) >> 8);
              }
            else
              {
                tmp = ((int) p[0] - r1) * a0;
                dest[0] = r1 + ((tmp + (tmp >> 8) + 0x80) >> 8);
                tmp = ((int) p[1] - g1) * a0;
                dest[1] = g1 + ((tmp + (tmp >> 8) + 0x80) >> 8);
                tmp = ((int) p[2] - b1) * a0;
                dest[2] = b1 + ((tmp + (tmp >> 8) + 0x80) >> 8);
              }
     }
            break;
          }
 
 if (dest_channels == 4)
   dest[3] = 0xff;

 j++;
);
  }
658}
659#undef INNER_LOOP

661static void
662composite_pixel (guchar *dest, int dest_x, int dest_channels, int dest_has_alpha,
 int src_has_alpha, int check_size, guint32 color1, guint32 color2,
 guint r, guint g, guint b, guint a)
665{
if (dest_has_alpha)
  {
    unsigned int w0 = a - (a >> 8);
    unsigned int w1 = ((0xff0000 - a) >> 8) * dest[3];
    unsigned int w = w0 + w1;
    
    if (w != 0)
{
 dest[0] = (r - (r >> 8) + w1 * dest[0]) / w;
 dest[1] = (g - (g >> 8) + w1 * dest[1]) / w;
 dest[2] = (b - (b >> 8) + w1 * dest[2]) / w;
 dest[3] = w / 0xff00;
}
    else
{
 dest[0] = 0;
 dest[1] = 0;
 dest[2] = 0;
 dest[3] = 0;
}
  }
else
  {
    dest[0] = (r + (0xff0000 - a) * dest[0]) / 0xff0000;
    dest[1] = (g + (0xff0000 - a) * dest[1]) / 0xff0000;
    dest[2] = (b + (0xff0000 - a) * dest[2]) / 0xff0000;
  }
693}

695static guchar *
696composite_line (int *weights, int n_x, int n_y,
guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha,
guchar **src, int src_channels, gboolean src_has_alpha,
int x_init, int x_step, int src_width,
int check_size, guint32 color1, guint32 color2)
701{
int x = x_init;
int i, j;

while (dest < dest_end)
  {
    int x_scaled = x >> SCALE_SHIFT16;
    unsigned int r = 0, g = 0, b = 0, a = 0;
    int *pixel_weights;
    
    pixel_weights = weights + ((x >> (SCALE_SHIFT16 - SUBSAMPLE_BITS4)) & SUBSAMPLE_MASK((1 << 4)-1)) * n_x * n_y;
    
    for (i=0; i<n_y; i++)
{
 guchar *q = src[i] + x_scaled * src_channels;
 int *line_weights = pixel_weights + n_x * i;
 
 for (j=0; j<n_x; j++)
   {
     unsigned int ta;

     if (src_has_alpha)
ta = q[3] * line_weights[j];
     else
ta = 0xff * line_weights[j];
     
     r += ta * q[0];
     g += ta * q[1];
     b += ta * q[2];
     a += ta;

     q += src_channels;
   }
}

    if (dest_has_alpha)
{
 unsigned int w0 = a - (a >> 8);
 unsigned int w1 = ((0xff0000 - a) >> 8) * dest[3];
 unsigned int w = w0 + w1;

 if (w != 0)
   {
     dest[0] = (r - (r >> 8) + w1 * dest[0]) / w;
     dest[1] = (g - (g >> 8) + w1 * dest[1]) / w;
     dest[2] = (b - (b >> 8) + w1 * dest[2]) / w;
     dest[3] = w / 0xff00;
   }
 else
   {
     dest[0] = 0;
     dest[1] = 0;
     dest[2] = 0;
     dest[3] = 0;
   }
}
    else
{
 dest[0] = (r + (0xff0000 - a) * dest[0]) / 0xff0000;
 dest[1] = (g + (0xff0000 - a) * dest[1]) / 0xff0000;
 dest[2] = (b + (0xff0000 - a) * dest[2]) / 0xff0000;
}
    
    dest += dest_channels;
    x += x_step;
  }

return dest;
769}

771static guchar *
772composite_line_22_4a4 (int *weights, int n_x, int n_y,
       guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha,
       guchar **src, int src_channels, gboolean src_has_alpha,
       int x_init, int x_step, int src_width,
       int check_size, guint32 color1, guint32 color2)
777{
int x = x_init;
guchar *src0 = src[0];
guchar *src1 = src[1];

g_return_val_if_fail (src_channels != 3, dest)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_20
 = 0; if (src_channels != 3) _g_boolean_var_20 = 1; _g_boolean_var_20
; }), 1))) { } else { g_return_if_fail_warning (((gchar*) 0),
 ((const char*) (__func__)), "src_channels != 3"); return (dest
); } } while (0);
g_return_val_if_fail (src_has_alpha, dest)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_21
 = 0; if (src_has_alpha) _g_boolean_var_21 = 1; _g_boolean_var_21
; }), 1))) { } else { g_return_if_fail_warning (((gchar*) 0),
 ((const char*) (__func__)), "src_has_alpha"); return (dest);
 } } while (0);

while (dest < dest_end)
  {
    int x_scaled = x >> SCALE_SHIFT16;
    unsigned int r, g, b, a, ta;
    int *pixel_weights;
    guchar *q0, *q1;
    int w1, w2, w3, w4;
    
    q0 = src0 + x_scaled * 4;
    q1 = src1 + x_scaled * 4;
    
    pixel_weights = (int *)((char *)weights +
((x >> (SCALE_SHIFT16 - SUBSAMPLE_BITS4 - 4)) & (SUBSAMPLE_MASK((1 << 4)-1) << 4)));
    
    w1 = pixel_weights[0];
    w2 = pixel_weights[1];
    w3 = pixel_weights[2];
    w4 = pixel_weights[3];

    a = w1 * q0[3];
    r = a * q0[0];
    g = a * q0[1];
    b = a * q0[2];

    ta = w2 * q0[7];
    r += ta * q0[4];
    g += ta * q0[5];
    b += ta * q0[6];
    a += ta;

    ta = w3 * q1[3];
    r += ta * q1[0];
    g += ta * q1[1];
    b += ta * q1[2];
    a += ta;

    ta = w4 * q1[7];
    r += ta * q1[4];
    g += ta * q1[5];
    b += ta * q1[6];
    a += ta;

    dest[0] = ((0xff0000 - a) * dest[0] + r) >> 24;
    dest[1] = ((0xff0000 - a) * dest[1] + g) >> 24;
    dest[2] = ((0xff0000 - a) * dest[2] + b) >> 24;
    dest[3] = a >> 16;
    
    dest += 4;
    x += x_step;
  }

return dest;
837}

839static void
840composite_pixel_color (guchar *dest, int dest_x, int dest_channels,
       int dest_has_alpha, int src_has_alpha, int check_size,
       guint32 color1, guint32 color2, guint r, guint g,
       guint b, guint a)
844{
int dest_r, dest_g, dest_b;
int check_shift = get_check_shift (check_size);

if ((dest_x >> check_shift) & 1)
  {
    dest_r = (color2 & 0xff0000) >> 16;
    dest_g = (color2 & 0xff00) >> 8;
    dest_b = color2 & 0xff;
  }
else
  {
    dest_r = (color1 & 0xff0000) >> 16;
    dest_g = (color1 & 0xff00) >> 8;
    dest_b = color1 & 0xff;
  }

dest[0] = ((0xff0000 - a) * dest_r + r) >> 24;
dest[1] = ((0xff0000 - a) * dest_g + g) >> 24;
dest[2] = ((0xff0000 - a) * dest_b + b) >> 24;

if (dest_has_alpha)
  dest[3] = 0xff;
else if (dest_channels == 4)
  dest[3] = a >> 16;
869}

871static guchar *
872composite_line_color (int *weights, int n_x, int n_y, guchar *dest,
      int dest_x, guchar *dest_end, int dest_channels,
      int dest_has_alpha, guchar **src, int src_channels,
      gboolean src_has_alpha, int x_init, int x_step,
      int src_width, int check_size, guint32 color1,
      guint32 color2)
878{
int x = x_init;
int i, j;
int check_shift = get_check_shift (check_size);
int dest_r1, dest_g1, dest_b1;
int dest_r2, dest_g2, dest_b2;

g_return_val_if_fail (check_size != 0, dest)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_22
 = 0; if (check_size != 0) _g_boolean_var_22 = 1; _g_boolean_var_22
; }), 1))) { } else { g_return_if_fail_warning (((gchar*) 0),
 ((const char*) (__func__)), "check_size != 0"); return (dest
); } } while (0);

dest_r1 = (color1 & 0xff0000) >> 16;
dest_g1 = (color1 & 0xff00) >> 8;
dest_b1 = color1 & 0xff;

dest_r2 = (color2 & 0xff0000) >> 16;
dest_g2 = (color2 & 0xff00) >> 8;
dest_b2 = color2 & 0xff;

while (dest < dest_end)
  {
    int x_scaled = x >> SCALE_SHIFT16;
    unsigned int r = 0, g = 0, b = 0, a = 0;
    int *pixel_weights;
    
    pixel_weights = weights + ((x >> (SCALE_SHIFT16 - SUBSAMPLE_BITS4)) & SUBSAMPLE_MASK((1 << 4)-1)) * n_x * n_y;

    for (i=0; i<n_y; i++)
{
 guchar *q = src[i] + x_scaled * src_channels;
 int *line_weights = pixel_weights + n_x * i;
 
 for (j=0; j<n_x; j++)
   {
     unsigned int ta;
     
     if (src_has_alpha)
ta = q[3] * line_weights[j];
     else
ta = 0xff * line_weights[j];
  
     r += ta * q[0];
     g += ta * q[1];
     b += ta * q[2];
     a += ta;

     q += src_channels;
   }
}

    if ((dest_x >> check_shift) & 1)
{
 dest[0] = ((0xff0000 - a) * dest_r2 + r) >> 24;
 dest[1] = ((0xff0000 - a) * dest_g2 + g) >> 24;
 dest[2] = ((0xff0000 - a) * dest_b2 + b) >> 24;
}
    else
{
 dest[0] = ((0xff0000 - a) * dest_r1 + r) >> 24;
 dest[1] = ((0xff0000 - a) * dest_g1 + g) >> 24;
 dest[2] = ((0xff0000 - a) * dest_b1 + b) >> 24;
}

    if (dest_has_alpha)
dest[3] = 0xff;
    else if (dest_channels == 4)
dest[3] = a >> 16;

    dest += dest_channels;
    x += x_step;
    dest_x++;
  }

return dest;
950}

952static void
953scale_pixel (guchar *dest, int dest_x, int dest_channels, int dest_has_alpha,
    int src_has_alpha, int check_size, guint32 color1, guint32 color2,
    guint r, guint g, guint b, guint a)
956{
if (src_has_alpha)
  {
    if (a == 0xff0000)
{
 /* Division by a constant is converted into a multiplication by an optimizing C compiler */
 dest[0] = r / 0xff0000;
 dest[1] = g / 0xff0000;
 dest[2] = b / 0xff0000;
 dest[3] = 0xff0000 >> 16;
}
    else if (a)
{
 double a1 = 1.0 / a;
 dest[0] = r * a1;
 dest[1] = g * a1;
 dest[2] = b * a1;
 dest[3] = a >> 16;
}
    else
{
 dest[0] = 0;
 dest[1] = 0;
 dest[2] = 0;
 dest[3] = 0;
}
  }
else
  {
    dest[0] = (r + 0xffffff) >> 24;
    dest[1] = (g + 0xffffff) >> 24;
    dest[2] = (b + 0xffffff) >> 24;
    
    if (dest_has_alpha)
dest[3] = 0xff;
  }
992}

994static guchar *
995scale_line (int *weights, int n_x, int n_y, guchar *dest, int dest_x,
   guchar *dest_end, int dest_channels, int dest_has_alpha,
   guchar **src, int src_channels, gboolean src_has_alpha, int x_init,
   int x_step, int src_width, int check_size, guint32 color1,
   guint32 color2)
1000{
gint64 x = x_init;
int i, j;
const gint64 n_xy = n_x * n_y;

while (dest < dest_end)
  {
    int x_scaled = x >> SCALE_SHIFT16;
    int *pixel_weights;

    pixel_weights = weights +
      ((x >> (SCALE_SHIFT16 - SUBSAMPLE_BITS4)) & SUBSAMPLE_MASK((1 << 4)-1)) * n_xy;

    if (src_has_alpha)
{
 unsigned int r = 0, g = 0, b = 0, a = 0;
 for (i = 0; i < n_y; i++)
   {
     guchar *q = src[i] + x_scaled * src_channels;
     int *line_weights  = pixel_weights + n_x * i;
     
     for (j = 0; j < n_x; j++)
{
  unsigned int ta;
  
  ta = q[3] * line_weights[j];
  r += ta * q[0];
  g += ta * q[1];
  b += ta * q[2];
  a += ta;
  
  q += src_channels;
}
   }

 if (a == 0xff0000)
   {
     /* Division by a constant is converted into a multiplication by an optimizing C compiler */
     dest[0] = r / 0xff0000;
     dest[1] = g / 0xff0000;
     dest[2] = b / 0xff0000;
     dest[3] = 0xff0000 >> 16;
   }
 else if (a)
   {
     double a1 = 1.0 / a;
     dest[0] = r * a1;
     dest[1] = g * a1;
     dest[2] = b * a1;
     dest[3] = a >> 16;
   }
 else
   {
     dest[0] = 0;
     dest[1] = 0;
     dest[2] = 0;
     dest[3] = 0;
   }
}
    else
{
 unsigned int r = 0, g = 0, b = 0;
 for (i = 0; i < n_y; i++)
   {
     guchar *q = src[i] + x_scaled * src_channels;
     int *line_weights  = pixel_weights + n_x * i;
     
     for (j = 0; j < n_x; j++)
{
  unsigned int ta = line_weights[j];
  
  r += ta * q[0];
  g += ta * q[1];
  b += ta * q[2];

  q += src_channels;
}
   }

 dest[0] = (r + 0xffff) >> 16;
 dest[1] = (g + 0xffff) >> 16;
 dest[2] = (b + 0xffff) >> 16;
 
 if (dest_has_alpha)
   dest[3] = 0xff;
}

    dest += dest_channels;
    
    x += x_step;
  }

return dest;
1093}


1096static guchar *
1097scale_line_22_33 (int *weights, int n_x, int n_y, guchar *dest, int dest_x,
  guchar *dest_end, int dest_channels, int dest_has_alpha,
  guchar **src, int src_channels, gboolean src_has_alpha,
  int x_init, int x_step, int src_width,
  int check_size, guint32 color1, guint32 color2)
1102{
int x = x_init;
guchar *src0 = src[0];
guchar *src1 = src[1];

while (dest < dest_end)
  {
    unsigned int r, g, b;
    int x_scaled = x >> SCALE_SHIFT16;
    int *pixel_weights;
    guchar *q0, *q1;
    int w1, w2, w3, w4;

    q0 = src0 + x_scaled * 3;
    q1 = src1 + x_scaled * 3;
    
    pixel_weights = weights +
      ((x >> (SCALE_SHIFT16 - SUBSAMPLE_BITS4)) & SUBSAMPLE_MASK((1 << 4)-1)) * 4;

    w1 = pixel_weights[0];
    w2 = pixel_weights[1];
    w3 = pixel_weights[2];
    w4 = pixel_weights[3];

    r = w1 * q0[0];
    g = w1 * q0[1];
    b = w1 * q0[2];

    r += w2 * q0[3];
    g += w2 * q0[4];
    b += w2 * q0[5];

    r += w3 * q1[0];
    g += w3 * q1[1];
    b += w3 * q1[2];

    r += w4 * q1[3];
    g += w4 * q1[4];
    b += w4 * q1[5];

    dest[0] = (r + 0x8000) >> 16;
    dest[1] = (g + 0x8000) >> 16;
    dest[2] = (b + 0x8000) >> 16;
    
    dest += 3;
    x += x_step;
  }

return dest;
1151}

1153static void
1154process_pixel (int *weights, int n_x, int n_y, guchar *dest, int dest_x,
      int dest_channels, int dest_has_alpha, guchar **src,
      int src_channels, gboolean src_has_alpha, int x_start,
      int src_width, int check_size, guint32 color1, guint32 color2,
      PixopsPixelFunc pixel_func)
1159{
unsigned int r = 0, g = 0, b = 0, a = 0;
int i, j;

for (i=0; i<n_y; i++)
  {
    int *line_weights  = weights + n_x * i;

    for (j=0; j<n_x; j++)
{
 unsigned int ta;
 guchar *q;

 if (x_start + j < 0)
   q = src[i];
 else if (x_start + j < src_width)
   q = src[i] + (x_start + j) * src_channels;
 else
   q = src[i] + (src_width - 1) * src_channels;

 if (src_has_alpha)
   ta = q[3] * line_weights[j];
 else
   ta = 0xff * line_weights[j];

 r += ta * q[0];
 g += ta * q[1];
 b += ta * q[2];
 a += ta;
}
  }

(*pixel_func) (dest, dest_x, dest_channels, dest_has_alpha, src_has_alpha,
  check_size, color1, color2, r, g, b, a);
1193}

1195static void 
1196correct_total (int    *weights, 
             int    n_x, 
             int    n_y,
             int    total, 
             double overall_alpha)
1201{
int correction = (int)(0.5 + 65536 * overall_alpha) - total;
int remaining, c, d, i;

if (correction != 0)
14
←
Assuming 'correction' is not equal to 0→
15
←
Taking true branch→
  {
    remaining = correction;
    for (d = 1, c = correction; c15.1
'c' is not equal to 0
 != 0 && remaining15.2
'remaining' is not equal to 0
1
'remaining' is not equal to 0
 != 0; d++, c = correction / d) 
16
←
Loop condition is true.  Entering loop body→
22
←
Assuming 'c' is not equal to 0→
23
←
Loop condition is true.  Entering loop body→
for (i = n_x * n_y - 1; i23.1
'i' is >= 0
 >= 0 && c17.1
'c' is not equal to 0
2
'c' is not equal to 0
 != 0 && remaining17.2
'remaining' is not equal to 0
3
'remaining' is not equal to 0
 != 0; i--) 
17
←
Assuming 'i' is >= 0→
18
←
Loop condition is true.  Entering loop body→
21
←
Assuming 'i' is < 0→
24
←
Loop condition is true.  Entering loop body→
 if (*(weights + i) + c >= 0) 
19
←
Assuming the condition is false→
20
←
Taking false branch→
25
←
The left operand of '+' is a garbage value
   {
     *(weights + i) += c;
     remaining -= c;
     if ((0 < remaining && remaining < c) ||
  (0 > remaining && remaining > c))
c = remaining;
   }
  }
1219}

1221static int *
1222make_filter_table (PixopsFilter *filter)
1223{
int i_offset, j_offset;
int n_x = filter->x.n;
int n_y = filter->y.n;
int *weights;

/* check n_x doesn't overflow */
if (G_MAXINT2147483647 / (SUBSAMPLE(1 << 4) * SUBSAMPLE(1 << 4)) < n_x)
1
Assuming the condition is false→
2
←
Taking false branch→
  return NULL((void*)0);

/* check n_y doesn't overflow */
if (G_MAXINT2147483647 / (SUBSAMPLE(1 << 4) * SUBSAMPLE(1 << 4) * n_x) < n_y)
3
←
Assuming the condition is false→
4
←
Taking false branch→
  return NULL((void*)0);

weights = g_try_new (int, SUBSAMPLE * SUBSAMPLE * n_x * n_y)(int *) (__extension__ ({ gsize __n = (gsize) ((1 << 4)
 * (1 << 4) * n_x * n_y); gsize __s = sizeof (int); gpointer
 __p; if (__s == 1) __p = g_try_malloc (__n); else if (__builtin_constant_p
 (__n) && (__s == 0 || __n <= (9223372036854775807L
 *2UL+1UL) / __s)) __p = g_try_malloc (__n * __s); else __p =
 g_try_malloc_n (__n, __s); __p; }));
5
←
Taking false branch→
6
←
Storing uninitialized value→
if (!weights)
7
←
Assuming 'weights' is non-null→
8
←
Taking false branch→
  return NULL((void*)0); /* overflow, bail */

for (i_offset=0; i_offset < SUBSAMPLE(1 << 4); i_offset++)
9
←
Loop condition is true.  Entering loop body→
  for (j_offset=0; j_offset < SUBSAMPLE(1 << 4); j_offset++)
10
←
Loop condition is true.  Entering loop body→
    {
      double weight;
      int *pixel_weights = weights + ((i_offset*SUBSAMPLE(1 << 4)) + j_offset) * n_x * n_y;
      int total = 0;
      int i, j;

      for (i=0; i < n_y; i++)
11
←
Assuming 'i' is >= 'n_y'→
12
←
Loop condition is false. Execution continues on line 1261→
        for (j=0; j < n_x; j++)
          {
            weight = filter->x.weights[(j_offset * n_x) + j] *
                     filter->y.weights[(i_offset * n_y) + i] *
                     filter->overall_alpha * 65536 + 0.5;

            total += (int)weight;

            *(pixel_weights + n_x * i + j) = weight;
          }

      correct_total (pixel_weights, n_x, n_y, total, filter->overall_alpha);
13
←
Calling 'correct_total'→
    }

return weights;
1265}

1267static void
1268pixops_process (guchar         *dest_buf,
int             render_x0,
int             render_y0,
int             render_x1,
int             render_y1,
int             dest_rowstride,
int             dest_channels,
gboolean        dest_has_alpha,
const guchar   *src_buf,
int             src_width,
int             src_height,
int             src_rowstride,
int             src_channels,
gboolean        src_has_alpha,
double          scale_x,
double          scale_y,
int             check_x,
int             check_y,
int             check_size,
guint32         color1,
guint32         color2,
PixopsFilter   *filter,
PixopsLineFunc  line_func,
PixopsPixelFunc pixel_func)
1292{
gint64 i, j;
gint64 x, y;			/* X and Y position in source (fixed_point) */

guchar **line_bufs;
int *filter_weights;

gint64 x_step;
gint64 y_step;

int check_shift;
gint64 scaled_x_offset;

gint64 run_end_x;
gint64 run_end_index;

x_step = (1 << SCALE_SHIFT16) / scale_x; /* X step in source (fixed point) */
y_step = (1 << SCALE_SHIFT16) / scale_y; /* Y step in source (fixed point) */

if (x_step == 0 || y_step == 0)
  return; /* overflow, bail out */

filter_weights = make_filter_table (filter);
if (!filter_weights)
  return; /* overflow, bail out */

line_bufs = g_new (guchar *, filter->y.n)(guchar * *) (__extension__ ({ gsize __n = (gsize) (filter->
y.n); gsize __s = sizeof (guchar *); gpointer __p; if (__s ==
 1) __p = g_malloc (__n); else if (__builtin_constant_p (__n)
 && (__s == 0 || __n <= (9223372036854775807L *2UL
+1UL) / __s)) __p = g_malloc (__n * __s); else __p = g_malloc_n
 (__n, __s); __p; }));

check_shift = check_size ? get_check_shift (check_size) : 0;

scaled_x_offset = floor (filter->x.offset * (1 << SCALE_SHIFT16));

/* Compute the index where we run off the end of the source buffer. The
 * furthest source pixel we access at index i is:
 *
 *  ((render_x0 + i) * x_step + scaled_x_offset) >> SCALE_SHIFT + filter->x.n - 1
 *
 * So, run_end_index is the smallest i for which this pixel is src_width,
 * i.e, for which:
 *
 *  (i + render_x0) * x_step >= ((src_width - filter->x.n + 1) << SCALE_SHIFT) - scaled_x_offset
 *
 */
1335#define MYDIV(a,b)((a) > 0 ? (a) / (b) : ((a) - (b) + 1) / (b)) ((a) > 0 ? (a) / (b) : ((a) - (b) + 1) / (b))    /* Division so that -1/5 = -1 */

run_end_x = (((src_width - (gint64) filter->x.n + 1) << SCALE_SHIFT16) - scaled_x_offset);
run_end_index = MYDIV (run_end_x + x_step - 1, x_step)((run_end_x + x_step - 1) > 0 ? (run_end_x + x_step - 1) /
 (x_step) : ((run_end_x + x_step - 1) - (x_step) + 1) / (x_step
)) - render_x0;
run_end_index = MIN (run_end_index, render_x1 - render_x0)(((run_end_index) < (render_x1 - render_x0)) ? (run_end_index
) : (render_x1 - render_x0));

y = render_y0 * y_step + floor (filter->y.offset * (1 << SCALE_SHIFT16));
for (i = 0; i < (render_y1 - render_y0); i++)
  {
    int dest_x;
    int y_start = y >> SCALE_SHIFT16;
    int x_start;
    int *run_weights = filter_weights +
                       ((y >> (SCALE_SHIFT16 - SUBSAMPLE_BITS4)) & SUBSAMPLE_MASK((1 << 4)-1)) *
                       filter->x.n * filter->y.n * SUBSAMPLE(1 << 4);
    guchar *new_outbuf;
    guint32 tcolor1, tcolor2;

    guchar *outbuf = dest_buf + (gsize)dest_rowstride * i;
    guchar *outbuf_end = outbuf + dest_channels * (render_x1 - render_x0);

    if (((i + check_y) >> check_shift) & 1)
{
 tcolor1 = color2;
 tcolor2 = color1;
}
    else
{
 tcolor1 = color1;
 tcolor2 = color2;
}

    for (j=0; j<filter->y.n; j++)
{
 if (y_start <  0)
   line_bufs[j] = (guchar *)src_buf;
 else if (y_start < src_height)
   line_bufs[j] = (guchar *)src_buf + (gsize)src_rowstride * y_start;
 else
   line_bufs[j] = (guchar *)src_buf + (gsize)src_rowstride * (src_height - 1);

 y_start++;
}

    dest_x = check_x;
    x = render_x0 * x_step + scaled_x_offset;
    x_start = x >> SCALE_SHIFT16;

    while (x_start < 0 && outbuf < outbuf_end)
{
 process_pixel (run_weights + ((x >> (SCALE_SHIFT16 - SUBSAMPLE_BITS4)) & SUBSAMPLE_MASK((1 << 4)-1)) * (filter->x.n * filter->y.n), filter->x.n, filter->y.n,
	 outbuf, dest_x, dest_channels, dest_has_alpha,
	 line_bufs, src_channels, src_has_alpha,
	 x >> SCALE_SHIFT16, src_width,
	 check_size, tcolor1, tcolor2, pixel_func);

 x += x_step;
 x_start = x >> SCALE_SHIFT16;
 dest_x++;
 outbuf += dest_channels;
}

    new_outbuf = (*line_func) (run_weights, filter->x.n, filter->y.n,
		 outbuf, dest_x, dest_buf + (gsize)dest_rowstride *
		 i + run_end_index * dest_channels,
		 dest_channels, dest_has_alpha,
		 line_bufs, src_channels, src_has_alpha,
		 x, x_step, src_width, check_size, tcolor1,
		 tcolor2);

    dest_x += (new_outbuf - outbuf) / dest_channels;

    x = (dest_x - check_x + render_x0) * x_step + scaled_x_offset;
    outbuf = new_outbuf;

    while (outbuf < outbuf_end)
{
 process_pixel (run_weights + ((x >> (SCALE_SHIFT16 - SUBSAMPLE_BITS4)) & SUBSAMPLE_MASK((1 << 4)-1)) * (filter->x.n * filter->y.n), filter->x.n, filter->y.n,
	 outbuf, dest_x, dest_channels, dest_has_alpha,
	 line_bufs, src_channels, src_has_alpha,
	 x >> SCALE_SHIFT16, src_width,
	 check_size, tcolor1, tcolor2, pixel_func);

 x += x_step;
 dest_x++;
 outbuf += dest_channels;
}

    y += y_step;
  }

g_free (line_bufs);
g_free (filter_weights);
1428}

1430/* Compute weights for reconstruction by replication followed by
* sampling with a box filter
*/
1433static gboolean
1434tile_make_weights (PixopsFilterDimension *dim,
   double                 scale)
1436{
int n = ceil (1 / scale + 1);
double *pixel_weights;
int offset;
int i;

pixel_weights = g_try_malloc_n (sizeof (double) * SUBSAMPLE(1 << 4), n);
if (pixel_weights == NULL((void*)0))
  return FALSE(0);

dim->n = n;
dim->offset = 0;
dim->weights = pixel_weights;

for (offset = 0; offset < SUBSAMPLE(1 << 4); offset++)
  {
    double x = (double)offset / SUBSAMPLE(1 << 4);
    double a = x + 1 / scale;

    for (i = 0; i < n; i++)
      {
        if (i < x)
          {
            if (i + 1 > x)
              *(pixel_weights++)  = (MIN (i + 1, a)(((i + 1) < (a)) ? (i + 1) : (a)) - x) * scale;
            else
              *(pixel_weights++) = 0;
          }
        else
          {
            if (a > i)
              *(pixel_weights++)  = (MIN (i + 1, a)(((i + 1) < (a)) ? (i + 1) : (a)) - i) * scale;
            else
              *(pixel_weights++) = 0;
          }
     }
  }

return TRUE(!(0));
1475}

1477/* Compute weights for a filter that, for minification
* is the same as 'tiles', and for magnification, is bilinear
* reconstruction followed by a sampling with a delta function.
*/
1481static gboolean
1482bilinear_magnify_make_weights (PixopsFilterDimension *dim,
	       double                 scale)
1484{
double *pixel_weights;
int n;
int offset;
int i;

if (scale > 1.0)            /* Linear */
  {
    n = 2;
    dim->offset = 0.5 * (1 / scale - 1);
  }
else                          /* Tile */
  {
    n = ceil (1.0 + 1.0 / scale);
    dim->offset = 0.0;
  }

dim->n = n;
dim->weights = g_try_malloc_n (sizeof (double) * SUBSAMPLE(1 << 4), n);
if (dim->weights == NULL((void*)0))
  return FALSE(0);

pixel_weights = dim->weights;

for (offset=0; offset < SUBSAMPLE(1 << 4); offset++)
  {
    double x = (double)offset / SUBSAMPLE(1 << 4);

    if (scale > 1.0)      /* Linear */
      {
        for (i = 0; i < n; i++)
          *(pixel_weights++) = (((i == 0) ? (1 - x) : x) / scale) * scale;
      }
    else                  /* Tile */
      {
        double a = x + 1 / scale;

        /*           x
         * ---------|--.-|----|--.-|-------  SRC
         * ------------|---------|---------  DEST
         */
        for (i = 0; i < n; i++)
          {
            if (i < x)
              {
                if (i + 1 > x)
                  *(pixel_weights++) = (MIN (i + 1, a)(((i + 1) < (a)) ? (i + 1) : (a)) - x) * scale;
                else
                  *(pixel_weights++) = 0;
              }
            else
              {
                if (a > i)
                  *(pixel_weights++) = (MIN (i + 1, a)(((i + 1) < (a)) ? (i + 1) : (a)) - i) * scale;
                else
                  *(pixel_weights++) = 0;
              }
          }
      }
  }

return TRUE(!(0));
1546}

1548/* Computes the integral from b0 to b1 of
*
* f(x) = x; 0 <= x < 1
* f(x) = 0; otherwise
*
* We combine two of these to compute the convolution of
* a box filter with a triangular spike.
*/
1556static double
1557linear_box_half (double b0, double b1)
1558{
double a0, a1;
double x0, x1;

a0 = 0.;
a1 = 1.;

if (a0 < b0)
  {
    if (a1 > b0)
      {
        x0 = b0;
        x1 = MIN (a1, b1)(((a1) < (b1)) ? (a1) : (b1));
      }
    else
      return 0;
  }
else
  {
    if (b1 > a0)
      {
        x0 = a0;
        x1 = MIN (a1, b1)(((a1) < (b1)) ? (a1) : (b1));
      }
    else
      return 0;
  }

return 0.5 * (x1*x1 - x0*x0);
1587}

1589/* Compute weights for reconstructing with bilinear
* interpolation, then sampling with a box filter
*/
1592static gboolean
1593bilinear_box_make_weights (PixopsFilterDimension *dim,
	   double                 scale)
1595{
int n = ceil (1/scale + 3.0);
double *pixel_weights;
double w;
int offset, i;

pixel_weights = g_malloc_n (sizeof (double) * SUBSAMPLE(1 << 4), n);
if (pixel_weights == NULL((void*)0))
  return FALSE(0);

dim->offset = -1.0;
dim->n = n;
dim->weights = pixel_weights;

for (offset = 0; offset < SUBSAMPLE(1 << 4); offset++)
  {
    double x = (double)offset / SUBSAMPLE(1 << 4);
    double a = x + 1 / scale;

    for (i = 0; i < n; i++)
      {
        w  = linear_box_half (0.5 + i - a, 0.5 + i - x);
        w += linear_box_half (1.5 + x - i, 1.5 + a - i);
    
        *(pixel_weights++) = w * scale;
      }
  }

return TRUE(!(0));
1624}

1626static gboolean
1627make_weights (PixopsFilter     *filter,
     PixopsInterpType  interp_type,	      
     double            scale_x,
     double            scale_y)
1631{
switch (interp_type)
  {
  case PIXOPS_INTERP_NEAREST:
  default:
    g_assert_not_reached ()do { g_assertion_message_expr (((gchar*) 0), "../cdk-pixbuf/pixops/pixops.c"
, 1636, ((const char*) (__func__)), ((void*)0)); } while (0);
    return FALSE(0);

  case PIXOPS_INTERP_TILES:
    if (!tile_make_weights (&filter->x, scale_x))
      return FALSE(0);
    if (!tile_make_weights (&filter->y, scale_y))
      {
        g_free (filter->x.weights);
        return FALSE(0);
      }
    return TRUE(!(0));
    
  case PIXOPS_INTERP_BILINEAR:
    if (!bilinear_magnify_make_weights (&filter->x, scale_x))
      return FALSE(0);
    if (!bilinear_magnify_make_weights (&filter->y, scale_y))
      {
        g_free (filter->x.weights);
        return FALSE(0);
      }
    return TRUE(!(0));
    
  case PIXOPS_INTERP_HYPER:
    if (!bilinear_box_make_weights (&filter->x, scale_x))
      return FALSE(0);
    if (!bilinear_box_make_weights (&filter->y, scale_y))
      {
        g_free (filter->x.weights);
        return FALSE(0);
      }
    return TRUE(!(0));
  }
1669}

1671/* Two-step scaler begins */

1673/* make_filter_table() bloats out in VM usage and consumes 100% CPU for
* tens of seconds when downscaling by a large factor.
* https://bugzilla.gnome.org/show_bug.cgi?id=80925
* We work round this by doing extreme reductions in two steps.
*
* The excessive CPU usage is accompanied by an excessive RAM usage because
* make_weights() allocates two arrays of weights proportional in size to
* n_x = (1 / scale_x + 3) and n_y = (1 / scale_y + 3),  then make_filter_table()
* allocates and fills an array of SUBSAMPLE * SUBSAMPLE * n_x * n_y doubles.
* Empirically, on machines with plenty of RAM, the execution time slopes upward
* when n_filters > 1000.
* SUBSAMPLE is 16 so each filter takes 16 x 16 doubles (8 bytes) = 2kb RAM.
* Limiting it to 1000 filters limits the scaler's RAM consumption to about 2MB
* which should be OK on machines with relatively little memory.
*
* CDK_INTER_BILINEAR, CDK_INTERP_TILES and CDK_INTER_HYPER all have
* similar symptoms; only CDK_INTERP_NEAREST does not need this trick.
**/
1691#define MAX_FILTERS1000 1000

1693/* Check whether prescaling is necessary to avoid the bug */
1694static gboolean
1695need_to_prescale (double           scale_x,
  double           scale_y,
  PixopsInterpType interp_type)
1698{
int n_x, n_y; /* See make_weights() */

/* The testsuite sets this to compare the results with and without it. */
if (g_getenv ("CDK_PIXBUF_DISABLE_TWO_STEP_SCALER"))
  return FALSE(0);

/* Calculate the number of weights created in make_weights() */
switch (interp_type) {
case PIXOPS_INTERP_HYPER:
  n_x = ceil (1 / scale_x + 3);
  n_y = ceil (1 / scale_y + 3);
  break;
case PIXOPS_INTERP_TILES:
case PIXOPS_INTERP_BILINEAR:
  n_x = ceil (1 / scale_x + 1);
  n_y = ceil (1 / scale_y + 1);
  break;
case PIXOPS_INTERP_NEAREST:
  /* Doesn't need the optimization */
  return FALSE(0);
default:
  g_assert_not_reached ()do { g_assertion_message_expr (((gchar*) 0), "../cdk-pixbuf/pixops/pixops.c"
, 1720, ((const char*) (__func__)), ((void*)0)); } while (0);
}

/* Limit the number of filters created by make_filter_table(). */
return (n_x * n_y > MAX_FILTERS1000);
1725}

1727/* Prescale the source image.
* If successful, it changes the source buffer's parameters to reflect the
* half-scaled image and the scaling factors to reflect the scaling left to do.
* It returns a pointer to the new image data or NULL, so that the caller knows
* whether they have to free the temporary buffer or not.
*/
1733static guchar *
1734prescale (const guchar     **src_bufp,
 int               *src_widthp,
 int               *src_heightp,
 int               *src_rowstridep,
 int                src_channels,
 gboolean           src_has_alpha,
 double            *scale_xp,
 double            *scale_yp,
 PixopsInterpType   interp_type)
1743{
/* Give local names to parameters that may be modified */
const guchar *src_buf = *src_bufp;
int           src_width = *src_widthp;
int           src_height = *src_heightp;
int           src_rowstride = *src_rowstridep;
double        scale_x = *scale_xp;
double        scale_y = *scale_yp;

/* How much we prescale each axis by */
double prescale_x, prescale_y;

/* The prescaled image */
int tmp_width, tmp_height;
int tmp_rowstride;
int tmp_channels;
gboolean tmp_has_alpha;
guchar *tmp_buf;

/* The time taken by make_filter_table() is roughly proportional to
 * 1/scale_x * 1/scale_y, i.e. to the area reduction factor, so we
 * reduce the image in two steps, each of which reduces the total area
 * by the same factor. */
prescale_x = sqrt (scale_x);
prescale_y = sqrt (scale_y);

/* Scale the whole source image into a top-left-aligned temporary pixbuf.
 * render_[xy][01] are done in the final scaling, not here, as they are
 * measured in the coordinate system of the scaled image. */
tmp_width = lrint (src_width * prescale_x);
tmp_height = lrint (src_height * prescale_y);

/* We are below the cdk_ interface, so create the temp image manually.
 * Code copied from cdk_pixbuf_new() */
tmp_channels = src_channels;
tmp_has_alpha = src_has_alpha;
tmp_rowstride = ((tmp_width * tmp_channels) + 3) & ~3;
tmp_buf = g_try_malloc_n (tmp_height, tmp_rowstride);
if (!tmp_buf)
  return NULL((void*)0); /* Skip the prescaling */

/* Prescale to an intermediate size */
_pixops_scale (tmp_buf, tmp_width, tmp_height, tmp_rowstride,
 tmp_channels, tmp_has_alpha, src_buf, src_width,
 src_height, src_rowstride, src_channels, src_has_alpha,
 0, 0, tmp_width, tmp_height, 0.0, 0.0,
 prescale_x, prescale_y,
 interp_type);

/* The second call to the scaler reads from the prescaled image */
*src_bufp = tmp_buf;
*src_widthp = tmp_width;
*src_heightp = tmp_height;
*src_rowstridep = tmp_rowstride;

/* Calculate how much scaling is left to do */
*scale_xp /= prescale_x;
*scale_yp /= prescale_y;

return tmp_buf;
1803}
1804/* End of two-step scaler */

1806static void
1807_pixops_composite_color_real (guchar          *dest_buf,
	      int              render_x0,
	      int              render_y0,
	      int              render_x1,
	      int              render_y1,
	      int              dest_rowstride,
	      int              dest_channels,
	      gboolean         dest_has_alpha,
	      const guchar    *src_buf,
	      int              src_width,
	      int              src_height,
	      int              src_rowstride,
	      int              src_channels,
	      gboolean         src_has_alpha,
	      double           scale_x,
	      double           scale_y,
	      PixopsInterpType interp_type,
	      int              overall_alpha,
	      int              check_x,
	      int              check_y,
	      int              check_size,
	      guint32          color1,
	      guint32          color2)
1830{
PixopsFilter filter;
PixopsLineFunc line_func;
guchar *tmp_buf = NULL((void*)0);

g_return_if_fail (!(dest_channels == 3 && dest_has_alpha))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_23
 = 0; if (!(dest_channels == 3 && dest_has_alpha)) _g_boolean_var_23
 = 1; _g_boolean_var_23; }), 1))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "!(dest_channels == 3 && dest_has_alpha)"
); return; } } while (0);
g_return_if_fail (!(src_channels == 3 && src_has_alpha))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_24
 = 0; if (!(src_channels == 3 && src_has_alpha)) _g_boolean_var_24
 = 1; _g_boolean_var_24; }), 1))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "!(src_channels == 3 && src_has_alpha)"
); return; } } while (0);

if (scale_x == 0 || scale_y == 0)
  return;

if (interp_type == PIXOPS_INTERP_NEAREST)
  {
    pixops_composite_color_nearest (dest_buf, render_x0, render_y0,
		      render_x1, render_y1, dest_rowstride,
		      dest_channels, dest_has_alpha, src_buf,
		      src_width, src_height, src_rowstride,
		      src_channels, src_has_alpha, scale_x,
		      scale_y, overall_alpha, check_x, check_y,
		      check_size, color1, color2);
    return;
  }

if (need_to_prescale (scale_x, scale_y, interp_type))
  tmp_buf = prescale (&src_buf, &src_width, &src_height, &src_rowstride,
	src_channels, src_has_alpha,
	&scale_x, &scale_y, interp_type);

filter.overall_alpha = overall_alpha / 255.;
if (!make_weights (&filter, interp_type, scale_x, scale_y))
  goto free_tmp;

line_func = composite_line_color;

pixops_process (dest_buf, render_x0, render_y0, render_x1, render_y1,
  dest_rowstride, dest_channels, dest_has_alpha,
  src_buf, src_width, src_height, src_rowstride, src_channels,
  src_has_alpha, scale_x, scale_y, check_x, check_y, check_size, color1, color2,
  &filter, line_func, composite_pixel_color);

g_free (filter.x.weights);
g_free (filter.y.weights);
1872free_tmp:
g_free (tmp_buf);
1874}

1876void
1877_pixops_composite_color (guchar          *dest_buf,
	 int              dest_width,
	 int              dest_height,
	 int              dest_rowstride,
	 int              dest_channels,
	 gboolean         dest_has_alpha,
	 const guchar    *src_buf,
	 int              src_width,
	 int              src_height,
	 int              src_rowstride,
	 int              src_channels,
	 gboolean         src_has_alpha,
	 int              dest_x,
	 int              dest_y,
	 int              dest_region_width,
	 int              dest_region_height,
	 double           offset_x,
	 double           offset_y,
	 double           scale_x,
	 double           scale_y,
	 PixopsInterpType interp_type,
	 int              overall_alpha,
	 int              check_x,
	 int              check_y,
	 int              check_size,
	 guint32          color1,
	 guint32          color2)
1904{
guchar *new_dest_buf;
int render_x0;
int render_y0;
int render_x1;
int render_y1;

if (!src_has_alpha && overall_alpha == 255)
  {
    _pixops_scale (dest_buf, dest_width, dest_height, dest_rowstride,
     dest_channels, dest_has_alpha, src_buf, src_width,
     src_height, src_rowstride, src_channels, src_has_alpha,
     dest_x, dest_y, dest_region_width, dest_region_height,
     offset_x, offset_y, scale_x, scale_y, interp_type);
    return;
  }

new_dest_buf = dest_buf + dest_y * dest_rowstride + dest_x *
               dest_channels;
render_x0 = dest_x - offset_x;
render_y0 = dest_y - offset_y;
render_x1 = dest_x + dest_region_width  - offset_x;
render_y1 = dest_y + dest_region_height - offset_y;

_pixops_composite_color_real (new_dest_buf, render_x0, render_y0, render_x1,
		render_y1, dest_rowstride, dest_channels,
		dest_has_alpha, src_buf, src_width,
		src_height, src_rowstride, src_channels,
		src_has_alpha, scale_x, scale_y,
		(PixopsInterpType)interp_type, overall_alpha,
		check_x, check_y, check_size, color1, color2);
1935}

1937/**
* _pixops_composite_real:
* @dest_buf: pointer to location to store result
* @render_x0: x0 of region of scaled source to store into @dest_buf
* @render_y0: y0 of region of scaled source to store into @dest_buf
* @render_x1: x1 of region of scaled source to store into @dest_buf
* @render_y1: y1 of region of scaled source to store into @dest_buf
* @dest_rowstride: rowstride of @dest_buf
* @dest_channels: number of channels in @dest_buf
* @dest_has_alpha: whether @dest_buf has alpha
* @src_buf: pointer to source pixels
* @src_width: width of source (used for clipping)
* @src_height: height of source (used for clipping)
* @src_rowstride: rowstride of source
* @src_channels: number of channels in @src_buf
* @src_has_alpha: whether @src_buf has alpha
* @scale_x: amount to scale source by in X direction
* @scale_y: amount to scale source by in Y direction
* @interp_type: type of enumeration
* @overall_alpha: overall alpha factor to multiply source by
* 
* Scale source buffer by scale_x / scale_y, then composite a given rectangle
* of the result into the destination buffer.
**/
1961static void
1962_pixops_composite_real (guchar          *dest_buf,
	int              render_x0,
	int              render_y0,
	int              render_x1,
	int              render_y1,
	int              dest_rowstride,
	int              dest_channels,
	gboolean         dest_has_alpha,
	const guchar    *src_buf,
	int              src_width,
	int              src_height,
	int              src_rowstride,
	int              src_channels,
	gboolean         src_has_alpha,
	double           scale_x,
	double           scale_y,
	PixopsInterpType interp_type,
	int              overall_alpha)
1980{
PixopsFilter filter;
PixopsLineFunc line_func;
guchar *tmp_buf = NULL((void*)0);

g_return_if_fail (!(dest_channels == 3 && dest_has_alpha))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_25
 = 0; if (!(dest_channels == 3 && dest_has_alpha)) _g_boolean_var_25
 = 1; _g_boolean_var_25; }), 1))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "!(dest_channels == 3 && dest_has_alpha)"
); return; } } while (0);
g_return_if_fail (!(src_channels == 3 && src_has_alpha))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_26
 = 0; if (!(src_channels == 3 && src_has_alpha)) _g_boolean_var_26
 = 1; _g_boolean_var_26; }), 1))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "!(src_channels == 3 && src_has_alpha)"
); return; } } while (0);

if (scale_x == 0 || scale_y == 0)
  return;

if (interp_type == PIXOPS_INTERP_NEAREST)
  {
    if (scale_x == 1.0 && scale_y == 1.0)
pixops_composite_nearest_noscale (dest_buf, render_x0, render_y0, render_x1, render_y1,
			  dest_rowstride, dest_channels, dest_has_alpha,
			  src_buf, src_width, src_height, src_rowstride, src_channels,
			  src_has_alpha, overall_alpha);
    else
pixops_composite_nearest (dest_buf, render_x0, render_y0, render_x1, render_y1,
		  dest_rowstride, dest_channels, dest_has_alpha,
		  src_buf, src_width, src_height, src_rowstride, src_channels,
		  src_has_alpha, scale_x, scale_y, overall_alpha);
    return;
  }

if (need_to_prescale (scale_x, scale_y, interp_type))
  tmp_buf = prescale (&src_buf, &src_width, &src_height, &src_rowstride,
	src_channels, src_has_alpha,
	&scale_x, &scale_y, interp_type);

filter.overall_alpha = overall_alpha / 255.;
if (!make_weights (&filter, interp_type, scale_x, scale_y))
  goto free_tmp;

if (filter.x.n == 2 && filter.y.n == 2 && dest_channels == 4 &&
    src_channels == 4 && src_has_alpha && !dest_has_alpha)
  line_func = composite_line_22_4a4;
else
  line_func = composite_line;

pixops_process (dest_buf, render_x0, render_y0, render_x1, render_y1,
  dest_rowstride, dest_channels, dest_has_alpha,
  src_buf, src_width, src_height, src_rowstride, src_channels,
  src_has_alpha, scale_x, scale_y, 0, 0, 0, 0, 0, 
  &filter, line_func, composite_pixel);

g_free (filter.x.weights);
g_free (filter.y.weights);
2029free_tmp:
g_free (tmp_buf);
2031}

2033void
2034_pixops_composite (guchar          *dest_buf,
                 int              dest_width,
                 int              dest_height,
                 int              dest_rowstride,
                 int              dest_channels,
                 int              dest_has_alpha,
                 const guchar    *src_buf,
                 int              src_width,
                 int              src_height,
                 int              src_rowstride,
                 int              src_channels,
                 int              src_has_alpha,
                 int              dest_x,
                 int              dest_y,
                 int              dest_region_width,
                 int              dest_region_height,
                 double           offset_x,
                 double           offset_y,
                 double           scale_x,
                 double           scale_y,
                 PixopsInterpType interp_type,
                 int              overall_alpha)
2056{
guchar *new_dest_buf;
int render_x0;
int render_y0;
int render_x1;
int render_y1;

if (!src_has_alpha && overall_alpha == 255)
  {
    _pixops_scale (dest_buf, dest_width, dest_height, dest_rowstride,
     dest_channels, dest_has_alpha, src_buf, src_width,
     src_height, src_rowstride, src_channels, src_has_alpha,
     dest_x, dest_y, dest_region_width, dest_region_height,
     offset_x, offset_y, scale_x, scale_y, interp_type);
    return;
  }

2073#ifdef USE_MEDIALIB
pixops_medialib_composite (dest_buf, dest_width, dest_height, dest_rowstride,
                           dest_channels, dest_has_alpha, src_buf,
                           src_width, src_height, src_rowstride,
                           src_channels, src_has_alpha, dest_x, dest_y,
                           dest_region_width, dest_region_height, offset_x,
	     offset_y, scale_x, scale_y,
                           (PixopsInterpType)interp_type, overall_alpha);
return;
2082#endif

new_dest_buf = dest_buf + (gsize)dest_y * dest_rowstride + (gsize)dest_x * dest_channels;
render_x0 = dest_x - offset_x;
render_y0 = dest_y - offset_y;
render_x1 = dest_x + dest_region_width  - offset_x;
render_y1 = dest_y + dest_region_height - offset_y;

_pixops_composite_real (new_dest_buf, render_x0, render_y0, render_x1,
	  render_y1, dest_rowstride, dest_channels,
	  dest_has_alpha, src_buf, src_width, src_height,
	  src_rowstride, src_channels, src_has_alpha, scale_x,
	  scale_y, (PixopsInterpType)interp_type,
	  overall_alpha);
2096}

2098#ifdef USE_MEDIALIB
2099static void
2100medialib_get_interpolation (mlInterp * ml_interp,
                          PixopsInterpType interp_type,
                          double scale_x,
                          double scale_y,
                          double overall_alpha)
2105{
mlib_s32 leftPadding, topPadding;
ml_interp->interp_table = NULL((void*)0);

/*
* medialib 2.1 and later supports scaling with user-defined interpolation
* tables, so this logic is used.  
*
* bilinear_magnify_make_weights builds an interpolation table of size 2x2 if
* the scale factor >= 1.0 and "ceil (1.0 + 1.0/scale)" otherwise.  These map
* most closely to MLIB_BILINEAR, which uses an interpolation table of size
* 2x2.
*
* tile_make_weights builds an interpolation table of size 2x2 if the scale
* factor >= 1.0 and "ceil (1.0 + 1.0/scale)" otherwise.  These map most
* closely to MLIB_BILINEAR, which uses an interpolation table of size 2x2.
*
* bilinear_box_make_weights builds an interpolation table of size 4x4 if the
* scale factor >= 1.0 and "ceil (1.0 + 1.0/scale)" otherwise.  These map most
* closely to MLIB_BICUBIC, which uses an interpolation table of size 4x4.
*
* PIXOPS_INTERP_NEAREST calls pixops_scale_nearest which does not use an
* interpolation table.  This maps to MLIB_NEAREST.
*/
switch (interp_type)
  {
  case PIXOPS_INTERP_BILINEAR:
    bilinear_magnify_make_weights (&(ml_interp->po_filter.x), scale_x);
    bilinear_magnify_make_weights (&(ml_interp->po_filter.y), scale_y);
    leftPadding = 0;
    topPadding  = 0;

    if (scale_x <= 1.0)
        ml_interp->tx = 0.5 * (1 - scale_x);
    else
        ml_interp->tx = 0.0;

    if (scale_y <= 1.0)
        ml_interp->ty = 0.5 * (1 - scale_y);
    else
        ml_interp->ty = 0.0;

    break;

  case PIXOPS_INTERP_TILES:
    tile_make_weights (&(ml_interp->po_filter.x), scale_x);
    tile_make_weights (&(ml_interp->po_filter.y), scale_y);
    leftPadding   = 0;
    topPadding    = 0;
    ml_interp->tx = 0.5 * (1 - scale_x);
    ml_interp->ty = 0.5 * (1 - scale_y);
    break;

  case PIXOPS_INTERP_HYPER:
    bilinear_box_make_weights (&(ml_interp->po_filter.x), scale_x);
    bilinear_box_make_weights (&(ml_interp->po_filter.y), scale_y);
    leftPadding   = 1;
    topPadding    = 1;
    ml_interp->tx = 0.5 * (1 - scale_x);
    ml_interp->ty = 0.5 * (1 - scale_y);
    break;

  case PIXOPS_INTERP_NEAREST:
  default:
    /*
     * Note that this function should not be called in the
     * PIXOPS_INTERP_NEAREST case since it does not use an interpolation
     * table.
     */
    g_assert_not_reached ()do { g_assertion_message_expr (((gchar*) 0), "../cdk-pixbuf/pixops/pixops.c"
, 2174, ((const char*) (__func__)), ((void*)0)); } while (0);
    break;
  }

/* 
* If overall_alpha is not 1.0, then multiply the vectors built by the
* sqrt (overall_alpha).  This will cause overall_alpha to get evenly
* blended across both axis.
*
* Note there is no need to multiply the vectors built by the various
* make-weight functions by sqrt (overall_alpha) since the make-weight
* functions are called with overall_alpha hardcoded to 1.0.
*/
if (overall_alpha != 1.0)
  {
    double sqrt_alpha = sqrt (overall_alpha);
    int i;

    for (i=0; i < SUBSAMPLE(1 << 4) * ml_interp->po_filter.x.n; i++)
       ml_interp->po_filter.x.weights[i] *= sqrt_alpha;
    for (i=0; i < SUBSAMPLE(1 << 4) * ml_interp->po_filter.y.n; i++)
       ml_interp->po_filter.y.weights[i] *= sqrt_alpha;
  }
  
ml_interp->interp_table = (void *) mlib_ImageInterpTableCreate (MLIB_DOUBLE,
  ml_interp->po_filter.x.n, ml_interp->po_filter.y.n, leftPadding,
  topPadding, SUBSAMPLE_BITS4, SUBSAMPLE_BITS4, 8,
  ml_interp->po_filter.x.weights, ml_interp->po_filter.y.weights);

g_free (ml_interp->po_filter.x.weights);
g_free (ml_interp->po_filter.y.weights);  
2205}

2207static void
2208pixops_medialib_composite (guchar          *dest_buf,
                         int              dest_width,
                         int              dest_height,
                         int              dest_rowstride,
                         int              dest_channels,
                         int              dest_has_alpha,
                         const guchar    *src_buf,
                         int              src_width,
                         int              src_height,
                         int              src_rowstride,
                         int              src_channels,
                         int              src_has_alpha,
                         int              dest_x,
                         int              dest_y,
                         int              dest_region_width,
                         int              dest_region_height,
                         double           offset_x,
                         double           offset_y,
                         double           scale_x,
                         double           scale_y,
                         PixopsInterpType interp_type,
                         int              overall_alpha)
2230{
mlib_blend blend;
g_return_if_fail (!(dest_channels == 3 && dest_has_alpha))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_27
 = 0; if (!(dest_channels == 3 && dest_has_alpha)) _g_boolean_var_27
 = 1; _g_boolean_var_27; }), 1))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "!(dest_channels == 3 && dest_has_alpha)"
); return; } } while (0);
g_return_if_fail (!(src_channels == 3 && src_has_alpha))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_28
 = 0; if (!(src_channels == 3 && src_has_alpha)) _g_boolean_var_28
 = 1; _g_boolean_var_28; }), 1))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "!(src_channels == 3 && src_has_alpha)"
); return; } } while (0);

if (scale_x == 0 || scale_y == 0)
  return;

if (!medialib_initialized)
  _pixops_use_medialib ();

if (!use_medialib)
  {
    /* Use non-mediaLib version */
    _pixops_composite_real (dest_buf + (gsize)dest_y * dest_rowstride + (gsize)dest_x *
	      dest_channels, dest_x - offset_x, dest_y -
	      offset_y, dest_x + dest_region_width - offset_x,
	      dest_y + dest_region_height - offset_y,
	      dest_rowstride, dest_channels, dest_has_alpha,
	      src_buf, src_width, src_height, src_rowstride,
	      src_channels, src_has_alpha, scale_x, scale_y,
	      interp_type, overall_alpha);
  }
else
  {
    mlInterp ml_interp;
    mlib_image img_src, img_dest;
    double ml_offset_x, ml_offset_y;

    if (!src_has_alpha && overall_alpha == 255 &&
 dest_channels <= src_channels) 
      {
        pixops_medialib_scale (dest_buf, dest_region_width,
		 dest_region_height, dest_rowstride,
		 dest_channels, dest_has_alpha, src_buf,
		 src_width, src_height, src_rowstride,
		 src_channels, src_has_alpha, dest_x, dest_y,
		 dest_region_width, dest_region_height,
		 offset_x, offset_y, scale_x, scale_y,
		 interp_type);
        return;
      }

    mlib_ImageSetStruct (&img_src, MLIB_BYTE, src_channels,
	   src_width, src_height, src_rowstride, src_buf);

    if (dest_x == 0 && dest_y == 0 &&
        dest_width  == dest_region_width &&
        dest_height == dest_region_height)
      {
        mlib_ImageSetStruct (&img_dest, MLIB_BYTE, dest_channels,
	       dest_width, dest_height, dest_rowstride,
	       dest_buf);
      }
    else
      {
 mlib_u8 *data = dest_buf + (gsize)dest_y * dest_rowstride +
		     (gsize)dest_x * dest_channels;

        mlib_ImageSetStruct (&img_dest, MLIB_BYTE, dest_channels,
	       dest_region_width, dest_region_height,
	       dest_rowstride, data);
      }

    ml_offset_x = floor (offset_x) - dest_x;
    ml_offset_y = floor (offset_y) - dest_y;

    if (interp_type == PIXOPS_INTERP_NEAREST)
      {
        blend = src_has_alpha ? MLIB_BLEND_CTK_SRC_OVER2 : MLIB_BLEND_CTK_SRC;

        mlib_ImageZoomTranslateBlend (&img_dest,
                                      &img_src,
                                      scale_x,
                                      scale_y,
                                      ml_offset_x,
                                      ml_offset_y,
                                      MLIB_NEAREST,
                                      MLIB_EDGE_SRC_EXTEND_INDEF,
                                      blend,
                                      overall_alpha,
                                      1);
      }
    else
      {
        blend = src_has_alpha ? MLIB_BLEND_CTK_SRC_OVER : MLIB_BLEND_CTK_SRC;

        if (interp_type == PIXOPS_INTERP_BILINEAR &&
     scale_x > 1.0 && scale_y > 1.0)
          {
            mlib_ImageZoomTranslateBlend (&img_dest,
                                          &img_src,
                                          scale_x,
                                          scale_y,
                                          ml_offset_x,
                                          ml_offset_y,
                                          MLIB_BILINEAR,
                                          MLIB_EDGE_SRC_EXTEND_INDEF,
                                          blend,
                                          overall_alpha,
                                          1);
          }
        else
          {
            medialib_get_interpolation (&ml_interp, interp_type, scale_x,
			  scale_y, overall_alpha/255.0);

            if (ml_interp.interp_table != NULL((void*)0))
              {
                mlib_ImageZoomTranslateTableBlend (&img_dest,
                                                   &img_src,
                                                   scale_x,
                                                   scale_y,
                                                   ml_offset_x + ml_interp.tx,
                                                   ml_offset_y + ml_interp.ty,
                                                   ml_interp.interp_table,
                                                   MLIB_EDGE_SRC_EXTEND_INDEF,
                                                   blend,
                                                   1);
                mlib_ImageInterpTableDelete (ml_interp.interp_table);
              }
            else
              {
                /* Should not happen - Use non-mediaLib version */
                _pixops_composite_real (dest_buf + (gsize)dest_y * dest_rowstride +
                                        (gsize)dest_x * dest_channels,
                                        dest_x - offset_x, dest_y - offset_y,
                                        dest_x + dest_region_width - offset_x,
                                        dest_y + dest_region_height - offset_y,
                                        dest_rowstride, dest_channels,
                                        dest_has_alpha, src_buf, src_width,
                                        src_height, src_rowstride,
                                        src_channels, src_has_alpha, scale_x,
                                        scale_y, interp_type, overall_alpha);
              }
          }
      }
  }
2368}
2369#endif

2371static void
2372_pixops_scale_real (guchar        *dest_buf,
    int            render_x0,
    int            render_y0,
    int            render_x1,
    int            render_y1,
    int            dest_rowstride,
    int            dest_channels,
    gboolean       dest_has_alpha,
    const guchar  *src_buf,
    int            src_width,
    int            src_height,
    int            src_rowstride,
    int            src_channels,
    gboolean       src_has_alpha,
    double         scale_x,
    double         scale_y,
    PixopsInterpType  interp_type)
2389{
PixopsFilter filter;
PixopsLineFunc line_func;
guchar *tmp_buf = NULL((void*)0);	/* Temporary image for two-step scaling */

g_return_if_fail (!(dest_channels == 3 && dest_has_alpha))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_29
 = 0; if (!(dest_channels == 3 && dest_has_alpha)) _g_boolean_var_29
 = 1; _g_boolean_var_29; }), 1))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "!(dest_channels == 3 && dest_has_alpha)"
); return; } } while (0);
g_return_if_fail (!(src_channels == 3 && src_has_alpha))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_30
 = 0; if (!(src_channels == 3 && src_has_alpha)) _g_boolean_var_30
 = 1; _g_boolean_var_30; }), 1))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "!(src_channels == 3 && src_has_alpha)"
); return; } } while (0);
g_return_if_fail (!(src_has_alpha && !dest_has_alpha))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_31
 = 0; if (!(src_has_alpha && !dest_has_alpha)) _g_boolean_var_31
 = 1; _g_boolean_var_31; }), 1))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "!(src_has_alpha && !dest_has_alpha)"
); return; } } while (0);

if (scale_x == 0 || scale_y == 0)
  return;

if (interp_type == PIXOPS_INTERP_NEAREST)
  {
    pixops_scale_nearest (dest_buf, render_x0, render_y0, render_x1,
	    render_y1, dest_rowstride, dest_channels,
	    dest_has_alpha, src_buf, src_width, src_height,
	    src_rowstride, src_channels, src_has_alpha,
	    scale_x, scale_y);
    return;
  }

if (need_to_prescale (scale_x, scale_y, interp_type))
  tmp_buf = prescale (&src_buf, &src_width, &src_height, &src_rowstride,
	src_channels, src_has_alpha,
	&scale_x, &scale_y, interp_type);

filter.overall_alpha = 1.0;
if (!make_weights (&filter, interp_type, scale_x, scale_y))
  goto free_tmp;

if (filter.x.n == 2 && filter.y.n == 2 && dest_channels == 3 && src_channels == 3)
  line_func = scale_line_22_33;
else
  line_func = scale_line;

pixops_process (dest_buf, render_x0, render_y0, render_x1, render_y1,
  dest_rowstride, dest_channels, dest_has_alpha,
  src_buf, src_width, src_height, src_rowstride, src_channels,
  src_has_alpha, scale_x, scale_y, 0, 0, 0, 0, 0,
  &filter, line_func, scale_pixel);

g_free (filter.x.weights);
g_free (filter.y.weights);
2433free_tmp:
g_free (tmp_buf);
2435}

2437void
2438_pixops_scale (guchar          *dest_buf,
             int              dest_width,
             int              dest_height,
             int              dest_rowstride,
             int              dest_channels,
             int              dest_has_alpha,
             const guchar    *src_buf,
             int              src_width,
             int              src_height,
             int              src_rowstride,
             int              src_channels,
             int              src_has_alpha,
             int              dest_x,
             int              dest_y,
             int              dest_region_width,
             int              dest_region_height,
             double           offset_x,
             double           offset_y,
             double           scale_x,
             double           scale_y,
             PixopsInterpType interp_type)
2459{
guchar *new_dest_buf;
int render_x0;
int render_y0;
int render_x1;
int render_y1;

2466#ifdef USE_MEDIALIB
pixops_medialib_scale (dest_buf, dest_width, dest_height, dest_rowstride,
                       dest_channels, dest_has_alpha, src_buf, src_width,
                       src_height, src_rowstride, src_channels,
                       src_has_alpha, dest_x, dest_y, dest_region_width,
	 dest_region_height, offset_x, offset_y, scale_x,
	 scale_y, (PixopsInterpType)interp_type);
return;
2474#endif

new_dest_buf = dest_buf + (gsize)dest_y * dest_rowstride + (gsize)dest_x * dest_channels;
render_x0    = dest_x - offset_x;
render_y0    = dest_y - offset_y;
render_x1    = dest_x + dest_region_width  - offset_x;
render_y1    = dest_y + dest_region_height - offset_y;

_pixops_scale_real (new_dest_buf, render_x0, render_y0, render_x1,
                    render_y1, dest_rowstride, dest_channels,
                    dest_has_alpha, src_buf, src_width, src_height,
                    src_rowstride, src_channels, src_has_alpha,
                    scale_x, scale_y, (PixopsInterpType)interp_type);
2487}

2489#ifdef USE_MEDIALIB
2490static void
2491pixops_medialib_scale     (guchar          *dest_buf,
                         int              dest_width,
                         int              dest_height,
                         int              dest_rowstride,
                         int              dest_channels,
                         int              dest_has_alpha,
                         const guchar    *src_buf,
                         int              src_width,
                         int              src_height,
                         int              src_rowstride,
                         int              src_channels,
                         int              src_has_alpha,
                         int              dest_x,
                         int              dest_y,
                         int              dest_region_width,
                         int              dest_region_height,
                         double           offset_x,
                         double           offset_y,
                         double           scale_x,
                         double           scale_y,
                         PixopsInterpType interp_type)
2512{
if (scale_x == 0 || scale_y == 0)
  return;

if (!medialib_initialized)
  _pixops_use_medialib ();

/*
 * We no longer support mediaLib 2.1 because it has a core dumping problem
 * in the mlib_ImageZoomTranslateTable function that has been corrected in
 * 2.2.  Although the mediaLib_zoom function could be used, it does not
 * work properly if the source and destination images have different 
 * values for "has_alpha" or "num_channels".  The complicated if-logic
 * required to support both versions is not worth supporting
 * mediaLib 2.1 moving forward.
 */
if (!use_medialib)
  {
    _pixops_scale_real (dest_buf + (gsize)dest_y * dest_rowstride + (gsize)dest_x *
	  dest_channels, dest_x - offset_x, dest_y - offset_y,
	  dest_x + dest_region_width - offset_x,
	  dest_y + dest_region_height - offset_y,
	  dest_rowstride, dest_channels, dest_has_alpha,
	  src_buf, src_width, src_height, src_rowstride,
	  src_channels, src_has_alpha, scale_x, scale_y,
	  interp_type);
  }
else 
  {
    mlInterp ml_interp;
    mlib_image img_orig_src, img_src, img_dest;
    double ml_offset_x, ml_offset_y;
    guchar *tmp_buf = NULL((void*)0);

    mlib_ImageSetStruct (&img_orig_src, MLIB_BYTE, src_channels, src_width, 
	   src_height, src_rowstride, src_buf);

    if (dest_x == 0 && dest_y == 0 &&
        dest_width == dest_region_width &&
        dest_height == dest_region_height)
      {
        mlib_ImageSetStruct (&img_dest, MLIB_BYTE, dest_channels,
	       dest_width, dest_height, dest_rowstride,
	       dest_buf);
      }
    else
      {
 mlib_u8 *data = dest_buf + (gsize)dest_y * dest_rowstride +
		     (gsize)dest_x * dest_channels;

        mlib_ImageSetStruct (&img_dest, MLIB_BYTE, dest_channels,
	       dest_region_width, dest_region_height,
	       dest_rowstride, data);
      }

    ml_offset_x = floor (offset_x) - dest_x;
    ml_offset_y = floor (offset_y) - dest_y;

   /*
    * Note that zoomTranslate and zoomTranslateTable are faster
    * than zoomTranslateBlend and zoomTranslateTableBlend.  However
    * the faster functions only work in the following case:
    *
    *   if (src_channels == dest_channels &&
    *       (!src_alpha && interp_table != PIXOPS_INTERP_NEAREST))
    *
    * We use the faster versions if we can.
    *
    * Note when the interp_type is BILINEAR and the interpolation
    * table will be size 2x2 (when both x/y scale factors > 1.0),
    * then we do not bother building the interpolation table.   In
    * this case we can just use MLIB_BILINEAR, which is faster than
    * using a specified interpolation table.
    */
    img_src = img_orig_src;

    if (!src_has_alpha)
      {
        if (src_channels > dest_channels)
          {
            int channels  = 3;
            int rowstride = (channels * src_width + 3) & ~3;
      
            tmp_buf = g_malloc_n (src_rowstride, src_height);

            if (src_buf != NULL((void*)0))
              {
                src_channels  = channels;
                src_rowstride = rowstride;
        
                mlib_ImageSetStruct (&img_src, MLIB_BYTE, src_channels,
		       src_width, src_height, src_rowstride,
		       tmp_buf);
                mlib_ImageChannelExtract (&img_src, &img_orig_src, 0xE);  
              }
          }
      }
  
    if (interp_type == PIXOPS_INTERP_NEAREST)
      {
        if (src_channels == dest_channels)
          {
            mlib_ImageZoomTranslate (&img_dest,
                                     &img_src,
                                     scale_x,
                                     scale_y,
                                     ml_offset_x,
                                     ml_offset_y,
                                     MLIB_NEAREST,
                                     MLIB_EDGE_SRC_EXTEND_INDEF);
          }
        else
          {
            mlib_ImageZoomTranslateBlend (&img_dest,
                                          &img_src,
                                          scale_x,
                                          scale_y,
                                          ml_offset_x,
                                          ml_offset_y,
                                          MLIB_NEAREST,
                                          MLIB_EDGE_SRC_EXTEND_INDEF,
                                          MLIB_BLEND_CTK_SRC,
                                          1.0,
                                          1);
          }
      }
    else if (src_channels == dest_channels && !src_has_alpha)
      {
        if (interp_type == PIXOPS_INTERP_BILINEAR &&
            scale_x > 1.0 && scale_y > 1.0)
          {
             mlib_ImageZoomTranslate (&img_dest,
                                      &img_src,
                                      scale_x,
                                      scale_y,
                                      ml_offset_x,
                                      ml_offset_y,
                                      MLIB_BILINEAR,
                                      MLIB_EDGE_SRC_EXTEND_INDEF);
          }
        else
          {
            medialib_get_interpolation (&ml_interp, interp_type,
                                        scale_x, scale_y, 1.0);

            if (ml_interp.interp_table != NULL((void*)0))
              {
                mlib_ImageZoomTranslateTable (&img_dest, 
                                              &img_src,
                                              scale_x,
                                              scale_y,
                                              ml_offset_x + ml_interp.tx,
                                              ml_offset_y + ml_interp.ty,
                                              ml_interp.interp_table,
                                              MLIB_EDGE_SRC_EXTEND_INDEF);

         mlib_ImageInterpTableDelete (ml_interp.interp_table);
              }
            else
              {
                /* Should not happen. */
                mlib_filter  ml_filter;

                switch (interp_type)
                  {
                  case PIXOPS_INTERP_BILINEAR:
                    ml_filter = MLIB_BILINEAR;
                    break;

                  case PIXOPS_INTERP_TILES:
                    ml_filter = MLIB_BILINEAR;
                    break;

                  case PIXOPS_INTERP_HYPER:
                    ml_filter = MLIB_BICUBIC;
                    break;
                  }

                mlib_ImageZoomTranslate (&img_dest,
                                         &img_src,
                                         scale_x,
                                         scale_y,
                                         ml_offset_x,
                                         ml_offset_y,
                                         ml_filter,
                                         MLIB_EDGE_SRC_EXTEND_INDEF);
              }
          }
      }

    /* Deal with case where src_channels != dest_channels || src_has_alpha */
    else if (interp_type == PIXOPS_INTERP_BILINEAR &&
             scale_x > 1.0 && scale_y > 1.0)
      {
        mlib_ImageZoomTranslateBlend (&img_dest,
                                      &img_src,
                                      scale_x,
                                      scale_y,
                                      ml_offset_x,
                                      ml_offset_y,
                                      MLIB_BILINEAR,
                                      MLIB_EDGE_SRC_EXTEND_INDEF,
                                      MLIB_BLEND_CTK_SRC,
                                      1.0,
                                      1);
      }
    else
      {
        medialib_get_interpolation (&ml_interp, interp_type,
                                    scale_x, scale_y, 1.0);

        if (ml_interp.interp_table != NULL((void*)0))
          {
            mlib_ImageZoomTranslateTableBlend (&img_dest,
                                               &img_src,
                                               scale_x,
                                               scale_y,
                                               ml_offset_x + ml_interp.tx,
                                               ml_offset_y + ml_interp.ty,
                                               ml_interp.interp_table,
                                               MLIB_EDGE_SRC_EXTEND_INDEF,
                                               MLIB_BLEND_CTK_SRC,
                                               1);
            mlib_ImageInterpTableDelete (ml_interp.interp_table);
          }
        else
          {
            mlib_filter  ml_filter;

            switch (interp_type)
              {
              case PIXOPS_INTERP_BILINEAR:
                ml_filter = MLIB_BILINEAR;
                break;
          
              case PIXOPS_INTERP_TILES:
                ml_filter = MLIB_BILINEAR;
                break;

              case PIXOPS_INTERP_HYPER:
                ml_filter = MLIB_BICUBIC;
                break;
              }

            mlib_ImageZoomTranslate (&img_dest,
                                     &img_src,
                                     scale_x,
                                     scale_y,
                                     ml_offset_x,
                                     ml_offset_y,
                                     ml_filter,
                                     MLIB_EDGE_SRC_EXTEND_INDEF);
          }
      }

    if (tmp_buf != NULL((void*)0))
      g_free (tmp_buf);
  }
2770}
2771#endif