Pillow

1
/*
2
 * The Python Imaging Library.
3
 *
4
 * standard decoder interfaces for the Imaging library
5
 *
6
 * history:
7
 * 1996-03-28 fl   Moved from _imagingmodule.c
8
 * 1996-04-15 fl   Support subregions in setimage
9
 * 1996-04-19 fl   Allocate decoder buffer (where appropriate)
10
 * 1996-05-02 fl   Added jpeg decoder
11
 * 1996-05-12 fl   Compile cleanly as C++
12
 * 1996-05-16 fl   Added hex decoder
13
 * 1996-05-26 fl   Added jpeg configuration parameters
14
 * 1996-12-14 fl   Added zip decoder
15
 * 1996-12-30 fl   Plugged potential memory leak for tiled images
16
 * 1997-01-03 fl   Added fli and msp decoders
17
 * 1997-01-04 fl   Added sun_rle and tga_rle decoders
18
 * 1997-05-31 fl   Added bitfield decoder
19
 * 1998-09-11 fl   Added orientation and pixelsize fields to tga_rle decoder
20
 * 1998-12-29 fl   Added mode/rawmode argument to decoders
21
 * 1998-12-30 fl   Added mode argument to *all* decoders
22
 * 2002-06-09 fl   Added stride argument to pcx decoder
23
 *
24
 * Copyright (c) 1997-2002 by Secret Labs AB.
25
 * Copyright (c) 1995-2002 by Fredrik Lundh.
26
 *
27
 * See the README file for information on usage and redistribution.
28
 */
29

30
/* FIXME: make these pluggable! */
31

32
#define PY_SSIZE_T_CLEAN
33
#include "Python.h"
34

35
#include "libImaging/Imaging.h"
36

37
#include "libImaging/Bit.h"
38
#include "libImaging/Bcn.h"
39
#include "libImaging/Gif.h"
40
#include "libImaging/Raw.h"
41
#include "libImaging/Sgi.h"
42

43
/* -------------------------------------------------------------------- */
44
/* Common                                                               */
45
/* -------------------------------------------------------------------- */
46

47
typedef struct {
48
    PyObject_HEAD int (*decode)(
49
        Imaging im, ImagingCodecState state, UINT8 *buffer, Py_ssize_t bytes
50
    );
51
    int (*cleanup)(ImagingCodecState state);
52
    struct ImagingCodecStateInstance state;
53
    Imaging im;
54
    PyObject *lock;
55
    int pulls_fd;
56
} ImagingDecoderObject;
57

58
static PyTypeObject ImagingDecoderType;
59

60
static ImagingDecoderObject *
61
PyImaging_DecoderNew(int contextsize) {
62
    ImagingDecoderObject *decoder;
63
    void *context;
64

65
    if (PyType_Ready(&ImagingDecoderType) < 0) {
66
        return NULL;
67
    }
68

69
    decoder = PyObject_New(ImagingDecoderObject, &ImagingDecoderType);
70
    if (decoder == NULL) {
71
        return NULL;
72
    }
73

74
    /* Clear the decoder state */
75
    memset(&decoder->state, 0, sizeof(decoder->state));
76

77
    /* Allocate decoder context */
78
    if (contextsize > 0) {
79
        context = (void *)calloc(1, contextsize);
80
        if (!context) {
81
            Py_DECREF(decoder);
82
            (void)ImagingError_MemoryError();
83
            return NULL;
84
        }
85
    } else {
86
        context = 0;
87
    }
88

89
    /* Initialize decoder context */
90
    decoder->state.context = context;
91

92
    /* Target image */
93
    decoder->lock = NULL;
94
    decoder->im = NULL;
95

96
    /* Initialize the cleanup function pointer */
97
    decoder->cleanup = NULL;
98

99
    /* set if the decoder needs to pull data from the fd, instead of
100
       having it pushed */
101
    decoder->pulls_fd = 0;
102

103
    return decoder;
104
}
105

106
static void
107
_dealloc(ImagingDecoderObject *decoder) {
108
    if (decoder->cleanup) {
109
        decoder->cleanup(&decoder->state);
110
    }
111
    free(decoder->state.buffer);
112
    free(decoder->state.context);
113
    Py_XDECREF(decoder->lock);
114
    Py_XDECREF(decoder->state.fd);
115
    PyObject_Del(decoder);
116
}
117

118
static PyObject *
119
_decode(ImagingDecoderObject *decoder, PyObject *args) {
120
    Py_buffer buffer;
121
    int status;
122
    ImagingSectionCookie cookie;
123

124
    if (!PyArg_ParseTuple(args, "y*", &buffer)) {
125
        return NULL;
126
    }
127

128
    if (!decoder->pulls_fd) {
129
        ImagingSectionEnter(&cookie);
130
    }
131

132
    status = decoder->decode(decoder->im, &decoder->state, buffer.buf, buffer.len);
133

134
    if (!decoder->pulls_fd) {
135
        ImagingSectionLeave(&cookie);
136
    }
137

138
    PyBuffer_Release(&buffer);
139
    return Py_BuildValue("ii", status, decoder->state.errcode);
140
}
141

142
static PyObject *
143
_decode_cleanup(ImagingDecoderObject *decoder, PyObject *args) {
144
    int status = 0;
145

146
    if (decoder->cleanup) {
147
        status = decoder->cleanup(&decoder->state);
148
    }
149

150
    return Py_BuildValue("i", status);
151
}
152

153
extern Imaging
154
PyImaging_AsImaging(PyObject *op);
155

156
static PyObject *
157
_setimage(ImagingDecoderObject *decoder, PyObject *args) {
158
    PyObject *op;
159
    Imaging im;
160
    ImagingCodecState state;
161
    int x0, y0, x1, y1;
162

163
    x0 = y0 = x1 = y1 = 0;
164

165
    /* FIXME: should publish the ImagingType descriptor */
166
    if (!PyArg_ParseTuple(args, "O|(iiii)", &op, &x0, &y0, &x1, &y1)) {
167
        return NULL;
168
    }
169
    im = PyImaging_AsImaging(op);
170
    if (!im) {
171
        return NULL;
172
    }
173

174
    decoder->im = im;
175

176
    state = &decoder->state;
177

178
    /* Setup decoding tile extent */
179
    if (x0 == 0 && x1 == 0) {
180
        state->xsize = im->xsize;
181
        state->ysize = im->ysize;
182
    } else {
183
        state->xoff = x0;
184
        state->yoff = y0;
185
        state->xsize = x1 - x0;
186
        state->ysize = y1 - y0;
187
    }
188

189
    if (state->xsize <= 0 || state->xsize + state->xoff > (int)im->xsize ||
190
        state->ysize <= 0 || state->ysize + state->yoff > (int)im->ysize) {
191
        PyErr_SetString(PyExc_ValueError, "tile cannot extend outside image");
192
        return NULL;
193
    }
194

195
    /* Allocate memory buffer (if bits field is set) */
196
    if (state->bits > 0) {
197
        if (!state->bytes) {
198
            if (state->xsize > ((INT_MAX / state->bits) - 7)) {
199
                return ImagingError_MemoryError();
200
            }
201
            state->bytes = (state->bits * state->xsize + 7) / 8;
202
        }
203
        /* malloc check ok, overflow checked above */
204
        state->buffer = (UINT8 *)calloc(1, state->bytes);
205
        if (!state->buffer) {
206
            return ImagingError_MemoryError();
207
        }
208
    }
209

210
    /* Keep a reference to the image object, to make sure it doesn't
211
       go away before we do */
212
    Py_INCREF(op);
213
    Py_XDECREF(decoder->lock);
214
    decoder->lock = op;
215

216
    Py_INCREF(Py_None);
217
    return Py_None;
218
}
219

220
static PyObject *
221
_setfd(ImagingDecoderObject *decoder, PyObject *args) {
222
    PyObject *fd;
223
    ImagingCodecState state;
224

225
    if (!PyArg_ParseTuple(args, "O", &fd)) {
226
        return NULL;
227
    }
228

229
    state = &decoder->state;
230

231
    Py_XINCREF(fd);
232
    state->fd = fd;
233

234
    Py_INCREF(Py_None);
235
    return Py_None;
236
}
237

238
static PyObject *
239
_get_pulls_fd(ImagingDecoderObject *decoder, void *closure) {
240
    return PyBool_FromLong(decoder->pulls_fd);
241
}
242

243
static struct PyMethodDef methods[] = {
244
    {"decode", (PyCFunction)_decode, METH_VARARGS},
245
    {"cleanup", (PyCFunction)_decode_cleanup, METH_VARARGS},
246
    {"setimage", (PyCFunction)_setimage, METH_VARARGS},
247
    {"setfd", (PyCFunction)_setfd, METH_VARARGS},
248
    {NULL, NULL} /* sentinel */
249
};
250

251
static struct PyGetSetDef getseters[] = {
252
    {"pulls_fd",
253
     (getter)_get_pulls_fd,
254
     NULL,
255
     "True if this decoder expects to pull from self.fd itself.",
256
     NULL},
257
    {NULL, NULL, NULL, NULL, NULL} /* sentinel */
258
};
259

260
static PyTypeObject ImagingDecoderType = {
261
    PyVarObject_HEAD_INIT(NULL, 0) "ImagingDecoder", /*tp_name*/
262
    sizeof(ImagingDecoderObject),                    /*tp_basicsize*/
263
    0,                                               /*tp_itemsize*/
264
    /* methods */
265
    (destructor)_dealloc, /*tp_dealloc*/
266
    0,                    /*tp_vectorcall_offset*/
267
    0,                    /*tp_getattr*/
268
    0,                    /*tp_setattr*/
269
    0,                    /*tp_as_async*/
270
    0,                    /*tp_repr*/
271
    0,                    /*tp_as_number*/
272
    0,                    /*tp_as_sequence*/
273
    0,                    /*tp_as_mapping*/
274
    0,                    /*tp_hash*/
275
    0,                    /*tp_call*/
276
    0,                    /*tp_str*/
277
    0,                    /*tp_getattro*/
278
    0,                    /*tp_setattro*/
279
    0,                    /*tp_as_buffer*/
280
    Py_TPFLAGS_DEFAULT,   /*tp_flags*/
281
    0,                    /*tp_doc*/
282
    0,                    /*tp_traverse*/
283
    0,                    /*tp_clear*/
284
    0,                    /*tp_richcompare*/
285
    0,                    /*tp_weaklistoffset*/
286
    0,                    /*tp_iter*/
287
    0,                    /*tp_iternext*/
288
    methods,              /*tp_methods*/
289
    0,                    /*tp_members*/
290
    getseters,            /*tp_getset*/
291
};
292

293
/* -------------------------------------------------------------------- */
294

295
int
296
get_unpacker(ImagingDecoderObject *decoder, const char *mode, const char *rawmode) {
297
    int bits;
298
    ImagingShuffler unpack;
299

300
    unpack = ImagingFindUnpacker(mode, rawmode, &bits);
301
    if (!unpack) {
302
        Py_DECREF(decoder);
303
        PyErr_SetString(PyExc_ValueError, "unknown raw mode for given image mode");
304
        return -1;
305
    }
306

307
    decoder->state.shuffle = unpack;
308
    decoder->state.bits = bits;
309

310
    return 0;
311
}
312

313
/* -------------------------------------------------------------------- */
314
/* BIT (packed fields)                                                  */
315
/* -------------------------------------------------------------------- */
316

317
PyObject *
318
PyImaging_BitDecoderNew(PyObject *self, PyObject *args) {
319
    ImagingDecoderObject *decoder;
320

321
    char *mode;
322
    int bits = 8;
323
    int pad = 8;
324
    int fill = 0;
325
    int sign = 0;
326
    int ystep = 1;
327
    if (!PyArg_ParseTuple(args, "s|iiiii", &mode, &bits, &pad, &fill, &sign, &ystep)) {
328
        return NULL;
329
    }
330

331
    if (strcmp(mode, "F") != 0) {
332
        PyErr_SetString(PyExc_ValueError, "bad image mode");
333
        return NULL;
334
    }
335

336
    decoder = PyImaging_DecoderNew(sizeof(BITSTATE));
337
    if (decoder == NULL) {
338
        return NULL;
339
    }
340

341
    decoder->decode = ImagingBitDecode;
342

343
    decoder->state.ystep = ystep;
344

345
    ((BITSTATE *)decoder->state.context)->bits = bits;
346
    ((BITSTATE *)decoder->state.context)->pad = pad;
347
    ((BITSTATE *)decoder->state.context)->fill = fill;
348
    ((BITSTATE *)decoder->state.context)->sign = sign;
349

350
    return (PyObject *)decoder;
351
}
352

353
/* -------------------------------------------------------------------- */
354
/* BCn: GPU block-compressed texture formats                            */
355
/* -------------------------------------------------------------------- */
356

357
PyObject *
358
PyImaging_BcnDecoderNew(PyObject *self, PyObject *args) {
359
    ImagingDecoderObject *decoder;
360

361
    char *mode;
362
    char *actual;
363
    int n = 0;
364
    char *pixel_format = "";
365
    if (!PyArg_ParseTuple(args, "si|s", &mode, &n, &pixel_format)) {
366
        return NULL;
367
    }
368

369
    switch (n) {
370
        case 1: /* BC1: 565 color, 1-bit alpha */
371
        case 2: /* BC2: 565 color, 4-bit alpha */
372
        case 3: /* BC3: 565 color, 2-endpoint 8-bit interpolated alpha */
373
        case 7: /* BC7: 4-channel 8-bit via everything */
374
            actual = "RGBA";
375
            break;
376
        case 4: /* BC4: 1-channel 8-bit via 1 BC3 alpha block */
377
            actual = "L";
378
            break;
379
        case 5: /* BC5: 2-channel 8-bit via 2 BC3 alpha blocks */
380
        case 6: /* BC6: 3-channel 16-bit float */
381
            actual = "RGB";
382
            break;
383
        default:
384
            PyErr_SetString(PyExc_ValueError, "block compression type unknown");
385
            return NULL;
386
    }
387

388
    if (strcmp(mode, actual) != 0) {
389
        PyErr_SetString(PyExc_ValueError, "bad image mode");
390
        return NULL;
391
    }
392

393
    decoder = PyImaging_DecoderNew(sizeof(char *));
394
    if (decoder == NULL) {
395
        return NULL;
396
    }
397

398
    decoder->decode = ImagingBcnDecode;
399
    decoder->state.state = n;
400
    ((BCNSTATE *)decoder->state.context)->pixel_format = pixel_format;
401

402
    return (PyObject *)decoder;
403
}
404

405
/* -------------------------------------------------------------------- */
406
/* FLI                                                                  */
407
/* -------------------------------------------------------------------- */
408

409
PyObject *
410
PyImaging_FliDecoderNew(PyObject *self, PyObject *args) {
411
    ImagingDecoderObject *decoder;
412

413
    decoder = PyImaging_DecoderNew(0);
414
    if (decoder == NULL) {
415
        return NULL;
416
    }
417

418
    decoder->decode = ImagingFliDecode;
419

420
    return (PyObject *)decoder;
421
}
422

423
/* -------------------------------------------------------------------- */
424
/* GIF                                                                  */
425
/* -------------------------------------------------------------------- */
426

427
PyObject *
428
PyImaging_GifDecoderNew(PyObject *self, PyObject *args) {
429
    ImagingDecoderObject *decoder;
430

431
    char *mode;
432
    int bits = 8;
433
    int interlace = 0;
434
    int transparency = -1;
435
    if (!PyArg_ParseTuple(args, "s|iii", &mode, &bits, &interlace, &transparency)) {
436
        return NULL;
437
    }
438

439
    if (strcmp(mode, "L") != 0 && strcmp(mode, "P") != 0) {
440
        PyErr_SetString(PyExc_ValueError, "bad image mode");
441
        return NULL;
442
    }
443

444
    decoder = PyImaging_DecoderNew(sizeof(GIFDECODERSTATE));
445
    if (decoder == NULL) {
446
        return NULL;
447
    }
448

449
    decoder->decode = ImagingGifDecode;
450

451
    ((GIFDECODERSTATE *)decoder->state.context)->bits = bits;
452
    ((GIFDECODERSTATE *)decoder->state.context)->interlace = interlace;
453
    ((GIFDECODERSTATE *)decoder->state.context)->transparency = transparency;
454

455
    return (PyObject *)decoder;
456
}
457

458
/* -------------------------------------------------------------------- */
459
/* HEX                                                                  */
460
/* -------------------------------------------------------------------- */
461

462
PyObject *
463
PyImaging_HexDecoderNew(PyObject *self, PyObject *args) {
464
    ImagingDecoderObject *decoder;
465

466
    char *mode;
467
    char *rawmode;
468
    if (!PyArg_ParseTuple(args, "ss", &mode, &rawmode)) {
469
        return NULL;
470
    }
471

472
    decoder = PyImaging_DecoderNew(0);
473
    if (decoder == NULL) {
474
        return NULL;
475
    }
476

477
    if (get_unpacker(decoder, mode, rawmode) < 0) {
478
        return NULL;
479
    }
480

481
    decoder->decode = ImagingHexDecode;
482

483
    return (PyObject *)decoder;
484
}
485

486
/* -------------------------------------------------------------------- */
487
/* LibTiff                                                              */
488
/* -------------------------------------------------------------------- */
489

490
#ifdef HAVE_LIBTIFF
491

492
#include "libImaging/TiffDecode.h"
493

494
#include <string.h>
495

496
PyObject *
497
PyImaging_LibTiffDecoderNew(PyObject *self, PyObject *args) {
498
    ImagingDecoderObject *decoder;
499
    char *mode;
500
    char *rawmode;
501
    char *compname;
502
    int fp;
503
    uint32_t ifdoffset;
504

505
    if (!PyArg_ParseTuple(args, "sssiI", &mode, &rawmode, &compname, &fp, &ifdoffset)) {
506
        return NULL;
507
    }
508

509
    TRACE(("new tiff decoder %s\n", compname));
510

511
    decoder = PyImaging_DecoderNew(sizeof(TIFFSTATE));
512
    if (decoder == NULL) {
513
        return NULL;
514
    }
515

516
    if (get_unpacker(decoder, mode, rawmode) < 0) {
517
        return NULL;
518
    }
519

520
    if (!ImagingLibTiffInit(&decoder->state, fp, ifdoffset)) {
521
        Py_DECREF(decoder);
522
        PyErr_SetString(PyExc_RuntimeError, "tiff codec initialization failed");
523
        return NULL;
524
    }
525

526
    decoder->decode = ImagingLibTiffDecode;
527

528
    return (PyObject *)decoder;
529
}
530

531
#endif
532

533
/* -------------------------------------------------------------------- */
534
/* PackBits                                                             */
535
/* -------------------------------------------------------------------- */
536

537
PyObject *
538
PyImaging_PackbitsDecoderNew(PyObject *self, PyObject *args) {
539
    ImagingDecoderObject *decoder;
540

541
    char *mode;
542
    char *rawmode;
543
    if (!PyArg_ParseTuple(args, "ss", &mode, &rawmode)) {
544
        return NULL;
545
    }
546

547
    decoder = PyImaging_DecoderNew(0);
548
    if (decoder == NULL) {
549
        return NULL;
550
    }
551

552
    if (get_unpacker(decoder, mode, rawmode) < 0) {
553
        return NULL;
554
    }
555

556
    decoder->decode = ImagingPackbitsDecode;
557

558
    return (PyObject *)decoder;
559
}
560

561
/* -------------------------------------------------------------------- */
562
/* PCD                                                                  */
563
/* -------------------------------------------------------------------- */
564

565
PyObject *
566
PyImaging_PcdDecoderNew(PyObject *self, PyObject *args) {
567
    ImagingDecoderObject *decoder;
568

569
    decoder = PyImaging_DecoderNew(0);
570
    if (decoder == NULL) {
571
        return NULL;
572
    }
573

574
    /* Unpack from PhotoYCC to RGB */
575
    if (get_unpacker(decoder, "RGB", "YCC;P") < 0) {
576
        return NULL;
577
    }
578

579
    decoder->decode = ImagingPcdDecode;
580

581
    return (PyObject *)decoder;
582
}
583

584
/* -------------------------------------------------------------------- */
585
/* PCX                                                                  */
586
/* -------------------------------------------------------------------- */
587

588
PyObject *
589
PyImaging_PcxDecoderNew(PyObject *self, PyObject *args) {
590
    ImagingDecoderObject *decoder;
591

592
    char *mode;
593
    char *rawmode;
594
    int stride;
595
    if (!PyArg_ParseTuple(args, "ssi", &mode, &rawmode, &stride)) {
596
        return NULL;
597
    }
598

599
    decoder = PyImaging_DecoderNew(0);
600
    if (decoder == NULL) {
601
        return NULL;
602
    }
603

604
    if (get_unpacker(decoder, mode, rawmode) < 0) {
605
        return NULL;
606
    }
607

608
    decoder->state.bytes = stride;
609

610
    decoder->decode = ImagingPcxDecode;
611

612
    return (PyObject *)decoder;
613
}
614

615
/* -------------------------------------------------------------------- */
616
/* RAW                                                                  */
617
/* -------------------------------------------------------------------- */
618

619
PyObject *
620
PyImaging_RawDecoderNew(PyObject *self, PyObject *args) {
621
    ImagingDecoderObject *decoder;
622

623
    char *mode;
624
    char *rawmode;
625
    int stride = 0;
626
    int ystep = 1;
627
    if (!PyArg_ParseTuple(args, "ss|ii", &mode, &rawmode, &stride, &ystep)) {
628
        return NULL;
629
    }
630

631
    decoder = PyImaging_DecoderNew(sizeof(RAWSTATE));
632
    if (decoder == NULL) {
633
        return NULL;
634
    }
635

636
    if (get_unpacker(decoder, mode, rawmode) < 0) {
637
        return NULL;
638
    }
639

640
    decoder->decode = ImagingRawDecode;
641

642
    decoder->state.ystep = ystep;
643

644
    ((RAWSTATE *)decoder->state.context)->stride = stride;
645

646
    return (PyObject *)decoder;
647
}
648

649
/* -------------------------------------------------------------------- */
650
/* SGI RLE                                                              */
651
/* -------------------------------------------------------------------- */
652

653
PyObject *
654
PyImaging_SgiRleDecoderNew(PyObject *self, PyObject *args) {
655
    ImagingDecoderObject *decoder;
656

657
    char *mode;
658
    char *rawmode;
659
    int ystep = 1;
660
    int bpc = 1;
661
    if (!PyArg_ParseTuple(args, "ss|ii", &mode, &rawmode, &ystep, &bpc)) {
662
        return NULL;
663
    }
664

665
    decoder = PyImaging_DecoderNew(sizeof(SGISTATE));
666
    if (decoder == NULL) {
667
        return NULL;
668
    }
669

670
    if (get_unpacker(decoder, mode, rawmode) < 0) {
671
        return NULL;
672
    }
673

674
    decoder->pulls_fd = 1;
675
    decoder->decode = ImagingSgiRleDecode;
676
    decoder->state.ystep = ystep;
677

678
    ((SGISTATE *)decoder->state.context)->bpc = bpc;
679

680
    return (PyObject *)decoder;
681
}
682

683
/* -------------------------------------------------------------------- */
684
/* SUN RLE                                                              */
685
/* -------------------------------------------------------------------- */
686

687
PyObject *
688
PyImaging_SunRleDecoderNew(PyObject *self, PyObject *args) {
689
    ImagingDecoderObject *decoder;
690

691
    char *mode;
692
    char *rawmode;
693
    if (!PyArg_ParseTuple(args, "ss", &mode, &rawmode)) {
694
        return NULL;
695
    }
696

697
    decoder = PyImaging_DecoderNew(0);
698
    if (decoder == NULL) {
699
        return NULL;
700
    }
701

702
    if (get_unpacker(decoder, mode, rawmode) < 0) {
703
        return NULL;
704
    }
705

706
    decoder->decode = ImagingSunRleDecode;
707

708
    return (PyObject *)decoder;
709
}
710

711
/* -------------------------------------------------------------------- */
712
/* TGA RLE                                                              */
713
/* -------------------------------------------------------------------- */
714

715
PyObject *
716
PyImaging_TgaRleDecoderNew(PyObject *self, PyObject *args) {
717
    ImagingDecoderObject *decoder;
718

719
    char *mode;
720
    char *rawmode;
721
    int ystep = 1;
722
    int depth = 8;
723
    if (!PyArg_ParseTuple(args, "ss|ii", &mode, &rawmode, &ystep, &depth)) {
724
        return NULL;
725
    }
726

727
    decoder = PyImaging_DecoderNew(0);
728
    if (decoder == NULL) {
729
        return NULL;
730
    }
731

732
    if (get_unpacker(decoder, mode, rawmode) < 0) {
733
        return NULL;
734
    }
735

736
    decoder->decode = ImagingTgaRleDecode;
737

738
    decoder->state.ystep = ystep;
739
    decoder->state.count = depth / 8;
740

741
    return (PyObject *)decoder;
742
}
743

744
/* -------------------------------------------------------------------- */
745
/* XBM                                                                  */
746
/* -------------------------------------------------------------------- */
747

748
PyObject *
749
PyImaging_XbmDecoderNew(PyObject *self, PyObject *args) {
750
    ImagingDecoderObject *decoder;
751

752
    decoder = PyImaging_DecoderNew(0);
753
    if (decoder == NULL) {
754
        return NULL;
755
    }
756

757
    if (get_unpacker(decoder, "1", "1;R") < 0) {
758
        return NULL;
759
    }
760

761
    decoder->decode = ImagingXbmDecode;
762

763
    return (PyObject *)decoder;
764
}
765

766
/* -------------------------------------------------------------------- */
767
/* ZIP                                                                  */
768
/* -------------------------------------------------------------------- */
769

770
#ifdef HAVE_LIBZ
771

772
#include "libImaging/ZipCodecs.h"
773

774
PyObject *
775
PyImaging_ZipDecoderNew(PyObject *self, PyObject *args) {
776
    ImagingDecoderObject *decoder;
777

778
    char *mode;
779
    char *rawmode;
780
    int interlaced = 0;
781
    if (!PyArg_ParseTuple(args, "ss|i", &mode, &rawmode, &interlaced)) {
782
        return NULL;
783
    }
784

785
    decoder = PyImaging_DecoderNew(sizeof(ZIPSTATE));
786
    if (decoder == NULL) {
787
        return NULL;
788
    }
789

790
    if (get_unpacker(decoder, mode, rawmode) < 0) {
791
        return NULL;
792
    }
793

794
    decoder->decode = ImagingZipDecode;
795
    decoder->cleanup = ImagingZipDecodeCleanup;
796

797
    ((ZIPSTATE *)decoder->state.context)->interlaced = interlaced;
798

799
    return (PyObject *)decoder;
800
}
801
#endif
802

803
/* -------------------------------------------------------------------- */
804
/* JPEG                                                                 */
805
/* -------------------------------------------------------------------- */
806

807
#ifdef HAVE_LIBJPEG
808

809
/* We better define this decoder last in this file, so the following
810
   undef's won't mess things up for the Imaging library proper. */
811

812
#undef HAVE_PROTOTYPES
813
#undef HAVE_STDDEF_H
814
#undef HAVE_STDLIB_H
815
#undef UINT8
816
#undef UINT16
817
#undef UINT32
818
#undef INT8
819
#undef INT16
820
#undef INT32
821

822
#include "libImaging/Jpeg.h"
823

824
PyObject *
825
PyImaging_JpegDecoderNew(PyObject *self, PyObject *args) {
826
    ImagingDecoderObject *decoder;
827

828
    char *mode;
829
    char *rawmode;  /* what we want from the decoder */
830
    char *jpegmode; /* what's in the file */
831
    int scale = 1;
832
    int draft = 0;
833

834
    if (!PyArg_ParseTuple(args, "ssz|ii", &mode, &rawmode, &jpegmode, &scale, &draft)) {
835
        return NULL;
836
    }
837

838
    if (!jpegmode) {
839
        jpegmode = "";
840
    }
841

842
    decoder = PyImaging_DecoderNew(sizeof(JPEGSTATE));
843
    if (decoder == NULL) {
844
        return NULL;
845
    }
846

847
    // libjpeg-turbo supports different output formats.
848
    // We are choosing Pillow's native format (3 color bytes + 1 padding)
849
    // to avoid extra conversion in Unpack.c.
850
    if (ImagingJpegUseJCSExtensions() && strcmp(rawmode, "RGB") == 0) {
851
        rawmode = "RGBX";
852
    }
853

854
    if (get_unpacker(decoder, mode, rawmode) < 0) {
855
        return NULL;
856
    }
857

858
    decoder->decode = ImagingJpegDecode;
859
    decoder->cleanup = ImagingJpegDecodeCleanup;
860

861
    strncpy(((JPEGSTATE *)decoder->state.context)->rawmode, rawmode, 8);
862
    strncpy(((JPEGSTATE *)decoder->state.context)->jpegmode, jpegmode, 8);
863

864
    ((JPEGSTATE *)decoder->state.context)->scale = scale;
865
    ((JPEGSTATE *)decoder->state.context)->draft = draft;
866

867
    return (PyObject *)decoder;
868
}
869
#endif
870

871
/* -------------------------------------------------------------------- */
872
/* JPEG 2000                                                            */
873
/* -------------------------------------------------------------------- */
874

875
#ifdef HAVE_OPENJPEG
876

877
#include "libImaging/Jpeg2K.h"
878

879
PyObject *
880
PyImaging_Jpeg2KDecoderNew(PyObject *self, PyObject *args) {
881
    ImagingDecoderObject *decoder;
882
    JPEG2KDECODESTATE *context;
883

884
    char *mode;
885
    char *format;
886
    OPJ_CODEC_FORMAT codec_format;
887
    int reduce = 0;
888
    int layers = 0;
889
    int fd = -1;
890
    PY_LONG_LONG length = -1;
891

892
    if (!PyArg_ParseTuple(
893
            args, "ss|iiiL", &mode, &format, &reduce, &layers, &fd, &length
894
        )) {
895
        return NULL;
896
    }
897

898
    if (strcmp(format, "j2k") == 0) {
899
        codec_format = OPJ_CODEC_J2K;
900
    } else if (strcmp(format, "jpt") == 0) {
901
        codec_format = OPJ_CODEC_JPT;
902
    } else if (strcmp(format, "jp2") == 0) {
903
        codec_format = OPJ_CODEC_JP2;
904
    } else {
905
        return NULL;
906
    }
907

908
    decoder = PyImaging_DecoderNew(sizeof(JPEG2KDECODESTATE));
909
    if (decoder == NULL) {
910
        return NULL;
911
    }
912

913
    decoder->pulls_fd = 1;
914
    decoder->decode = ImagingJpeg2KDecode;
915
    decoder->cleanup = ImagingJpeg2KDecodeCleanup;
916

917
    context = (JPEG2KDECODESTATE *)decoder->state.context;
918

919
    context->fd = fd;
920
    context->length = (off_t)length;
921
    context->format = codec_format;
922
    context->reduce = reduce;
923
    context->layers = layers;
924

925
    return (PyObject *)decoder;
926
}
927
#endif /* HAVE_OPENJPEG */
928