← Back to branch summary

~ubuntu-branches/ubuntu/saucy/python-imaging/saucy-proposed

« back to all changes in this revision

Viewing changes to .pc/git-updates.diff/decode.c

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-03-20 16:44:01 UTC
  • mfrom: (2.1.13 experimental)
  • Revision ID: package-import@ubuntu.com-20130320164401-ptf6m0ttg4zw72az
Tags: 1.1.7+2.0.0-1
Pillow 2.0.0 release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/git-updates.diff/decode.c
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
 
#include "Python.h"
33
 
 
34
 
#if PY_VERSION_HEX < 0x01060000
35
 
#define PyObject_New PyObject_NEW
36
 
#define PyObject_Del PyMem_DEL
37
 
#endif
38
 
 
39
 
#include "Imaging.h"
40
 
 
41
 
#include "Gif.h"
42
 
#include "Lzw.h"
43
 
#include "Raw.h"
44
 
#include "Bit.h"
45
 
 
46
 
 
47
 
/* -------------------------------------------------------------------- */
48
 
/* Common                                                               */
49
 
/* -------------------------------------------------------------------- */
50
 
 
51
 
typedef struct {
52
 
    PyObject_HEAD
53
 
    int (*decode)(Imaging im, ImagingCodecState state,
54
 
                  UINT8* buffer, int bytes);
55
 
    struct ImagingCodecStateInstance state;
56
 
    Imaging im;
57
 
    PyObject* lock;
58
 
} ImagingDecoderObject;
59
 
 
60
 
staticforward PyTypeObject ImagingDecoderType;
61
 
 
62
 
static ImagingDecoderObject*
63
 
PyImaging_DecoderNew(int contextsize)
64
 
{
65
 
    ImagingDecoderObject *decoder;
66
 
    void *context;
67
 
 
68
 
    ImagingDecoderType.ob_type = &PyType_Type;
69
 
 
70
 
    decoder = PyObject_New(ImagingDecoderObject, &ImagingDecoderType);
71
 
    if (decoder == NULL)
72
 
        return NULL;
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) PyErr_NoMemory();
83
 
            return NULL;
84
 
        }
85
 
    } else
86
 
        context = 0;
87
 
 
88
 
    /* Initialize decoder context */
89
 
    decoder->state.context = context;
90
 
 
91
 
    /* Target image */
92
 
    decoder->lock = NULL;
93
 
    decoder->im = NULL;
94
 
 
95
 
    return decoder;
96
 
}
97
 
 
98
 
static void
99
 
_dealloc(ImagingDecoderObject* decoder)
100
 
{
101
 
    free(decoder->state.buffer);
102
 
    free(decoder->state.context);
103
 
    Py_XDECREF(decoder->lock);
104
 
    PyObject_Del(decoder);
105
 
}
106
 
 
107
 
static PyObject* 
108
 
_decode(ImagingDecoderObject* decoder, PyObject* args)
109
 
{
110
 
    UINT8* buffer;
111
 
    int bufsize, status;
112
 
 
113
 
    if (!PyArg_ParseTuple(args, "s#", &buffer, &bufsize))
114
 
        return NULL;
115
 
 
116
 
    status = decoder->decode(decoder->im, &decoder->state, buffer, bufsize);
117
 
 
118
 
    return Py_BuildValue("ii", status, decoder->state.errcode);
119
 
}
120
 
 
121
 
extern Imaging PyImaging_AsImaging(PyObject *op);
122
 
 
123
 
static PyObject*
124
 
_setimage(ImagingDecoderObject* decoder, PyObject* args)
125
 
{
126
 
    PyObject* op;
127
 
    Imaging im;
128
 
    ImagingCodecState state;
129
 
    int x0, y0, x1, y1;
130
 
 
131
 
    x0 = y0 = x1 = y1 = 0;
132
 
 
133
 
    /* FIXME: should publish the ImagingType descriptor */
134
 
    if (!PyArg_ParseTuple(args, "O|(iiii)", &op, &x0, &y0, &x1, &y1))
135
 
        return NULL;
136
 
    im = PyImaging_AsImaging(op);
137
 
    if (!im)
138
 
        return NULL;
139
 
 
140
 
    decoder->im = im;
141
 
 
142
 
    state = &decoder->state;
143
 
 
144
 
    /* Setup decoding tile extent */
145
 
    if (x0 == 0 && x1 == 0) {
146
 
        state->xsize = im->xsize;
147
 
        state->ysize = im->ysize;
148
 
    } else {
149
 
        state->xoff = x0;
150
 
        state->yoff = y0;
151
 
        state->xsize = x1 - x0;
152
 
        state->ysize = y1 - y0;
153
 
    }
154
 
 
155
 
    if (state->xsize <= 0 ||
156
 
        state->xsize + state->xoff > (int) im->xsize ||
157
 
        state->ysize <= 0 ||
158
 
        state->ysize + state->yoff > (int) im->ysize) {
159
 
        PyErr_SetString(PyExc_ValueError, "tile cannot extend outside image");
160
 
        return NULL;
161
 
    }
162
 
 
163
 
    /* Allocate memory buffer (if bits field is set) */
164
 
    if (state->bits > 0) {
165
 
        if (!state->bytes)
166
 
            state->bytes = (state->bits * state->xsize+7)/8;
167
 
        state->buffer = (UINT8*) malloc(state->bytes);
168
 
        if (!state->buffer)
169
 
            return PyErr_NoMemory();
170
 
    }
171
 
 
172
 
    /* Keep a reference to the image object, to make sure it doesn't
173
 
       go away before we do */
174
 
    Py_INCREF(op);
175
 
    Py_XDECREF(decoder->lock);
176
 
    decoder->lock = op;
177
 
 
178
 
    Py_INCREF(Py_None);
179
 
    return Py_None;
180
 
}
181
 
 
182
 
static struct PyMethodDef methods[] = {
183
 
    {"decode", (PyCFunction)_decode, 1},
184
 
    {"setimage", (PyCFunction)_setimage, 1},
185
 
    {NULL, NULL} /* sentinel */
186
 
};
187
 
 
188
 
static PyObject*  
189
 
_getattr(ImagingDecoderObject* self, char* name)
190
 
{
191
 
    return Py_FindMethod(methods, (PyObject*) self, name);
192
 
}
193
 
 
194
 
statichere PyTypeObject ImagingDecoderType = {
195
 
        PyObject_HEAD_INIT(NULL)
196
 
        0,                              /*ob_size*/
197
 
        "ImagingDecoder",               /*tp_name*/
198
 
        sizeof(ImagingDecoderObject),   /*tp_size*/
199
 
        0,                              /*tp_itemsize*/
200
 
        /* methods */
201
 
        (destructor)_dealloc,           /*tp_dealloc*/
202
 
        0,                              /*tp_print*/
203
 
        (getattrfunc)_getattr,          /*tp_getattr*/
204
 
        0,                              /*tp_setattr*/
205
 
        0,                              /*tp_compare*/
206
 
        0,                              /*tp_repr*/
207
 
        0,                              /*tp_hash*/
208
 
};
209
 
 
210
 
/* -------------------------------------------------------------------- */
211
 
 
212
 
int
213
 
get_unpacker(ImagingDecoderObject* decoder, const char* mode,
214
 
             const char* rawmode)
215
 
{
216
 
    int bits;
217
 
    ImagingShuffler unpack;
218
 
 
219
 
    unpack = ImagingFindUnpacker(mode, rawmode, &bits);
220
 
    if (!unpack) {
221
 
        Py_DECREF(decoder);
222
 
        PyErr_SetString(PyExc_ValueError, "unknown raw mode");
223
 
        return -1;
224
 
    }
225
 
 
226
 
    decoder->state.shuffle = unpack;
227
 
    decoder->state.bits = bits;
228
 
 
229
 
    return 0;
230
 
}
231
 
 
232
 
 
233
 
/* -------------------------------------------------------------------- */
234
 
/* BIT (packed fields)                                                  */
235
 
/* -------------------------------------------------------------------- */
236
 
 
237
 
PyObject*
238
 
PyImaging_BitDecoderNew(PyObject* self, PyObject* args)
239
 
{
240
 
    ImagingDecoderObject* decoder;
241
 
 
242
 
    char* mode;
243
 
    int bits  = 8;
244
 
    int pad   = 8;
245
 
    int fill  = 0;
246
 
    int sign  = 0;
247
 
    int ystep = 1;
248
 
    if (!PyArg_ParseTuple(args, "s|iiiii", &mode, &bits, &pad, &fill,
249
 
                          &sign, &ystep))
250
 
        return NULL;
251
 
 
252
 
    if (strcmp(mode, "F") != 0) {
253
 
        PyErr_SetString(PyExc_ValueError, "bad image mode");
254
 
        return NULL;
255
 
    }
256
 
 
257
 
    decoder = PyImaging_DecoderNew(sizeof(BITSTATE));
258
 
    if (decoder == NULL)
259
 
        return NULL;
260
 
 
261
 
    decoder->decode = ImagingBitDecode;
262
 
 
263
 
    decoder->state.ystep = ystep;
264
 
 
265
 
    ((BITSTATE*)decoder->state.context)->bits = bits;
266
 
    ((BITSTATE*)decoder->state.context)->pad  = pad;
267
 
    ((BITSTATE*)decoder->state.context)->fill = fill;
268
 
    ((BITSTATE*)decoder->state.context)->sign = sign;
269
 
 
270
 
    return (PyObject*) decoder;
271
 
}
272
 
 
273
 
 
274
 
/* -------------------------------------------------------------------- */
275
 
/* FLI                                                                  */
276
 
/* -------------------------------------------------------------------- */
277
 
 
278
 
PyObject*
279
 
PyImaging_FliDecoderNew(PyObject* self, PyObject* args)
280
 
{
281
 
    ImagingDecoderObject* decoder;
282
 
 
283
 
    decoder = PyImaging_DecoderNew(0);
284
 
    if (decoder == NULL)
285
 
        return NULL;
286
 
 
287
 
    decoder->decode = ImagingFliDecode;
288
 
 
289
 
    return (PyObject*) decoder;
290
 
}
291
 
 
292
 
 
293
 
/* -------------------------------------------------------------------- */
294
 
/* GIF                                                                  */
295
 
/* -------------------------------------------------------------------- */
296
 
 
297
 
PyObject*
298
 
PyImaging_GifDecoderNew(PyObject* self, PyObject* args)
299
 
{
300
 
    ImagingDecoderObject* decoder;
301
 
 
302
 
    char* mode;
303
 
    int bits = 8;
304
 
    int interlace = 0;
305
 
    if (!PyArg_ParseTuple(args, "s|ii", &mode, &bits, &interlace))
306
 
        return NULL;
307
 
 
308
 
    if (strcmp(mode, "L") != 0 && strcmp(mode, "P") != 0) {
309
 
        PyErr_SetString(PyExc_ValueError, "bad image mode");
310
 
        return NULL;
311
 
    }
312
 
 
313
 
    decoder = PyImaging_DecoderNew(sizeof(GIFDECODERSTATE));
314
 
    if (decoder == NULL)
315
 
        return NULL;
316
 
 
317
 
    decoder->decode = ImagingGifDecode;
318
 
 
319
 
    ((GIFDECODERSTATE*)decoder->state.context)->bits = bits;
320
 
    ((GIFDECODERSTATE*)decoder->state.context)->interlace = interlace;
321
 
 
322
 
    return (PyObject*) decoder;
323
 
}
324
 
 
325
 
 
326
 
/* -------------------------------------------------------------------- */
327
 
/* HEX                                                                  */
328
 
/* -------------------------------------------------------------------- */
329
 
 
330
 
PyObject*
331
 
PyImaging_HexDecoderNew(PyObject* self, PyObject* args)
332
 
{
333
 
    ImagingDecoderObject* decoder;
334
 
 
335
 
    char* mode;
336
 
    char* rawmode;
337
 
    if (!PyArg_ParseTuple(args, "ss", &mode, &rawmode))
338
 
        return NULL;
339
 
 
340
 
    decoder = PyImaging_DecoderNew(0);
341
 
    if (decoder == NULL)
342
 
        return NULL;
343
 
 
344
 
    if (get_unpacker(decoder, mode, rawmode) < 0)
345
 
        return NULL;
346
 
 
347
 
    decoder->decode = ImagingHexDecode;
348
 
 
349
 
    return (PyObject*) decoder;
350
 
}
351
 
 
352
 
 
353
 
/* -------------------------------------------------------------------- */
354
 
/* LZW                                                                  */
355
 
/* -------------------------------------------------------------------- */
356
 
 
357
 
PyObject*
358
 
PyImaging_TiffLzwDecoderNew(PyObject* self, PyObject* args)
359
 
{
360
 
    ImagingDecoderObject* decoder;
361
 
 
362
 
    char* mode;
363
 
    char* rawmode;
364
 
    int filter = 0;
365
 
    if (!PyArg_ParseTuple(args, "ss|i", &mode, &rawmode, &filter))
366
 
        return NULL;
367
 
 
368
 
    decoder = PyImaging_DecoderNew(sizeof(LZWSTATE));
369
 
    if (decoder == NULL)
370
 
        return NULL;
371
 
 
372
 
    if (get_unpacker(decoder, mode, rawmode) < 0)
373
 
        return NULL;
374
 
 
375
 
    decoder->decode = ImagingLzwDecode;
376
 
 
377
 
    ((LZWSTATE*)decoder->state.context)->filter = filter;
378
 
 
379
 
    return (PyObject*) decoder;
380
 
}
381
 
 
382
 
 
383
 
/* -------------------------------------------------------------------- */
384
 
/* MSP                                                                  */
385
 
/* -------------------------------------------------------------------- */
386
 
 
387
 
PyObject*
388
 
PyImaging_MspDecoderNew(PyObject* self, PyObject* args)
389
 
{
390
 
    ImagingDecoderObject* decoder;
391
 
 
392
 
    decoder = PyImaging_DecoderNew(0);
393
 
    if (decoder == NULL)
394
 
        return NULL;
395
 
 
396
 
    if (get_unpacker(decoder, "1", "1") < 0)
397
 
        return NULL;
398
 
 
399
 
    decoder->decode = ImagingMspDecode;
400
 
 
401
 
    return (PyObject*) decoder;
402
 
}
403
 
 
404
 
 
405
 
/* -------------------------------------------------------------------- */
406
 
/* PackBits                                                             */
407
 
/* -------------------------------------------------------------------- */
408
 
 
409
 
PyObject*
410
 
PyImaging_PackbitsDecoderNew(PyObject* self, PyObject* args)
411
 
{
412
 
    ImagingDecoderObject* decoder;
413
 
 
414
 
    char* mode;
415
 
    char* rawmode;
416
 
    if (!PyArg_ParseTuple(args, "ss", &mode, &rawmode))
417
 
        return NULL;
418
 
 
419
 
    decoder = PyImaging_DecoderNew(0);
420
 
    if (decoder == NULL)
421
 
        return NULL;
422
 
 
423
 
    if (get_unpacker(decoder, mode, rawmode) < 0)
424
 
        return NULL;
425
 
 
426
 
    decoder->decode = ImagingPackbitsDecode;
427
 
 
428
 
    return (PyObject*) decoder;
429
 
}
430
 
 
431
 
 
432
 
/* -------------------------------------------------------------------- */
433
 
/* PCD                                                                  */
434
 
/* -------------------------------------------------------------------- */
435
 
 
436
 
PyObject*
437
 
PyImaging_PcdDecoderNew(PyObject* self, PyObject* args)
438
 
{
439
 
    ImagingDecoderObject* decoder;
440
 
 
441
 
    decoder = PyImaging_DecoderNew(0);
442
 
    if (decoder == NULL)
443
 
        return NULL;
444
 
 
445
 
    /* Unpack from PhotoYCC to RGB */
446
 
    if (get_unpacker(decoder, "RGB", "YCC;P") < 0)
447
 
        return NULL;
448
 
 
449
 
    decoder->decode = ImagingPcdDecode;
450
 
 
451
 
    return (PyObject*) decoder;
452
 
}
453
 
 
454
 
 
455
 
/* -------------------------------------------------------------------- */
456
 
/* PCX                                                                  */
457
 
/* -------------------------------------------------------------------- */
458
 
 
459
 
PyObject*
460
 
PyImaging_PcxDecoderNew(PyObject* self, PyObject* args)
461
 
{
462
 
    ImagingDecoderObject* decoder;
463
 
 
464
 
    char* mode;
465
 
    char* rawmode;
466
 
    int stride;
467
 
    if (!PyArg_ParseTuple(args, "ssi", &mode, &rawmode, &stride))
468
 
        return NULL;
469
 
 
470
 
    decoder = PyImaging_DecoderNew(0);
471
 
    if (decoder == NULL)
472
 
        return NULL;
473
 
 
474
 
    if (get_unpacker(decoder, mode, rawmode) < 0)
475
 
        return NULL;
476
 
 
477
 
    decoder->state.bytes = stride;
478
 
 
479
 
    decoder->decode = ImagingPcxDecode;
480
 
 
481
 
    return (PyObject*) decoder;
482
 
}
483
 
 
484
 
 
485
 
/* -------------------------------------------------------------------- */
486
 
/* RAW                                                                  */
487
 
/* -------------------------------------------------------------------- */
488
 
 
489
 
PyObject*
490
 
PyImaging_RawDecoderNew(PyObject* self, PyObject* args)
491
 
{
492
 
    ImagingDecoderObject* decoder;
493
 
 
494
 
    char* mode;
495
 
    char* rawmode;
496
 
    int stride = 0;
497
 
    int ystep  = 1;
498
 
    if (!PyArg_ParseTuple(args, "ss|ii", &mode, &rawmode, &stride, &ystep))
499
 
        return NULL;
500
 
 
501
 
    decoder = PyImaging_DecoderNew(sizeof(RAWSTATE));
502
 
    if (decoder == NULL)
503
 
        return NULL;
504
 
 
505
 
    if (get_unpacker(decoder, mode, rawmode) < 0)
506
 
        return NULL;
507
 
 
508
 
    decoder->decode = ImagingRawDecode;
509
 
 
510
 
    decoder->state.ystep = ystep;
511
 
 
512
 
    ((RAWSTATE*)decoder->state.context)->stride = stride;
513
 
 
514
 
    return (PyObject*) decoder;
515
 
}
516
 
 
517
 
 
518
 
/* -------------------------------------------------------------------- */
519
 
/* SUN RLE                                                              */
520
 
/* -------------------------------------------------------------------- */
521
 
 
522
 
PyObject*
523
 
PyImaging_SunRleDecoderNew(PyObject* self, PyObject* args)
524
 
{
525
 
    ImagingDecoderObject* decoder;
526
 
 
527
 
    char* mode;
528
 
    char* rawmode;
529
 
    if (!PyArg_ParseTuple(args, "ss", &mode, &rawmode))
530
 
        return NULL;
531
 
 
532
 
    decoder = PyImaging_DecoderNew(0);
533
 
    if (decoder == NULL)
534
 
        return NULL;
535
 
 
536
 
    if (get_unpacker(decoder, mode, rawmode) < 0)
537
 
        return NULL;
538
 
 
539
 
    decoder->decode = ImagingSunRleDecode;
540
 
 
541
 
    return (PyObject*) decoder;
542
 
}
543
 
 
544
 
 
545
 
/* -------------------------------------------------------------------- */
546
 
/* TGA RLE                                                              */
547
 
/* -------------------------------------------------------------------- */
548
 
 
549
 
PyObject*
550
 
PyImaging_TgaRleDecoderNew(PyObject* self, PyObject* args)
551
 
{
552
 
    ImagingDecoderObject* decoder;
553
 
 
554
 
    char* mode;
555
 
    char* rawmode;
556
 
    int ystep = 1;
557
 
    int depth = 8;
558
 
    if (!PyArg_ParseTuple(args, "ss|ii", &mode, &rawmode, &ystep, &depth))
559
 
        return NULL;
560
 
 
561
 
    decoder = PyImaging_DecoderNew(0);
562
 
    if (decoder == NULL)
563
 
        return NULL;
564
 
 
565
 
    if (get_unpacker(decoder, mode, rawmode) < 0)
566
 
        return NULL;
567
 
 
568
 
    decoder->decode = ImagingTgaRleDecode;
569
 
 
570
 
    decoder->state.ystep = ystep;
571
 
    decoder->state.count = depth / 8;
572
 
 
573
 
    return (PyObject*) decoder;
574
 
}
575
 
 
576
 
 
577
 
/* -------------------------------------------------------------------- */
578
 
/* XBM                                                                  */
579
 
/* -------------------------------------------------------------------- */
580
 
 
581
 
PyObject*
582
 
PyImaging_XbmDecoderNew(PyObject* self, PyObject* args)
583
 
{
584
 
    ImagingDecoderObject* decoder;
585
 
 
586
 
    decoder = PyImaging_DecoderNew(0);
587
 
    if (decoder == NULL)
588
 
        return NULL;
589
 
 
590
 
    if (get_unpacker(decoder, "1", "1;R") < 0)
591
 
        return NULL;
592
 
 
593
 
    decoder->decode = ImagingXbmDecode;
594
 
 
595
 
    return (PyObject*) decoder;
596
 
}
597
 
 
598
 
 
599
 
/* -------------------------------------------------------------------- */
600
 
/* ZIP                                                                  */
601
 
/* -------------------------------------------------------------------- */
602
 
 
603
 
#ifdef HAVE_LIBZ
604
 
 
605
 
#include "Zip.h"
606
 
 
607
 
PyObject*
608
 
PyImaging_ZipDecoderNew(PyObject* self, PyObject* args)
609
 
{
610
 
    ImagingDecoderObject* decoder;
611
 
 
612
 
    char* mode;
613
 
    char* rawmode;
614
 
    int interlaced = 0;
615
 
    if (!PyArg_ParseTuple(args, "ss|i", &mode, &rawmode, &interlaced))
616
 
        return NULL;
617
 
 
618
 
    decoder = PyImaging_DecoderNew(sizeof(ZIPSTATE));
619
 
    if (decoder == NULL)
620
 
        return NULL;
621
 
 
622
 
    if (get_unpacker(decoder, mode, rawmode) < 0)
623
 
        return NULL;
624
 
 
625
 
    decoder->decode = ImagingZipDecode;
626
 
 
627
 
    ((ZIPSTATE*)decoder->state.context)->interlaced = interlaced;
628
 
 
629
 
    return (PyObject*) decoder;
630
 
}
631
 
#endif
632
 
 
633
 
 
634
 
/* -------------------------------------------------------------------- */
635
 
/* JPEG                                                                 */
636
 
/* -------------------------------------------------------------------- */
637
 
 
638
 
#ifdef HAVE_LIBJPEG
639
 
 
640
 
/* We better define this decoder last in this file, so the following
641
 
   undef's won't mess things up for the Imaging library proper. */
642
 
 
643
 
#undef  HAVE_PROTOTYPES
644
 
#undef  HAVE_STDDEF_H
645
 
#undef  HAVE_STDLIB_H
646
 
#undef  UINT8
647
 
#undef  UINT16
648
 
#undef  UINT32
649
 
#undef  INT8
650
 
#undef  INT16
651
 
#undef  INT32
652
 
 
653
 
#include "Jpeg.h"
654
 
 
655
 
PyObject*
656
 
PyImaging_JpegDecoderNew(PyObject* self, PyObject* args)
657
 
{
658
 
    ImagingDecoderObject* decoder;
659
 
 
660
 
    char* mode;
661
 
    char* rawmode; /* what we wan't from the decoder */
662
 
    char* jpegmode; /* what's in the file */
663
 
    int scale = 1;
664
 
    int draft = 0;
665
 
    if (!PyArg_ParseTuple(args, "ssz|ii", &mode, &rawmode, &jpegmode,
666
 
                          &scale, &draft))
667
 
        return NULL;
668
 
 
669
 
    if (!jpegmode)
670
 
        jpegmode = "";
671
 
 
672
 
    decoder = PyImaging_DecoderNew(sizeof(JPEGSTATE));
673
 
    if (decoder == NULL)
674
 
        return NULL;
675
 
 
676
 
    if (get_unpacker(decoder, mode, rawmode) < 0)
677
 
        return NULL;
678
 
 
679
 
    decoder->decode = ImagingJpegDecode;
680
 
 
681
 
    strncpy(((JPEGSTATE*)decoder->state.context)->rawmode, rawmode, 8);
682
 
    strncpy(((JPEGSTATE*)decoder->state.context)->jpegmode, jpegmode, 8);
683
 
 
684
 
    ((JPEGSTATE*)decoder->state.context)->scale = scale;
685
 
    ((JPEGSTATE*)decoder->state.context)->draft = draft;
686
 
 
687
 
    return (PyObject*) decoder;
688
 
}
689
 
#endif