PyObject* PyImaging_PcxEncoderNew(PyObject* self, PyObject* args) { ImagingEncoderObject* encoder; char *mode; char *rawmode; int bits = 8; if (!PyArg_ParseTuple(args, "ss|ii", &mode, &rawmode, &bits)) { return NULL; } encoder = PyImaging_EncoderNew(0); if (encoder == NULL) { return NULL; } 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; char *rawmode; int stride = 0; int ystep = 1; if (!PyArg_ParseTuple(args, "ss|ii", &mode, &rawmode, &stride, &ystep)) return NULL; encoder = PyImaging_EncoderNew(0); if (encoder == NULL) return NULL; 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_GifEncoderNew(PyObject* self, PyObject* args) { ImagingEncoderObject* encoder; char *mode; char *rawmode; int bits = 8; int interlace = 0; if (!PyArg_ParseTuple(args, "ss|ii", &mode, &rawmode, &bits, &interlace)) return NULL; encoder = PyImaging_EncoderNew(sizeof(GIFENCODERSTATE)); if (encoder == NULL) return NULL; 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_ZipEncoderNew(PyObject* self, PyObject* args) { ImagingEncoderObject* encoder; char* mode; char* rawmode; int optimize = 0; char* dictionary = NULL; int dictionary_size = 0; if (!PyArg_ParseTuple(args, "ss|is#", &mode, &rawmode, &optimize, &dictionary, &dictionary_size)) return NULL; encoder = PyImaging_EncoderNew(sizeof(ZIPSTATE)); if (encoder == NULL) return NULL; if (get_packer(encoder, mode, rawmode) < 0) return NULL; encoder->encode = ImagingZipEncode; if (rawmode[0] == 'P') /* disable filtering */ ((ZIPSTATE*)encoder->state.context)->mode = ZIP_PNG_PALETTE; ((ZIPSTATE*)encoder->state.context)->optimize = optimize; ((ZIPSTATE*)encoder->state.context)->dictionary = dictionary; ((ZIPSTATE*)encoder->state.context)->dictionary_size = dictionary_size; return (PyObject*) encoder; }
PyObject* PyImaging_WebPEncoderNew(PyObject* self, PyObject* args) { ImagingEncoderObject* encoder; char* mode; char* rawmode; int quality = 0; if (!PyArg_ParseTuple(args, ARG("ss|i", "ss|i"), &mode, &rawmode, &quality)) return NULL; encoder = PyImaging_EncoderNew(sizeof(WEBPCONTEXT)); if (encoder == NULL) return NULL; if (get_packer(encoder, mode, rawmode) < 0) return NULL; encoder->encode = ImagingWebPEncode; ((WEBPCONTEXT*)encoder->state.context)->quality = quality; return (PyObject*) encoder; }
PyObject* PyImaging_JpegEncoderNew(PyObject* self, PyObject* args) { ImagingEncoderObject* encoder; char *mode; char *rawmode; int quality = 0; int progressive = 0; int smooth = 0; int optimize = 0; int streamtype = 0; /* 0=interchange, 1=tables only, 2=image only */ int xdpi = 0, ydpi = 0; int subsampling = -1; /* -1=default, 0=none, 1=medium, 2=high */ char* extra = NULL; int extra_size; if (!PyArg_ParseTuple(args, "ss|iiiiiiiis#", &mode, &rawmode, &quality, &progressive, &smooth, &optimize, &streamtype, &xdpi, &ydpi, &subsampling, &extra, &extra_size)) return NULL; encoder = PyImaging_EncoderNew(sizeof(JPEGENCODERSTATE)); if (encoder == NULL) return NULL; if (get_packer(encoder, mode, rawmode) < 0) return NULL; if (extra && extra_size > 0) { char* p = malloc(extra_size); if (!p) return PyErr_NoMemory(); memcpy(p, extra, extra_size); extra = p; } else extra = NULL; encoder->encode = ImagingJpegEncode; ((JPEGENCODERSTATE*)encoder->state.context)->quality = quality; ((JPEGENCODERSTATE*)encoder->state.context)->subsampling = subsampling; ((JPEGENCODERSTATE*)encoder->state.context)->progressive = progressive; ((JPEGENCODERSTATE*)encoder->state.context)->smooth = smooth; ((JPEGENCODERSTATE*)encoder->state.context)->optimize = optimize; ((JPEGENCODERSTATE*)encoder->state.context)->streamtype = streamtype; ((JPEGENCODERSTATE*)encoder->state.context)->xdpi = xdpi; ((JPEGENCODERSTATE*)encoder->state.context)->ydpi = ydpi; ((JPEGENCODERSTATE*)encoder->state.context)->extra = extra; ((JPEGENCODERSTATE*)encoder->state.context)->extra_size = extra_size; return (PyObject*) encoder; }
PyObject* PyImaging_ZipEncoderNew(PyObject* self, PyObject* args) { ImagingEncoderObject* encoder; char* mode; char* rawmode; int optimize = 0; int compress_level = -1; int compress_type = -1; char* dictionary = NULL; int dictionary_size = 0; if (!PyArg_ParseTuple(args, "ss|iii"PY_ARG_BYTES_LENGTH, &mode, &rawmode, &optimize, &compress_level, &compress_type, &dictionary, &dictionary_size)) return NULL; /* Copy to avoid referencing Python's memory, but there's no mechanism to free this memory later, so this function (and several others here) leaks. */ if (dictionary && dictionary_size > 0) { char* p = malloc(dictionary_size); if (!p) return PyErr_NoMemory(); memcpy(p, dictionary, dictionary_size); dictionary = p; } else dictionary = NULL; encoder = PyImaging_EncoderNew(sizeof(ZIPSTATE)); if (encoder == NULL) return NULL; if (get_packer(encoder, mode, rawmode) < 0) return NULL; encoder->encode = ImagingZipEncode; if (rawmode[0] == 'P') /* 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; }
PyObject* PyImaging_XbmEncoderNew(PyObject* self, PyObject* args) { ImagingEncoderObject* encoder; encoder = PyImaging_EncoderNew(0); if (encoder == NULL) return NULL; if (get_packer(encoder, "1", "1;R") < 0) return NULL; encoder->encode = ImagingXbmEncode; return (PyObject*) encoder; }
PyObject* PyImaging_LibTiffEncoderNew(PyObject* self, PyObject* args) { ImagingEncoderObject* encoder; char* mode; char* rawmode; char* compname; char* filename; int fp; PyObject *dir; PyObject *key, *value; Py_ssize_t pos = 0; int status; Py_ssize_t d_size; PyObject *keys, *values; if (! PyArg_ParseTuple(args, "sssisO", &mode, &rawmode, &compname, &fp, &filename, &dir)) { return NULL; } if (!PyDict_Check(dir)) { PyErr_SetString(PyExc_ValueError, "Invalid Dictionary"); return NULL; } else { d_size = PyDict_Size(dir); TRACE(("dict size: %d\n", (int)d_size)); keys = PyDict_Keys(dir); values = PyDict_Values(dir); for (pos=0;pos<d_size;pos++){ TRACE((" key: %d\n", (int)PyInt_AsLong(PyList_GetItem(keys,pos)))); } pos = 0; } TRACE(("new tiff encoder %s fp: %d, filename: %s \n", compname, fp, filename)); encoder = PyImaging_EncoderNew(sizeof(TIFFSTATE)); if (encoder == NULL) return NULL; if (get_packer(encoder, mode, rawmode) < 0) return NULL; if (! ImagingLibTiffEncodeInit(&encoder->state, filename, fp)) { Py_DECREF(encoder); PyErr_SetString(PyExc_RuntimeError, "tiff codec initialization failed"); return NULL; } // While failes on 64 bit machines, complains that pos is an int instead of a Py_ssize_t // while (PyDict_Next(dir, &pos, &key, &value)) { for (pos=0;pos<d_size;pos++){ key = PyList_GetItem(keys,pos); value = PyList_GetItem(values,pos); status = 0; TRACE(("Attempting to set key: %d\n", (int)PyInt_AsLong(key))); if (PyInt_Check(value)) { TRACE(("Setting from Int: %d %ld \n", (int)PyInt_AsLong(key),PyInt_AsLong(value))); status = ImagingLibTiffSetField(&encoder->state, (ttag_t) PyInt_AsLong(key), PyInt_AsLong(value)); } else if(PyBytes_Check(value)) { TRACE(("Setting from Bytes: %d, %s \n", (int)PyInt_AsLong(key),PyBytes_AsString(value))); status = ImagingLibTiffSetField(&encoder->state, (ttag_t) PyInt_AsLong(key), PyBytes_AsString(value)); } else if(PyList_Check(value)) { int len,i; float *floatav; int *intav; TRACE(("Setting from List: %d \n", (int)PyInt_AsLong(key))); len = (int)PyList_Size(value); if (len) { if (PyInt_Check(PyList_GetItem(value,0))) { TRACE((" %d elements, setting as ints \n", len)); intav = malloc(sizeof(int)*len); if (intav) { for (i=0;i<len;i++) { intav[i] = (int)PyInt_AsLong(PyList_GetItem(value,i)); } status = ImagingLibTiffSetField(&encoder->state, (ttag_t) PyInt_AsLong(key), intav); free(intav); } } else { TRACE((" %d elements, setting as floats \n", len)); floatav = malloc(sizeof(float)*len); if (floatav) { for (i=0;i<len;i++) { floatav[i] = (float)PyFloat_AsDouble(PyList_GetItem(value,i)); } status = ImagingLibTiffSetField(&encoder->state, (ttag_t) PyInt_AsLong(key), floatav); free(floatav); } } } } else if (PyFloat_Check(value)) { TRACE(("Setting from Float: %d, %f \n", (int)PyInt_AsLong(key),PyFloat_AsDouble(value))); status = ImagingLibTiffSetField(&encoder->state, (ttag_t) PyInt_AsLong(key), (float)PyFloat_AsDouble(value)); } else { TRACE(("Unhandled type for key %d : %s \n", (int)PyInt_AsLong(key), PyBytes_AsString(PyObject_Str(value)))); } if (!status) { TRACE(("Error setting Field\n")); Py_DECREF(encoder); PyErr_SetString(PyExc_RuntimeError, "Error setting from dictionary"); return NULL; } } encoder->encode = ImagingLibTiffEncode; return (PyObject*) encoder; }
PyObject* PyImaging_JpegEncoderNew(PyObject* self, PyObject* args) { ImagingEncoderObject* encoder; char *mode; char *rawmode; int quality = 0; int progressive = 0; int smooth = 0; int optimize = 0; int streamtype = 0; /* 0=interchange, 1=tables only, 2=image only */ int xdpi = 0, ydpi = 0; int subsampling = -1; /* -1=default, 0=none, 1=medium, 2=high */ PyObject* qtables=NULL; unsigned int **qarrays = NULL; char* extra = NULL; int extra_size; char* rawExif = NULL; int rawExifLen = 0; if (!PyArg_ParseTuple(args, "ss|iiiiiiiiO"PY_ARG_BYTES_LENGTH""PY_ARG_BYTES_LENGTH, &mode, &rawmode, &quality, &progressive, &smooth, &optimize, &streamtype, &xdpi, &ydpi, &subsampling, &qtables, &extra, &extra_size, &rawExif, &rawExifLen)) return NULL; encoder = PyImaging_EncoderNew(sizeof(JPEGENCODERSTATE)); if (encoder == NULL) return NULL; if (get_packer(encoder, mode, rawmode) < 0) return NULL; qarrays = get_qtables_arrays(qtables); if (extra && extra_size > 0) { char* p = malloc(extra_size); if (!p) return PyErr_NoMemory(); memcpy(p, extra, extra_size); extra = p; } else extra = NULL; if (rawExif && rawExifLen > 0) { char* pp = malloc(rawExifLen); if (!pp) return PyErr_NoMemory(); memcpy(pp, rawExif, rawExifLen); rawExif = pp; } else rawExif = NULL; encoder->encode = ImagingJpegEncode; ((JPEGENCODERSTATE*)encoder->state.context)->quality = quality; ((JPEGENCODERSTATE*)encoder->state.context)->qtables = qarrays; ((JPEGENCODERSTATE*)encoder->state.context)->subsampling = subsampling; ((JPEGENCODERSTATE*)encoder->state.context)->progressive = progressive; ((JPEGENCODERSTATE*)encoder->state.context)->smooth = smooth; ((JPEGENCODERSTATE*)encoder->state.context)->optimize = optimize; ((JPEGENCODERSTATE*)encoder->state.context)->streamtype = streamtype; ((JPEGENCODERSTATE*)encoder->state.context)->xdpi = xdpi; ((JPEGENCODERSTATE*)encoder->state.context)->ydpi = ydpi; ((JPEGENCODERSTATE*)encoder->state.context)->extra = extra; ((JPEGENCODERSTATE*)encoder->state.context)->extra_size = extra_size; ((JPEGENCODERSTATE*)encoder->state.context)->rawExif = rawExif; ((JPEGENCODERSTATE*)encoder->state.context)->rawExifLen = rawExifLen; return (PyObject*) encoder; }
PyObject* PyImaging_LibTiffEncoderNew(PyObject* self, PyObject* args) { ImagingEncoderObject* encoder; char* mode; char* rawmode; char* compname; char* filename; int compression; int fp; PyObject *dir; PyObject *key, *value; Py_ssize_t pos = 0; int status; Py_ssize_t d_size; PyObject *keys, *values; if (! PyArg_ParseTuple(args, "sssisO", &mode, &rawmode, &compname, &fp, &filename, &dir)) { return NULL; } if (!PyDict_Check(dir)) { PyErr_SetString(PyExc_ValueError, "Invalid Dictionary"); return NULL; } else { d_size = PyDict_Size(dir); TRACE(("dict size: %d\n", (int)d_size)); keys = PyDict_Keys(dir); values = PyDict_Values(dir); for (pos=0;pos<d_size;pos++){ TRACE((" key: %d\n", (int)PyInt_AsLong(PyList_GetItem(keys,pos)))); } pos = 0; } TRACE(("new tiff encoder %s fp: %d, filename: %s \n", compname, fp, filename)); /* UNDONE -- we can probably do almost any arbitrary compression here, * so long as we're doing row/stripe based actions and not tiles. */ if (strcasecmp(compname, "tiff_ccitt") == 0) { compression = COMPRESSION_CCITTRLE; } else if (strcasecmp(compname, "group3") == 0) { compression = COMPRESSION_CCITTFAX3; } else if (strcasecmp(compname, "group4") == 0) { compression = COMPRESSION_CCITTFAX4; } else if (strcasecmp(compname, "tiff_jpeg") == 0) { compression = COMPRESSION_OJPEG; } else if (strcasecmp(compname, "tiff_adobe_deflate") == 0) { compression = COMPRESSION_ADOBE_DEFLATE; } else if (strcasecmp(compname, "tiff_thunderscan") == 0) { compression = COMPRESSION_THUNDERSCAN; } else if (strcasecmp(compname, "tiff_deflate") == 0) { compression = COMPRESSION_DEFLATE; } else if (strcasecmp(compname, "tiff_sgilog") == 0) { compression = COMPRESSION_SGILOG; } else if (strcasecmp(compname, "tiff_sgilog24") == 0) { compression = COMPRESSION_SGILOG24; } else if (strcasecmp(compname, "tiff_raw_16") == 0) { compression = COMPRESSION_CCITTRLEW; } else { PyErr_SetString(PyExc_ValueError, "unknown compession"); return NULL; } TRACE(("Found compression: %d\n", compression)); encoder = PyImaging_EncoderNew(sizeof(TIFFSTATE)); if (encoder == NULL) return NULL; if (get_packer(encoder, mode, rawmode) < 0) return NULL; if (! ImagingLibTiffEncodeInit(&encoder->state, filename, fp)) { Py_DECREF(encoder); PyErr_SetString(PyExc_RuntimeError, "tiff codec initialization failed"); return NULL; } // While failes on 64 bit machines, complains that pos is an int instead of a Py_ssize_t // while (PyDict_Next(dir, &pos, &key, &value)) { for (pos=0;pos<d_size;pos++){ key = PyList_GetItem(keys,pos); value = PyList_GetItem(values,pos); status = 0; TRACE(("Attempting to set key: %d\n", (int)PyInt_AsLong(key))); if (PyInt_Check(value)) { TRACE(("Setting from Int: %d %ld \n", (int)PyInt_AsLong(key),PyInt_AsLong(value))); status = ImagingLibTiffSetField(&encoder->state, (ttag_t) PyInt_AsLong(key), PyInt_AsLong(value)); } else if(PyBytes_Check(value)) { TRACE(("Setting from Bytes: %d, %s \n", (int)PyInt_AsLong(key),PyBytes_AsString(value))); status = ImagingLibTiffSetField(&encoder->state, (ttag_t) PyInt_AsLong(key), PyBytes_AsString(value)); } else if(PyList_Check(value)) { int len,i; float *floatav; TRACE(("Setting from List: %d \n", (int)PyInt_AsLong(key))); len = (int)PyList_Size(value); TRACE((" %d elements, setting as floats \n", len)); floatav = malloc(sizeof(float)*len); if (floatav) { for (i=0;i<len;i++) { floatav[i] = (float)PyFloat_AsDouble(PyList_GetItem(value,i)); } status = ImagingLibTiffSetField(&encoder->state, (ttag_t) PyInt_AsLong(key), floatav); free(floatav); } } else if (PyFloat_Check(value)) { TRACE(("Setting from Float: %d, %f \n", (int)PyInt_AsLong(key),PyFloat_AsDouble(value))); status = ImagingLibTiffSetField(&encoder->state, (ttag_t) PyInt_AsLong(key), (float)PyFloat_AsDouble(value)); } else { TRACE(("Unhandled type for key %d : %s \n", (int)PyInt_AsLong(key), PyBytes_AsString(PyObject_Str(value)))); } if (!status) { TRACE(("Error setting Field\n")); Py_DECREF(encoder); PyErr_SetString(PyExc_RuntimeError, "Error setting from dictionary"); return NULL; } } encoder->encode = ImagingLibTiffEncode; return (PyObject*) encoder; }