Bug Summary

File:encode.c
Warning:line 131, column 11
PyObject ownership leak with reference count of 1

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name encode.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/encode.c

src/encode.c

→
1/*
2 * The Python Imaging Library.
3 *
4 * standard encoder interfaces for the Imaging library
5 *
6 * History:
7 * 1996-04-19 fl Based on decoders.c
8 * 1996-05-12 fl Compile cleanly as C++
9 * 1996-12-30 fl Plugged potential memory leak for tiled images
10 * 1997-01-03 fl Added GIF encoder
11 * 1997-01-05 fl Plugged encoder buffer leaks
12 * 1997-01-11 fl Added encode_to_file method
13 * 1998-03-09 fl Added mode/rawmode argument to encoders
14 * 1998-07-09 fl Added interlace argument to GIF encoder
15 * 1999-02-07 fl Added PCX encoder
16 *
17 * Copyright (c) 1997-2001 by Secret Labs AB
18 * Copyright (c) 1996-1997 by Fredrik Lundh
19 *
20 * See the README file for information on usage and redistribution.
21 */
22
23/* FIXME: make these pluggable! */
24
25#define PY_SSIZE_T_CLEAN
26#include "Python.h"
27
28#include "libImaging/Imaging.h"
29#include "libImaging/Gif.h"
30
31#ifdef HAVE_UNISTD_H1
32#include <unistd.h> /* write */
33#endif
34
35/* -------------------------------------------------------------------- */
36/* Common */
37/* -------------------------------------------------------------------- */
38
39typedef struct {
40 PyObject_HEADPyObject ob_base; int (*encode)(
41 Imaging im, ImagingCodecState state, UINT8 *buffer, int bytes);
42 int (*cleanup)(ImagingCodecState state);
43 struct ImagingCodecStateInstance state;
44 Imaging im;
45 PyObject *lock;
46 int pushes_fd;
47} ImagingEncoderObject;
48
49static PyTypeObject ImagingEncoderType;
50
51static ImagingEncoderObject *
52PyImaging_EncoderNew(int contextsize) {
53 ImagingEncoderObject *encoder;
54 void *context;
55
56 if (PyType_Ready(&ImagingEncoderType) < 0) {
57 return NULL((void*)0);
58 }
59
60 encoder = PyObject_New(ImagingEncoderObject, &ImagingEncoderType)( (ImagingEncoderObject *) _PyObject_New(&ImagingEncoderType
) );
61 if (encoder == NULL((void*)0)) {
62 return NULL((void*)0);
63 }
64
65 /* Clear the encoder state */
66 memset(&encoder->state, 0, sizeof(encoder->state));
67
68 /* Allocate encoder context */
69 if (contextsize > 0) {
70 context = (void *)calloc(1, contextsize);
71 if (!context) {
72 Py_DECREF(encoder)_Py_DECREF(((PyObject*)(encoder)));
73 (void)ImagingError_MemoryError();
74 return NULL((void*)0);
75 }
76 } else {
77 context = 0;
78 }
79
80 /* Initialize encoder context */
81 encoder->state.context = context;
82
83 /* Most encoders don't need this */
84 encoder->cleanup = NULL((void*)0);
85
86 /* Target image */
87 encoder->lock = NULL((void*)0);
88 encoder->im = NULL((void*)0);
89 encoder->pushes_fd = 0;
90
91 return encoder;
92}
93
94static void
95_dealloc(ImagingEncoderObject *encoder) {
96 if (encoder->cleanup) {
97 encoder->cleanup(&encoder->state);
98 }
99 free(encoder->state.buffer);
100 free(encoder->state.context);
101 Py_XDECREF(encoder->lock)_Py_XDECREF(((PyObject*)(encoder->lock)));
102 Py_XDECREF(encoder->state.fd)_Py_XDECREF(((PyObject*)(encoder->state.fd)));
103 PyObject_DelPyObject_Free(encoder);
104}
105
106static PyObject *
107_encode_cleanup(ImagingEncoderObject *encoder, PyObject *args) {
108 int status = 0;
109
110 if (encoder->cleanup) {
111 status = encoder->cleanup(&encoder->state);
112 }
113
114 return Py_BuildValue_Py_BuildValue_SizeT("i", status);
115}
116
117static PyObject *
118_encode(ImagingEncoderObject *encoder, PyObject *args) {
119 PyObject *buf;
120 PyObject *result;
121 int status;
122
123 /* Encode to a Python string (allocated by this method) */
124
125 Py_ssize_t bufsize = 16384;
126
127 if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "|n", &bufsize)) {
1
Assuming the condition is false
→
2
←
Taking false branch
→
128 return NULL((void*)0);
129 }
130
131 buf = PyBytes_FromStringAndSize(NULL((void*)0), bufsize);
3
←
Calling 'PyBytes_FromStringAndSize'
→
5
←
Returning from 'PyBytes_FromStringAndSize'
→
12
←
PyObject ownership leak with reference count of 1
132 if (!buf) {
6
←
Assuming 'buf' is non-null
→
7
←
Taking false branch
→
133 return NULL((void*)0);
134 }
135
136 status = encoder->encode(
137 encoder->im, &encoder->state, (UINT8 *)PyBytes_AsString(buf), bufsize);
138
139 /* adjust string length to avoid slicing in encoder */
140 if (_PyBytes_Resize(&buf, (status > 0) ? status : 0) < 0) {
8
←
Assuming 'status' is <= 0
→
9
←
'?' condition is false
→
10
←
Assuming the condition is true
→
11
←
Taking true branch
→
141 return NULL((void*)0);
142 }
143
144 result = Py_BuildValue_Py_BuildValue_SizeT("iiO", status, encoder->state.errcode, buf);
145
146 Py_DECREF(buf)_Py_DECREF(((PyObject*)(buf))); /* must release buffer!!! */
147
148 return result;
149}
150
151static PyObject *
152_encode_to_pyfd(ImagingEncoderObject *encoder, PyObject *args) {
153 PyObject *result;
154 int status;
155
156 if (!encoder->pushes_fd) {
157 // UNDONE, appropriate errcode???
158 result = Py_BuildValue_Py_BuildValue_SizeT("ii", 0, IMAGING_CODEC_CONFIG-8);
159 ;
160 return result;
161 }
162
163 status = encoder->encode(encoder->im, &encoder->state, (UINT8 *)NULL((void*)0), 0);
164
165 result = Py_BuildValue_Py_BuildValue_SizeT("ii", status, encoder->state.errcode);
166
167 return result;
168}
169
170static PyObject *
171_encode_to_file(ImagingEncoderObject *encoder, PyObject *args) {
172 UINT8 *buf;
173 int status;
174 ImagingSectionCookie cookie;
175
176 /* Encode to a file handle */
177
178 Py_ssize_t fh;
179 Py_ssize_t bufsize = 16384;
180
181 if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "n|n", &fh, &bufsize)) {
182 return NULL((void*)0);
183 }
184
185 /* Allocate an encoder buffer */
186 /* malloc check ok, either constant int, or checked by PyArg_ParseTuple */
187 buf = (UINT8 *)malloc(bufsize);
188 if (!buf) {
189 return ImagingError_MemoryError();
190 }
191
192 ImagingSectionEnter(&cookie);
193
194 do {
195 /* This replaces the inner loop in the ImageFile _save
196 function. */
197
198 status = encoder->encode(encoder->im, &encoder->state, buf, bufsize);
199
200 if (status > 0) {
201 if (write(fh, buf, status) < 0) {
202 ImagingSectionLeave(&cookie);
203 free(buf);
204 return PyErr_SetFromErrno(PyExc_OSError);
205 }
206 }
207
208 } while (encoder->state.errcode == 0);
209
210 ImagingSectionLeave(&cookie);
211
212 free(buf);
213
214 return Py_BuildValue_Py_BuildValue_SizeT("i", encoder->state.errcode);
215}
216
217extern Imaging
218PyImaging_AsImaging(PyObject *op);
219
220static PyObject *
221_setimage(ImagingEncoderObject *encoder, PyObject *args) {
222 PyObject *op;
223 Imaging im;
224 ImagingCodecState state;
225 Py_ssize_t x0, y0, x1, y1;
226
227 /* Define where image data should be stored */
228
229 x0 = y0 = x1 = y1 = 0;
230
231 /* FIXME: should publish the ImagingType descriptor */
232 if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O|(nnnn)", &op, &x0, &y0, &x1, &y1)) {
233 return NULL((void*)0);
234 }
235 im = PyImaging_AsImaging(op);
236 if (!im) {
237 return NULL((void*)0);
238 }
239
240 encoder->im = im;
241
242 state = &encoder->state;
243
244 if (x0 == 0 && x1 == 0) {
245 state->xsize = im->xsize;
246 state->ysize = im->ysize;
247 } else {
248 state->xoff = x0;
249 state->yoff = y0;
250 state->xsize = x1 - x0;
251 state->ysize = y1 - y0;
252 }
253
254 if (state->xsize <= 0 || state->xsize + state->xoff > im->xsize ||
255 state->ysize <= 0 || state->ysize + state->yoff > im->ysize) {
256 PyErr_SetString(PyExc_SystemError, "tile cannot extend outside image");
257 return NULL((void*)0);
258 }
259
260 /* Allocate memory buffer (if bits field is set) */
261 if (state->bits > 0) {
262 if (state->xsize > ((INT_MAX2147483647 / state->bits) - 7)) {
263 return ImagingError_MemoryError();
264 }
265 state->bytes = (state->bits * state->xsize + 7) / 8;
266 /* malloc check ok, overflow checked above */
267 state->buffer = (UINT8 *)calloc(1, state->bytes);
268 if (!state->buffer) {
269 return ImagingError_MemoryError();
270 }
271 }
272
273 /* Keep a reference to the image object, to make sure it doesn't
274 go away before we do */
275 Py_INCREF(op)_Py_INCREF(((PyObject*)(op)));
276 Py_XDECREF(encoder->lock)_Py_XDECREF(((PyObject*)(encoder->lock)));
277 encoder->lock = op;
278
279 Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
280 return Py_None(&_Py_NoneStruct);
281}
282
283static PyObject *
284_setfd(ImagingEncoderObject *encoder, PyObject *args) {
285 PyObject *fd;
286 ImagingCodecState state;
287
288 if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O", &fd)) {
289 return NULL((void*)0);
290 }
291
292 state = &encoder->state;
293
294 Py_XINCREF(fd)_Py_XINCREF(((PyObject*)(fd)));
295 state->fd = fd;
296
297 Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
298 return Py_None(&_Py_NoneStruct);
299}
300
301static PyObject *
302_get_pushes_fd(ImagingEncoderObject *encoder) {
303 return PyBool_FromLong(encoder->pushes_fd);
304}
305
306static struct PyMethodDef methods[] = {
307 {"encode", (PyCFunction)_encode, METH_VARARGS0x0001},
308 {"cleanup", (PyCFunction)_encode_cleanup, METH_VARARGS0x0001},
309 {"encode_to_file", (PyCFunction)_encode_to_file, METH_VARARGS0x0001},
310 {"encode_to_pyfd", (PyCFunction)_encode_to_pyfd, METH_VARARGS0x0001},
311 {"setimage", (PyCFunction)_setimage, METH_VARARGS0x0001},
312 {"setfd", (PyCFunction)_setfd, METH_VARARGS0x0001},
313 {NULL((void*)0), NULL((void*)0)} /* sentinel */
314};
315
316static struct PyGetSetDef getseters[] = {
317 {"pushes_fd",
318 (getter)_get_pushes_fd,
319 NULL((void*)0),
320 "True if this decoder expects to push directly to self.fd",
321 NULL((void*)0)},
322 {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)} /* sentinel */
323};
324
325static PyTypeObject ImagingEncoderType = {
326 PyVarObject_HEAD_INIT(NULL, 0){ { 1, ((void*)0) }, 0 }, "ImagingEncoder", /*tp_name*/
327 sizeof(ImagingEncoderObject), /*tp_size*/
328 0, /*tp_itemsize*/
329 /* methods */
330 (destructor)_dealloc, /*tp_dealloc*/
331 0, /*tp_print*/
332 0, /*tp_getattr*/
333 0, /*tp_setattr*/
334 0, /*tp_compare*/
335 0, /*tp_repr*/
336 0, /*tp_as_number */
337 0, /*tp_as_sequence */
338 0, /*tp_as_mapping */
339 0, /*tp_hash*/
340 0, /*tp_call*/
341 0, /*tp_str*/
342 0, /*tp_getattro*/
343 0, /*tp_setattro*/
344 0, /*tp_as_buffer*/
345 Py_TPFLAGS_DEFAULT( 0 | (1UL << 18) | 0), /*tp_flags*/
346 0, /*tp_doc*/
347 0, /*tp_traverse*/
348 0, /*tp_clear*/
349 0, /*tp_richcompare*/
350 0, /*tp_weaklistoffset*/
351 0, /*tp_iter*/
352 0, /*tp_iternext*/
353 methods, /*tp_methods*/
354 0, /*tp_members*/
355 getseters, /*tp_getset*/
356};
357
358/* -------------------------------------------------------------------- */
359
360int
361get_packer(ImagingEncoderObject *encoder, const char *mode, const char *rawmode) {
362 int bits;
363 ImagingShuffler pack;
364
365 pack = ImagingFindPacker(mode, rawmode, &bits);
366 if (!pack) {
367 Py_DECREF(encoder)_Py_DECREF(((PyObject*)(encoder)));
368 PyErr_Format(PyExc_ValueError, "No packer found from %s to %s", mode, rawmode);
369 return -1;
370 }
371
372 encoder->state.shuffle = pack;
373 encoder->state.bits = bits;
374
375 return 0;
376}
377
378/* -------------------------------------------------------------------- */
379/* EPS */
380/* -------------------------------------------------------------------- */
381
382PyObject *
383PyImaging_EpsEncoderNew(PyObject *self, PyObject *args) {
384 ImagingEncoderObject *encoder;
385
386 encoder = PyImaging_EncoderNew(0);
387 if (encoder == NULL((void*)0)) {
388 return NULL((void*)0);
389 }
390
391 encoder->encode = ImagingEpsEncode;
392
393 return (PyObject *)encoder;
394}
395
396/* -------------------------------------------------------------------- */
397/* GIF */
398/* -------------------------------------------------------------------- */
399
400PyObject *
401PyImaging_GifEncoderNew(PyObject *self, PyObject *args) {
402 ImagingEncoderObject *encoder;
403
404 char *mode;
405 char *rawmode;
406 Py_ssize_t bits = 8;
407 Py_ssize_t interlace = 0;
408 if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "ss|nn", &mode, &rawmode, &bits, &interlace)) {
409 return NULL((void*)0);
410 }
411
412 encoder = PyImaging_EncoderNew(sizeof(GIFENCODERSTATE));
413 if (encoder == NULL((void*)0)) {
414 return NULL((void*)0);
415 }
416
417 if (get_packer(encoder, mode, rawmode) < 0) {
418 return NULL((void*)0);
419 }
420
421 encoder->encode = ImagingGifEncode;
422
423 ((GIFENCODERSTATE *)encoder->state.context)->bits = bits;
424 ((GIFENCODERSTATE *)encoder->state.context)->interlace = interlace;
425
426 return (PyObject *)encoder;
427}
428
429/* -------------------------------------------------------------------- */
430/* PCX */
431/* -------------------------------------------------------------------- */
432
433PyObject *
434PyImaging_PcxEncoderNew(PyObject *self, PyObject *args) {
435 ImagingEncoderObject *encoder;
436
437 char *mode;
438 char *rawmode;
439 Py_ssize_t bits = 8;
440
441 if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "ss|n", &mode, &rawmode, &bits)) {
442 return NULL((void*)0);
443 }
444
445 encoder = PyImaging_EncoderNew(0);
446 if (encoder == NULL((void*)0)) {
447 return NULL((void*)0);
448 }
449
450 if (get_packer(encoder, mode, rawmode) < 0) {
451 return NULL((void*)0);
452 }
453
454 encoder->encode = ImagingPcxEncode;
455
456 return (PyObject *)encoder;
457}
458
459/* -------------------------------------------------------------------- */
460/* RAW */
461/* -------------------------------------------------------------------- */
462
463PyObject *
464PyImaging_RawEncoderNew(PyObject *self, PyObject *args) {
465 ImagingEncoderObject *encoder;
466
467 char *mode;
468 char *rawmode;
469 Py_ssize_t stride = 0;
470 Py_ssize_t ystep = 1;
471
472 if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "ss|nn", &mode, &rawmode, &stride, &ystep)) {
473 return NULL((void*)0);
474 }
475
476 encoder = PyImaging_EncoderNew(0);
477 if (encoder == NULL((void*)0)) {
478 return NULL((void*)0);
479 }
480
481 if (get_packer(encoder, mode, rawmode) < 0) {
482 return NULL((void*)0);
483 }
484
485 encoder->encode = ImagingRawEncode;
486
487 encoder->state.ystep = ystep;
488 encoder->state.count = stride;
489
490 return (PyObject *)encoder;
491}
492
493/* -------------------------------------------------------------------- */
494/* TGA */
495/* -------------------------------------------------------------------- */
496
497PyObject *
498PyImaging_TgaRleEncoderNew(PyObject *self, PyObject *args) {
499 ImagingEncoderObject *encoder;
500
501 char *mode;
502 char *rawmode;
503 Py_ssize_t ystep = 1;
504
505 if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "ss|n", &mode, &rawmode, &ystep)) {
506 return NULL((void*)0);
507 }
508
509 encoder = PyImaging_EncoderNew(0);
510 if (encoder == NULL((void*)0)) {
511 return NULL((void*)0);
512 }
513
514 if (get_packer(encoder, mode, rawmode) < 0) {
515 return NULL((void*)0);
516 }
517
518 encoder->encode = ImagingTgaRleEncode;
519
520 encoder->state.ystep = ystep;
521
522 return (PyObject *)encoder;
523}
524
525/* -------------------------------------------------------------------- */
526/* XBM */
527/* -------------------------------------------------------------------- */
528
529PyObject *
530PyImaging_XbmEncoderNew(PyObject *self, PyObject *args) {
531 ImagingEncoderObject *encoder;
532
533 encoder = PyImaging_EncoderNew(0);
534 if (encoder == NULL((void*)0)) {
535 return NULL((void*)0);
536 }
537
538 if (get_packer(encoder, "1", "1;R") < 0) {
539 return NULL((void*)0);
540 }
541
542 encoder->encode = ImagingXbmEncode;
543
544 return (PyObject *)encoder;
545}
546
547/* -------------------------------------------------------------------- */
548/* ZIP */
549/* -------------------------------------------------------------------- */
550
551#ifdef HAVE_LIBZ1
552
553#include "libImaging/ZipCodecs.h"
554
555PyObject *
556PyImaging_ZipEncoderNew(PyObject *self, PyObject *args) {
557 ImagingEncoderObject *encoder;
558
559 char *mode;
560 char *rawmode;
561 Py_ssize_t optimize = 0;
562 Py_ssize_t compress_level = -1;
563 Py_ssize_t compress_type = -1;
564 char *dictionary = NULL((void*)0);
565 Py_ssize_t dictionary_size = 0;
566 if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
567 args,
568 "ss|nnny#",
569 &mode,
570 &rawmode,
571 &optimize,
572 &compress_level,
573 &compress_type,
574 &dictionary,
575 &dictionary_size)) {
576 return NULL((void*)0);
577 }
578
579 /* Copy to avoid referencing Python's memory */
580 if (dictionary && dictionary_size > 0) {
581 /* malloc check ok, size comes from PyArg_ParseTuple */
582 char *p = malloc(dictionary_size);
583 if (!p) {
584 return ImagingError_MemoryError();
585 }
586 memcpy(p, dictionary, dictionary_size);
587 dictionary = p;
588 } else {
589 dictionary = NULL((void*)0);
590 }
591
592 encoder = PyImaging_EncoderNew(sizeof(ZIPSTATE));
593 if (encoder == NULL((void*)0)) {
594 free(dictionary);
595 return NULL((void*)0);
596 }
597
598 if (get_packer(encoder, mode, rawmode) < 0) {
599 free(dictionary);
600 return NULL((void*)0);
601 }
602
603 encoder->encode = ImagingZipEncode;
604 encoder->cleanup = ImagingZipEncodeCleanup;
605
606 if (rawmode[0] == 'P') {
607 /* disable filtering */
608 ((ZIPSTATE *)encoder->state.context)->mode = ZIP_PNG_PALETTE1;
609 }
610
611 ((ZIPSTATE *)encoder->state.context)->optimize = optimize;
612 ((ZIPSTATE *)encoder->state.context)->compress_level = compress_level;
613 ((ZIPSTATE *)encoder->state.context)->compress_type = compress_type;
614 ((ZIPSTATE *)encoder->state.context)->dictionary = dictionary;
615 ((ZIPSTATE *)encoder->state.context)->dictionary_size = dictionary_size;
616
617 return (PyObject *)encoder;
618}
619#endif
620
621/* -------------------------------------------------------------------- */
622/* LibTiff */
623/* -------------------------------------------------------------------- */
624
625#ifdef HAVE_LIBTIFF1
626
627#include "libImaging/TiffDecode.h"
628
629#include <string.h>
630
631PyObject *
632PyImaging_LibTiffEncoderNew(PyObject *self, PyObject *args) {
633 ImagingEncoderObject *encoder;
634
635 char *mode;
636 char *rawmode;
637 char *compname;
638 char *filename;
639 Py_ssize_t fp;
640
641 PyObject *tags, *types;
642 PyObject *key, *value;
643 Py_ssize_t pos = 0;
644 int key_int, status, is_core_tag, is_var_length, num_core_tags, i;
645 TIFFDataType type = TIFF_NOTYPE;
646 // This list also exists in TiffTags.py
647 const int core_tags[] = {256, 257, 258, 259, 262, 263, 266, 269, 274,
648 277, 278, 280, 281, 340, 341, 282, 283, 284,
649 286, 287, 296, 297, 320, 321, 338, 32995, 32998,
650 32996, 339, 32997, 330, 531, 530, 65537, 301, 532};
651
652 Py_ssize_t tags_size;
653 PyObject *item;
654
655 if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
656 args,
657 "sssnsOO",
658 &mode,
659 &rawmode,
660 &compname,
661 &fp,
662 &filename,
663 &tags,
664 &types)) {
665 return NULL((void*)0);
666 }
667
668 if (!PyList_Check(tags)((((((PyObject*)(tags))->ob_type))->tp_flags & ((1UL
<< 25))) != 0)) {
669 PyErr_SetString(PyExc_ValueError, "Invalid tags list");
670 return NULL((void*)0);
671 } else {
672 tags_size = PyList_Size(tags);
673 TRACE(("tags size: %d\n", (int)tags_size));
674 for (pos = 0; pos < tags_size; pos++) {
675 item = PyList_GetItem(tags, pos);
676 if (!PyTuple_Check(item)((((((PyObject*)(item))->ob_type))->tp_flags & ((1UL
<< 26))) != 0) || PyTuple_Size(item) != 2) {
677 PyErr_SetString(PyExc_ValueError, "Invalid tags list");
678 return NULL((void*)0);
679 }
680 }
681 pos = 0;
682 }
683 if (!PyDict_Check(types)((((((PyObject*)(types))->ob_type))->tp_flags & ((1UL
<< 29))) != 0)) {
684 PyErr_SetString(PyExc_ValueError, "Invalid types dictionary");
685 return NULL((void*)0);
686 }
687
688 TRACE(("new tiff encoder %s fp: %d, filename: %s \n", compname, fp, filename));
689
690 encoder = PyImaging_EncoderNew(sizeof(TIFFSTATE));
691 if (encoder == NULL((void*)0)) {
692 return NULL((void*)0);
693 }
694
695 if (get_packer(encoder, mode, rawmode) < 0) {
696 return NULL((void*)0);
697 }
698
699 if (!ImagingLibTiffEncodeInit(&encoder->state, filename, fp)) {
700 Py_DECREF(encoder)_Py_DECREF(((PyObject*)(encoder)));
701 PyErr_SetString(PyExc_RuntimeError, "tiff codec initialization failed");
702 return NULL((void*)0);
703 }
704
705 num_core_tags = sizeof(core_tags) / sizeof(int);
706 for (pos = 0; pos < tags_size; pos++) {
707 item = PyList_GetItem(tags, pos);
708 // We already checked that tags is a 2-tuple list.
709 key = PyTuple_GetItem(item, 0);
710 key_int = (int)PyLong_AsLong(key);
711 value = PyTuple_GetItem(item, 1);
712 status = 0;
713 is_core_tag = 0;
714 is_var_length = 0;
715 type = TIFF_NOTYPE;
716
717 for (i = 0; i < num_core_tags; i++) {
718 if (core_tags[i] == key_int) {
719 is_core_tag = 1;
720 break;
721 }
722 }
723
724 if (!is_core_tag) {
725 PyObject *tag_type = PyDict_GetItem(types, key);
726 if (tag_type) {
727 int type_int = PyLong_AsLong(tag_type);
728 if (type_int >= TIFF_BYTE && type_int <= TIFF_DOUBLE) {
729 type = (TIFFDataType)type_int;
730 }
731 }
732 }
733
734 if (type == TIFF_NOTYPE) {
735 // Autodetect type. Types should not be changed for backwards
736 // compatibility.
737 if (PyLong_Check(value)((((((PyObject*)(value))->ob_type))->tp_flags & ((1UL
<< 24))) != 0)) {
738 type = TIFF_LONG;
739 } else if (PyFloat_Check(value)((((PyObject*)(value))->ob_type) == (&PyFloat_Type) ||
PyType_IsSubtype((((PyObject*)(value))->ob_type), (&PyFloat_Type
)))) {
740 type = TIFF_DOUBLE;
741 } else if (PyBytes_Check(value)((((((PyObject*)(value))->ob_type))->tp_flags & ((1UL
<< 27))) != 0)) {
742 type = TIFF_ASCII;
743 }
744 }
745
746 if (PyTuple_Check(value)((((((PyObject*)(value))->ob_type))->tp_flags & ((1UL
<< 26))) != 0)) {
747 Py_ssize_t len;
748 len = PyTuple_Size(value);
749
750 is_var_length = 1;
751
752 if (!len) {
753 continue;
754 }
755
756 if (type == TIFF_NOTYPE) {
757 // Autodetect type based on first item. Types should not be
758 // changed for backwards compatibility.
759 if (PyLong_Check(PyTuple_GetItem(value, 0))((((((PyObject*)(PyTuple_GetItem(value, 0)))->ob_type))->
tp_flags & ((1UL << 24))) != 0)) {
760 type = TIFF_LONG;
761 } else if (PyFloat_Check(PyTuple_GetItem(value, 0))((((PyObject*)(PyTuple_GetItem(value, 0)))->ob_type) == (&
PyFloat_Type) || PyType_IsSubtype((((PyObject*)(PyTuple_GetItem
(value, 0)))->ob_type), (&PyFloat_Type)))) {
762 type = TIFF_FLOAT;
763 }
764 }
765 }
766
767 if (!is_core_tag) {
768 // Register field for non core tags.
769 if (type == TIFF_BYTE) {
770 is_var_length = 1;
771 }
772 if (ImagingLibTiffMergeFieldInfo(
773 &encoder->state, type, key_int, is_var_length)) {
774 continue;
775 }
776 }
777
778 if (type == TIFF_BYTE || type == TIFF_UNDEFINED) {
779 status = ImagingLibTiffSetField(
780 &encoder->state,
781 (ttag_t)key_int,
782 PyBytes_Size(value),
783 PyBytes_AsString(value));
784 } else if (is_var_length) {
785 Py_ssize_t len, i;
786 TRACE(("Setting from Tuple: %d \n", key_int));
787 len = PyTuple_Size(value);
788
789 if (key_int == TIFFTAG_COLORMAP320) {
790 int stride = 256;
791 if (len != 768) {
792 PyErr_SetString(
793 PyExc_ValueError, "Requiring 768 items for Colormap");
794 return NULL((void*)0);
795 }
796 UINT16 *av;
797 /* malloc check ok, calloc checks for overflow */
798 av = calloc(len, sizeof(UINT16));
799 if (av) {
800 for (i = 0; i < len; i++) {
801 av[i] = (UINT16)PyLong_AsLong(PyTuple_GetItem(value, i));
802 }
803 status = ImagingLibTiffSetField(
804 &encoder->state,
805 (ttag_t)key_int,
806 av,
807 av + stride,
808 av + stride * 2);
809 free(av);
810 }
811 } else if (key_int == TIFFTAG_YCBCRSUBSAMPLING530) {
812 status = ImagingLibTiffSetField(
813 &encoder->state,
814 (ttag_t)key_int,
815 (UINT16)PyLong_AsLong(PyTuple_GetItem(value, 0)),
816 (UINT16)PyLong_AsLong(PyTuple_GetItem(value, 1)));
817 } else if (type == TIFF_SHORT) {
818 UINT16 *av;
819 /* malloc check ok, calloc checks for overflow */
820 av = calloc(len, sizeof(UINT16));
821 if (av) {
822 for (i = 0; i < len; i++) {
823 av[i] = (UINT16)PyLong_AsLong(PyTuple_GetItem(value, i));
824 }
825 status = ImagingLibTiffSetField(
826 &encoder->state, (ttag_t)key_int, len, av);
827 free(av);
828 }
829 } else if (type == TIFF_LONG) {
830 UINT32 *av;
831 /* malloc check ok, calloc checks for overflow */
832 av = calloc(len, sizeof(UINT32));
833 if (av) {
834 for (i = 0; i < len; i++) {
835 av[i] = (UINT32)PyLong_AsLong(PyTuple_GetItem(value, i));
836 }
837 status = ImagingLibTiffSetField(
838 &encoder->state, (ttag_t)key_int, len, av);
839 free(av);
840 }
841 } else if (type == TIFF_SBYTE) {
842 INT8 *av;
843 /* malloc check ok, calloc checks for overflow */
844 av = calloc(len, sizeof(INT8));
845 if (av) {
846 for (i = 0; i < len; i++) {
847 av[i] = (INT8)PyLong_AsLong(PyTuple_GetItem(value, i));
848 }
849 status = ImagingLibTiffSetField(
850 &encoder->state, (ttag_t)key_int, len, av);
851 free(av);
852 }
853 } else if (type == TIFF_SSHORT) {
854 INT16 *av;
855 /* malloc check ok, calloc checks for overflow */
856 av = calloc(len, sizeof(INT16));
857 if (av) {
858 for (i = 0; i < len; i++) {
859 av[i] = (INT16)PyLong_AsLong(PyTuple_GetItem(value, i));
860 }
861 status = ImagingLibTiffSetField(
862 &encoder->state, (ttag_t)key_int, len, av);
863 free(av);
864 }
865 } else if (type == TIFF_SLONG) {
866 INT32 *av;
867 /* malloc check ok, calloc checks for overflow */
868 av = calloc(len, sizeof(INT32));
869 if (av) {
870 for (i = 0; i < len; i++) {
871 av[i] = (INT32)PyLong_AsLong(PyTuple_GetItem(value, i));
872 }
873 status = ImagingLibTiffSetField(
874 &encoder->state, (ttag_t)key_int, len, av);
875 free(av);
876 }
877 } else if (type == TIFF_FLOAT) {
878 FLOAT32float *av;
879 /* malloc check ok, calloc checks for overflow */
880 av = calloc(len, sizeof(FLOAT32float));
881 if (av) {
882 for (i = 0; i < len; i++) {
883 av[i] = (FLOAT32float)PyFloat_AsDouble(PyTuple_GetItem(value, i));
884 }
885 status = ImagingLibTiffSetField(
886 &encoder->state, (ttag_t)key_int, len, av);
887 free(av);
888 }
889 } else if (type == TIFF_DOUBLE) {
890 FLOAT64double *av;
891 /* malloc check ok, calloc checks for overflow */
892 av = calloc(len, sizeof(FLOAT64double));
893 if (av) {
894 for (i = 0; i < len; i++) {
895 av[i] = PyFloat_AsDouble(PyTuple_GetItem(value, i));
896 }
897 status = ImagingLibTiffSetField(
898 &encoder->state, (ttag_t)key_int, len, av);
899 free(av);
900 }
901 }
902 } else {
903 if (type == TIFF_SHORT) {
904 status = ImagingLibTiffSetField(
905 &encoder->state, (ttag_t)key_int, (UINT16)PyLong_AsLong(value));
906 } else if (type == TIFF_LONG) {
907 status = ImagingLibTiffSetField(
908 &encoder->state, (ttag_t)key_int, (UINT32)PyLong_AsLong(value));
909 } else if (type == TIFF_SSHORT) {
910 status = ImagingLibTiffSetField(
911 &encoder->state, (ttag_t)key_int, (INT16)PyLong_AsLong(value));
912 } else if (type == TIFF_SLONG) {
913 status = ImagingLibTiffSetField(
914 &encoder->state, (ttag_t)key_int, (INT32)PyLong_AsLong(value));
915 } else if (type == TIFF_FLOAT) {
916 status = ImagingLibTiffSetField(
917 &encoder->state, (ttag_t)key_int, (FLOAT32float)PyFloat_AsDouble(value));
918 } else if (type == TIFF_DOUBLE) {
919 status = ImagingLibTiffSetField(
920 &encoder->state, (ttag_t)key_int, (FLOAT64double)PyFloat_AsDouble(value));
921 } else if (type == TIFF_SBYTE) {
922 status = ImagingLibTiffSetField(
923 &encoder->state, (ttag_t)key_int, (INT8)PyLong_AsLong(value));
924 } else if (type == TIFF_ASCII) {
925 status = ImagingLibTiffSetField(
926 &encoder->state, (ttag_t)key_int, PyBytes_AsString(value));
927 } else if (type == TIFF_RATIONAL) {
928 status = ImagingLibTiffSetField(
929 &encoder->state, (ttag_t)key_int, (FLOAT64double)PyFloat_AsDouble(value));
930 } else {
931 TRACE(
932 ("Unhandled type for key %d : %s \n",
933 key_int,
934 PyBytes_AsString(PyObject_Str(value))));
935 }
936 }
937 if (!status) {
938 TRACE(("Error setting Field\n"));
939 Py_DECREF(encoder)_Py_DECREF(((PyObject*)(encoder)));
940 PyErr_SetString(PyExc_RuntimeError, "Error setting from dictionary");
941 return NULL((void*)0);
942 }
943 }
944
945 encoder->encode = ImagingLibTiffEncode;
946
947 return (PyObject *)encoder;
948}
949
950#endif
951
952/* -------------------------------------------------------------------- */
953/* JPEG */
954/* -------------------------------------------------------------------- */
955
956#ifdef HAVE_LIBJPEG1
957
958/* We better define this encoder last in this file, so the following
959 undef's won't mess things up for the Imaging library proper. */
960
961#undef HAVE_PROTOTYPES
962#undef HAVE_STDDEF_H
963#undef HAVE_STDLIB_H
964#undef UINT8
965#undef UINT16
966#undef UINT32
967#undef INT8
968#undef INT16
969#undef INT32
970
971#include "libImaging/Jpeg.h"
972
973static unsigned int *
974get_qtables_arrays(PyObject *qtables, int *qtablesLen) {
975 PyObject *tables;
976 PyObject *table;
977 PyObject *table_data;
978 int i, j, num_tables;
979 unsigned int *qarrays;
980
981 if ((qtables == NULL((void*)0)) || (qtables == Py_None(&_Py_NoneStruct))) {
982 return NULL((void*)0);
983 }
984
985 if (!PySequence_Check(qtables)) {
986 PyErr_SetString(PyExc_ValueError, "Invalid quantization tables");
987 return NULL((void*)0);
988 }
989
990 tables = PySequence_Fast(qtables, "expected a sequence");
991 num_tables = PySequence_Size(qtables);
992 if (num_tables < 1 || num_tables > NUM_QUANT_TBLS4) {
993 PyErr_SetString(
994 PyExc_ValueError,
995 "Not a valid number of quantization tables. Should be between 1 and 4.");
996 Py_DECREF(tables)_Py_DECREF(((PyObject*)(tables)));
997 return NULL((void*)0);
998 }
999 /* malloc check ok, num_tables <4, DCTSIZE2 == 64 from jpeglib.h */
1000 qarrays = (unsigned int *)malloc(num_tables * DCTSIZE264 * sizeof(unsigned int));
1001 if (!qarrays) {
1002 Py_DECREF(tables)_Py_DECREF(((PyObject*)(tables)));
1003 return ImagingError_MemoryError();
1004 }
1005 for (i = 0; i < num_tables; i++) {
1006 table = PySequence_Fast_GET_ITEM(tables, i)(((((((PyObject*)(tables))->ob_type))->tp_flags & (
(1UL << 25))) != 0) ? (((PyListObject *)(tables))->ob_item
[i]) : ((((void) (0)), (PyTupleObject *)(tables))->ob_item
[i]));
1007 if (!PySequence_Check(table)) {
1008 PyErr_SetString(PyExc_ValueError, "Invalid quantization tables");
1009 goto JPEG_QTABLES_ERR;
1010 }
1011 if (PySequence_Size(table) != DCTSIZE264) {
1012 PyErr_SetString(PyExc_ValueError, "Invalid quantization table size");
1013 goto JPEG_QTABLES_ERR;
1014 }
1015 table_data = PySequence_Fast(table, "expected a sequence");
1016 for (j = 0; j < DCTSIZE264; j++) {
1017 qarrays[i * DCTSIZE264 + j] =
1018 PyLong_AS_LONG(PySequence_Fast_GET_ITEM(table_data, j))PyLong_AsLong((((((((PyObject*)(table_data))->ob_type))->
tp_flags & ((1UL << 25))) != 0) ? (((PyListObject *
)(table_data))->ob_item[j]) : ((((void) (0)), (PyTupleObject
*)(table_data))->ob_item[j])));
1019 }
1020 Py_DECREF(table_data)_Py_DECREF(((PyObject*)(table_data)));
1021 }
1022
1023 *qtablesLen = num_tables;
1024
1025JPEG_QTABLES_ERR:
1026 Py_DECREF(tables)_Py_DECREF(((PyObject*)(tables))); // Run on both error and not error
1027 if (PyErr_Occurred()) {
1028 free(qarrays);
1029 qarrays = NULL((void*)0);
1030 return NULL((void*)0);
1031 }
1032
1033 return qarrays;
1034}
1035
1036PyObject *
1037PyImaging_JpegEncoderNew(PyObject *self, PyObject *args) {
1038 ImagingEncoderObject *encoder;
1039
1040 char *mode;
1041 char *rawmode;
1042 Py_ssize_t quality = 0;
1043 Py_ssize_t progressive = 0;
1044 Py_ssize_t smooth = 0;
1045 Py_ssize_t optimize = 0;
1046 Py_ssize_t streamtype = 0; /* 0=interchange, 1=tables only, 2=image only */
1047 Py_ssize_t xdpi = 0, ydpi = 0;
1048 Py_ssize_t subsampling = -1; /* -1=default, 0=none, 1=medium, 2=high */
1049 PyObject *qtables = NULL((void*)0);
1050 unsigned int *qarrays = NULL((void*)0);
1051 int qtablesLen = 0;
1052 char *extra = NULL((void*)0);
1053 Py_ssize_t extra_size;
1054 char *rawExif = NULL((void*)0);
1055 Py_ssize_t rawExifLen = 0;
1056
1057 if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
1058 args,
1059 "ss|nnnnnnnnOy#y#",
1060 &mode,
1061 &rawmode,
1062 &quality,
1063 &progressive,
1064 &smooth,
1065 &optimize,
1066 &streamtype,
1067 &xdpi,
1068 &ydpi,
1069 &subsampling,
1070 &qtables,
1071 &extra,
1072 &extra_size,
1073 &rawExif,
1074 &rawExifLen)) {
1075 return NULL((void*)0);
1076 }
1077
1078 encoder = PyImaging_EncoderNew(sizeof(JPEGENCODERSTATE));
1079 if (encoder == NULL((void*)0)) {
1080 return NULL((void*)0);
1081 }
1082
1083 // libjpeg-turbo supports different output formats.
1084 // We are choosing Pillow's native format (3 color bytes + 1 padding)
1085 // to avoid extra conversion in Pack.c.
1086 if (ImagingJpegUseJCSExtensions() && strcmp(rawmode, "RGB") == 0) {
1087 rawmode = "RGBX";
1088 }
1089
1090 if (get_packer(encoder, mode, rawmode) < 0) {
1091 return NULL((void*)0);
1092 }
1093
1094 // Freed in JpegEncode, Case 5
1095 qarrays = get_qtables_arrays(qtables, &qtablesLen);
1096
1097 if (extra && extra_size > 0) {
1098 /* malloc check ok, length is from python parsearg */
1099 char *p = malloc(extra_size); // Freed in JpegEncode, Case 5
1100 if (!p) {
1101 return ImagingError_MemoryError();
1102 }
1103 memcpy(p, extra, extra_size);
1104 extra = p;
1105 } else {
1106 extra = NULL((void*)0);
1107 }
1108
1109 if (rawExif && rawExifLen > 0) {
1110 /* malloc check ok, length is from python parsearg */
1111 char *pp = malloc(rawExifLen); // Freed in JpegEncode, Case 5
1112 if (!pp) {
1113 if (extra) {
1114 free(extra);
1115 }
1116 return ImagingError_MemoryError();
1117 }
1118 memcpy(pp, rawExif, rawExifLen);
1119 rawExif = pp;
1120 } else {
1121 rawExif = NULL((void*)0);
1122 }
1123
1124 encoder->encode = ImagingJpegEncode;
1125
1126 strncpy(((JPEGENCODERSTATE *)encoder->state.context)->rawmode, rawmode, 8);
1127
1128 ((JPEGENCODERSTATE *)encoder->state.context)->quality = quality;
1129 ((JPEGENCODERSTATE *)encoder->state.context)->qtables = qarrays;
1130 ((JPEGENCODERSTATE *)encoder->state.context)->qtablesLen = qtablesLen;
1131 ((JPEGENCODERSTATE *)encoder->state.context)->subsampling = subsampling;
1132 ((JPEGENCODERSTATE *)encoder->state.context)->progressive = progressive;
1133 ((JPEGENCODERSTATE *)encoder->state.context)->smooth = smooth;
1134 ((JPEGENCODERSTATE *)encoder->state.context)->optimize = optimize;
1135 ((JPEGENCODERSTATE *)encoder->state.context)->streamtype = streamtype;
1136 ((JPEGENCODERSTATE *)encoder->state.context)->xdpi = xdpi;
1137 ((JPEGENCODERSTATE *)encoder->state.context)->ydpi = ydpi;
1138 ((JPEGENCODERSTATE *)encoder->state.context)->extra = extra;
1139 ((JPEGENCODERSTATE *)encoder->state.context)->extra_size = extra_size;
1140 ((JPEGENCODERSTATE *)encoder->state.context)->rawExif = rawExif;
1141 ((JPEGENCODERSTATE *)encoder->state.context)->rawExifLen = rawExifLen;
1142
1143 return (PyObject *)encoder;
1144}
1145
1146#endif
1147
1148/* -------------------------------------------------------------------- */
1149/* JPEG 2000 */
1150/* -------------------------------------------------------------------- */
1151
1152#ifdef HAVE_OPENJPEG1
1153
1154#include "libImaging/Jpeg2K.h"
1155
1156static void
1157j2k_decode_coord_tuple(PyObject *tuple, int *x, int *y) {
1158 *x = *y = 0;
1159
1160 if (tuple && PyTuple_Check(tuple)((((((PyObject*)(tuple))->ob_type))->tp_flags & ((1UL
<< 26))) != 0) && PyTuple_GET_SIZE(tuple)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(tuple))))->
ob_size) == 2) {
1161 *x = (int)PyLong_AsLong(PyTuple_GET_ITEM(tuple, 0)((((void) (0)), (PyTupleObject *)(tuple))->ob_item[0]));
1162 *y = (int)PyLong_AsLong(PyTuple_GET_ITEM(tuple, 1)((((void) (0)), (PyTupleObject *)(tuple))->ob_item[1]));
1163
1164 if (*x < 0) {
1165 *x = 0;
1166 }
1167 if (*y < 0) {
1168 *y = 0;
1169 }
1170 }
1171}
1172
1173PyObject *
1174PyImaging_Jpeg2KEncoderNew(PyObject *self, PyObject *args) {
1175 ImagingEncoderObject *encoder;
1176 JPEG2KENCODESTATE *context;
1177
1178 char *mode;
1179 char *format;
1180 OPJ_CODEC_FORMAT codec_format;
1181 PyObject *offset = NULL((void*)0), *tile_offset = NULL((void*)0), *tile_size = NULL((void*)0);
1182 char *quality_mode = "rates";
1183 PyObject *quality_layers = NULL((void*)0);
1184 Py_ssize_t num_resolutions = 0;
1185 PyObject *cblk_size = NULL((void*)0), *precinct_size = NULL((void*)0);
1186 PyObject *irreversible = NULL((void*)0);
1187 char *progression = "LRCP";
1188 OPJ_PROG_ORDER prog_order;
1189 char *cinema_mode = "no";
1190 OPJ_CINEMA_MODE cine_mode;
1191 Py_ssize_t fd = -1;
1192
1193 if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
1194 args,
1195 "ss|OOOsOnOOOssn",
1196 &mode,
1197 &format,
1198 &offset,
1199 &tile_offset,
1200 &tile_size,
1201 &quality_mode,
1202 &quality_layers,
1203 &num_resolutions,
1204 &cblk_size,
1205 &precinct_size,
1206 &irreversible,
1207 &progression,
1208 &cinema_mode,
1209 &fd)) {
1210 return NULL((void*)0);
1211 }
1212
1213 if (strcmp(format, "j2k") == 0) {
1214 codec_format = OPJ_CODEC_J2K;
1215 } else if (strcmp(format, "jpt") == 0) {
1216 codec_format = OPJ_CODEC_JPT;
1217 } else if (strcmp(format, "jp2") == 0) {
1218 codec_format = OPJ_CODEC_JP2;
1219 } else {
1220 return NULL((void*)0);
1221 }
1222
1223 if (strcmp(progression, "LRCP") == 0) {
1224 prog_order = OPJ_LRCP;
1225 } else if (strcmp(progression, "RLCP") == 0) {
1226 prog_order = OPJ_RLCP;
1227 } else if (strcmp(progression, "RPCL") == 0) {
1228 prog_order = OPJ_RPCL;
1229 } else if (strcmp(progression, "PCRL") == 0) {
1230 prog_order = OPJ_PCRL;
1231 } else if (strcmp(progression, "CPRL") == 0) {
1232 prog_order = OPJ_CPRL;
1233 } else {
1234 return NULL((void*)0);
1235 }
1236
1237 if (strcmp(cinema_mode, "no") == 0) {
1238 cine_mode = OPJ_OFF;
1239 } else if (strcmp(cinema_mode, "cinema2k-24") == 0) {
1240 cine_mode = OPJ_CINEMA2K_24;
1241 } else if (strcmp(cinema_mode, "cinema2k-48") == 0) {
1242 cine_mode = OPJ_CINEMA2K_48;
1243 } else if (strcmp(cinema_mode, "cinema4k-24") == 0) {
1244 cine_mode = OPJ_CINEMA4K_24;
1245 } else {
1246 return NULL((void*)0);
1247 }
1248
1249 encoder = PyImaging_EncoderNew(sizeof(JPEG2KENCODESTATE));
1250 if (!encoder) {
1251 return NULL((void*)0);
1252 }
1253
1254 encoder->encode = ImagingJpeg2KEncode;
1255 encoder->cleanup = ImagingJpeg2KEncodeCleanup;
1256 encoder->pushes_fd = 1;
1257
1258 context = (JPEG2KENCODESTATE *)encoder->state.context;
1259
1260 context->fd = fd;
1261 context->format = codec_format;
1262 context->offset_x = context->offset_y = 0;
1263
1264 j2k_decode_coord_tuple(offset, &context->offset_x, &context->offset_y);
1265 j2k_decode_coord_tuple(
1266 tile_offset, &context->tile_offset_x, &context->tile_offset_y);
1267 j2k_decode_coord_tuple(tile_size, &context->tile_size_x, &context->tile_size_y);
1268
1269 /* Error on illegal tile offsets */
1270 if (context->tile_size_x && context->tile_size_y) {
1271 if (context->tile_offset_x <= context->offset_x - context->tile_size_x ||
1272 context->tile_offset_y <= context->offset_y - context->tile_size_y) {
1273 PyErr_SetString(
1274 PyExc_ValueError,
1275 "JPEG 2000 tile offset too small; top left tile must "
1276 "intersect image area");
1277 Py_DECREF(encoder)_Py_DECREF(((PyObject*)(encoder)));
1278 return NULL((void*)0);
1279 }
1280
1281 if (context->tile_offset_x > context->offset_x ||
1282 context->tile_offset_y > context->offset_y) {
1283 PyErr_SetString(
1284 PyExc_ValueError,
1285 "JPEG 2000 tile offset too large to cover image area");
1286 Py_DECREF(encoder)_Py_DECREF(((PyObject*)(encoder)));
1287 return NULL((void*)0);
1288 }
1289 }
1290
1291 if (quality_layers && PySequence_Check(quality_layers)) {
1292 context->quality_is_in_db = strcmp(quality_mode, "dB") == 0;
1293 context->quality_layers = quality_layers;
1294 Py_INCREF(quality_layers)_Py_INCREF(((PyObject*)(quality_layers)));
1295 }
1296
1297 context->num_resolutions = num_resolutions;
1298
1299 j2k_decode_coord_tuple(cblk_size, &context->cblk_width, &context->cblk_height);
1300 j2k_decode_coord_tuple(
1301 precinct_size, &context->precinct_width, &context->precinct_height);
1302
1303 context->irreversible = PyObject_IsTrue(irreversible);
1304 context->progression = prog_order;
1305 context->cinema_mode = cine_mode;
1306
1307 return (PyObject *)encoder;
1308}
1309
1310#endif
1311
1312/*
1313 * Local Variables:
1314 * c-basic-offset: 4
1315 * End:
1316 *
1317 */
←

/opt/pyrefcon/lib/pyrefcon/models/models/PyBytes_FromStringAndSize.model

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