src/_imaging.c

Bug Summary

File:	_imaging.c
Warning:	line 4172, column 38 PyObject ownership leak with reference count of 1

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name _imaging.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -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 -analyzer-output=html -analyzer-checker=python -analyzer-disable-checker=deadcode -analyzer-config prune-paths=true,suppress-c++-stdlib=true,suppress-null-return-paths=false,crosscheck-with-z3=true,model-path=/opt/pyrefcon/lib/pyrefcon/models/models -analyzer-config experimental-enable-naive-ctu-analysis=true,ctu-dir=/tmp/pyrefcon/Pillow/csa-scan,ctu-index-name=/tmp/pyrefcon/Pillow/csa-scan/externalDefMap.txt,ctu-invocation-list=/tmp/pyrefcon/Pillow/csa-scan/invocations.yaml,display-ctu-progress=false -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debug-info-kind=limited -dwarf-version=4 -debugger-tuning=gdb -fcoverage-compilation-dir=/tmp/pyrefcon/Pillow -resource-dir /opt/pyrefcon/lib/clang/13.0.0 -isystem /opt/pyrefcon/lib/pyrefcon/models/python3.8 -D NDEBUG -D _FORTIFY_SOURCE=2 -D HAVE_LIBJPEG -D HAVE_OPENJPEG -D HAVE_LIBZ -D HAVE_LIBIMAGEQUANT -D HAVE_LIBTIFF -D HAVE_XCB -D PILLOW_VERSION="8.4.0.dev0" -I /usr/include/freetype2 -I /usr/include/openjpeg-2.3 -I /tmp/pyrefcon/Pillow -I /usr/include/x86_64-linux-gnu -I /usr/include/fribidi -I /usr/include -internal-isystem /opt/pyrefcon/lib/clang/13.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-result -Wsign-compare -Wall -Wformat -Werror=format-security -Wformat -Werror=format-security -Wdate-time -fdebug-compilation-dir=/tmp/pyrefcon/Pillow -ferror-limit 19 -fwrapv -pthread -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/pyrefcon/Pillow/csa-scan/reports -x c src/_imaging.c

src/_imaging.c

→

1/*
* The Python Imaging Library.
*
* the imaging library bindings
*
* history:
* 1995-09-24 fl   Created
* 1996-03-24 fl   Ready for first public release (release 0.0)
* 1996-03-25 fl   Added fromstring (for Jack's "img" library)
* 1996-03-28 fl   Added channel operations
* 1996-03-31 fl   Added point operation
* 1996-04-08 fl   Added new/new_block/new_array factories
* 1996-04-13 fl   Added decoders
* 1996-05-04 fl   Added palette hack
* 1996-05-12 fl   Compile cleanly as C++
* 1996-05-19 fl   Added matrix conversions, gradient fills
* 1996-05-27 fl   Added display_mode
* 1996-07-22 fl   Added getbbox, offset
* 1996-07-23 fl   Added sequence semantics
* 1996-08-13 fl   Added logical operators, point mode
* 1996-08-16 fl   Modified paste interface
* 1996-09-06 fl   Added putdata methods, use abstract interface
* 1996-11-01 fl   Added xbm encoder
* 1996-11-04 fl   Added experimental path stuff, draw_lines, etc
* 1996-12-10 fl   Added zip decoder, crc32 interface
* 1996-12-14 fl   Added modulo arithmetics
* 1996-12-29 fl   Added zip encoder
* 1997-01-03 fl   Added fli and msp decoders
* 1997-01-04 fl   Added experimental sun_rle and tga_rle decoders
* 1997-01-05 fl   Added gif encoder, getpalette hack
* 1997-02-23 fl   Added histogram mask
* 1997-05-12 fl   Minor tweaks to match the IFUNC95 interface
* 1997-05-21 fl   Added noise generator, spread effect
* 1997-06-05 fl   Added mandelbrot generator
* 1997-08-02 fl   Modified putpalette to coerce image mode if necessary
* 1998-01-11 fl   Added INT32 support
* 1998-01-22 fl   Fixed draw_points to draw the last point too
* 1998-06-28 fl   Added getpixel, getink, draw_ink
* 1998-07-12 fl   Added getextrema
* 1998-07-17 fl   Added point conversion to arbitrary formats
* 1998-09-21 fl   Added support for resampling filters
* 1998-09-22 fl   Added support for quad transform
* 1998-12-29 fl   Added support for arcs, chords, and pieslices
* 1999-01-10 fl   Added some experimental arrow graphics stuff
* 1999-02-06 fl   Added draw_bitmap, font acceleration stuff
* 2001-04-17 fl   Fixed some egcs compiler nits
* 2001-09-17 fl   Added screen grab primitives (win32)
* 2002-03-09 fl   Added stretch primitive
* 2002-03-10 fl   Fixed filter handling in rotate
* 2002-06-06 fl   Added I, F, and RGB support to putdata
* 2002-06-08 fl   Added rankfilter
* 2002-06-09 fl   Added support for user-defined filter kernels
* 2002-11-19 fl   Added clipboard grab primitives (win32)
* 2002-12-11 fl   Added draw context
* 2003-04-26 fl   Tweaks for Python 2.3 beta 1
* 2003-05-21 fl   Added createwindow primitive (win32)
* 2003-09-13 fl   Added thread section hooks
* 2003-09-15 fl   Added expand helper
* 2003-09-26 fl   Added experimental LA support
* 2004-02-21 fl   Handle zero-size images in quantize
* 2004-06-05 fl   Added ptr attribute (used to access Imaging objects)
* 2004-06-05 fl   Don't crash when fetching pixels from zero-wide images
* 2004-09-17 fl   Added getcolors
* 2004-10-04 fl   Added modefilter
* 2005-10-02 fl   Added access proxy
* 2006-06-18 fl   Always draw last point in polyline
*
* Copyright (c) 1997-2006 by Secret Labs AB
* Copyright (c) 1995-2006 by Fredrik Lundh
*
* See the README file for information on usage and redistribution.
*/

74#define PY_SSIZE_T_CLEAN
75#include "Python.h"

77#ifdef HAVE_LIBJPEG1
78#include "jconfig.h"
79#endif

81#ifdef HAVE_LIBZ1
82#include "zlib.h"
83#endif

85#ifdef HAVE_LIBTIFF1
86#ifndef _TIFFIO_
87#include <tiffio.h>
88#endif
89#endif

91#include "libImaging/Imaging.h"

93#define _USE_MATH_DEFINES
94#include <math.h>

96/* Configuration stuff. Feel free to undef things you don't need. */
97#define WITH_IMAGECHOPS  /* ImageChops support */
98#define WITH_IMAGEDRAW   /* ImageDraw support */
99#define WITH_MAPPING     /* use memory mapping to read some file formats */
100#define WITH_IMAGEPATH   /* ImagePath stuff */
101#define WITH_ARROW       /* arrow graphics stuff (experimental) */
102#define WITH_EFFECTS     /* special effects */
103#define WITH_QUANTIZE    /* quantization support */
104#define WITH_RANKFILTER  /* rank filter */
105#define WITH_MODEFILTER  /* mode filter */
106#define WITH_THREADING   /* "friendly" threading support */
107#define WITH_UNSHARPMASK /* Kevin Cazabon's unsharpmask module */

109#undef VERBOSE

111#define B16(p, i)((((int)p[(i)]) << 8) + p[(i) + 1]) ((((int)p[(i)]) << 8) + p[(i) + 1])
112#define L16(p, i)((((int)p[(i) + 1]) << 8) + p[(i)]) ((((int)p[(i) + 1]) << 8) + p[(i)])
113#define S16(v)((v) < 32768 ? (v) : ((v)-65536)) ((v) < 32768 ? (v) : ((v)-65536))

115/* -------------------------------------------------------------------- */
116/* OBJECT ADMINISTRATION                        */
117/* -------------------------------------------------------------------- */

119typedef struct {
  PyObject_HEADPyObject ob_base; Imaging image;
  ImagingAccess access;
122} ImagingObject;

124static PyTypeObject Imaging_Type;

126#ifdef WITH_IMAGEDRAW

128typedef struct {
  /* to write a character, cut out sxy from glyph data, place
     at current position plus dxy, and advance by (dx, dy) */
  int dx, dy;
  int dx0, dy0, dx1, dy1;
  int sx0, sy0, sx1, sy1;
134} Glyph;

136typedef struct {
  PyObject_HEADPyObject ob_base; ImagingObject *ref;
  Imaging bitmap;
  int ysize;
  int baseline;
  Glyph glyphs[256];
142} ImagingFontObject;

144static PyTypeObject ImagingFont_Type;

146typedef struct {
  PyObject_HEADPyObject ob_base; ImagingObject *image;
  UINT8unsigned char ink[4];
  int blend;
150} ImagingDrawObject;

152static PyTypeObject ImagingDraw_Type;

154#endif

156typedef struct {
  PyObject_HEADPyObject ob_base; ImagingObject *image;
  int readonly;
159} PixelAccessObject;

161static PyTypeObject PixelAccess_Type;

163PyObject *
164PyImagingNew(Imaging imOut) {
  ImagingObject *imagep;

  if (!imOut) {
      return NULL((void*)0);
  }

  imagep = PyObject_New(ImagingObject, &Imaging_Type)( (ImagingObject *) _PyObject_New(&Imaging_Type) );
  if (imagep == NULL((void*)0)) {
      ImagingDelete(imOut);
      return NULL((void*)0);
  }

177#ifdef VERBOSE
  printf("imaging %p allocated\n", imagep)__printf_chk (2 - 1, "imaging %p allocated\n", imagep);
179#endif

  imagep->image = imOut;
  imagep->access = ImagingAccessNew(imOut);

  return (PyObject *)imagep;
185}

187static void
188_dealloc(ImagingObject *imagep) {
189#ifdef VERBOSE
  printf("imaging %p deleted\n", imagep)__printf_chk (2 - 1, "imaging %p deleted\n", imagep);
191#endif

  if (imagep->access) {
      ImagingAccessDelete(imagep->image, imagep->access);
  }
  ImagingDelete(imagep->image);
  PyObject_DelPyObject_Free(imagep);
198}

200#define PyImaging_Check(op)((((PyObject*)(op))->ob_type) == &Imaging_Type) (Py_TYPE(op)(((PyObject*)(op))->ob_type) == &Imaging_Type)

202Imaging
203PyImaging_AsImaging(PyObject *op) {
  if (!PyImaging_Check(op)((((PyObject*)(op))->ob_type) == &Imaging_Type)) {
      PyErr_BadInternalCall()_PyErr_BadInternalCall("src/_imaging.c", 205);
      return NULL((void*)0);
  }

  return ((ImagingObject *)op)->image;
210}

212/* -------------------------------------------------------------------- */
213/* THREAD HANDLING                                                      */
214/* -------------------------------------------------------------------- */

216void
217ImagingSectionEnter(ImagingSectionCookie *cookie) {
218#ifdef WITH_THREADING
  *cookie = (PyThreadState *)PyEval_SaveThread();
220#endif
221}

223void
224ImagingSectionLeave(ImagingSectionCookie *cookie) {
225#ifdef WITH_THREADING
  PyEval_RestoreThread((PyThreadState *)*cookie);
227#endif
228}

230/* -------------------------------------------------------------------- */
231/* BUFFER HANDLING                                                      */
232/* -------------------------------------------------------------------- */
233/* Python compatibility API */

235int
236PyImaging_CheckBuffer(PyObject *buffer) {
  return PyObject_CheckBuffer(buffer)(((buffer)->ob_type->tp_as_buffer != ((void*)0)) &&
 ((buffer)->ob_type->tp_as_buffer->bf_getbuffer != (
(void*)0)));
238}

240int
241PyImaging_GetBuffer(PyObject *buffer, Py_buffer *view) {
  /* must call check_buffer first! */
  return PyObject_GetBuffer(buffer, view, PyBUF_SIMPLE0);
244}

246/* -------------------------------------------------------------------- */
247/* EXCEPTION REROUTING                                                  */
248/* -------------------------------------------------------------------- */

250/* error messages */
251static const char *must_be_sequence = "argument must be a sequence";
252static const char *must_be_two_coordinates =
  "coordinate list must contain exactly 2 coordinates";
254static const char *wrong_mode = "unrecognized image mode";
255static const char *wrong_raw_mode = "unrecognized raw mode";
256static const char *outside_image = "image index out of range";
257static const char *outside_palette = "palette index out of range";
258static const char *wrong_palette_size = "invalid palette size";
259static const char *no_palette = "image has no palette";
260static const char *readonly = "image is readonly";
261/* static const char* no_content = "image has no content"; */

263void *
264ImagingError_OSError(void) {
  PyErr_SetString(PyExc_OSError, "error when accessing file");
  return NULL((void*)0);
267}

269void *
270ImagingError_MemoryError(void) {
  return PyErr_NoMemory();
272}

274void *
275ImagingError_Mismatch(void) {
  PyErr_SetString(PyExc_ValueError, "images do not match");
  return NULL((void*)0);
278}

280void *
281ImagingError_ModeError(void) {
  PyErr_SetString(PyExc_ValueError, "image has wrong mode");
  return NULL((void*)0);
284}

286void *
287ImagingError_ValueError(const char *message) {
  PyErr_SetString(
      PyExc_ValueError, (message) ? (char *)message : "unrecognized argument value");
  return NULL((void*)0);
291}

293void
294ImagingError_Clear(void) {
  PyErr_Clear();
296}

298/* -------------------------------------------------------------------- */
299/* HELPERS                                */
300/* -------------------------------------------------------------------- */

302static int
303getbands(const char *mode) {
  Imaging im;
  int bands;

  /* FIXME: add primitive to libImaging to avoid extra allocation */
  im = ImagingNew(mode, 0, 0);
  if (!im) {
      return -1;
  }

  bands = im->bands;

  ImagingDelete(im);

  return bands;
318}

320#define TYPE_UINT8(0x100 | sizeof(unsigned char)) (0x100 | sizeof(UINT8unsigned char))
321#define TYPE_INT32(0x200 | sizeof(int)) (0x200 | sizeof(INT32int))
322#define TYPE_FLOAT16(0x500 | sizeof(unsigned short)) (0x500 | sizeof(FLOAT16unsigned short))
323#define TYPE_FLOAT32(0x300 | sizeof(float)) (0x300 | sizeof(FLOAT32float))
324#define TYPE_DOUBLE(0x400 | sizeof(double)) (0x400 | sizeof(double))

326static void *
327getlist(PyObject *arg, Py_ssize_t *length, const char *wrong_length, int type) {
  /* - allocates and returns a c array of the items in the
        python sequence arg.
     - the size of the returned array is in length
     - all of the arg items must be numeric items of the type
        specified in type
     - sequence length is checked against the length parameter IF
        an error parameter is passed in wrong_length
     - caller is responsible for freeing the memory
  */

  Py_ssize_t i, n;
  int itemp;
  double dtemp;
  FLOAT32float ftemp;
  UINT8unsigned char *list;
  PyObject *seq;
  PyObject *op;

  if (!PySequence_Check(arg)) {
      PyErr_SetString(PyExc_TypeError, must_be_sequence);
      return NULL((void*)0);
  }

  n = PySequence_Size(arg);
  if (length && wrong_length && n != *length) {
      PyErr_SetString(PyExc_ValueError, wrong_length);
      return NULL((void*)0);
  }

  /* malloc check ok, type & ff is just a sizeof(something)
     calloc checks for overflow */
  list = calloc(n, type & 0xff);
  if (!list) {
      return ImagingError_MemoryError();
  }

  seq = PySequence_Fast(arg, must_be_sequence);
  if (!seq) {
      free(list);
      return NULL((void*)0);
  }

  for (i = 0; i < n; i++) {
      op = PySequence_Fast_GET_ITEM(seq, i)(((((((PyObject*)(seq))->ob_type))->tp_flags & ((1UL
 << 25))) != 0) ? (((PyListObject *)(seq))->ob_item[
i]) : ((((void) (0)), (PyTupleObject *)(seq))->ob_item[i])
);
      // DRY, branch prediction is going to work _really_ well
      // on this switch. And 3 fewer loops to copy/paste.
      switch (type) {
          case TYPE_UINT8(0x100 | sizeof(unsigned char)):
              itemp = PyLong_AsLong(op);
              list[i] = CLIP8(itemp)((itemp) <= 0 ? 0 : (itemp) < 256 ? (itemp) : 255);
              break;
          case TYPE_INT32(0x200 | sizeof(int)):
              itemp = PyLong_AsLong(op);
              memcpy(list + i * sizeof(INT32int), &itemp, sizeof(itemp));
              break;
          case TYPE_FLOAT32(0x300 | sizeof(float)):
              ftemp = (FLOAT32float)PyFloat_AsDouble(op);
              memcpy(list + i * sizeof(ftemp), &ftemp, sizeof(ftemp));
              break;
          case TYPE_DOUBLE(0x400 | sizeof(double)):
              dtemp = PyFloat_AsDouble(op);
              memcpy(list + i * sizeof(dtemp), &dtemp, sizeof(dtemp));
              break;
      }
  }

  Py_DECREF(seq)_Py_DECREF(((PyObject*)(seq)));

  if (PyErr_Occurred()) {
      free(list);
      return NULL((void*)0);
  }

  if (length) {
      *length = n;
  }

  return list;
406}

408FLOAT32float
409float16tofloat32(const FLOAT16unsigned short in) {
  UINT32unsigned int t1;
  UINT32unsigned int t2;
  UINT32unsigned int t3;
  FLOAT32float out[1] = {0};

  t1 = in & 0x7fff;  // Non-sign bits
  t2 = in & 0x8000;  // Sign bit
  t3 = in & 0x7c00;  // Exponent

  t1 <<= 13;  // Align mantissa on MSB
  t2 <<= 16;  // Shift sign bit into position

  t1 += 0x38000000;  // Adjust bias

  t1 = (t3 == 0 ? 0 : t1);  // Denormals-as-zero

  t1 |= t2;  // Re-insert sign bit

  memcpy(out, &t1, 4);
  return out[0];
430}

432static inline PyObject *
433getpixel(Imaging im, ImagingAccess access, int x, int y) {
  union {
      UINT8unsigned char b[4];
      UINT16unsigned short h;
      INT32int i;
      FLOAT32float f;
  } pixel;

  if (x < 0) {
      x = im->xsize + x;
  }
  if (y < 0) {
      y = im->ysize + y;
  }

  if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) {
      PyErr_SetString(PyExc_IndexError, outside_image);
      return NULL((void*)0);
  }

  access->get_pixel(im, x, y, &pixel);

  switch (im->type) {
      case IMAGING_TYPE_UINT80:
          switch (im->bands) {
              case 1:
                  return PyLong_FromLong(pixel.b[0]);
              case 2:
                  return Py_BuildValue_Py_BuildValue_SizeT("BB", pixel.b[0], pixel.b[1]);
              case 3:
                  return Py_BuildValue_Py_BuildValue_SizeT("BBB", pixel.b[0], pixel.b[1], pixel.b[2]);
              case 4:
                  return Py_BuildValue_Py_BuildValue_SizeT(
                      "BBBB", pixel.b[0], pixel.b[1], pixel.b[2], pixel.b[3]);
          }
          break;
      case IMAGING_TYPE_INT321:
          return PyLong_FromLong(pixel.i);
      case IMAGING_TYPE_FLOAT322:
          return PyFloat_FromDouble(pixel.f);
      case IMAGING_TYPE_SPECIAL3:
          if (strncmp(im->mode, "I;16", 4) == 0) {
              return PyLong_FromLong(pixel.h);
          }
          break;
  }

  /* unknown type */
  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
483}

485static char *
486getink(PyObject *color, Imaging im, char *ink) {
  int g = 0, b = 0, a = 0;
  double f = 0;
  /* Windows 64 bit longs are 32 bits, and 0xFFFFFFFF (white) is a
     python long (not int) that raises an overflow error when trying
     to return it into a 32 bit C long
  */
  PY_LONG_LONGlong long r = 0;
  FLOAT32float ftmp;
  INT32int itmp;

  /* fill ink buffer (four bytes) with something that can
     be cast to either UINT8 or INT32 */

  int rIsInt = 0;
  if (PyTuple_Check(color)((((((PyObject*)(color))->ob_type))->tp_flags & ((1UL
 << 26))) != 0) && PyTuple_GET_SIZE(color)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(color))))->
ob_size) == 1) {
      color = PyTuple_GetItem(color, 0);
  }
  if (im->type == IMAGING_TYPE_UINT80 || im->type == IMAGING_TYPE_INT321 ||
      im->type == IMAGING_TYPE_SPECIAL3) {
      if (PyLong_Check(color)((((((PyObject*)(color))->ob_type))->tp_flags & ((1UL
 << 24))) != 0)) {
          r = PyLong_AsLongLong(color);
          if (r == -1 && PyErr_Occurred()) {
              return NULL((void*)0);
          }
          rIsInt = 1;
      } else if (im->type == IMAGING_TYPE_UINT80) {
          if (!PyTuple_Check(color)((((((PyObject*)(color))->ob_type))->tp_flags & ((1UL
 << 26))) != 0)) {
              PyErr_SetString(PyExc_TypeError, "color must be int or tuple");
              return NULL((void*)0);
          }
      } else {
          PyErr_SetString(
              PyExc_TypeError, "color must be int or single-element tuple");
          return NULL((void*)0);
      }
  }

  switch (im->type) {
      case IMAGING_TYPE_UINT80:
          /* unsigned integer */
          if (im->bands == 1) {
              /* unsigned integer, single layer */
              if (rIsInt != 1) {
                  if (PyTuple_GET_SIZE(color)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(color))))->
ob_size) != 1) {
                      PyErr_SetString(PyExc_TypeError, "color must be int or single-element tuple");
                      return NULL((void*)0);
                  } else if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(color, "L", &r)) {
                      return NULL((void*)0);
                  }
              }
              ink[0] = (char)CLIP8(r)((r) <= 0 ? 0 : (r) < 256 ? (r) : 255);
              ink[1] = ink[2] = ink[3] = 0;
          } else {
              a = 255;
              if (rIsInt) {
                  /* compatibility: ABGR */
                  a = (UINT8unsigned char)(r >> 24);
                  b = (UINT8unsigned char)(r >> 16);
                  g = (UINT8unsigned char)(r >> 8);
                  r = (UINT8unsigned char)r;
              } else {
                  int tupleSize = PyTuple_GET_SIZE(color)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(color))))->
ob_size);
                  if (im->bands == 2) {
                      if (tupleSize != 1 && tupleSize != 2) {
                          PyErr_SetString(PyExc_TypeError, "color must be int, or tuple of one or two elements");
                          return NULL((void*)0);
                      } else if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(color, "L|i", &r, &a)) {
                          return NULL((void*)0);
                      }
                      g = b = r;
                  } else {
                      if (tupleSize != 3 && tupleSize != 4) {
                          PyErr_SetString(PyExc_TypeError, "color must be int, or tuple of one, three or four elements");
                          return NULL((void*)0);
                      } else if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(color, "Lii|i", &r, &g, &b, &a)) {
                          return NULL((void*)0);
                      }
                  }
              }
              ink[0] = (char)CLIP8(r)((r) <= 0 ? 0 : (r) < 256 ? (r) : 255);
              ink[1] = (char)CLIP8(g)((g) <= 0 ? 0 : (g) < 256 ? (g) : 255);
              ink[2] = (char)CLIP8(b)((b) <= 0 ? 0 : (b) < 256 ? (b) : 255);
              ink[3] = (char)CLIP8(a)((a) <= 0 ? 0 : (a) < 256 ? (a) : 255);
          }
          return ink;
      case IMAGING_TYPE_INT321:
          /* signed integer */
          itmp = r;
          memcpy(ink, &itmp, sizeof(itmp));
          return ink;
      case IMAGING_TYPE_FLOAT322:
          /* floating point */
          f = PyFloat_AsDouble(color);
          if (f == -1.0 && PyErr_Occurred()) {
              return NULL((void*)0);
          }
          ftmp = f;
          memcpy(ink, &ftmp, sizeof(ftmp));
          return ink;
      case IMAGING_TYPE_SPECIAL3:
          if (strncmp(im->mode, "I;16", 4) == 0) {
              ink[0] = (UINT8unsigned char)r;
              ink[1] = (UINT8unsigned char)(r >> 8);
              ink[2] = ink[3] = 0;
              return ink;
          }
  }

  PyErr_SetString(PyExc_ValueError, wrong_mode);
  return NULL((void*)0);
597}

599/* -------------------------------------------------------------------- */
600/* FACTORIES                                */
601/* -------------------------------------------------------------------- */

603static PyObject *
604_fill(PyObject *self, PyObject *args) {
  char *mode;
  int xsize, ysize;
  PyObject *color;
  char buffer[4];
  Imaging im;

  xsize = ysize = 256;
  color = NULL((void*)0);

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "s|(ii)O", &mode, &xsize, &ysize, &color)) {
      return NULL((void*)0);
  }

  im = ImagingNewDirty(mode, xsize, ysize);
  if (!im) {
      return NULL((void*)0);
  }

  buffer[0] = buffer[1] = buffer[2] = buffer[3] = 0;
  if (color) {
      if (!getink(color, im, buffer)) {
          ImagingDelete(im);
          return NULL((void*)0);
      }
  }

  (void)ImagingFill(im, buffer);

  return PyImagingNew(im);
634}

636static PyObject *
637_new(PyObject *self, PyObject *args) {
  char *mode;
  int xsize, ysize;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "s(ii)", &mode, &xsize, &ysize)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingNew(mode, xsize, ysize));
646}

648static PyObject *
649_new_block(PyObject *self, PyObject *args) {
  char *mode;
  int xsize, ysize;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "s(ii)", &mode, &xsize, &ysize)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingNewBlock(mode, xsize, ysize));
658}

660static PyObject *
661_linear_gradient(PyObject *self, PyObject *args) {
  char *mode;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "s", &mode)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingFillLinearGradient(mode));
669}

671static PyObject *
672_radial_gradient(PyObject *self, PyObject *args) {
  char *mode;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "s", &mode)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingFillRadialGradient(mode));
680}

682static PyObject *
683_alpha_composite(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep1;
  ImagingObject *imagep2;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
          args, "O!O!", &Imaging_Type, &imagep1, &Imaging_Type, &imagep2)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingAlphaComposite(imagep1->image, imagep2->image));
693}

695static PyObject *
696_blend(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep1;
  ImagingObject *imagep2;
  double alpha;

  alpha = 0.5;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
          args, "O!O!|d", &Imaging_Type, &imagep1, &Imaging_Type, &imagep2, &alpha)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingBlend(imagep1->image, imagep2->image, (float)alpha));
708}

710/* -------------------------------------------------------------------- */
711/* METHODS                                                              */
712/* -------------------------------------------------------------------- */

714static INT16short *
715_prepare_lut_table(PyObject *table, Py_ssize_t table_size) {
  int i;
  Py_buffer buffer_info;
  INT32int data_type = TYPE_FLOAT32(0x300 | sizeof(float));
  float item = 0;
  void *table_data = NULL((void*)0);
  int free_table_data = 0;
  INT16short *prepared;

724/* NOTE: This value should be the same as in ColorLUT.c */
725#define PRECISION_BITS (16 - 8 - 2)

  const char *wrong_size =
      ("The table should have table_channels * "
       "size1D * size2D * size3D float items.");

  if (PyObject_CheckBuffer(table)(((table)->ob_type->tp_as_buffer != ((void*)0)) &&
 ((table)->ob_type->tp_as_buffer->bf_getbuffer != ((
void*)0)))) {
      if (!PyObject_GetBuffer(table, &buffer_info, PyBUF_CONTIG_RO(0x0008) | PyBUF_FORMAT0x0004)) {
          if (buffer_info.ndim == 1 && buffer_info.shape[0] == table_size) {
              if (strlen(buffer_info.format) == 1) {
                  switch (buffer_info.format[0]) {
                      case 'e':
                          data_type = TYPE_FLOAT16(0x500 | sizeof(unsigned short));
                          table_data = buffer_info.buf;
                          break;
                      case 'f':
                          data_type = TYPE_FLOAT32(0x300 | sizeof(float));
                          table_data = buffer_info.buf;
                          break;
                      case 'd':
                          data_type = TYPE_DOUBLE(0x400 | sizeof(double));
                          table_data = buffer_info.buf;
                          break;
                  }
              }
          }
          PyBuffer_Release(&buffer_info);
      }
  }

  if (!table_data) {
      free_table_data = 1;
      table_data = getlist(table, &table_size, wrong_size, TYPE_FLOAT32(0x300 | sizeof(float)));
      if (!table_data) {
          return NULL((void*)0);
      }
  }

  /* malloc check ok, max is 2 * 4 * 65**3 = 2197000 */
  prepared = (INT16short *)malloc(sizeof(INT16short) * table_size);
  if (!prepared) {
      if (free_table_data) {
          free(table_data);
      }
      return (INT16short *)ImagingError_MemoryError();
  }

  for (i = 0; i < table_size; i++) {
      FLOAT16unsigned short htmp;
      double dtmp;
      switch (data_type) {
          case TYPE_FLOAT16(0x500 | sizeof(unsigned short)):
              memcpy(&htmp, ((char *)table_data) + i * sizeof(htmp), sizeof(htmp));
              item = float16tofloat32(htmp);
              break;
          case TYPE_FLOAT32(0x300 | sizeof(float)):
              memcpy(
                  &item, ((char *)table_data) + i * sizeof(FLOAT32float), sizeof(FLOAT32float));
              break;
          case TYPE_DOUBLE(0x400 | sizeof(double)):
              memcpy(&dtmp, ((char *)table_data) + i * sizeof(dtmp), sizeof(dtmp));
              item = (FLOAT32float)dtmp;
              break;
      }
      /* Max value for INT16 */
      if (item >= (0x7fff - 0.5) / (255 << PRECISION_BITS)) {
          prepared[i] = 0x7fff;
          continue;
      }
      /* Min value for INT16 */
      if (item <= (-0x8000 + 0.5) / (255 << PRECISION_BITS)) {
          prepared[i] = -0x8000;
          continue;
      }
      if (item < 0) {
          prepared[i] = item * (255 << PRECISION_BITS) - 0.5;
      } else {
          prepared[i] = item * (255 << PRECISION_BITS) + 0.5;
      }
  }

806#undef PRECISION_BITS
  if (free_table_data) {
      free(table_data);
  }
  return prepared;
811}

813static PyObject *
814_color_lut_3d(ImagingObject *self, PyObject *args) {
  char *mode;
  int filter;
  int table_channels;
  int size1D, size2D, size3D;
  PyObject *table;

  INT16short *prepared_table;
  Imaging imOut;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
          args,
          "siiiiiO:color_lut_3d",
          &mode,
          &filter,
          &table_channels,
          &size1D,
          &size2D,
          &size3D,
          &table)) {
      return NULL((void*)0);
  }

  /* actually, it is trilinear */
  if (filter != IMAGING_TRANSFORM_BILINEAR2) {
      PyErr_SetString(PyExc_ValueError, "Only LINEAR filter is supported.");
      return NULL((void*)0);
  }

  if (1 > table_channels || table_channels > 4) {
      PyErr_SetString(PyExc_ValueError, "table_channels should be from 1 to 4");
      return NULL((void*)0);
  }

  if (2 > size1D || size1D > 65 || 2 > size2D || size2D > 65 || 2 > size3D ||
      size3D > 65) {
      PyErr_SetString(
          PyExc_ValueError, "Table size in any dimension should be from 2 to 65");
      return NULL((void*)0);
  }

  prepared_table =
      _prepare_lut_table(table, table_channels * size1D * size2D * size3D);
  if (!prepared_table) {
      return NULL((void*)0);
  }

  imOut = ImagingNewDirty(mode, self->image->xsize, self->image->ysize);
  if (!imOut) {
      free(prepared_table);
      return NULL((void*)0);
  }

  if (!ImagingColorLUT3D_linear(
          imOut,
          self->image,
          table_channels,
          size1D,
          size2D,
          size3D,
          prepared_table)) {
      free(prepared_table);
      ImagingDelete(imOut);
      return NULL((void*)0);
  }

  free(prepared_table);

  return PyImagingNew(imOut);
883}

885static PyObject *
886_convert(ImagingObject *self, PyObject *args) {
  char *mode;
  int dither = 0;
  ImagingObject *paletteimage = NULL((void*)0);

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "s|iO", &mode, &dither, &paletteimage)) {
      return NULL((void*)0);
  }
  if (paletteimage != NULL((void*)0)) {
      if (!PyImaging_Check(paletteimage)((((PyObject*)(paletteimage))->ob_type) == &Imaging_Type
)) {
          PyObject_Print((PyObject *)paletteimage, stderrstderr, 0);
          PyErr_SetString(
              PyExc_ValueError, "palette argument must be image with mode 'P'");
          return NULL((void*)0);
      }
      if (paletteimage->image->palette == NULL((void*)0)) {
          PyErr_SetString(PyExc_ValueError, "null palette");
          return NULL((void*)0);
      }
  }

  return PyImagingNew(ImagingConvert(
      self->image, mode, paletteimage ? paletteimage->image->palette : NULL((void*)0), dither));
909}

911static PyObject *
912_convert2(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep1;
  ImagingObject *imagep2;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
          args, "O!O!", &Imaging_Type, &imagep1, &Imaging_Type, &imagep2)) {
      return NULL((void*)0);
  }

  if (!ImagingConvert2(imagep1->image, imagep2->image)) {
      return NULL((void*)0);
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
926}

928static PyObject *
929_convert_matrix(ImagingObject *self, PyObject *args) {
  char *mode;
  float m[12];
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "s(ffff)", &mode, m + 0, m + 1, m + 2, m + 3)) {
      PyErr_Clear();
      if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
              args,
              "s(ffffffffffff)",
              &mode,
              m + 0,
              m + 1,
              m + 2,
              m + 3,
              m + 4,
              m + 5,
              m + 6,
              m + 7,
              m + 8,
              m + 9,
              m + 10,
              m + 11)) {
          return NULL((void*)0);
      }
  }

  return PyImagingNew(ImagingConvertMatrix(self->image, mode, m));
955}

957static PyObject *
958_convert_transparent(ImagingObject *self, PyObject *args) {
  char *mode;
  int r, g, b;
  if (PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "s(iii)", &mode, &r, &g, &b)) {
      return PyImagingNew(ImagingConvertTransparent(self->image, mode, r, g, b));
  }
  PyErr_Clear();
  if (PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "si", &mode, &r)) {
      return PyImagingNew(ImagingConvertTransparent(self->image, mode, r, 0, 0));
  }
  return NULL((void*)0);
969}

971static PyObject *
972_copy(ImagingObject *self, PyObject *args) {
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "")) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingCopy(self->image));
978}

980static PyObject *
981_crop(ImagingObject *self, PyObject *args) {
  int x0, y0, x1, y1;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "(iiii)", &x0, &y0, &x1, &y1)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingCrop(self->image, x0, y0, x1, y1));
988}

990static PyObject *
991_expand_image(ImagingObject *self, PyObject *args) {
  int x, y;
  int mode = 0;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "ii|i", &x, &y, &mode)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingExpand(self->image, x, y, mode));
999}

1001static PyObject *
1002_filter(ImagingObject *self, PyObject *args) {
  PyObject *imOut;
  Py_ssize_t kernelsize;
  FLOAT32float *kerneldata;

  int xsize, ysize, i;
  float divisor, offset;
  PyObject *kernel = NULL((void*)0);
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
          args, "(ii)ffO", &xsize, &ysize, &divisor, &offset, &kernel)) {
      return NULL((void*)0);
  }

  /* get user-defined kernel */
  kerneldata = getlist(kernel, &kernelsize, NULL((void*)0), TYPE_FLOAT32(0x300 | sizeof(float)));
  if (!kerneldata) {
      return NULL((void*)0);
  }
  if (kernelsize != (Py_ssize_t)xsize * (Py_ssize_t)ysize) {
      free(kerneldata);
      return ImagingError_ValueError("bad kernel size");
  }

  for (i = 0; i < kernelsize; ++i) {
      kerneldata[i] /= divisor;
  }

  imOut = PyImagingNew(ImagingFilter(self->image, xsize, ysize, kerneldata, offset));

  free(kerneldata);

  return imOut;
1034}

1036#ifdef WITH_UNSHARPMASK
1037static PyObject *
1038_gaussian_blur(ImagingObject *self, PyObject *args) {
  Imaging imIn;
  Imaging imOut;

  float radius = 0;
  int passes = 3;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "f|i", &radius, &passes)) {
      return NULL((void*)0);
  }

  imIn = self->image;
  imOut = ImagingNewDirty(imIn->mode, imIn->xsize, imIn->ysize);
  if (!imOut) {
      return NULL((void*)0);
  }

  if (!ImagingGaussianBlur(imOut, imIn, radius, passes)) {
      ImagingDelete(imOut);
      return NULL((void*)0);
  }

  return PyImagingNew(imOut);
1060}
1061#endif

1063static PyObject *
1064_getpalette(ImagingObject *self, PyObject *args) {
  PyObject *palette;
  int palettesize = 256;
  int bits;
  ImagingShuffler pack;

  char *mode = "RGB";
  char *rawmode = "RGB";
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "|ss", &mode, &rawmode)) {
      return NULL((void*)0);
  }

  if (!self->image->palette) {
      PyErr_SetString(PyExc_ValueError, no_palette);
      return NULL((void*)0);
  }

  pack = ImagingFindPacker(mode, rawmode, &bits);
  if (!pack) {
      PyErr_SetString(PyExc_ValueError, wrong_raw_mode);
      return NULL((void*)0);
  }

  palette = PyBytes_FromStringAndSize(NULL((void*)0), palettesize * bits / 8);
  if (!palette) {
      return NULL((void*)0);
  }

  pack(
      (UINT8unsigned char *)PyBytes_AsString(palette), self->image->palette->palette, palettesize);

  return palette;
1096}

1098static PyObject *
1099_getpalettemode(ImagingObject *self) {
  if (!self->image->palette) {
      PyErr_SetString(PyExc_ValueError, no_palette);
      return NULL((void*)0);
  }

  return PyUnicode_FromString(self->image->palette->mode);
1106}

1108static inline int
1109_getxy(PyObject *xy, int *x, int *y) {
  PyObject *value;

  if (!PyTuple_Check(xy)((((((PyObject*)(xy))->ob_type))->tp_flags & ((1UL <<
 26))) != 0) || PyTuple_GET_SIZE(xy)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(xy))))->
ob_size) != 2) {
      goto badarg;
  }

  value = PyTuple_GET_ITEM(xy, 0)((((void) (0)), (PyTupleObject *)(xy))->ob_item[0]);
  if (PyLong_Check(value)((((((PyObject*)(value))->ob_type))->tp_flags & ((1UL
 << 24))) != 0)) {
      *x = PyLong_AS_LONG(value)PyLong_AsLong(value);
  } else if (PyFloat_Check(value)((((PyObject*)(value))->ob_type) == (&PyFloat_Type) ||
 PyType_IsSubtype((((PyObject*)(value))->ob_type), (&PyFloat_Type
)))) {
      *x = (int)PyFloat_AS_DOUBLE(value)(((PyFloatObject *)(value))->ob_fval);
  } else {
      PyObject *int_value = PyObject_CallMethod_PyObject_CallMethod_SizeT(value, "__int__", NULL((void*)0));
      if (int_value != NULL((void*)0) && PyLong_Check(int_value)((((((PyObject*)(int_value))->ob_type))->tp_flags &
 ((1UL << 24))) != 0)) {
          *x = PyLong_AS_LONG(int_value)PyLong_AsLong(int_value);
      } else {
          goto badval;
      }
  }

  value = PyTuple_GET_ITEM(xy, 1)((((void) (0)), (PyTupleObject *)(xy))->ob_item[1]);
  if (PyLong_Check(value)((((((PyObject*)(value))->ob_type))->tp_flags & ((1UL
 << 24))) != 0)) {
      *y = PyLong_AS_LONG(value)PyLong_AsLong(value);
  } else if (PyFloat_Check(value)((((PyObject*)(value))->ob_type) == (&PyFloat_Type) ||
 PyType_IsSubtype((((PyObject*)(value))->ob_type), (&PyFloat_Type
)))) {
      *y = (int)PyFloat_AS_DOUBLE(value)(((PyFloatObject *)(value))->ob_fval);
  } else {
      PyObject *int_value = PyObject_CallMethod_PyObject_CallMethod_SizeT(value, "__int__", NULL((void*)0));
      if (int_value != NULL((void*)0) && PyLong_Check(int_value)((((((PyObject*)(int_value))->ob_type))->tp_flags &
 ((1UL << 24))) != 0)) {
          *y = PyLong_AS_LONG(int_value)PyLong_AsLong(int_value);
      } else {
          goto badval;
      }
  }

  return 0;

1146badarg:
  PyErr_SetString(PyExc_TypeError, "argument must be sequence of length 2");
  return -1;

1150badval:
  PyErr_SetString(PyExc_TypeError, "an integer is required");
  return -1;
1153}

1155static PyObject *
1156_getpixel(ImagingObject *self, PyObject *args) {
  PyObject *xy;
  int x, y;

  if (PyTuple_GET_SIZE(args)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(args))))->
ob_size) != 1) {
      PyErr_SetString(PyExc_TypeError, "argument 1 must be sequence of length 2");
      return NULL((void*)0);
  }

  xy = PyTuple_GET_ITEM(args, 0)((((void) (0)), (PyTupleObject *)(args))->ob_item[0]);

  if (_getxy(xy, &x, &y)) {
      return NULL((void*)0);
  }

  if (self->access == NULL((void*)0)) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  return getpixel(self->image, self->access, x, y);
1177}

1179union hist_extrema {
  UINT8unsigned char u[2];
  INT32int i[2];
  FLOAT32float f[2];
1183};

1185static union hist_extrema *
1186parse_histogram_extremap(
  ImagingObject *self, PyObject *extremap, union hist_extrema *ep) {
  int i0, i1;
  double f0, f1;

  if (extremap) {
      switch (self->image->type) {
          case IMAGING_TYPE_UINT80:
              if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(extremap, "ii", &i0, &i1)) {
                  return NULL((void*)0);
              }
              ep->u[0] = CLIP8(i0)((i0) <= 0 ? 0 : (i0) < 256 ? (i0) : 255);
              ep->u[1] = CLIP8(i1)((i1) <= 0 ? 0 : (i1) < 256 ? (i1) : 255);
              break;
          case IMAGING_TYPE_INT321:
              if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(extremap, "ii", &i0, &i1)) {
                  return NULL((void*)0);
              }
              ep->i[0] = i0;
              ep->i[1] = i1;
              break;
          case IMAGING_TYPE_FLOAT322:
              if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(extremap, "dd", &f0, &f1)) {
                  return NULL((void*)0);
              }
              ep->f[0] = (FLOAT32float)f0;
              ep->f[1] = (FLOAT32float)f1;
              break;
          default:
              return NULL((void*)0);
      }
  } else {
      return NULL((void*)0);
  }
  return ep;
1221}

1223static PyObject *
1224_histogram(ImagingObject *self, PyObject *args) {
  ImagingHistogram h;
  PyObject *list;
  int i;
  union hist_extrema extrema;
  union hist_extrema *ep;

  PyObject *extremap = NULL((void*)0);
  ImagingObject *maskp = NULL((void*)0);
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "|OO!", &extremap, &Imaging_Type, &maskp)) {
      return NULL((void*)0);
  }

  /* Using a var to avoid allocations. */
  ep = parse_histogram_extremap(self, extremap, &extrema);
  h = ImagingGetHistogram(self->image, (maskp) ? maskp->image : NULL((void*)0), ep);

  if (!h) {
      return NULL((void*)0);
  }

  /* Build an integer list containing the histogram */
  list = PyList_New(h->bands * 256);
  for (i = 0; i < h->bands * 256; i++) {
      PyObject *item;
      item = PyLong_FromLong(h->histogram[i]);
      if (item == NULL((void*)0)) {
          Py_DECREF(list)_Py_DECREF(((PyObject*)(list)));
          list = NULL((void*)0);
          break;
      }
      PyList_SetItem(list, i, item);
  }

  /* Destroy the histogram structure */
  ImagingHistogramDelete(h);

  return list;
1262}

1264static PyObject *
1265_entropy(ImagingObject *self, PyObject *args) {
  ImagingHistogram h;
  int idx, length;
  long sum;
  double entropy, fsum, p;
  union hist_extrema extrema;
  union hist_extrema *ep;

  PyObject *extremap = NULL((void*)0);
  ImagingObject *maskp = NULL((void*)0);
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "|OO!", &extremap, &Imaging_Type, &maskp)) {
      return NULL((void*)0);
  }

  /* Using a local var to avoid allocations. */
  ep = parse_histogram_extremap(self, extremap, &extrema);
  h = ImagingGetHistogram(self->image, (maskp) ? maskp->image : NULL((void*)0), ep);

  if (!h) {
      return NULL((void*)0);
  }

  /* Calculate the histogram entropy */
  /* First, sum the histogram data */
  length = h->bands * 256;
  sum = 0;
  for (idx = 0; idx < length; idx++) {
      sum += h->histogram[idx];
  }

  /* Next, normalize the histogram data, */
  /* using the histogram sum value */
  fsum = (double)sum;
  entropy = 0.0;
  for (idx = 0; idx < length; idx++) {
      p = (double)h->histogram[idx] / fsum;
      if (p != 0.0) {
          entropy += p * log(p) * M_LOG2E1.4426950408889634074;
      }
  }

  /* Destroy the histogram structure */
  ImagingHistogramDelete(h);

  return PyFloat_FromDouble(-entropy);
1310}

1312#ifdef WITH_MODEFILTER
1313static PyObject *
1314_modefilter(ImagingObject *self, PyObject *args) {
  int size;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "i", &size)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingModeFilter(self->image, size));
1321}
1322#endif

1324static PyObject *
1325_offset(ImagingObject *self, PyObject *args) {
  int xoffset, yoffset;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "ii", &xoffset, &yoffset)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingOffset(self->image, xoffset, yoffset));
1332}

1334static PyObject *
1335_paste(ImagingObject *self, PyObject *args) {
  int status;
  char ink[4];

  PyObject *source;
  int x0, y0, x1, y1;
  ImagingObject *maskp = NULL((void*)0);
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
          args, "O(iiii)|O!", &source, &x0, &y0, &x1, &y1, &Imaging_Type, &maskp)) {
      return NULL((void*)0);
  }

  if (PyImaging_Check(source)((((PyObject*)(source))->ob_type) == &Imaging_Type)) {
      status = ImagingPaste(
          self->image,
          PyImaging_AsImaging(source),
          (maskp) ? maskp->image : NULL((void*)0),
          x0,
          y0,
          x1,
          y1);

  } else {
      if (!getink(source, self->image, ink)) {
          return NULL((void*)0);
      }
      status = ImagingFill2(
          self->image, ink, (maskp) ? maskp->image : NULL((void*)0), x0, y0, x1, y1);
  }

  if (status < 0) {
      return NULL((void*)0);
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
1371}

1373static PyObject *
1374_point(ImagingObject *self, PyObject *args) {
  static const char *wrong_number = "wrong number of lut entries";

  Py_ssize_t n;
  int i, bands;
  Imaging im;

  PyObject *list;
  char *mode;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "Oz", &list, &mode)) {
      return NULL((void*)0);
  }

  if (mode && !strcmp(mode, "F")) {
      FLOAT32float *data;

      /* map from 8-bit data to floating point */
      n = 256;
      data = getlist(list, &n, wrong_number, TYPE_FLOAT32(0x300 | sizeof(float)));
      if (!data) {
          return NULL((void*)0);
      }
      im = ImagingPoint(self->image, mode, (void *)data);
      free(data);

  } else if (!strcmp(self->image->mode, "I") && mode && !strcmp(mode, "L")) {
      UINT8unsigned char *data;

      /* map from 16-bit subset of 32-bit data to 8-bit */
      /* FIXME: support arbitrary number of entries (requires API change) */
      n = 65536;
      data = getlist(list, &n, wrong_number, TYPE_UINT8(0x100 | sizeof(unsigned char)));
      if (!data) {
          return NULL((void*)0);
      }
      im = ImagingPoint(self->image, mode, (void *)data);
      free(data);

  } else {
      INT32int *data;
      UINT8unsigned char lut[1024];

      if (mode) {
          bands = getbands(mode);
          if (bands < 0) {
              return NULL((void*)0);
          }
      } else {
          bands = self->image->bands;
      }

      /* map to integer data */
      n = 256 * bands;
      data = getlist(list, &n, wrong_number, TYPE_INT32(0x200 | sizeof(int)));
      if (!data) {
          return NULL((void*)0);
      }

      if (mode && !strcmp(mode, "I")) {
          im = ImagingPoint(self->image, mode, (void *)data);
      } else if (mode && bands > 1) {
          for (i = 0; i < 256; i++) {
              lut[i * 4] = CLIP8(data[i])((data[i]) <= 0 ? 0 : (data[i]) < 256 ? (data[i]) : 255
);
              lut[i * 4 + 1] = CLIP8(data[i + 256])((data[i + 256]) <= 0 ? 0 : (data[i + 256]) < 256 ? (data
[i + 256]) : 255);
              lut[i * 4 + 2] = CLIP8(data[i + 512])((data[i + 512]) <= 0 ? 0 : (data[i + 512]) < 256 ? (data
[i + 512]) : 255);
              if (n > 768) {
                  lut[i * 4 + 3] = CLIP8(data[i + 768])((data[i + 768]) <= 0 ? 0 : (data[i + 768]) < 256 ? (data
[i + 768]) : 255);
              }
          }
          im = ImagingPoint(self->image, mode, (void *)lut);
      } else {
          /* map individual bands */
          for (i = 0; i < n; i++) {
              lut[i] = CLIP8(data[i])((data[i]) <= 0 ? 0 : (data[i]) < 256 ? (data[i]) : 255
);
          }
          im = ImagingPoint(self->image, mode, (void *)lut);
      }
      free(data);
  }

  return PyImagingNew(im);
1455}

1457static PyObject *
1458_point_transform(ImagingObject *self, PyObject *args) {
  double scale = 1.0;
  double offset = 0.0;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "|dd", &scale, &offset)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingPointTransform(self->image, scale, offset));
1466}

1468static PyObject *
1469_putdata(ImagingObject *self, PyObject *args) {
  Imaging image;
  // i & n are # pixels, require py_ssize_t. x can be as large as n. y, just because.
  Py_ssize_t n, i, x, y;

  PyObject *data;
  PyObject *seq = NULL((void*)0);
  PyObject *op;
  double scale = 1.0;
  double offset = 0.0;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O|dd", &data, &scale, &offset)) {
      return NULL((void*)0);
  }

  if (!PySequence_Check(data)) {
      PyErr_SetString(PyExc_TypeError, must_be_sequence);
      return NULL((void*)0);
  }

  image = self->image;

  n = PyObject_LengthPyObject_Size(data);
  if (n > (Py_ssize_t)image->xsize * (Py_ssize_t)image->ysize) {
      PyErr_SetString(PyExc_TypeError, "too many data entries");
      return NULL((void*)0);
  }

  if (image->image8) {
      if (PyBytes_Check(data)((((((PyObject*)(data))->ob_type))->tp_flags & ((1UL
 << 27))) != 0)) {
          unsigned char *p;
          p = (unsigned char *)PyBytes_AS_STRING(data)(((void) (0)), (((PyBytesObject *)(data))->ob_sval));
          if (scale == 1.0 && offset == 0.0) {
              /* Plain string data */
              for (i = y = 0; i < n; i += image->xsize, y++) {
                  x = n - i;
                  if (x > (int)image->xsize) {
                      x = image->xsize;
                  }
                  memcpy(image->image8[y], p + i, x);
              }
          } else {
              /* Scaled and clipped string data */
              for (i = x = y = 0; i < n; i++) {
                  image->image8[y][x] = CLIP8((int)(p[i] * scale + offset))(((int)(p[i] * scale + offset)) <= 0 ? 0 : ((int)(p[i] * scale
 + offset)) < 256 ? ((int)(p[i] * scale + offset)) : 255);
                  if (++x >= (int)image->xsize) {
                      x = 0, y++;
                  }
              }
          }
      } else {
          seq = PySequence_Fast(data, must_be_sequence);
          if (!seq) {
              PyErr_SetString(PyExc_TypeError, must_be_sequence);
              return NULL((void*)0);
          }
          if (scale == 1.0 && offset == 0.0) {
              /* Clipped data */
              for (i = x = y = 0; i < n; i++) {
                  op = PySequence_Fast_GET_ITEM(seq, i)(((((((PyObject*)(seq))->ob_type))->tp_flags & ((1UL
 << 25))) != 0) ? (((PyListObject *)(seq))->ob_item[
i]) : ((((void) (0)), (PyTupleObject *)(seq))->ob_item[i])
);
                  image->image8[y][x] = (UINT8unsigned char)CLIP8(PyLong_AsLong(op))((PyLong_AsLong(op)) <= 0 ? 0 : (PyLong_AsLong(op)) < 256
 ? (PyLong_AsLong(op)) : 255);
                  if (++x >= (int)image->xsize) {
                      x = 0, y++;
                  }
              }

          } else {
              /* Scaled and clipped data */
              for (i = x = y = 0; i < n; i++) {
                  PyObject *op = PySequence_Fast_GET_ITEM(seq, i)(((((((PyObject*)(seq))->ob_type))->tp_flags & ((1UL
 << 25))) != 0) ? (((PyListObject *)(seq))->ob_item[
i]) : ((((void) (0)), (PyTupleObject *)(seq))->ob_item[i])
);
                  image->image8[y][x] =
                      CLIP8((int)(PyFloat_AsDouble(op) * scale + offset))(((int)(PyFloat_AsDouble(op) * scale + offset)) <= 0 ? 0 :
 ((int)(PyFloat_AsDouble(op) * scale + offset)) < 256 ? ((
int)(PyFloat_AsDouble(op) * scale + offset)) : 255);
                  if (++x >= (int)image->xsize) {
                      x = 0, y++;
                  }
              }
          }
          PyErr_Clear(); /* Avoid weird exceptions */
      }
  } else {
      /* 32-bit images */
      seq = PySequence_Fast(data, must_be_sequence);
      if (!seq) {
          PyErr_SetString(PyExc_TypeError, must_be_sequence);
          return NULL((void*)0);
      }
      switch (image->type) {
          case IMAGING_TYPE_INT321:
              for (i = x = y = 0; i < n; i++) {
                  op = PySequence_Fast_GET_ITEM(seq, i)(((((((PyObject*)(seq))->ob_type))->tp_flags & ((1UL
 << 25))) != 0) ? (((PyListObject *)(seq))->ob_item[
i]) : ((((void) (0)), (PyTupleObject *)(seq))->ob_item[i])
);
                  IMAGING_PIXEL_INT32(image, x, y)((image)->image32[(y)][(x)]) =
                      (INT32int)(PyFloat_AsDouble(op) * scale + offset);
                  if (++x >= (int)image->xsize) {
                      x = 0, y++;
                  }
              }
              PyErr_Clear(); /* Avoid weird exceptions */
              break;
          case IMAGING_TYPE_FLOAT322:
              for (i = x = y = 0; i < n; i++) {
                  op = PySequence_Fast_GET_ITEM(seq, i)(((((((PyObject*)(seq))->ob_type))->tp_flags & ((1UL
 << 25))) != 0) ? (((PyListObject *)(seq))->ob_item[
i]) : ((((void) (0)), (PyTupleObject *)(seq))->ob_item[i])
);
                  IMAGING_PIXEL_FLOAT32(image, x, y)(((float *)(image)->image32[y])[x]) =
                      (FLOAT32float)(PyFloat_AsDouble(op) * scale + offset);
                  if (++x >= (int)image->xsize) {
                      x = 0, y++;
                  }
              }
              PyErr_Clear(); /* Avoid weird exceptions */
              break;
          default:
              for (i = x = y = 0; i < n; i++) {
                  union {
                      char ink[4];
                      INT32int inkint;
                  } u;

                  u.inkint = 0;

                  op = PySequence_Fast_GET_ITEM(seq, i)(((((((PyObject*)(seq))->ob_type))->tp_flags & ((1UL
 << 25))) != 0) ? (((PyListObject *)(seq))->ob_item[
i]) : ((((void) (0)), (PyTupleObject *)(seq))->ob_item[i])
);
                  if (!op || !getink(op, image, u.ink)) {
                      Py_DECREF(seq)_Py_DECREF(((PyObject*)(seq)));
                      return NULL((void*)0);
                  }
                  /* FIXME: what about scale and offset? */
                  image->image32[y][x] = u.inkint;
                  if (++x >= (int)image->xsize) {
                      x = 0, y++;
                  }
              }
              PyErr_Clear(); /* Avoid weird exceptions */
              break;
      }
  }

  Py_XDECREF(seq)_Py_XDECREF(((PyObject*)(seq)));

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
1607}

1609#ifdef WITH_QUANTIZE

1611static PyObject *
1612_quantize(ImagingObject *self, PyObject *args) {
  int colours = 256;
  int method = 0;
  int kmeans = 0;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "|iii", &colours, &method, &kmeans)) {
      return NULL((void*)0);
  }

  if (!self->image->xsize || !self->image->ysize) {
      /* no content; return an empty image */
      return PyImagingNew(ImagingNew("P", self->image->xsize, self->image->ysize));
  }

  return PyImagingNew(ImagingQuantize(self->image, colours, method, kmeans));
1626}
1627#endif

1629static PyObject *
1630_putpalette(ImagingObject *self, PyObject *args) {
  ImagingShuffler unpack;
  int bits;

  char *rawmode;
  UINT8unsigned char *palette;
  Py_ssize_t palettesize;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "sy#", &rawmode, &palette, &palettesize)) {
      return NULL((void*)0);
  }

  if (strcmp(self->image->mode, "L") && strcmp(self->image->mode, "LA") &&
      strcmp(self->image->mode, "P") && strcmp(self->image->mode, "PA")) {
      PyErr_SetString(PyExc_ValueError, wrong_mode);
      return NULL((void*)0);
  }

  unpack = ImagingFindUnpacker("RGB", rawmode, &bits);
  if (!unpack) {
      PyErr_SetString(PyExc_ValueError, wrong_raw_mode);
      return NULL((void*)0);
  }

  if (palettesize * 8 / bits > 256) {
      PyErr_SetString(PyExc_ValueError, wrong_palette_size);
      return NULL((void*)0);
  }

  ImagingPaletteDelete(self->image->palette);

  strcpy(self->image->mode, strlen(self->image->mode) == 2 ? "PA" : "P");

  self->image->palette = ImagingPaletteNew("RGB");

  unpack(self->image->palette->palette, palette, palettesize * 8 / bits);

  return PyLong_FromLong(palettesize * 8 / bits);
1667}

1669static PyObject *
1670_putpalettealpha(ImagingObject *self, PyObject *args) {
  int index;
  int alpha = 0;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "i|i", &index, &alpha)) {
      return NULL((void*)0);
  }

  if (!self->image->palette) {
      PyErr_SetString(PyExc_ValueError, no_palette);
      return NULL((void*)0);
  }

  if (index < 0 || index >= 256) {
      PyErr_SetString(PyExc_ValueError, outside_palette);
      return NULL((void*)0);
  }

  strcpy(self->image->palette->mode, "RGBA");
  self->image->palette->palette[index * 4 + 3] = (UINT8unsigned char)alpha;

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
1692}

1694static PyObject *
1695_putpalettealphas(ImagingObject *self, PyObject *args) {
  int i;
  UINT8unsigned char *values;
  Py_ssize_t length;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "y#", &values, &length)) {
      return NULL((void*)0);
  }

  if (!self->image->palette) {
      PyErr_SetString(PyExc_ValueError, no_palette);
      return NULL((void*)0);
  }

  if (length > 256) {
      PyErr_SetString(PyExc_ValueError, outside_palette);
      return NULL((void*)0);
  }

  strcpy(self->image->palette->mode, "RGBA");
  for (i = 0; i < length; i++) {
      self->image->palette->palette[i * 4 + 3] = (UINT8unsigned char)values[i];
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
1720}

1722static PyObject *
1723_putpixel(ImagingObject *self, PyObject *args) {
  Imaging im;
  char ink[4];

  int x, y;
  PyObject *color;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "(ii)O", &x, &y, &color)) {
      return NULL((void*)0);
  }

  im = self->image;

  if (x < 0) {
      x = im->xsize + x;
  }
  if (y < 0) {
      y = im->ysize + y;
  }

  if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) {
      PyErr_SetString(PyExc_IndexError, outside_image);
      return NULL((void*)0);
  }

  if (!getink(color, im, ink)) {
      return NULL((void*)0);
  }

  if (self->access) {
      self->access->put_pixel(im, x, y, ink);
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
1757}

1759#ifdef WITH_RANKFILTER
1760static PyObject *
1761_rankfilter(ImagingObject *self, PyObject *args) {
  int size, rank;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "ii", &size, &rank)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingRankFilter(self->image, size, rank));
1768}
1769#endif

1771static PyObject *
1772_resize(ImagingObject *self, PyObject *args) {
  Imaging imIn;
  Imaging imOut;

  int xsize, ysize;
  int filter = IMAGING_TRANSFORM_NEAREST0;
  float box[4] = {0, 0, 0, 0};

  imIn = self->image;
  box[2] = imIn->xsize;
  box[3] = imIn->ysize;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
          args,
          "(ii)|i(ffff)",
          &xsize,
          &ysize,
          &filter,
          &box[0],
          &box[1],
          &box[2],
          &box[3])) {
      return NULL((void*)0);
  }

  if (xsize < 1 || ysize < 1) {
      return ImagingError_ValueError("height and width must be > 0");
  }

  if (box[0] < 0 || box[1] < 0) {
      return ImagingError_ValueError("box offset can't be negative");
  }

  if (box[2] > imIn->xsize || box[3] > imIn->ysize) {
      return ImagingError_ValueError("box can't exceed original image size");
  }

  if (box[2] - box[0] < 0 || box[3] - box[1] < 0) {
      return ImagingError_ValueError("box can't be empty");
  }

  // If box's coordinates are int and box size matches requested size
  if (box[0] - (int)box[0] == 0 && box[2] - box[0] == xsize &&
      box[1] - (int)box[1] == 0 && box[3] - box[1] == ysize) {
      imOut = ImagingCrop(imIn, box[0], box[1], box[2], box[3]);
  } else if (filter == IMAGING_TRANSFORM_NEAREST0) {
      double a[6];

      memset(a, 0, sizeof a);
      a[0] = (double)(box[2] - box[0]) / xsize;
      a[4] = (double)(box[3] - box[1]) / ysize;
      a[2] = box[0];
      a[5] = box[1];

      imOut = ImagingNewDirty(imIn->mode, xsize, ysize);

      imOut = ImagingTransform(
          imOut, imIn, IMAGING_TRANSFORM_AFFINE0, 0, 0, xsize, ysize, a, filter, 1);
  } else {
      imOut = ImagingResample(imIn, xsize, ysize, filter, box);
  }

  return PyImagingNew(imOut);
1835}

1837static PyObject *
1838_reduce(ImagingObject *self, PyObject *args) {
  Imaging imIn;
  Imaging imOut;

  int xscale, yscale;
  int box[4] = {0, 0, 0, 0};

  imIn = self->image;
  box[2] = imIn->xsize;
  box[3] = imIn->ysize;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
          args,
          "(ii)|(iiii)",
          &xscale,
          &yscale,
          &box[0],
          &box[1],
          &box[2],
          &box[3])) {
      return NULL((void*)0);
  }

  if (xscale < 1 || yscale < 1) {
      return ImagingError_ValueError("scale must be > 0");
  }

  if (box[0] < 0 || box[1] < 0) {
      return ImagingError_ValueError("box offset can't be negative");
  }

  if (box[2] > imIn->xsize || box[3] > imIn->ysize) {
      return ImagingError_ValueError("box can't exceed original image size");
  }

  if (box[2] <= box[0] || box[3] <= box[1]) {
      return ImagingError_ValueError("box can't be empty");
  }

  if (xscale == 1 && yscale == 1) {
      imOut = ImagingCrop(imIn, box[0], box[1], box[2], box[3]);
  } else {
      // Change box format: (left, top, width, height)
      box[2] -= box[0];
      box[3] -= box[1];
      imOut = ImagingReduce(imIn, xscale, yscale, box);
  }

  return PyImagingNew(imOut);
1887}

1889#define IS_RGB(mode)(!strcmp(mode, "RGB") || !strcmp(mode, "RGBA") || !strcmp(mode
, "RGBX")) \
  (!strcmp(mode, "RGB") || !strcmp(mode, "RGBA") || !strcmp(mode, "RGBX"))

1892static PyObject *
1893im_setmode(ImagingObject *self, PyObject *args) {
  /* attempt to modify the mode of an image in place */

  Imaging im;

  char *mode;
  Py_ssize_t modelen;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "s#:setmode", &mode, &modelen)) {
      return NULL((void*)0);
  }

  im = self->image;

  /* move all logic in here to the libImaging primitive */

  if (!strcmp(im->mode, mode)) {
      ; /* same mode; always succeeds */
  } else if (IS_RGB(im->mode)(!strcmp(im->mode, "RGB") || !strcmp(im->mode, "RGBA") ||
 !strcmp(im->mode, "RGBX")) && IS_RGB(mode)(!strcmp(mode, "RGB") || !strcmp(mode, "RGBA") || !strcmp(mode
, "RGBX"))) {
      /* color to color */
      strcpy(im->mode, mode);
      im->bands = modelen;
      if (!strcmp(mode, "RGBA")) {
          (void)ImagingFillBand(im, 3, 255);
      }
  } else {
      /* trying doing an in-place conversion */
      if (!ImagingConvertInPlace(im, mode)) {
          return NULL((void*)0);
      }
  }

  if (self->access) {
      ImagingAccessDelete(im, self->access);
  }
  self->access = ImagingAccessNew(im);

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
1931}

1933static PyObject *
1934_transform2(ImagingObject *self, PyObject *args) {
  static const char *wrong_number = "wrong number of matrix entries";

  Imaging imOut;
  Py_ssize_t n;
  double *a;

  ImagingObject *imagep;
  int x0, y0, x1, y1;
  int method;
  PyObject *data;
  int filter = IMAGING_TRANSFORM_NEAREST0;
  int fill = 1;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
          args,
          "(iiii)O!iO|ii",
          &x0,
          &y0,
          &x1,
          &y1,
          &Imaging_Type,
          &imagep,
          &method,
          &data,
          &filter,
          &fill)) {
      return NULL((void*)0);
  }

  switch (method) {
      case IMAGING_TRANSFORM_AFFINE0:
          n = 6;
          break;
      case IMAGING_TRANSFORM_PERSPECTIVE2:
          n = 8;
          break;
      case IMAGING_TRANSFORM_QUAD3:
          n = 8;
          break;
      default:
          n = -1; /* force error */
  }

  a = getlist(data, &n, wrong_number, TYPE_DOUBLE(0x400 | sizeof(double)));
  if (!a) {
      return NULL((void*)0);
  }

  imOut = ImagingTransform(
      self->image, imagep->image, method, x0, y0, x1, y1, a, filter, fill);

  free(a);

  if (!imOut) {
      return NULL((void*)0);
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
1993}

1995static PyObject *
1996_transpose(ImagingObject *self, PyObject *args) {
  Imaging imIn;
  Imaging imOut;

  int op;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "i", &op)) {
      return NULL((void*)0);
  }

  imIn = self->image;

  switch (op) {
      case 0: /* flip left right */
      case 1: /* flip top bottom */
      case 3: /* rotate 180 */
          imOut = ImagingNewDirty(imIn->mode, imIn->xsize, imIn->ysize);
          break;
      case 2: /* rotate 90 */
      case 4: /* rotate 270 */
      case 5: /* transpose */
      case 6: /* transverse */
          imOut = ImagingNewDirty(imIn->mode, imIn->ysize, imIn->xsize);
          break;
      default:
          PyErr_SetString(PyExc_ValueError, "No such transpose operation");
          return NULL((void*)0);
  }

  if (imOut) {
      switch (op) {
          case 0:
              (void)ImagingFlipLeftRight(imOut, imIn);
              break;
          case 1:
              (void)ImagingFlipTopBottom(imOut, imIn);
              break;
          case 2:
              (void)ImagingRotate90(imOut, imIn);
              break;
          case 3:
              (void)ImagingRotate180(imOut, imIn);
              break;
          case 4:
              (void)ImagingRotate270(imOut, imIn);
              break;
          case 5:
              (void)ImagingTranspose(imOut, imIn);
              break;
          case 6:
              (void)ImagingTransverse(imOut, imIn);
              break;
      }
  }

  return PyImagingNew(imOut);
2051}

2053#ifdef WITH_UNSHARPMASK
2054static PyObject *
2055_unsharp_mask(ImagingObject *self, PyObject *args) {
  Imaging imIn;
  Imaging imOut;

  float radius;
  int percent, threshold;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "fii", &radius, &percent, &threshold)) {
      return NULL((void*)0);
  }

  imIn = self->image;
  imOut = ImagingNewDirty(imIn->mode, imIn->xsize, imIn->ysize);
  if (!imOut) {
      return NULL((void*)0);
  }

  if (!ImagingUnsharpMask(imOut, imIn, radius, percent, threshold)) {
      return NULL((void*)0);
  }

  return PyImagingNew(imOut);
2076}
2077#endif

2079static PyObject *
2080_box_blur(ImagingObject *self, PyObject *args) {
  Imaging imIn;
  Imaging imOut;

  float radius;
  int n = 1;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "f|i", &radius, &n)) {
      return NULL((void*)0);
  }

  imIn = self->image;
  imOut = ImagingNewDirty(imIn->mode, imIn->xsize, imIn->ysize);
  if (!imOut) {
      return NULL((void*)0);
  }

  if (!ImagingBoxBlur(imOut, imIn, radius, n)) {
      ImagingDelete(imOut);
      return NULL((void*)0);
  }

  return PyImagingNew(imOut);
2102}

2104/* -------------------------------------------------------------------- */

2106static PyObject *
2107_isblock(ImagingObject *self) {
  return PyBool_FromLong(self->image->block != NULL((void*)0));
2109}

2111static PyObject *
2112_getbbox(ImagingObject *self) {
  int bbox[4];
  if (!ImagingGetBBox(self->image, bbox)) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  return Py_BuildValue_Py_BuildValue_SizeT("iiii", bbox[0], bbox[1], bbox[2], bbox[3]);
2120}

2122static PyObject *
2123_getcolors(ImagingObject *self, PyObject *args) {
  ImagingColorItem *items;
  int i, colors;
  PyObject *out;

  int maxcolors = 256;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "i:getcolors", &maxcolors)) {
      return NULL((void*)0);
  }

  items = ImagingGetColors(self->image, maxcolors, &colors);
  if (!items) {
      return NULL((void*)0);
  }

  if (colors > maxcolors) {
      out = Py_None(&_Py_NoneStruct);
      Py_INCREF(out)_Py_INCREF(((PyObject*)(out)));
  } else {
      out = PyList_New(colors);
      for (i = 0; i < colors; i++) {
          ImagingColorItem *v = &items[i];
          PyObject *item = Py_BuildValue_Py_BuildValue_SizeT(
              "iN", v->count, getpixel(self->image, self->access, v->x, v->y));
          PyList_SetItem(out, i, item);
      }
  }

  free(items);

  return out;
2154}

2156static PyObject *
2157_getextrema(ImagingObject *self) {
  union {
      UINT8unsigned char u[2];
      INT32int i[2];
      FLOAT32float f[2];
      UINT16unsigned short s[2];
  } extrema;
  int status;

  status = ImagingGetExtrema(self->image, &extrema);
  if (status < 0) {
      return NULL((void*)0);
  }

  if (status) {
      switch (self->image->type) {
          case IMAGING_TYPE_UINT80:
              return Py_BuildValue_Py_BuildValue_SizeT("BB", extrema.u[0], extrema.u[1]);
          case IMAGING_TYPE_INT321:
              return Py_BuildValue_Py_BuildValue_SizeT("ii", extrema.i[0], extrema.i[1]);
          case IMAGING_TYPE_FLOAT322:
              return Py_BuildValue_Py_BuildValue_SizeT("dd", extrema.f[0], extrema.f[1]);
          case IMAGING_TYPE_SPECIAL3:
              if (strcmp(self->image->mode, "I;16") == 0) {
                  return Py_BuildValue_Py_BuildValue_SizeT("HH", extrema.s[0], extrema.s[1]);
              }
      }
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
2188}

2190static PyObject *
2191_getprojection(ImagingObject *self) {
  unsigned char *xprofile;
  unsigned char *yprofile;
  PyObject *result;

  /* malloc check ok */
  xprofile = malloc(self->image->xsize);
  yprofile = malloc(self->image->ysize);

  if (xprofile == NULL((void*)0) || yprofile == NULL((void*)0)) {
      free(xprofile);
      free(yprofile);
      return ImagingError_MemoryError();
  }

  ImagingGetProjection(
      self->image, (unsigned char *)xprofile, (unsigned char *)yprofile);

  result = Py_BuildValue_Py_BuildValue_SizeT(
      "y#y#",
      xprofile,
      (Py_ssize_t)self->image->xsize,
      yprofile,
      (Py_ssize_t)self->image->ysize);

  free(xprofile);
  free(yprofile);

  return result;
2220}

2222/* -------------------------------------------------------------------- */

2224static PyObject *
2225_getband(ImagingObject *self, PyObject *args) {
  int band;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "i", &band)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingGetBand(self->image, band));
2233}

2235static PyObject *
2236_fillband(ImagingObject *self, PyObject *args) {
  int band;
  int color;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "ii", &band, &color)) {
      return NULL((void*)0);
  }

  if (!ImagingFillBand(self->image, band, color)) {
      return NULL((void*)0);
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
2250}

2252static PyObject *
2253_putband(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep;
  int band;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O!i", &Imaging_Type, &imagep, &band)) {
      return NULL((void*)0);
  }

  if (!ImagingPutBand(self->image, imagep->image, band)) {
      return NULL((void*)0);
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
2266}

2268static PyObject *
2269_merge(PyObject *self, PyObject *args) {
  char *mode;
  ImagingObject *band0 = NULL((void*)0);
  ImagingObject *band1 = NULL((void*)0);
  ImagingObject *band2 = NULL((void*)0);
  ImagingObject *band3 = NULL((void*)0);
  Imaging bands[4] = {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)};

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
          args,
          "sO!|O!O!O!",
          &mode,
          &Imaging_Type,
          &band0,
          &Imaging_Type,
          &band1,
          &Imaging_Type,
          &band2,
          &Imaging_Type,
          &band3)) {
      return NULL((void*)0);
  }

  if (band0) {
      bands[0] = band0->image;
  }
  if (band1) {
      bands[1] = band1->image;
  }
  if (band2) {
      bands[2] = band2->image;
  }
  if (band3) {
      bands[3] = band3->image;
  }

  return PyImagingNew(ImagingMerge(mode, bands));
2306}

2308static PyObject *
2309_split(ImagingObject *self) {
  int fails = 0;
  Py_ssize_t i;
  PyObject *list;
  PyObject *imaging_object;
  Imaging bands[4] = {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)};

  if (!ImagingSplit(self->image, bands)) {
      return NULL((void*)0);
  }

  list = PyTuple_New(self->image->bands);
  for (i = 0; i < self->image->bands; i++) {
      imaging_object = PyImagingNew(bands[i]);
      if (!imaging_object) {
          fails += 1;
      }
      PyTuple_SET_ITEM(list, i, imaging_object)PyTuple_SetItem(list, i, imaging_object);
  }
  if (fails) {
      Py_DECREF(list)_Py_DECREF(((PyObject*)(list)));
      list = NULL((void*)0);
  }
  return list;
2333}

2335/* -------------------------------------------------------------------- */

2337#ifdef WITH_IMAGECHOPS

2339static PyObject *
2340_chop_invert(ImagingObject *self) {
  return PyImagingNew(ImagingNegative(self->image));
2342}

2344static PyObject *
2345_chop_lighter(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O!", &Imaging_Type, &imagep)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingChopLighter(self->image, imagep->image));
2353}

2355static PyObject *
2356_chop_darker(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O!", &Imaging_Type, &imagep)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingChopDarker(self->image, imagep->image));
2364}

2366static PyObject *
2367_chop_difference(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O!", &Imaging_Type, &imagep)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingChopDifference(self->image, imagep->image));
2375}

2377static PyObject *
2378_chop_multiply(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O!", &Imaging_Type, &imagep)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingChopMultiply(self->image, imagep->image));
2386}

2388static PyObject *
2389_chop_screen(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O!", &Imaging_Type, &imagep)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingChopScreen(self->image, imagep->image));
2397}

2399static PyObject *
2400_chop_add(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep;
  float scale;
  int offset;

  scale = 1.0;
  offset = 0;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O!|fi", &Imaging_Type, &imagep, &scale, &offset)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingChopAdd(self->image, imagep->image, scale, offset));
2413}

2415static PyObject *
2416_chop_subtract(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep;
  float scale;
  int offset;

  scale = 1.0;
  offset = 0;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O!|fi", &Imaging_Type, &imagep, &scale, &offset)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingChopSubtract(self->image, imagep->image, scale, offset));
2429}

2431static PyObject *
2432_chop_and(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O!", &Imaging_Type, &imagep)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingChopAnd(self->image, imagep->image));
2440}

2442static PyObject *
2443_chop_or(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O!", &Imaging_Type, &imagep)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingChopOr(self->image, imagep->image));
2451}

2453static PyObject *
2454_chop_xor(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O!", &Imaging_Type, &imagep)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingChopXor(self->image, imagep->image));
2462}

2464static PyObject *
2465_chop_add_modulo(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O!", &Imaging_Type, &imagep)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingChopAddModulo(self->image, imagep->image));
2473}

2475static PyObject *
2476_chop_subtract_modulo(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O!", &Imaging_Type, &imagep)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingChopSubtractModulo(self->image, imagep->image));
2484}

2486static PyObject *
2487_chop_soft_light(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O!", &Imaging_Type, &imagep)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingChopSoftLight(self->image, imagep->image));
2495}

2497static PyObject *
2498_chop_hard_light(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O!", &Imaging_Type, &imagep)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingChopHardLight(self->image, imagep->image));
2506}

2508static PyObject *
2509_chop_overlay(ImagingObject *self, PyObject *args) {
  ImagingObject *imagep;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O!", &Imaging_Type, &imagep)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingOverlay(self->image, imagep->image));
2517}
2518#endif

2520/* -------------------------------------------------------------------- */

2522#ifdef WITH_IMAGEDRAW

2524static PyObject *
2525_font_new(PyObject *self_, PyObject *args) {
  ImagingFontObject *self;
  int i, y0, y1;
  static const char *wrong_length = "descriptor table has wrong size";

  ImagingObject *imagep;
  unsigned char *glyphdata;
  Py_ssize_t glyphdata_length;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
          args, "O!y#", &Imaging_Type, &imagep, &glyphdata, &glyphdata_length)) {
      return NULL((void*)0);
  }

  if (glyphdata_length != 256 * 20) {
      PyErr_SetString(PyExc_ValueError, wrong_length);
      return NULL((void*)0);
  }

  self = PyObject_New(ImagingFontObject, &ImagingFont_Type)( (ImagingFontObject *) _PyObject_New(&ImagingFont_Type) );
  if (self == NULL((void*)0)) {
      return NULL((void*)0);
  }

  /* glyph bitmap */
  self->bitmap = imagep->image;

  y0 = y1 = 0;

  /* glyph glyphs */
  for (i = 0; i < 256; i++) {
      self->glyphs[i].dx = S16(B16(glyphdata, 0))((((((int)glyphdata[(0)]) << 8) + glyphdata[(0) + 1])) <
? (((((int)glyphdata[(0)]) << 8) + glyphdata[(0)
 + 1])) : ((((((int)glyphdata[(0)]) << 8) + glyphdata[(
0) + 1]))-65536));
      self->glyphs[i].dy = S16(B16(glyphdata, 2))((((((int)glyphdata[(2)]) << 8) + glyphdata[(2) + 1])) <
? (((((int)glyphdata[(2)]) << 8) + glyphdata[(2)
 + 1])) : ((((((int)glyphdata[(2)]) << 8) + glyphdata[(
2) + 1]))-65536));
      self->glyphs[i].dx0 = S16(B16(glyphdata, 4))((((((int)glyphdata[(4)]) << 8) + glyphdata[(4) + 1])) <
? (((((int)glyphdata[(4)]) << 8) + glyphdata[(4)
 + 1])) : ((((((int)glyphdata[(4)]) << 8) + glyphdata[(
4) + 1]))-65536));
      self->glyphs[i].dy0 = S16(B16(glyphdata, 6))((((((int)glyphdata[(6)]) << 8) + glyphdata[(6) + 1])) <
? (((((int)glyphdata[(6)]) << 8) + glyphdata[(6)
 + 1])) : ((((((int)glyphdata[(6)]) << 8) + glyphdata[(
6) + 1]))-65536));
      self->glyphs[i].dx1 = S16(B16(glyphdata, 8))((((((int)glyphdata[(8)]) << 8) + glyphdata[(8) + 1])) <
? (((((int)glyphdata[(8)]) << 8) + glyphdata[(8)
 + 1])) : ((((((int)glyphdata[(8)]) << 8) + glyphdata[(
8) + 1]))-65536));
      self->glyphs[i].dy1 = S16(B16(glyphdata, 10))((((((int)glyphdata[(10)]) << 8) + glyphdata[(10) + 1])
) < 32768 ? (((((int)glyphdata[(10)]) << 8) + glyphdata
[(10) + 1])) : ((((((int)glyphdata[(10)]) << 8) + glyphdata
[(10) + 1]))-65536));
      self->glyphs[i].sx0 = S16(B16(glyphdata, 12))((((((int)glyphdata[(12)]) << 8) + glyphdata[(12) + 1])
) < 32768 ? (((((int)glyphdata[(12)]) << 8) + glyphdata
[(12) + 1])) : ((((((int)glyphdata[(12)]) << 8) + glyphdata
[(12) + 1]))-65536));
      self->glyphs[i].sy0 = S16(B16(glyphdata, 14))((((((int)glyphdata[(14)]) << 8) + glyphdata[(14) + 1])
) < 32768 ? (((((int)glyphdata[(14)]) << 8) + glyphdata
[(14) + 1])) : ((((((int)glyphdata[(14)]) << 8) + glyphdata
[(14) + 1]))-65536));
      self->glyphs[i].sx1 = S16(B16(glyphdata, 16))((((((int)glyphdata[(16)]) << 8) + glyphdata[(16) + 1])
) < 32768 ? (((((int)glyphdata[(16)]) << 8) + glyphdata
[(16) + 1])) : ((((((int)glyphdata[(16)]) << 8) + glyphdata
[(16) + 1]))-65536));
      self->glyphs[i].sy1 = S16(B16(glyphdata, 18))((((((int)glyphdata[(18)]) << 8) + glyphdata[(18) + 1])
) < 32768 ? (((((int)glyphdata[(18)]) << 8) + glyphdata
[(18) + 1])) : ((((((int)glyphdata[(18)]) << 8) + glyphdata
[(18) + 1]))-65536));
      if (self->glyphs[i].dy0 < y0) {
          y0 = self->glyphs[i].dy0;
      }
      if (self->glyphs[i].dy1 > y1) {
          y1 = self->glyphs[i].dy1;
      }
      glyphdata += 20;
  }

  self->baseline = -y0;
  self->ysize = y1 - y0;

  /* keep a reference to the bitmap object */
  Py_INCREF(imagep)_Py_INCREF(((PyObject*)(imagep)));
  self->ref = imagep;

  return (PyObject *)self;
2582}

2584static void
2585_font_dealloc(ImagingFontObject *self) {
  Py_XDECREF(self->ref)_Py_XDECREF(((PyObject*)(self->ref)));
  PyObject_DelPyObject_Free(self);
2588}

2590static inline int
2591textwidth(ImagingFontObject *self, const unsigned char *text) {
  int xsize;

  for (xsize = 0; *text; text++) {
      xsize += self->glyphs[*text].dx;
  }

  return xsize;
2599}

2601void
2602_font_text_asBytes(PyObject *encoded_string, unsigned char **text) {
  /* Allocates *text, returns a 'new reference'. Caller is required to free */

  PyObject *bytes = NULL((void*)0);
  Py_ssize_t len = 0;
  char *buffer;

  *text = NULL((void*)0);

  if (PyUnicode_CheckExact(encoded_string)((((PyObject*)(encoded_string))->ob_type) == &PyUnicode_Type
)) {
      bytes = PyUnicode_AsLatin1String(encoded_string);
      if (!bytes) {
          return;
      }
      PyBytes_AsStringAndSize(bytes, &buffer, &len);
  } else if (PyBytes_Check(encoded_string)((((((PyObject*)(encoded_string))->ob_type))->tp_flags &
 ((1UL << 27))) != 0)) {
      PyBytes_AsStringAndSize(encoded_string, &buffer, &len);
  }

  *text = calloc(len + 1, 1);
  if (*text) {
      memcpy(*text, buffer, len);
  } else {
      ImagingError_MemoryError();
  }
  if (bytes) {
      Py_DECREF(bytes)_Py_DECREF(((PyObject*)(bytes)));
  }

  return;
2632}

2634static PyObject *
2635_font_getmask(ImagingFontObject *self, PyObject *args) {
  Imaging im;
  Imaging bitmap;
  int x, b;
  int i = 0;
  int status;
  Glyph *glyph;

  PyObject *encoded_string;

  unsigned char *text;
  char *mode = "";

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O|s:getmask", &encoded_string, &mode)) {
      return NULL((void*)0);
  }

  _font_text_asBytes(encoded_string, &text);
  if (!text) {
      return NULL((void*)0);
  }

  im = ImagingNew(self->bitmap->mode, textwidth(self, text), self->ysize);
  if (!im) {
      free(text);
      return ImagingError_MemoryError();
  }

  b = 0;
  (void)ImagingFill(im, &b);

  b = self->baseline;
  for (x = 0; text[i]; i++) {
      glyph = &self->glyphs[text[i]];
      bitmap =
          ImagingCrop(self->bitmap, glyph->sx0, glyph->sy0, glyph->sx1, glyph->sy1);
      if (!bitmap) {
          goto failed;
      }
      status = ImagingPaste(
          im,
          bitmap,
          NULL((void*)0),
          glyph->dx0 + x,
          glyph->dy0 + b,
          glyph->dx1 + x,
          glyph->dy1 + b);
      ImagingDelete(bitmap);
      if (status < 0) {
          goto failed;
      }
      x = x + glyph->dx;
      b = b + glyph->dy;
  }
  free(text);
  return PyImagingNew(im);

2692failed:
  free(text);
  ImagingDelete(im);
  Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
2696}

2698static PyObject *
2699_font_getsize(ImagingFontObject *self, PyObject *args) {
  unsigned char *text;
  PyObject *encoded_string;
  PyObject *val;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O:getsize", &encoded_string)) {
      return NULL((void*)0);
  }

  _font_text_asBytes(encoded_string, &text);
  if (!text) {
      return NULL((void*)0);
  }

  val = Py_BuildValue_Py_BuildValue_SizeT("ii", textwidth(self, text), self->ysize);
  free(text);
  return val;
2716}

2718static struct PyMethodDef _font_methods[] = {
  {"getmask", (PyCFunction)_font_getmask, METH_VARARGS0x0001},
  {"getsize", (PyCFunction)_font_getsize, METH_VARARGS0x0001},
  {NULL((void*)0), NULL((void*)0)} /* sentinel */
2722};

2724/* -------------------------------------------------------------------- */

2726static PyObject *
2727_draw_new(PyObject *self_, PyObject *args) {
  ImagingDrawObject *self;

  ImagingObject *imagep;
  int blend = 0;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O!|i", &Imaging_Type, &imagep, &blend)) {
      return NULL((void*)0);
  }

  self = PyObject_New(ImagingDrawObject, &ImagingDraw_Type)( (ImagingDrawObject *) _PyObject_New(&ImagingDraw_Type) );
  if (self == NULL((void*)0)) {
      return NULL((void*)0);
  }

  /* keep a reference to the image object */
  Py_INCREF(imagep)_Py_INCREF(((PyObject*)(imagep)));
  self->image = imagep;

  self->ink[0] = self->ink[1] = self->ink[2] = self->ink[3] = 0;

  self->blend = blend;

  return (PyObject *)self;
2750}

2752static void
2753_draw_dealloc(ImagingDrawObject *self) {
  Py_XDECREF(self->image)_Py_XDECREF(((PyObject*)(self->image)));
  PyObject_DelPyObject_Free(self);
2756}

2758extern Py_ssize_t
2759PyPath_Flatten(PyObject *data, double **xy);

2761static PyObject *
2762_draw_ink(ImagingDrawObject *self, PyObject *args) {
  INT32int ink = 0;
  PyObject *color;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O", &color)) {
      return NULL((void*)0);
  }

  if (!getink(color, self->image->image, (char *)&ink)) {
      return NULL((void*)0);
  }

  return PyLong_FromLong((int)ink);
2774}

2776static PyObject *
2777_draw_arc(ImagingDrawObject *self, PyObject *args) {
  double *xy;
  Py_ssize_t n;

  PyObject *data;
  int ink;
  int width = 0;
  float start, end;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "Offi|i", &data, &start, &end, &ink, &width)) {
      return NULL((void*)0);
  }

  n = PyPath_Flatten(data, &xy);
  if (n < 0) {
      return NULL((void*)0);
  }
  if (n != 2) {
      PyErr_SetString(PyExc_TypeError, must_be_two_coordinates);
      free(xy);
      return NULL((void*)0);
  }

  n = ImagingDrawArc(
      self->image->image,
      (int)xy[0],
      (int)xy[1],
      (int)xy[2],
      (int)xy[3],
      start,
      end,
      &ink,
      width,
      self->blend);

  free(xy);

  if (n < 0) {
      return NULL((void*)0);
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
2819}

2821static PyObject *
2822_draw_bitmap(ImagingDrawObject *self, PyObject *args) {
  double *xy;
  Py_ssize_t n;

  PyObject *data;
  ImagingObject *bitmap;
  int ink;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "OO!i", &data, &Imaging_Type, &bitmap, &ink)) {
      return NULL((void*)0);
  }

  n = PyPath_Flatten(data, &xy);
  if (n < 0) {
      return NULL((void*)0);
  }
  if (n != 1) {
      PyErr_SetString(
          PyExc_TypeError, "coordinate list must contain exactly 1 coordinate");
      free(xy);
      return NULL((void*)0);
  }

  n = ImagingDrawBitmap(
      self->image->image, (int)xy[0], (int)xy[1], bitmap->image, &ink, self->blend);

  free(xy);

  if (n < 0) {
      return NULL((void*)0);
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
2855}

2857static PyObject *
2858_draw_chord(ImagingDrawObject *self, PyObject *args) {
  double *xy;
  Py_ssize_t n;

  PyObject *data;
  int ink, fill;
  int width = 0;
  float start, end;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "Offii|i", &data, &start, &end, &ink, &fill, &width)) {
      return NULL((void*)0);
  }

  n = PyPath_Flatten(data, &xy);
  if (n < 0) {
      return NULL((void*)0);
  }
  if (n != 2) {
      PyErr_SetString(PyExc_TypeError, must_be_two_coordinates);
      free(xy);
      return NULL((void*)0);
  }

  n = ImagingDrawChord(
      self->image->image,
      (int)xy[0],
      (int)xy[1],
      (int)xy[2],
      (int)xy[3],
      start,
      end,
      &ink,
      fill,
      width,
      self->blend);

  free(xy);

  if (n < 0) {
      return NULL((void*)0);
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
2901}

2903static PyObject *
2904_draw_ellipse(ImagingDrawObject *self, PyObject *args) {
  double *xy;
  Py_ssize_t n;

  PyObject *data;
  int ink;
  int fill = 0;
  int width = 0;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "Oi|ii", &data, &ink, &fill, &width)) {
      return NULL((void*)0);
  }

  n = PyPath_Flatten(data, &xy);
  if (n < 0) {
      return NULL((void*)0);
  }
  if (n != 2) {
      PyErr_SetString(PyExc_TypeError, must_be_two_coordinates);
      free(xy);
      return NULL((void*)0);
  }

  n = ImagingDrawEllipse(
      self->image->image,
      (int)xy[0],
      (int)xy[1],
      (int)xy[2],
      (int)xy[3],
      &ink,
      fill,
      width,
      self->blend);

  free(xy);

  if (n < 0) {
      return NULL((void*)0);
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
2945}

2947static PyObject *
2948_draw_lines(ImagingDrawObject *self, PyObject *args) {
  double *xy;
  Py_ssize_t i, n;

  PyObject *data;
  int ink;
  int width = 0;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "Oi|i", &data, &ink, &width)) {
      return NULL((void*)0);
  }

  n = PyPath_Flatten(data, &xy);
  if (n < 0) {
      return NULL((void*)0);
  }

  if (width <= 1) {
      double *p = NULL((void*)0);
      for (i = 0; i < n - 1; i++) {
          p = &xy[i + i];
          if (ImagingDrawLine(
                  self->image->image,
                  (int)p[0],
                  (int)p[1],
                  (int)p[2],
                  (int)p[3],
                  &ink,
                  self->blend) < 0) {
              free(xy);
              return NULL((void*)0);
          }
      }
      if (p) { /* draw last point */
          ImagingDrawPoint(
              self->image->image, (int)p[2], (int)p[3], &ink, self->blend);
      }
  } else {
      for (i = 0; i < n - 1; i++) {
          double *p = &xy[i + i];
          if (ImagingDrawWideLine(
                  self->image->image,
                  (int)p[0],
                  (int)p[1],
                  (int)p[2],
                  (int)p[3],
                  &ink,
                  width,
                  self->blend) < 0) {
              free(xy);
              return NULL((void*)0);
          }
      }
  }

  free(xy);

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
3006}

3008static PyObject *
3009_draw_points(ImagingDrawObject *self, PyObject *args) {
  double *xy;
  Py_ssize_t i, n;

  PyObject *data;
  int ink;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "Oi", &data, &ink)) {
      return NULL((void*)0);
  }

  n = PyPath_Flatten(data, &xy);
  if (n < 0) {
      return NULL((void*)0);
  }

  for (i = 0; i < n; i++) {
      double *p = &xy[i + i];
      if (ImagingDrawPoint(
              self->image->image, (int)p[0], (int)p[1], &ink, self->blend) < 0) {
          free(xy);
          return NULL((void*)0);
      }
  }

  free(xy);

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
3037}

3039#ifdef WITH_ARROW

3041/* from outline.c */
3042extern ImagingOutline
3043PyOutline_AsOutline(PyObject *outline);

3045static PyObject *
3046_draw_outline(ImagingDrawObject *self, PyObject *args) {
  ImagingOutline outline;

  PyObject *outline_;
  int ink;
  int fill = 0;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "Oi|i", &outline_, &ink, &fill)) {
      return NULL((void*)0);
  }

  outline = PyOutline_AsOutline(outline_);
  if (!outline) {
      PyErr_SetString(PyExc_TypeError, "expected outline object");
      return NULL((void*)0);
  }

  if (ImagingDrawOutline(self->image->image, outline, &ink, fill, self->blend) < 0) {
      return NULL((void*)0);
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
3068}

3070#endif

3072static PyObject *
3073_draw_pieslice(ImagingDrawObject *self, PyObject *args) {
  double *xy;
  Py_ssize_t n;

  PyObject *data;
  int ink, fill;
  int width = 0;
  float start, end;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "Offii|i", &data, &start, &end, &ink, &fill, &width)) {
      return NULL((void*)0);
  }

  n = PyPath_Flatten(data, &xy);
  if (n < 0) {
      return NULL((void*)0);
  }
  if (n != 2) {
      PyErr_SetString(PyExc_TypeError, must_be_two_coordinates);
      free(xy);
      return NULL((void*)0);
  }

  n = ImagingDrawPieslice(
      self->image->image,
      (int)xy[0],
      (int)xy[1],
      (int)xy[2],
      (int)xy[3],
      start,
      end,
      &ink,
      fill,
      width,
      self->blend);

  free(xy);

  if (n < 0) {
      return NULL((void*)0);
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
3116}

3118static PyObject *
3119_draw_polygon(ImagingDrawObject *self, PyObject *args) {
  double *xy;
  int *ixy;
  Py_ssize_t n, i;

  PyObject *data;
  int ink;
  int fill = 0;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "Oi|i", &data, &ink, &fill)) {
      return NULL((void*)0);
  }

  n = PyPath_Flatten(data, &xy);
  if (n < 0) {
      return NULL((void*)0);
  }
  if (n < 2) {
      PyErr_SetString(
          PyExc_TypeError, "coordinate list must contain at least 2 coordinates");
      free(xy);
      return NULL((void*)0);
  }

  /* Copy list of vertices to array */
  ixy = (int *)calloc(n, 2 * sizeof(int));
  if (ixy == NULL((void*)0)) {
      free(xy);
      return ImagingError_MemoryError();
  }

  for (i = 0; i < n; i++) {
      ixy[i + i] = (int)xy[i + i];
      ixy[i + i + 1] = (int)xy[i + i + 1];
  }

  free(xy);

  if (ImagingDrawPolygon(self->image->image, n, ixy, &ink, fill, self->blend) < 0) {
      free(ixy);
      return NULL((void*)0);
  }

  free(ixy);

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
3165}

3167static PyObject *
3168_draw_rectangle(ImagingDrawObject *self, PyObject *args) {
  double *xy;
  Py_ssize_t n;

  PyObject *data;
  int ink;
  int fill = 0;
  int width = 0;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "Oi|ii", &data, &ink, &fill, &width)) {
      return NULL((void*)0);
  }

  n = PyPath_Flatten(data, &xy);
  if (n < 0) {
      return NULL((void*)0);
  }
  if (n != 2) {
      PyErr_SetString(PyExc_TypeError, must_be_two_coordinates);
      free(xy);
      return NULL((void*)0);
  }

  n = ImagingDrawRectangle(
      self->image->image,
      (int)xy[0],
      (int)xy[1],
      (int)xy[2],
      (int)xy[3],
      &ink,
      fill,
      width,
      self->blend);

  free(xy);

  if (n < 0) {
      return NULL((void*)0);
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
3209}

3211static struct PyMethodDef _draw_methods[] = {
3212#ifdef WITH_IMAGEDRAW
  /* Graphics (ImageDraw) */
  {"draw_lines", (PyCFunction)_draw_lines, METH_VARARGS0x0001},
3215#ifdef WITH_ARROW
  {"draw_outline", (PyCFunction)_draw_outline, METH_VARARGS0x0001},
3217#endif
  {"draw_polygon", (PyCFunction)_draw_polygon, METH_VARARGS0x0001},
  {"draw_rectangle", (PyCFunction)_draw_rectangle, METH_VARARGS0x0001},
  {"draw_points", (PyCFunction)_draw_points, METH_VARARGS0x0001},
  {"draw_arc", (PyCFunction)_draw_arc, METH_VARARGS0x0001},
  {"draw_bitmap", (PyCFunction)_draw_bitmap, METH_VARARGS0x0001},
  {"draw_chord", (PyCFunction)_draw_chord, METH_VARARGS0x0001},
  {"draw_ellipse", (PyCFunction)_draw_ellipse, METH_VARARGS0x0001},
  {"draw_pieslice", (PyCFunction)_draw_pieslice, METH_VARARGS0x0001},
  {"draw_ink", (PyCFunction)_draw_ink, METH_VARARGS0x0001},
3227#endif
  {NULL((void*)0), NULL((void*)0)} /* sentinel */
3229};

3231#endif

3233static PyObject *
3234pixel_access_new(ImagingObject *imagep, PyObject *args) {
  PixelAccessObject *self;

  int readonly = 0;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "|i", &readonly)) {
      return NULL((void*)0);
  }

  self = PyObject_New(PixelAccessObject, &PixelAccess_Type)( (PixelAccessObject *) _PyObject_New(&PixelAccess_Type) );
  if (self == NULL((void*)0)) {
      return NULL((void*)0);
  }

  /* keep a reference to the image object */
  Py_INCREF(imagep)_Py_INCREF(((PyObject*)(imagep)));
  self->image = imagep;

  self->readonly = readonly;

  return (PyObject *)self;
3254}

3256static void
3257pixel_access_dealloc(PixelAccessObject *self) {
  Py_XDECREF(self->image)_Py_XDECREF(((PyObject*)(self->image)));
  PyObject_DelPyObject_Free(self);
3260}

3262static PyObject *
3263pixel_access_getitem(PixelAccessObject *self, PyObject *xy) {
  int x, y;
  if (_getxy(xy, &x, &y)) {
      return NULL((void*)0);
  }

  return getpixel(self->image->image, self->image->access, x, y);
3270}

3272static int
3273pixel_access_setitem(PixelAccessObject *self, PyObject *xy, PyObject *color) {
  Imaging im = self->image->image;
  char ink[4];
  int x, y;

  if (self->readonly) {
      (void)ImagingError_ValueError(readonly);
      return -1;
  }

  if (_getxy(xy, &x, &y)) {
      return -1;
  }

  if (x < 0) {
      x = im->xsize + x;
  }
  if (y < 0) {
      y = im->ysize + y;
  }

  if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) {
      PyErr_SetString(PyExc_IndexError, outside_image);
      return -1;
  }

  if (!color) { /* FIXME: raise exception? */
      return 0;
  }

  if (!getink(color, im, ink)) {
      return -1;
  }

  self->image->access->put_pixel(im, x, y, ink);

  return 0;
3310}

3312/* -------------------------------------------------------------------- */
3313/* EFFECTS (experimental)                            */
3314/* -------------------------------------------------------------------- */

3316#ifdef WITH_EFFECTS

3318static PyObject *
3319_effect_mandelbrot(ImagingObject *self, PyObject *args) {
  int xsize = 512;
  int ysize = 512;
  double extent[4];
  int quality = 100;

  extent[0] = -3;
  extent[1] = -2.5;
  extent[2] = 2;
  extent[3] = 2.5;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
          args,
          "|(ii)(dddd)i",
          &xsize,
          &ysize,
          &extent[0],
          &extent[1],
          &extent[2],
          &extent[3],
          &quality)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingEffectMandelbrot(xsize, ysize, extent, quality));
3344}

3346static PyObject *
3347_effect_noise(ImagingObject *self, PyObject *args) {
  int xsize, ysize;
  float sigma = 128;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "(ii)|f", &xsize, &ysize, &sigma)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingEffectNoise(xsize, ysize, sigma));
3355}

3357static PyObject *
3358_effect_spread(ImagingObject *self, PyObject *args) {
  int dist;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "i", &dist)) {
      return NULL((void*)0);
  }

  return PyImagingNew(ImagingEffectSpread(self->image, dist));
3366}

3368#endif

3370/* -------------------------------------------------------------------- */
3371/* UTILITIES                                */
3372/* -------------------------------------------------------------------- */

3374static PyObject *
3375_getcodecstatus(PyObject *self, PyObject *args) {
  int status;
  char *msg;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "i", &status)) {
      return NULL((void*)0);
  }

  switch (status) {
      case IMAGING_CODEC_OVERRUN-1:
          msg = "buffer overrun";
          break;
      case IMAGING_CODEC_BROKEN-2:
          msg = "broken data stream";
          break;
      case IMAGING_CODEC_UNKNOWN-3:
          msg = "unrecognized data stream contents";
          break;
      case IMAGING_CODEC_CONFIG-8:
          msg = "codec configuration error";
          break;
      case IMAGING_CODEC_MEMORY-9:
          msg = "out of memory";
          break;
      default:
          Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
  }

  return PyUnicode_FromString(msg);
3404}

3406/* -------------------------------------------------------------------- */
3407/* DEBUGGING HELPERS                            */
3408/* -------------------------------------------------------------------- */

3410static PyObject *
3411_save_ppm(ImagingObject *self, PyObject *args) {
  char *filename;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "s", &filename)) {
      return NULL((void*)0);
  }

  if (!ImagingSavePPM(self->image, filename)) {
      return NULL((void*)0);
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
3424}

3426/* -------------------------------------------------------------------- */

3428/* methods */

3430static struct PyMethodDef methods[] = {

  /* Put commonly used methods first */
  {"getpixel", (PyCFunction)_getpixel, METH_VARARGS0x0001},
  {"putpixel", (PyCFunction)_putpixel, METH_VARARGS0x0001},

  {"pixel_access", (PyCFunction)pixel_access_new, METH_VARARGS0x0001},

  /* Standard processing methods (Image) */
  {"color_lut_3d", (PyCFunction)_color_lut_3d, METH_VARARGS0x0001},
  {"convert", (PyCFunction)_convert, METH_VARARGS0x0001},
  {"convert2", (PyCFunction)_convert2, METH_VARARGS0x0001},
  {"convert_matrix", (PyCFunction)_convert_matrix, METH_VARARGS0x0001},
  {"convert_transparent", (PyCFunction)_convert_transparent, METH_VARARGS0x0001},
  {"copy", (PyCFunction)_copy, METH_VARARGS0x0001},
  {"crop", (PyCFunction)_crop, METH_VARARGS0x0001},
  {"expand", (PyCFunction)_expand_image, METH_VARARGS0x0001},
  {"filter", (PyCFunction)_filter, METH_VARARGS0x0001},
  {"histogram", (PyCFunction)_histogram, METH_VARARGS0x0001},
  {"entropy", (PyCFunction)_entropy, METH_VARARGS0x0001},
3450#ifdef WITH_MODEFILTER
  {"modefilter", (PyCFunction)_modefilter, METH_VARARGS0x0001},
3452#endif
  {"offset", (PyCFunction)_offset, METH_VARARGS0x0001},
  {"paste", (PyCFunction)_paste, METH_VARARGS0x0001},
  {"point", (PyCFunction)_point, METH_VARARGS0x0001},
  {"point_transform", (PyCFunction)_point_transform, METH_VARARGS0x0001},
  {"putdata", (PyCFunction)_putdata, METH_VARARGS0x0001},
3458#ifdef WITH_QUANTIZE
  {"quantize", (PyCFunction)_quantize, METH_VARARGS0x0001},
3460#endif
3461#ifdef WITH_RANKFILTER
  {"rankfilter", (PyCFunction)_rankfilter, METH_VARARGS0x0001},
3463#endif
  {"resize", (PyCFunction)_resize, METH_VARARGS0x0001},
  {"reduce", (PyCFunction)_reduce, METH_VARARGS0x0001},
  {"transpose", (PyCFunction)_transpose, METH_VARARGS0x0001},
  {"transform2", (PyCFunction)_transform2, METH_VARARGS0x0001},

  {"isblock", (PyCFunction)_isblock, METH_NOARGS0x0004},

  {"getbbox", (PyCFunction)_getbbox, METH_NOARGS0x0004},
  {"getcolors", (PyCFunction)_getcolors, METH_VARARGS0x0001},
  {"getextrema", (PyCFunction)_getextrema, METH_NOARGS0x0004},
  {"getprojection", (PyCFunction)_getprojection, METH_NOARGS0x0004},

  {"getband", (PyCFunction)_getband, METH_VARARGS0x0001},
  {"putband", (PyCFunction)_putband, METH_VARARGS0x0001},
  {"split", (PyCFunction)_split, METH_NOARGS0x0004},
  {"fillband", (PyCFunction)_fillband, METH_VARARGS0x0001},

  {"setmode", (PyCFunction)im_setmode, METH_VARARGS0x0001},

  {"getpalette", (PyCFunction)_getpalette, METH_VARARGS0x0001},
  {"getpalettemode", (PyCFunction)_getpalettemode, METH_NOARGS0x0004},
  {"putpalette", (PyCFunction)_putpalette, METH_VARARGS0x0001},
  {"putpalettealpha", (PyCFunction)_putpalettealpha, METH_VARARGS0x0001},
  {"putpalettealphas", (PyCFunction)_putpalettealphas, METH_VARARGS0x0001},

3489#ifdef WITH_IMAGECHOPS
  /* Channel operations (ImageChops) */
  {"chop_invert", (PyCFunction)_chop_invert, METH_NOARGS0x0004},
  {"chop_lighter", (PyCFunction)_chop_lighter, METH_VARARGS0x0001},
  {"chop_darker", (PyCFunction)_chop_darker, METH_VARARGS0x0001},
  {"chop_difference", (PyCFunction)_chop_difference, METH_VARARGS0x0001},
  {"chop_multiply", (PyCFunction)_chop_multiply, METH_VARARGS0x0001},
  {"chop_screen", (PyCFunction)_chop_screen, METH_VARARGS0x0001},
  {"chop_add", (PyCFunction)_chop_add, METH_VARARGS0x0001},
  {"chop_subtract", (PyCFunction)_chop_subtract, METH_VARARGS0x0001},
  {"chop_add_modulo", (PyCFunction)_chop_add_modulo, METH_VARARGS0x0001},
  {"chop_subtract_modulo", (PyCFunction)_chop_subtract_modulo, METH_VARARGS0x0001},
  {"chop_and", (PyCFunction)_chop_and, METH_VARARGS0x0001},
  {"chop_or", (PyCFunction)_chop_or, METH_VARARGS0x0001},
  {"chop_xor", (PyCFunction)_chop_xor, METH_VARARGS0x0001},
  {"chop_soft_light", (PyCFunction)_chop_soft_light, METH_VARARGS0x0001},
  {"chop_hard_light", (PyCFunction)_chop_hard_light, METH_VARARGS0x0001},
  {"chop_overlay", (PyCFunction)_chop_overlay, METH_VARARGS0x0001},

3508#endif

3510#ifdef WITH_UNSHARPMASK
  /* Kevin Cazabon's unsharpmask extension */
  {"gaussian_blur", (PyCFunction)_gaussian_blur, METH_VARARGS0x0001},
  {"unsharp_mask", (PyCFunction)_unsharp_mask, METH_VARARGS0x0001},
3514#endif

  {"box_blur", (PyCFunction)_box_blur, METH_VARARGS0x0001},

3518#ifdef WITH_EFFECTS
  /* Special effects */
  {"effect_spread", (PyCFunction)_effect_spread, METH_VARARGS0x0001},
3521#endif

  /* Misc. */
  {"new_block", (PyCFunction)_new_block, METH_VARARGS0x0001},

  {"save_ppm", (PyCFunction)_save_ppm, METH_VARARGS0x0001},

  {NULL((void*)0), NULL((void*)0)} /* sentinel */
3529};

3531/* attributes */

3533static PyObject *
3534_getattr_mode(ImagingObject *self, void *closure) {
  return PyUnicode_FromString(self->image->mode);
3536}

3538static PyObject *
3539_getattr_size(ImagingObject *self, void *closure) {
  return Py_BuildValue_Py_BuildValue_SizeT("ii", self->image->xsize, self->image->ysize);
3541}

3543static PyObject *
3544_getattr_bands(ImagingObject *self, void *closure) {
  return PyLong_FromLong(self->image->bands);
3546}

3548static PyObject *
3549_getattr_id(ImagingObject *self, void *closure) {
  return PyLong_FromSsize_t((Py_ssize_t)self->image);
3551}

3553static PyObject *
3554_getattr_ptr(ImagingObject *self, void *closure) {
  return PyCapsule_New(self->image, IMAGING_MAGIC"PIL Imaging", NULL((void*)0));
3556}

3558static PyObject *
3559_getattr_unsafe_ptrs(ImagingObject *self, void *closure) {
  return Py_BuildValue_Py_BuildValue_SizeT(
      "(sn)(sn)(sn)",
      "image8",
      self->image->image8,
      "image32",
      self->image->image32,
      "image",
      self->image->image);
3568};

3570static struct PyGetSetDef getsetters[] = {
  {"mode", (getter)_getattr_mode},
  {"size", (getter)_getattr_size},
  {"bands", (getter)_getattr_bands},
  {"id", (getter)_getattr_id},
  {"ptr", (getter)_getattr_ptr},
  {"unsafe_ptrs", (getter)_getattr_unsafe_ptrs},
  {NULL((void*)0)}};

3579/* basic sequence semantics */

3581static Py_ssize_t
3582image_length(ImagingObject *self) {
  Imaging im = self->image;

  return (Py_ssize_t)im->xsize * im->ysize;
3586}

3588static PyObject *
3589image_item(ImagingObject *self, Py_ssize_t i) {
  int x, y;
  Imaging im = self->image;

  if (im->xsize > 0) {
      x = i % im->xsize;
      y = i / im->xsize;
  } else {
      x = y = 0; /* leave it to getpixel to raise an exception */
  }

  return getpixel(im, self->access, x, y);
3601}

3603static PySequenceMethods image_as_sequence = {
  (lenfunc)image_length,      /*sq_length*/
  (binaryfunc)NULL((void*)0),           /*sq_concat*/
  (ssizeargfunc)NULL((void*)0),         /*sq_repeat*/
  (ssizeargfunc)image_item,   /*sq_item*/
  (ssizessizeargfunc)NULL((void*)0),    /*sq_slice*/
  (ssizeobjargproc)NULL((void*)0),      /*sq_ass_item*/
  (ssizessizeobjargproc)NULL((void*)0), /*sq_ass_slice*/
3611};

3613/* type description */

3615static PyTypeObject Imaging_Type = {
  PyVarObject_HEAD_INIT(NULL, 0){ { 1, ((void*)0) }, 0 }, "ImagingCore", /*tp_name*/
  sizeof(ImagingObject),                        /*tp_size*/
  0,                                            /*tp_itemsize*/
  /* methods */
  (destructor)_dealloc, /*tp_dealloc*/
  0,                    /*tp_print*/
  0,                    /*tp_getattr*/
  0,                    /*tp_setattr*/
  0,                    /*tp_compare*/
  0,                    /*tp_repr*/
  0,                    /*tp_as_number */
  &image_as_sequence,   /*tp_as_sequence */
  0,                    /*tp_as_mapping */
  0,                    /*tp_hash*/
  0,                    /*tp_call*/
  0,                    /*tp_str*/
  0,                    /*tp_getattro*/
  0,                    /*tp_setattro*/
  0,                    /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT( 0 | (1UL << 18) | 0),   /*tp_flags*/
  0,                    /*tp_doc*/
  0,                    /*tp_traverse*/
  0,                    /*tp_clear*/
  0,                    /*tp_richcompare*/
  0,                    /*tp_weaklistoffset*/
  0,                    /*tp_iter*/
  0,                    /*tp_iternext*/
  methods,              /*tp_methods*/
  0,                    /*tp_members*/
  getsetters,           /*tp_getset*/
3646};

3648#ifdef WITH_IMAGEDRAW

3650static PyTypeObject ImagingFont_Type = {
  PyVarObject_HEAD_INIT(NULL, 0){ { 1, ((void*)0) }, 0 }, "ImagingFont", /*tp_name*/
  sizeof(ImagingFontObject),                    /*tp_size*/
  0,                                            /*tp_itemsize*/
  /* methods */
  (destructor)_font_dealloc, /*tp_dealloc*/
  0,                         /*tp_print*/
  0,                         /*tp_getattr*/
  0,                         /*tp_setattr*/
  0,                         /*tp_compare*/
  0,                         /*tp_repr*/
  0,                         /*tp_as_number */
  0,                         /*tp_as_sequence */
  0,                         /*tp_as_mapping */
  0,                         /*tp_hash*/
  0,                         /*tp_call*/
  0,                         /*tp_str*/
  0,                         /*tp_getattro*/
  0,                         /*tp_setattro*/
  0,                         /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT( 0 | (1UL << 18) | 0),        /*tp_flags*/
  0,                         /*tp_doc*/
  0,                         /*tp_traverse*/
  0,                         /*tp_clear*/
  0,                         /*tp_richcompare*/
  0,                         /*tp_weaklistoffset*/
  0,                         /*tp_iter*/
  0,                         /*tp_iternext*/
  _font_methods,             /*tp_methods*/
  0,                         /*tp_members*/
  0,                         /*tp_getset*/
3681};

3683static PyTypeObject ImagingDraw_Type = {
  PyVarObject_HEAD_INIT(NULL, 0){ { 1, ((void*)0) }, 0 }, "ImagingDraw", /*tp_name*/
  sizeof(ImagingDrawObject),                    /*tp_size*/
  0,                                            /*tp_itemsize*/
  /* methods */
  (destructor)_draw_dealloc, /*tp_dealloc*/
  0,                         /*tp_print*/
  0,                         /*tp_getattr*/
  0,                         /*tp_setattr*/
  0,                         /*tp_compare*/
  0,                         /*tp_repr*/
  0,                         /*tp_as_number */
  0,                         /*tp_as_sequence */
  0,                         /*tp_as_mapping */
  0,                         /*tp_hash*/
  0,                         /*tp_call*/
  0,                         /*tp_str*/
  0,                         /*tp_getattro*/
  0,                         /*tp_setattro*/
  0,                         /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT( 0 | (1UL << 18) | 0),        /*tp_flags*/
  0,                         /*tp_doc*/
  0,                         /*tp_traverse*/
  0,                         /*tp_clear*/
  0,                         /*tp_richcompare*/
  0,                         /*tp_weaklistoffset*/
  0,                         /*tp_iter*/
  0,                         /*tp_iternext*/
  _draw_methods,             /*tp_methods*/
  0,                         /*tp_members*/
  0,                         /*tp_getset*/
3714};

3716#endif

3718static PyMappingMethods pixel_access_as_mapping = {
  (lenfunc)NULL((void*)0),                       /*mp_length*/
  (binaryfunc)pixel_access_getitem,    /*mp_subscript*/
  (objobjargproc)pixel_access_setitem, /*mp_ass_subscript*/
3722};

3724/* type description */

3726static PyTypeObject PixelAccess_Type = {
  PyVarObject_HEAD_INIT(NULL, 0){ { 1, ((void*)0) }, 0 }, "PixelAccess",
  sizeof(PixelAccessObject),
  0,
  /* methods */
  (destructor)pixel_access_dealloc, /*tp_dealloc*/
  0,                                /*tp_print*/
  0,                                /*tp_getattr*/
  0,                                /*tp_setattr*/
  0,                                /*tp_compare*/
  0,                                /*tp_repr*/
  0,                                /*tp_as_number */
  0,                                /*tp_as_sequence */
  &pixel_access_as_mapping,         /*tp_as_mapping */
  0                                 /*tp_hash*/
3741};

3743/* -------------------------------------------------------------------- */

3745static PyObject *
3746_get_stats(PyObject *self, PyObject *args) {
  PyObject *d;
  ImagingMemoryArena arena = &ImagingDefaultArena;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, ":get_stats")) {
      return NULL((void*)0);
  }

  d = PyDict_New();
  if (!d) {
      return NULL((void*)0);
  }
  PyDict_SetItemString(d, "new_count", PyLong_FromLong(arena->stats_new_count));
  PyDict_SetItemString(
      d, "allocated_blocks", PyLong_FromLong(arena->stats_allocated_blocks));
  PyDict_SetItemString(
      d, "reused_blocks", PyLong_FromLong(arena->stats_reused_blocks));
  PyDict_SetItemString(
      d, "reallocated_blocks", PyLong_FromLong(arena->stats_reallocated_blocks));
  PyDict_SetItemString(d, "freed_blocks", PyLong_FromLong(arena->stats_freed_blocks));
  PyDict_SetItemString(d, "blocks_cached", PyLong_FromLong(arena->blocks_cached));
  return d;
3768}

3770static PyObject *
3771_reset_stats(PyObject *self, PyObject *args) {
  ImagingMemoryArena arena = &ImagingDefaultArena;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, ":reset_stats")) {
      return NULL((void*)0);
  }

  arena->stats_new_count = 0;
  arena->stats_allocated_blocks = 0;
  arena->stats_reused_blocks = 0;
  arena->stats_reallocated_blocks = 0;
  arena->stats_freed_blocks = 0;

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
3786}

3788static PyObject *
3789_get_alignment(PyObject *self, PyObject *args) {
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, ":get_alignment")) {
      return NULL((void*)0);
  }

  return PyLong_FromLong(ImagingDefaultArena.alignment);
3795}

3797static PyObject *
3798_get_block_size(PyObject *self, PyObject *args) {
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, ":get_block_size")) {
      return NULL((void*)0);
  }

  return PyLong_FromLong(ImagingDefaultArena.block_size);
3804}

3806static PyObject *
3807_get_blocks_max(PyObject *self, PyObject *args) {
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, ":get_blocks_max")) {
      return NULL((void*)0);
  }

  return PyLong_FromLong(ImagingDefaultArena.blocks_max);
3813}

3815static PyObject *
3816_set_alignment(PyObject *self, PyObject *args) {
  int alignment;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "i:set_alignment", &alignment)) {
      return NULL((void*)0);
  }

  if (alignment < 1 || alignment > 128) {
      PyErr_SetString(PyExc_ValueError, "alignment should be from 1 to 128");
      return NULL((void*)0);
  }
  /* Is power of two */
  if (alignment & (alignment - 1)) {
      PyErr_SetString(PyExc_ValueError, "alignment should be power of two");
      return NULL((void*)0);
  }

  ImagingDefaultArena.alignment = alignment;

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
3836}

3838static PyObject *
3839_set_block_size(PyObject *self, PyObject *args) {
  int block_size;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "i:set_block_size", &block_size)) {
      return NULL((void*)0);
  }

  if (block_size <= 0) {
      PyErr_SetString(PyExc_ValueError, "block_size should be greater than 0");
      return NULL((void*)0);
  }

  if (block_size & 0xfff) {
      PyErr_SetString(PyExc_ValueError, "block_size should be multiple of 4096");
      return NULL((void*)0);
  }

  ImagingDefaultArena.block_size = block_size;

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
3859}

3861static PyObject *
3862_set_blocks_max(PyObject *self, PyObject *args) {
  int blocks_max;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "i:set_blocks_max", &blocks_max)) {
      return NULL((void*)0);
  }

  if (blocks_max < 0) {
      PyErr_SetString(PyExc_ValueError, "blocks_max should be greater than 0");
      return NULL((void*)0);
  } else if (
      (unsigned long)blocks_max >
      SIZE_MAX(18446744073709551615UL) / sizeof(ImagingDefaultArena.blocks_pool[0])) {
      PyErr_SetString(PyExc_ValueError, "blocks_max is too large");
      return NULL((void*)0);
  }

  if (!ImagingMemorySetBlocksMax(&ImagingDefaultArena, blocks_max)) {
      return ImagingError_MemoryError();
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
3884}

3886static PyObject *
3887_clear_cache(PyObject *self, PyObject *args) {
  int i = 0;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "|i:clear_cache", &i)) {
      return NULL((void*)0);
  }

  ImagingMemoryClearCache(&ImagingDefaultArena, i);

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
3898}

3900/* -------------------------------------------------------------------- */

3902/* FIXME: this is something of a mess.  Should replace this with
 pluggable codecs, but not before PIL 1.2 */

3905/* Decoders (in decode.c) */
3906extern PyObject *
3907PyImaging_BcnDecoderNew(PyObject *self, PyObject *args);
3908extern PyObject *
3909PyImaging_BitDecoderNew(PyObject *self, PyObject *args);
3910extern PyObject *
3911PyImaging_FliDecoderNew(PyObject *self, PyObject *args);
3912extern PyObject *
3913PyImaging_GifDecoderNew(PyObject *self, PyObject *args);
3914extern PyObject *
3915PyImaging_HexDecoderNew(PyObject *self, PyObject *args);
3916extern PyObject *
3917PyImaging_JpegDecoderNew(PyObject *self, PyObject *args);
3918extern PyObject *
3919PyImaging_Jpeg2KDecoderNew(PyObject *self, PyObject *args);
3920extern PyObject *
3921PyImaging_LibTiffDecoderNew(PyObject *self, PyObject *args);
3922extern PyObject *
3923PyImaging_PackbitsDecoderNew(PyObject *self, PyObject *args);
3924extern PyObject *
3925PyImaging_PcdDecoderNew(PyObject *self, PyObject *args);
3926extern PyObject *
3927PyImaging_PcxDecoderNew(PyObject *self, PyObject *args);
3928extern PyObject *
3929PyImaging_RawDecoderNew(PyObject *self, PyObject *args);
3930extern PyObject *
3931PyImaging_SgiRleDecoderNew(PyObject *self, PyObject *args);
3932extern PyObject *
3933PyImaging_SunRleDecoderNew(PyObject *self, PyObject *args);
3934extern PyObject *
3935PyImaging_TgaRleDecoderNew(PyObject *self, PyObject *args);
3936extern PyObject *
3937PyImaging_XbmDecoderNew(PyObject *self, PyObject *args);
3938extern PyObject *
3939PyImaging_ZipDecoderNew(PyObject *self, PyObject *args);

3941/* Encoders (in encode.c) */
3942extern PyObject *
3943PyImaging_EpsEncoderNew(PyObject *self, PyObject *args);
3944extern PyObject *
3945PyImaging_GifEncoderNew(PyObject *self, PyObject *args);
3946extern PyObject *
3947PyImaging_JpegEncoderNew(PyObject *self, PyObject *args);
3948extern PyObject *
3949PyImaging_Jpeg2KEncoderNew(PyObject *self, PyObject *args);
3950extern PyObject *
3951PyImaging_PcxEncoderNew(PyObject *self, PyObject *args);
3952extern PyObject *
3953PyImaging_RawEncoderNew(PyObject *self, PyObject *args);
3954extern PyObject *
3955PyImaging_TgaRleEncoderNew(PyObject *self, PyObject *args);
3956extern PyObject *
3957PyImaging_XbmEncoderNew(PyObject *self, PyObject *args);
3958extern PyObject *
3959PyImaging_ZipEncoderNew(PyObject *self, PyObject *args);
3960extern PyObject *
3961PyImaging_LibTiffEncoderNew(PyObject *self, PyObject *args);

3963/* Display support etc (in display.c) */
3964#ifdef _WIN32
3965extern PyObject *
3966PyImaging_CreateWindowWin32(PyObject *self, PyObject *args);
3967extern PyObject *
3968PyImaging_DisplayWin32(PyObject *self, PyObject *args);
3969extern PyObject *
3970PyImaging_DisplayModeWin32(PyObject *self, PyObject *args);
3971extern PyObject *
3972PyImaging_GrabScreenWin32(PyObject *self, PyObject *args);
3973extern PyObject *
3974PyImaging_GrabClipboardWin32(PyObject *self, PyObject *args);
3975extern PyObject *
3976PyImaging_ListWindowsWin32(PyObject *self, PyObject *args);
3977extern PyObject *
3978PyImaging_EventLoopWin32(PyObject *self, PyObject *args);
3979extern PyObject *
3980PyImaging_DrawWmf(PyObject *self, PyObject *args);
3981#endif
3982#ifdef HAVE_XCB1
3983extern PyObject *
3984PyImaging_GrabScreenX11(PyObject *self, PyObject *args);
3985#endif

3987/* Experimental path stuff (in path.c) */
3988extern PyObject *
3989PyPath_Create(ImagingObject *self, PyObject *args);

3991/* Experimental outline stuff (in outline.c) */
3992extern PyObject *
3993PyOutline_Create(ImagingObject *self, PyObject *args);

3995extern PyObject *
3996PyImaging_MapBuffer(PyObject *self, PyObject *args);

3998static PyMethodDef functions[] = {

  /* Object factories */
  {"alpha_composite", (PyCFunction)_alpha_composite, METH_VARARGS0x0001},
  {"blend", (PyCFunction)_blend, METH_VARARGS0x0001},
  {"fill", (PyCFunction)_fill, METH_VARARGS0x0001},
  {"new", (PyCFunction)_new, METH_VARARGS0x0001},
  {"merge", (PyCFunction)_merge, METH_VARARGS0x0001},

  /* Functions */
  {"convert", (PyCFunction)_convert2, METH_VARARGS0x0001},

  /* Codecs */
  {"bcn_decoder", (PyCFunction)PyImaging_BcnDecoderNew, METH_VARARGS0x0001},
  {"bit_decoder", (PyCFunction)PyImaging_BitDecoderNew, METH_VARARGS0x0001},
  {"eps_encoder", (PyCFunction)PyImaging_EpsEncoderNew, METH_VARARGS0x0001},
  {"fli_decoder", (PyCFunction)PyImaging_FliDecoderNew, METH_VARARGS0x0001},
  {"gif_decoder", (PyCFunction)PyImaging_GifDecoderNew, METH_VARARGS0x0001},
  {"gif_encoder", (PyCFunction)PyImaging_GifEncoderNew, METH_VARARGS0x0001},
  {"hex_decoder", (PyCFunction)PyImaging_HexDecoderNew, METH_VARARGS0x0001},
  {"hex_encoder", (PyCFunction)PyImaging_EpsEncoderNew, METH_VARARGS0x0001}, /* EPS=HEX! */
4019#ifdef HAVE_LIBJPEG1
  {"jpeg_decoder", (PyCFunction)PyImaging_JpegDecoderNew, METH_VARARGS0x0001},
  {"jpeg_encoder", (PyCFunction)PyImaging_JpegEncoderNew, METH_VARARGS0x0001},
4022#endif
4023#ifdef HAVE_OPENJPEG1
  {"jpeg2k_decoder", (PyCFunction)PyImaging_Jpeg2KDecoderNew, METH_VARARGS0x0001},
  {"jpeg2k_encoder", (PyCFunction)PyImaging_Jpeg2KEncoderNew, METH_VARARGS0x0001},
4026#endif
4027#ifdef HAVE_LIBTIFF1
  {"libtiff_decoder", (PyCFunction)PyImaging_LibTiffDecoderNew, METH_VARARGS0x0001},
  {"libtiff_encoder", (PyCFunction)PyImaging_LibTiffEncoderNew, METH_VARARGS0x0001},
4030#endif
  {"packbits_decoder", (PyCFunction)PyImaging_PackbitsDecoderNew, METH_VARARGS0x0001},
  {"pcd_decoder", (PyCFunction)PyImaging_PcdDecoderNew, METH_VARARGS0x0001},
  {"pcx_decoder", (PyCFunction)PyImaging_PcxDecoderNew, METH_VARARGS0x0001},
  {"pcx_encoder", (PyCFunction)PyImaging_PcxEncoderNew, METH_VARARGS0x0001},
  {"raw_decoder", (PyCFunction)PyImaging_RawDecoderNew, METH_VARARGS0x0001},
  {"raw_encoder", (PyCFunction)PyImaging_RawEncoderNew, METH_VARARGS0x0001},
  {"sgi_rle_decoder", (PyCFunction)PyImaging_SgiRleDecoderNew, METH_VARARGS0x0001},
  {"sun_rle_decoder", (PyCFunction)PyImaging_SunRleDecoderNew, METH_VARARGS0x0001},
  {"tga_rle_decoder", (PyCFunction)PyImaging_TgaRleDecoderNew, METH_VARARGS0x0001},
  {"tga_rle_encoder", (PyCFunction)PyImaging_TgaRleEncoderNew, METH_VARARGS0x0001},
  {"xbm_decoder", (PyCFunction)PyImaging_XbmDecoderNew, METH_VARARGS0x0001},
  {"xbm_encoder", (PyCFunction)PyImaging_XbmEncoderNew, METH_VARARGS0x0001},
4043#ifdef HAVE_LIBZ1
  {"zip_decoder", (PyCFunction)PyImaging_ZipDecoderNew, METH_VARARGS0x0001},
  {"zip_encoder", (PyCFunction)PyImaging_ZipEncoderNew, METH_VARARGS0x0001},
4046#endif

4048/* Memory mapping */
4049#ifdef WITH_MAPPING
  {"map_buffer", (PyCFunction)PyImaging_MapBuffer, METH_VARARGS0x0001},
4051#endif

4053/* Display support */
4054#ifdef _WIN32
  {"display", (PyCFunction)PyImaging_DisplayWin32, METH_VARARGS0x0001},
  {"display_mode", (PyCFunction)PyImaging_DisplayModeWin32, METH_VARARGS0x0001},
  {"grabscreen_win32", (PyCFunction)PyImaging_GrabScreenWin32, METH_VARARGS0x0001},
  {"grabclipboard_win32", (PyCFunction)PyImaging_GrabClipboardWin32, METH_VARARGS0x0001},
  {"createwindow", (PyCFunction)PyImaging_CreateWindowWin32, METH_VARARGS0x0001},
  {"eventloop", (PyCFunction)PyImaging_EventLoopWin32, METH_VARARGS0x0001},
  {"listwindows", (PyCFunction)PyImaging_ListWindowsWin32, METH_VARARGS0x0001},
  {"drawwmf", (PyCFunction)PyImaging_DrawWmf, METH_VARARGS0x0001},
4063#endif
4064#ifdef HAVE_XCB1
  {"grabscreen_x11", (PyCFunction)PyImaging_GrabScreenX11, METH_VARARGS0x0001},
4066#endif

  /* Utilities */
  {"getcodecstatus", (PyCFunction)_getcodecstatus, METH_VARARGS0x0001},

4071/* Special effects (experimental) */
4072#ifdef WITH_EFFECTS
  {"effect_mandelbrot", (PyCFunction)_effect_mandelbrot, METH_VARARGS0x0001},
  {"effect_noise", (PyCFunction)_effect_noise, METH_VARARGS0x0001},
  {"linear_gradient", (PyCFunction)_linear_gradient, METH_VARARGS0x0001},
  {"radial_gradient", (PyCFunction)_radial_gradient, METH_VARARGS0x0001},
  {"wedge", (PyCFunction)_linear_gradient, METH_VARARGS0x0001}, /* Compatibility */
4078#endif

4080/* Drawing support stuff */
4081#ifdef WITH_IMAGEDRAW
  {"font", (PyCFunction)_font_new, METH_VARARGS0x0001},
  {"draw", (PyCFunction)_draw_new, METH_VARARGS0x0001},
4084#endif

4086/* Experimental path stuff */
4087#ifdef WITH_IMAGEPATH
  {"path", (PyCFunction)PyPath_Create, METH_VARARGS0x0001},
4089#endif

4091/* Experimental arrow graphics stuff */
4092#ifdef WITH_ARROW
  {"outline", (PyCFunction)PyOutline_Create, METH_VARARGS0x0001},
4094#endif

  /* Resource management */
  {"get_stats", (PyCFunction)_get_stats, METH_VARARGS0x0001},
  {"reset_stats", (PyCFunction)_reset_stats, METH_VARARGS0x0001},
  {"get_alignment", (PyCFunction)_get_alignment, METH_VARARGS0x0001},
  {"get_block_size", (PyCFunction)_get_block_size, METH_VARARGS0x0001},
  {"get_blocks_max", (PyCFunction)_get_blocks_max, METH_VARARGS0x0001},
  {"set_alignment", (PyCFunction)_set_alignment, METH_VARARGS0x0001},
  {"set_block_size", (PyCFunction)_set_block_size, METH_VARARGS0x0001},
  {"set_blocks_max", (PyCFunction)_set_blocks_max, METH_VARARGS0x0001},
  {"clear_cache", (PyCFunction)_clear_cache, METH_VARARGS0x0001},

  {NULL((void*)0), NULL((void*)0)} /* sentinel */
4108};

4110static int
4111setup_module(PyObject *m) {
  PyObject *d = PyModule_GetDict(m);
  const char *version = (char *)PILLOW_VERSION"8.4.0.dev0";

  /* Ready object types */
  if (PyType_Ready(&Imaging_Type) < 0) {
2
←
Assuming the condition is false→
3
←
Taking false branch→
      return -1;
  }

4120#ifdef WITH_IMAGEDRAW
  if (PyType_Ready(&ImagingFont_Type) < 0) {
4
←
Assuming the condition is false→
5
←
Taking false branch→
      return -1;
  }

  if (PyType_Ready(&ImagingDraw_Type) < 0) {
6
←
Assuming the condition is false→
7
←
Taking false branch→
      return -1;
  }
4128#endif
  if (PyType_Ready(&PixelAccess_Type) < 0) {
8
←
Assuming the condition is false→
9
←
Taking false branch→
      return -1;
  }

  ImagingAccessInit();

4135#ifdef HAVE_LIBJPEG1
  {
      extern const char *ImagingJpegVersion(void);
      PyDict_SetItemString(
          d, "jpeglib_version", PyUnicode_FromString(ImagingJpegVersion()));
  }
4141#endif

4143#ifdef HAVE_OPENJPEG1
  {
      extern const char *ImagingJpeg2KVersion(void);
      PyDict_SetItemString(
          d, "jp2klib_version", PyUnicode_FromString(ImagingJpeg2KVersion()));
  }
4149#endif

  PyObject *have_libjpegturbo;
4152#ifdef LIBJPEG_TURBO_VERSION2.0.3
  have_libjpegturbo = Py_True((PyObject *) &_Py_TrueStruct);
4154#define tostr1(a) #a
4155#define tostr(a) tostr1(a)
  PyDict_SetItemString(
      d, "libjpeg_turbo_version", PyUnicode_FromString(tostr(LIBJPEG_TURBO_VERSION2.0.3)));
4158#undef tostr
4159#undef tostr1
4160#else
  have_libjpegturbo = Py_False((PyObject *) &_Py_FalseStruct);
4162#endif
  Py_INCREF(have_libjpegturbo)_Py_INCREF(((PyObject*)(have_libjpegturbo)));
  PyModule_AddObject(m, "HAVE_LIBJPEGTURBO", have_libjpegturbo);

  PyObject *have_libimagequant;
4167#ifdef HAVE_LIBIMAGEQUANT1
  have_libimagequant = Py_True((PyObject *) &_Py_TrueStruct);
  {
      extern const char *ImagingImageQuantVersion(void);
      PyDict_SetItemString(
          d, "imagequant_version", PyUnicode_FromString(ImagingImageQuantVersion()));
10
←
Calling 'PyUnicode_FromString'→
12
←
Returning from 'PyUnicode_FromString'→
13
←
PyObject ownership leak with reference count of 1
  }
4174#else
  have_libimagequant = Py_False((PyObject *) &_Py_FalseStruct);
4176#endif
  Py_INCREF(have_libimagequant)_Py_INCREF(((PyObject*)(have_libimagequant)));
  PyModule_AddObject(m, "HAVE_LIBIMAGEQUANT", have_libimagequant);

4180#ifdef HAVE_LIBZ1
  /* zip encoding strategies */
  PyModule_AddIntConstant(m, "DEFAULT_STRATEGY", Z_DEFAULT_STRATEGY0);
  PyModule_AddIntConstant(m, "FILTERED", Z_FILTERED1);
  PyModule_AddIntConstant(m, "HUFFMAN_ONLY", Z_HUFFMAN_ONLY2);
  PyModule_AddIntConstant(m, "RLE", Z_RLE3);
  PyModule_AddIntConstant(m, "FIXED", Z_FIXED4);
  {
      extern const char *ImagingZipVersion(void);
      PyDict_SetItemString(
          d, "zlib_version", PyUnicode_FromString(ImagingZipVersion()));
  }
4192#endif

4194#ifdef HAVE_LIBTIFF1
  {
      extern const char *ImagingTiffVersion(void);
      PyDict_SetItemString(
          d, "libtiff_version", PyUnicode_FromString(ImagingTiffVersion()));

      // Test for libtiff 4.0 or later, excluding libtiff 3.9.6 and 3.9.7
      PyObject *support_custom_tags;
4202#if TIFFLIB_VERSION20191103 >= 20111221 && TIFFLIB_VERSION20191103 != 20120218 && \
  TIFFLIB_VERSION20191103 != 20120922
      support_custom_tags = Py_True((PyObject *) &_Py_TrueStruct);
4205#else
      support_custom_tags = Py_False((PyObject *) &_Py_FalseStruct);
4207#endif
      PyDict_SetItemString(d, "libtiff_support_custom_tags", support_custom_tags);
  }
4210#endif

  PyObject *have_xcb;
4213#ifdef HAVE_XCB1
  have_xcb = Py_True((PyObject *) &_Py_TrueStruct);
4215#else
  have_xcb = Py_False((PyObject *) &_Py_FalseStruct);
4217#endif
  Py_INCREF(have_xcb)_Py_INCREF(((PyObject*)(have_xcb)));
  PyModule_AddObject(m, "HAVE_XCB", have_xcb);

  PyDict_SetItemString(d, "PILLOW_VERSION", PyUnicode_FromString(version));

  return 0;
4224}

4226PyMODINIT_FUNCPyObject*
4227PyInit__imaging(void) {
  PyObject *m;

  static PyModuleDef module_def = {
      PyModuleDef_HEAD_INIT{ { 1, ((void*)0) }, ((void*)0), 0, ((void*)0), },
      "_imaging", /* m_name */
      NULL((void*)0),       /* m_doc */
      -1,         /* m_size */
      functions,  /* m_methods */
  };

  m = PyModule_Create(&module_def)PyModule_Create2(&module_def, 1013);

  if (setup_module(m) < 0) {
1
Calling 'setup_module'→
      return NULL((void*)0);
  }

  return m;
4245}

←

/opt/pyrefcon/lib/pyrefcon/models/models/PyUnicode_FromString.model

1#ifndef PyUnicode_FromString
2struct _object;
3typedef struct _object PyObject;
4PyObject* clang_analyzer_PyObject_New_Reference();
5PyObject *PyUnicode_FromString(const char *u) {
6  return clang_analyzer_PyObject_New_Reference();
11
←
Setting reference count to 1→
7}
8#else
9#warning "API PyUnicode_FromString is defined as a macro."
10#endif