#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "thirdparty/pythoncapi_compat.h"

#include "libImaging/Imaging.h"

#include "libImaging/Bcn.h"

#include "libImaging/Gif.h"

#ifdef HAVE_UNISTD_H

#include <unistd.h> /* write */

typedef struct {

PyObject_HEAD int (*encode)(

Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes

);

int (*cleanup)(ImagingCodecState state);

struct ImagingCodecStateInstance state;

Imaging im;

PyObject *lock;

int pushes_fd;

} ImagingEncoderObject;

static PyTypeObject ImagingEncoderType;

static ImagingEncoderObject *

PyImaging_EncoderNew(int contextsize) {

ImagingEncoderObject *encoder;

void *context;

if (PyType_Ready(&ImagingEncoderType) < 0) {

return NULL;

}

encoder = PyObject_New(ImagingEncoderObject, &ImagingEncoderType);

if (encoder == NULL) {

return NULL;

}

/* Clear the encoder state */

memset(&encoder->state, 0, sizeof(encoder->state));

/* Allocate encoder context */

if (contextsize > 0) {

context = (void *)calloc(1, contextsize);

if (!context) {

Py_DECREF(encoder);

(void)ImagingError_MemoryError();

return NULL;

}

} else {

context = 0;

}

/* Initialize encoder context */

encoder->state.context = context;

/* Most encoders don't need this */

encoder->cleanup = NULL;

/* Target image */

encoder->lock = NULL;

encoder->im = NULL;

encoder->pushes_fd = 0;

return encoder;

}

static void

_dealloc(ImagingEncoderObject *encoder) {

if (encoder->cleanup) {

encoder->cleanup(&encoder->state);

}

free(encoder->state.buffer);

free(encoder->state.context);

Py_XDECREF(encoder->lock);

Py_XDECREF(encoder->state.fd);

PyObject_Del(encoder);

}

static PyObject *

_encode_cleanup(ImagingEncoderObject *encoder, PyObject *args) {

int status = 0;

if (encoder->cleanup) {

status = encoder->cleanup(&encoder->state);

}

return Py_BuildValue("i", status);

}

static PyObject *

_encode(ImagingEncoderObject *encoder, PyObject *args) {

PyObject *buf;

PyObject *result;

int status;

/* Encode to a Python string (allocated by this method) */

Py_ssize_t bufsize = 16384;

if (!PyArg_ParseTuple(args, "|n", &bufsize)) {

return NULL;

}

buf = PyBytes_FromStringAndSize(NULL, bufsize);

if (!buf) {

return NULL;

}

status = encoder->encode(

encoder->im, &encoder->state, (UINT8 *)PyBytes_AsString(buf), bufsize

);

/* adjust string length to avoid slicing in encoder */

if (_PyBytes_Resize(&buf, (status > 0) ? status : 0) < 0) {

return NULL;

}

result = Py_BuildValue("iiO", status, encoder->state.errcode, buf);

Py_DECREF(buf); /* must release buffer!!! */

return result;

}

static PyObject *

_encode_to_pyfd(ImagingEncoderObject *encoder, PyObject *args) {

PyObject *result;

int status;

if (!encoder->pushes_fd) {

// UNDONE, appropriate errcode???

result = Py_BuildValue("ii", 0, IMAGING_CODEC_CONFIG);

return result;

}

status = encoder->encode(encoder->im, &encoder->state, (UINT8 *)NULL, 0);

result = Py_BuildValue("ii", status, encoder->state.errcode);

return result;

}

static PyObject *

_encode_to_file(ImagingEncoderObject *encoder, PyObject *args) {

UINT8 *buf;

int status;

ImagingSectionCookie cookie;

/* Encode to a file handle */

Py_ssize_t fh;

Py_ssize_t bufsize = 16384;

if (!PyArg_ParseTuple(args, "n|n", &fh, &bufsize)) {

return NULL;

}

/* Allocate an encoder buffer */

/* malloc check ok, either constant int, or checked by PyArg_ParseTuple */

buf = (UINT8 *)malloc(bufsize);

if (!buf) {

return ImagingError_MemoryError();

}

ImagingSectionEnter(&cookie);

do {

/* This replaces the inner loop in the ImageFile _save

status = encoder->encode(encoder->im, &encoder->state, buf, bufsize);

if (status > 0) {

if (write(fh, buf, status) < 0) {

ImagingSectionLeave(&cookie);

free(buf);

return PyErr_SetFromErrno(PyExc_OSError);

}

}

} while (encoder->state.errcode == 0);

ImagingSectionLeave(&cookie);

free(buf);

return Py_BuildValue("i", encoder->state.errcode);

}

extern Imaging

PyImaging_AsImaging(PyObject *op);

static PyObject *

_setimage(ImagingEncoderObject *encoder, PyObject *args) {

PyObject *op, *extents;

Imaging im;

ImagingCodecState state;

Py_ssize_t x0, y0, x1, y1;

/* FIXME: should publish the ImagingType descriptor */

if (!PyArg_ParseTuple(args, "OO", &op, &extents)) {

return NULL;

}

im = PyImaging_AsImaging(op);

if (!im) {

return NULL;

}

if (extents == Py_None) {

x0 = 0;

y0 = 0;

x1 = im->xsize;

y1 = im->ysize;

} else {

if (!PyTuple_Check(extents) || PyTuple_GET_SIZE(extents) != 4) {

PyErr_SetString(PyExc_ValueError, "invalid extents");

return NULL;

}

for (int i = 0; i < 4; i++) {

PyObject *extent = PyTuple_GetItem(extents, i);

if (!PyLong_Check(extent)) {

PyErr_SetString(PyExc_ValueError, "invalid extents");

return NULL;

}

Py_ssize_t e = (Py_ssize_t)PyLong_AsLong(extent);

if (i == 0) {

x0 = e;

} else if (i == 1) {

y0 = e;

} else if (i == 2) {

x1 = e;

} else {

y1 = e;

}

}

}

if (im->xsize == 0 || im->ysize == 0) {

PyErr_SetString(PyExc_ValueError, "cannot write empty image");

return NULL;

}

if (x0 < 0 || y0 < 0 || x1 <= x0 || y1 <= y0 || x1 > im->xsize || y1 > im->ysize) {

PyErr_SetString(PyExc_SystemError, "tile cannot extend outside image");

return NULL;

}

encoder->im = im;

state = &encoder->state;

state->xoff = x0;

state->yoff = y0;

state->xsize = x1 - x0;

state->ysize = y1 - y0;

/* Allocate memory buffer (if bits field is set) */

if (state->bits > 0) {

if (state->xsize > ((INT_MAX / state->bits) - 7)) {

return ImagingError_MemoryError();

}

state->bytes = (state->bits * state->xsize + 7) / 8;

/* malloc check ok, overflow checked above */

state->buffer = (UINT8 *)calloc(1, state->bytes);

if (!state->buffer) {

return ImagingError_MemoryError();

}

}

/* Keep a reference to the image object, to make sure it doesn't

Py_INCREF(op);

Py_XDECREF(encoder->lock);

encoder->lock = op;

Py_RETURN_NONE;

}

static PyObject *

_setfd(ImagingEncoderObject *encoder, PyObject *args) {

PyObject *fd;

ImagingCodecState state;

if (!PyArg_ParseTuple(args, "O", &fd)) {

return NULL;

}

state = &encoder->state;

Py_XINCREF(fd);

state->fd = fd;

Py_RETURN_NONE;

}

static PyObject *

_get_pushes_fd(ImagingEncoderObject *encoder, void *closure) {

return PyBool_FromLong(encoder->pushes_fd);

}

static struct PyMethodDef methods[] = {

{"encode", (PyCFunction)_encode, METH_VARARGS},

{"cleanup", (PyCFunction)_encode_cleanup, METH_VARARGS},

{"encode_to_file", (PyCFunction)_encode_to_file, METH_VARARGS},

{"encode_to_pyfd", (PyCFunction)_encode_to_pyfd, METH_NOARGS},

{"setimage", (PyCFunction)_setimage, METH_VARARGS},

{"setfd", (PyCFunction)_setfd, METH_VARARGS},

{NULL, NULL} /* sentinel */

};

static struct PyGetSetDef getseters[] = {

{"pushes_fd",

(getter)_get_pushes_fd,

NULL,

"True if this decoder expects to push directly to self.fd",

NULL},

{NULL, NULL, NULL, NULL, NULL} /* sentinel */

};

static PyTypeObject ImagingEncoderType = {

PyVarObject_HEAD_INIT(NULL, 0).tp_name = "ImagingEncoder",

.tp_basicsize = sizeof(ImagingEncoderObject),

.tp_dealloc = (destructor)_dealloc,

.tp_methods = methods,

.tp_getset = getseters,

};

get_packer(ImagingEncoderObject *encoder, const ModeID mode, const RawModeID rawmode) {

int bits;

ImagingShuffler pack;

pack = ImagingFindPacker(mode, rawmode, &bits);

if (!pack) {

Py_DECREF(encoder);

PyErr_Format(

PyExc_ValueError,

"No packer found from %s to %s",

getModeData(mode)->name,

getRawModeData(rawmode)->name

);

return -1;

}

encoder->state.shuffle = pack;

encoder->state.bits = bits;

return 0;

}

PyObject *

PyImaging_BcnEncoderNew(PyObject *self, PyObject *args) {

ImagingEncoderObject *encoder;

char *mode;

int n;

if (!PyArg_ParseTuple(args, "si", &mode, &n)) {

return NULL;

}

encoder = PyImaging_EncoderNew(0);

if (encoder == NULL) {

return NULL;

}

encoder->encode = ImagingBcnEncode;

encoder->state.state = n;

return (PyObject *)encoder;

}

PyObject *

PyImaging_EpsEncoderNew(PyObject *self, PyObject *args) {

ImagingEncoderObject *encoder;

encoder = PyImaging_EncoderNew(0);

if (encoder == NULL) {

return NULL;

}

encoder->encode = ImagingEpsEncode;

return (PyObject *)encoder;

}

PyObject *

PyImaging_GifEncoderNew(PyObject *self, PyObject *args) {

ImagingEncoderObject *encoder;

char *mode_name;

char *rawmode_name;

Py_ssize_t bits = 8;

Py_ssize_t interlace = 0;

if (!PyArg_ParseTuple(

args, "ss|nn", &mode_name, &rawmode_name, &bits, &interlace

)) {

return NULL;

}

encoder = PyImaging_EncoderNew(sizeof(GIFENCODERSTATE));

if (encoder == NULL) {

return NULL;

}

const ModeID mode = findModeID(mode_name);

const RawModeID rawmode = findRawModeID(rawmode_name);

if (get_packer(encoder, mode, rawmode) < 0) {

return NULL;

}

encoder->encode = ImagingGifEncode;

((GIFENCODERSTATE *)encoder->state.context)->bits = bits;

((GIFENCODERSTATE *)encoder->state.context)->interlace = interlace;

return (PyObject *)encoder;

}

PyObject *

PyImaging_PcxEncoderNew(PyObject *self, PyObject *args) {

ImagingEncoderObject *encoder;

char *mode_name;

char *rawmode_name;

Py_ssize_t bits = 8;

if (!PyArg_ParseTuple(args, "ss|n", &mode_name, &rawmode_name, &bits)) {

return NULL;

}

encoder = PyImaging_EncoderNew(0);

if (encoder == NULL) {

return NULL;

}

const ModeID mode = findModeID(mode_name);

const RawModeID rawmode = findRawModeID(rawmode_name);

if (get_packer(encoder, mode, rawmode) < 0) {

return NULL;

}

encoder->encode = ImagingPcxEncode;

return (PyObject *)encoder;

}

PyObject *

PyImaging_RawEncoderNew(PyObject *self, PyObject *args) {

ImagingEncoderObject *encoder;

char *mode_name;

char *rawmode_name;

Py_ssize_t stride = 0;

Py_ssize_t ystep = 1;

if (!PyArg_ParseTuple(args, "ss|nn", &mode_name, &rawmode_name, &stride, &ystep)) {

return NULL;

}

encoder = PyImaging_EncoderNew(0);

if (encoder == NULL) {

return NULL;

}

const ModeID mode = findModeID(mode_name);

const RawModeID rawmode = findRawModeID(rawmode_name);

if (get_packer(encoder, mode, rawmode) < 0) {

return NULL;

}

encoder->encode = ImagingRawEncode;

encoder->state.ystep = ystep;

encoder->state.count = stride;

return (PyObject *)encoder;

}

PyObject *

PyImaging_TgaRleEncoderNew(PyObject *self, PyObject *args) {

ImagingEncoderObject *encoder;

char *mode_name;

char *rawmode_name;

Py_ssize_t ystep = 1;

if (!PyArg_ParseTuple(args, "ss|n", &mode_name, &rawmode_name, &ystep)) {

return NULL;

}

encoder = PyImaging_EncoderNew(0);

if (encoder == NULL) {

return NULL;

}

const ModeID mode = findModeID(mode_name);

const RawModeID rawmode = findRawModeID(rawmode_name);

if (get_packer(encoder, mode, rawmode) < 0) {

return NULL;

}

encoder->encode = ImagingTgaRleEncode;

encoder->state.ystep = ystep;

return (PyObject *)encoder;

}

PyObject *

PyImaging_XbmEncoderNew(PyObject *self, PyObject *args) {

ImagingEncoderObject *encoder;

encoder = PyImaging_EncoderNew(0);

if (encoder == NULL) {

return NULL;

}

if (get_packer(encoder, IMAGING_MODE_1, IMAGING_RAWMODE_1_R) < 0) {

return NULL;

}

encoder->encode = ImagingXbmEncode;

return (PyObject *)encoder;

}

#ifdef HAVE_LIBZ

#include "libImaging/ZipCodecs.h"

PyObject *

PyImaging_ZipEncoderNew(PyObject *self, PyObject *args) {

ImagingEncoderObject *encoder;

char *mode_name;

char *rawmode_name;

Py_ssize_t optimize = 0;

Py_ssize_t compress_level = -1;

Py_ssize_t compress_type = -1;

char *dictionary = NULL;

Py_ssize_t dictionary_size = 0;

if (!PyArg_ParseTuple(

args,

"ss|nnny#",

&mode_name,

&rawmode_name,

&optimize,

&compress_level,

&compress_type,

&dictionary,

&dictionary_size

)) {

return NULL;

}

/* Copy to avoid referencing Python's memory */

if (dictionary && dictionary_size > 0) {

/* malloc check ok, size comes from PyArg_ParseTuple */

char *p = malloc(dictionary_size);

if (!p) {

return ImagingError_MemoryError();

}

memcpy(p, dictionary, dictionary_size);

dictionary = p;

} else {

dictionary = NULL;

}

encoder = PyImaging_EncoderNew(sizeof(ZIPSTATE));

if (encoder == NULL) {

free(dictionary);

return NULL;

}

const ModeID mode = findModeID(mode_name);

const RawModeID rawmode = findRawModeID(rawmode_name);

if (get_packer(encoder, mode, rawmode) < 0) {

free(dictionary);

return NULL;

}

encoder->encode = ImagingZipEncode;

encoder->cleanup = ImagingZipEncodeCleanup;

if (rawmode == IMAGING_RAWMODE_P || rawmode == IMAGING_RAWMODE_PA) {

/* disable filtering */

((ZIPSTATE *)encoder->state.context)->mode = ZIP_PNG_PALETTE;

}

((ZIPSTATE *)encoder->state.context)->optimize = optimize;

((ZIPSTATE *)encoder->state.context)->compress_level = compress_level;

((ZIPSTATE *)encoder->state.context)->compress_type = compress_type;

((ZIPSTATE *)encoder->state.context)->dictionary = dictionary;

((ZIPSTATE *)encoder->state.context)->dictionary_size = dictionary_size;

return (PyObject *)encoder;

}

#ifdef HAVE_LIBTIFF

#include "libImaging/TiffDecode.h"

#include <string.h>

PyObject *

PyImaging_LibTiffEncoderNew(PyObject *self, PyObject *args) {

ImagingEncoderObject *encoder;

char *mode_name;

char *rawmode_name;

char *compname;

char *filename;

Py_ssize_t fp;

PyObject *tags, *types;

PyObject *key, *value;

Py_ssize_t pos = 0;

int key_int, status, is_core_tag, is_var_length, num_core_tags, i;

TIFFDataType type = TIFF_NOTYPE;

// This list also exists in TiffTags.py

const int core_tags[] = {256, 257, 258, 259, 262, 263, 266, 269, 274, 277,

278, 280, 281, 282, 283, 284, 286, 287, 296, 297,

301, 320, 321, 330, 333, 338, 339, 340, 341, 530,

531, 532, 32995, 32996, 32997, 32998, 65537};

Py_ssize_t tags_size;

PyObject *item;

if (!PyArg_ParseTuple(

args,

"sssnsOO",

&mode_name,

&rawmode_name,

&compname,

&fp,

&filename,

&tags,

&types

)) {

return NULL;

}

if (!PyList_Check(tags)) {

PyErr_SetString(PyExc_ValueError, "Invalid tags list");

return NULL;

} else {

tags_size = PyList_Size(tags);

TRACE(("tags size: %d\n", (int)tags_size));

for (pos = 0; pos < tags_size; pos++) {

item = PyList_GetItemRef(tags, pos);

if (item == NULL) {

return NULL;

}

if (!PyTuple_Check(item) || PyTuple_Size(item) != 2) {

Py_DECREF(item);

PyErr_SetString(PyExc_ValueError, "Invalid tags list");

return NULL;

}

Py_DECREF(item);

}

pos = 0;

}

if (!PyDict_Check(types)) {

PyErr_SetString(PyExc_ValueError, "Invalid types dictionary");

return NULL;

}

TRACE(("new tiff encoder %s fp: %d, filename: %s \n", compname, fp, filename));

encoder = PyImaging_EncoderNew(sizeof(TIFFSTATE));

if (encoder == NULL) {

return NULL;

}

const ModeID mode = findModeID(mode_name);

const RawModeID rawmode = findRawModeID(rawmode_name);

if (get_packer(encoder, mode, rawmode) < 0) {

Py_DECREF(encoder);

return NULL;

}

if (!ImagingLibTiffEncodeInit(&encoder->state, filename, fp)) {

Py_DECREF(encoder);

PyErr_SetString(PyExc_RuntimeError, "tiff codec initialization failed");

return NULL;

}

encoder->cleanup = ImagingLibTiffEncodeCleanup;

num_core_tags = sizeof(core_tags) / sizeof(int);

for (pos = 0; pos < tags_size; pos++) {

item = PyList_GetItemRef(tags, pos);

if (item == NULL) {

Py_DECREF(encoder);

return NULL;

}

// We already checked that tags is a 2-tuple list.

key = PyTuple_GET_ITEM(item, 0);

key_int = (int)PyLong_AsLong(key);

value = PyTuple_GET_ITEM(item, 1);

status = 0;

is_core_tag = 0;

is_var_length = 0;

type = TIFF_NOTYPE;

for (i = 0; i < num_core_tags; i++) {

if (core_tags[i] == key_int) {

is_core_tag = 1;

break;

}

}

if (!is_core_tag) {

PyObject *tag_type;

if (PyDict_GetItemRef(types, key, &tag_type) < 0) {

Py_DECREF(encoder);

Py_DECREF(item);

return NULL; // Exception has been already set

}

if (tag_type) {

int type_int = PyLong_AsLong(tag_type);

if (type_int >= TIFF_BYTE && type_int <= TIFF_LONG8) {

type = (TIFFDataType)type_int;

}

Py_DECREF(tag_type);

}

}

if (type == TIFF_NOTYPE) {

// Autodetect type. Types should not be changed for backwards

// compatibility.

if (PyLong_Check(value)) {

type = TIFF_LONG;

} else if (PyFloat_Check(value)) {

type = TIFF_DOUBLE;

} else if (PyBytes_Check(value)) {

type = TIFF_ASCII;

}

}

if (PyTuple_Check(value)) {

Py_ssize_t len;

len = PyTuple_Size(value);

is_var_length = 1;

if (!len) {

continue;

}

if (type == TIFF_NOTYPE) {

// Autodetect type based on first item. Types should not be

// changed for backwards compatibility.

if (PyLong_Check(PyTuple_GetItem(value, 0))) {

type = TIFF_LONG;

} else if (PyFloat_Check(PyTuple_GetItem(value, 0))) {

type = TIFF_FLOAT;

}

}

}

if (!is_core_tag) {

// Register field for non core tags.

if (type == TIFF_BYTE) {

is_var_length = 1;

}

if (ImagingLibTiffMergeFieldInfo(

&encoder->state, type, key_int, is_var_length

)) {

continue;

}

}

if (type == TIFF_BYTE || type == TIFF_UNDEFINED ||

key_int == TIFFTAG_INKNAMES) {

if (!PyBytes_Check(value)) {

Py_DECREF(encoder);

Py_DECREF(item);

PyErr_SetString(PyExc_ValueError, "Incorrect tag value type");

return NULL;

}

status = ImagingLibTiffSetField(

&encoder->state,

(ttag_t)key_int,

PyBytes_Size(value),

PyBytes_AsString(value)

);

} else if (is_var_length) {

Py_ssize_t len, i;

TRACE(("Setting from Tuple: %d \n", key_int));

len = PyTuple_Size(value);

if (key_int == TIFFTAG_COLORMAP) {

int stride = 256;

if (len != 768) {

Py_DECREF(encoder);

Py_DECREF(item);

PyErr_SetString(

PyExc_ValueError, "Requiring 768 items for Colormap"

);

return NULL;

}

UINT16 *av;

/* malloc check ok, calloc checks for overflow */

av = calloc(len, sizeof(UINT16));

if (av) {

for (i = 0; i < len; i++) {

av[i] = (UINT16)PyLong_AsLong(PyTuple_GetItem(value, i));

}

status = ImagingLibTiffSetField(

&encoder->state,

(ttag_t)key_int,

av,

av + stride,

av + stride * 2

);

free(av);

}

} else if (key_int == TIFFTAG_YCBCRSUBSAMPLING) {

status = ImagingLibTiffSetField(

&encoder->state,

(ttag_t)key_int,

(UINT16)PyLong_AsLong(PyTuple_GetItem(value, 0)),

(UINT16)PyLong_AsLong(PyTuple_GetItem(value, 1))

);

} else if (type == TIFF_SHORT) {

UINT16 *av;

/* malloc check ok, calloc checks for overflow */

av = calloc(len, sizeof(UINT16));

if (av) {

for (i = 0; i < len; i++) {

av[i] = (UINT16)PyLong_AsLong(PyTuple_GetItem(value, i));

}

status = ImagingLibTiffSetField(

&encoder->state, (ttag_t)key_int, len, av

);

free(av);

}

} else if (type == TIFF_LONG) {

UINT32 *av;

/* malloc check ok, calloc checks for overflow */

av = calloc(len, sizeof(UINT32));

if (av) {

for (i = 0; i < len; i++) {

av[i] = (UINT32)PyLong_AsLong(PyTuple_GetItem(value, i));

}

status = ImagingLibTiffSetField(

&encoder->state, (ttag_t)key_int, len, av

);

free(av);

}

} else if (type == TIFF_SBYTE) {

INT8 *av;

/* malloc check ok, calloc checks for overflow */

av = calloc(len, sizeof(INT8));

if (av) {

for (i = 0; i < len; i++) {

av[i] = (INT8)PyLong_AsLong(PyTuple_GetItem(value, i));

}

status = ImagingLibTiffSetField(

&encoder->state, (ttag_t)key_int, len, av

);

free(av);

}

} else if (type == TIFF_SSHORT) {

INT16 *av;

/* malloc check ok, calloc checks for overflow */

av = calloc(len, sizeof(INT16));

if (av) {

for (i = 0; i < len; i++) {

av[i] = (INT16)PyLong_AsLong(PyTuple_GetItem(value, i));

}

status = ImagingLibTiffSetField(

&encoder->state, (ttag_t)key_int, len, av

);

free(av);

}

} else if (type == TIFF_SLONG) {

INT32 *av;

/* malloc check ok, calloc checks for overflow */

av = calloc(len, sizeof(INT32));

if (av) {

for (i = 0; i < len; i++) {

av[i] = (INT32)PyLong_AsLong(PyTuple_GetItem(value, i));

}

status = ImagingLibTiffSetField(

&encoder->state, (ttag_t)key_int, len, av

);

free(av);

}

} else if (type == TIFF_FLOAT) {

FLOAT32 *av;

/* malloc check ok, calloc checks for overflow */

av = calloc(len, sizeof(FLOAT32));

if (av) {

for (i = 0; i < len; i++) {

av[i] = (FLOAT32)PyFloat_AsDouble(PyTuple_GetItem(value, i));

}

status = ImagingLibTiffSetField(

&encoder->state, (ttag_t)key_int, len, av

);

free(av);

}

} else if (type == TIFF_DOUBLE) {

FLOAT64 *av;

/* malloc check ok, calloc checks for overflow */

av = calloc(len, sizeof(FLOAT64));

if (av) {

for (i = 0; i < len; i++) {

av[i] = PyFloat_AsDouble(PyTuple_GetItem(value, i));

}

status = ImagingLibTiffSetField(

&encoder->state, (ttag_t)key_int, len, av

);

free(av);

}

} else if (type == TIFF_RATIONAL) {

FLOAT32 *av;

/* malloc check ok, calloc checks for overflow */

av = calloc(len, sizeof(FLOAT32));

if (av) {

for (i = 0; i < len; i++) {

av[i] = (FLOAT32)PyFloat_AsDouble(PyTuple_GetItem(value, i));