?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Split 8-bit-to-native conversion in bmp.c into a function, add support for plugging...
[kugel-rb.git] / apps / recorder / jpeg_load.c
blob9393e60de87781bf6cacc6f8b9d3acca86ca86cf
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * JPEG image viewer
11 * (This is a real mess if it has to be coded in one single C file)
12 *
13 * Copyright (C) 2009 Andrew Mahone fractional decode, split IDCT - 16-point
14 * IDCT based on IJG jpeg-7 pre-release
15 * File scrolling addition (C) 2005 Alexander Spyridakis
16 * Copyright (C) 2004 Jörg Hohensohn aka [IDC]Dragon
17 * Heavily borrowed from the IJG implementation (C) Thomas G. Lane
18 * Small & fast downscaling IDCT (C) 2002 by Guido Vollbeding JPEGclub.org
19 *
20 * This program is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU General Public License
22 * as published by the Free Software Foundation; either version 2
23 * of the License, or (at your option) any later version.
24 *
25 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
26 * KIND, either express or implied.
27 *
28 ****************************************************************************/
29
30 #include "plugin.h"
31 #include "debug.h"
32 #include "jpeg_load.h"
33 /*#define JPEG_BS_DEBUG*/
34 /* for portability of below JPEG code */
35 #define MEMSET(p,v,c) memset(p,v,c)
36 #define MEMCPY(d,s,c) memcpy(d,s,c)
37 #define INLINE static inline
38 #define ENDIAN_SWAP16(n) n /* only for poor little endian machines */
39 #ifdef ROCKBOX_DEBUG_JPEG
40 #define JDEBUGF DEBUGF
41 #else
42 #define JDEBUGF(...)
43 #endif
44
45 /**************** begin JPEG code ********************/
46
47 #ifdef HAVE_LCD_COLOR
48 typedef struct uint8_rgb jpeg_pix_t;
49 #else
50 typedef uint8_t jpeg_pix_t;
51 #endif
52 #define JPEG_PIX_SZ (sizeof(jpeg_pix_t))
53
54 /* This can't be in jpeg_load.h because plugin.h includes it, and it conflicts
55 * with the definition in jpeg_decoder.h
56 */
57 struct jpeg
58 {
59 #ifdef JPEG_FROM_MEM
60 unsigned char *data;
61 unsigned long len;
62 #else
63 int fd;
64 int buf_left;
65 unsigned char *buf_index;
66 #endif
67 unsigned long int bitbuf;
68 int bitbuf_bits;
69 int marker_ind;
70 int marker_val;
71 unsigned char marker;
72 int x_size, y_size; /* size of image (can be less than block boundary) */
73 int x_phys, y_phys; /* physical size, block aligned */
74 int x_mbl; /* x dimension of MBL */
75 int y_mbl; /* y dimension of MBL */
76 int blocks; /* blocks per MB */
77 int restart_interval; /* number of MCUs between RSTm markers */
78 int restart; /* blocks until next restart marker */
79 int mcu_row; /* current row relative to first row of this row of MCUs */
80 unsigned char *out_ptr; /* pointer to current row to output */
81 int cur_row; /* current row relative to top of image */
82 int set_rows;
83 int store_pos[4]; /* for Y block ordering */
84 #ifdef HAVE_LCD_COLOR
85 int last_dc_val[3];
86 int h_scale[2]; /* horizontal scalefactor = (2**N) / 8 */
87 int v_scale[2]; /* same as above, for vertical direction */
88 int k_need[2]; /* per component zig-zag index of last needed coefficient */
89 int zero_need[2]; /* per compenent number of coefficients to zero */
90 #else
91 int last_dc_val;
92 int h_scale[1]; /* horizontal scalefactor = (2**N) / 8 */
93 int v_scale[1]; /* same as above, for vertical direction */
94 int k_need[1]; /* per component zig-zag index of last needed coefficient */
95 int zero_need[1]; /* per compenent number of coefficients to zero */
96 #endif
97 jpeg_pix_t *img_buf;
98
99 int quanttable[4][QUANT_TABLE_LENGTH]; /* raw quantization tables 0-3 */
100
101 struct huffman_table hufftable[2]; /* Huffman tables */
102 struct derived_tbl dc_derived_tbls[2]; /* Huffman-LUTs */
103 struct derived_tbl ac_derived_tbls[2];
104
105 struct frame_component frameheader[3]; /* Component descriptor */
106 struct scan_component scanheader[3]; /* currently not used */
107
108 int mcu_membership[6]; /* info per block */
109 int tab_membership[6];
110 int subsample_x[3]; /* info per component */
111 int subsample_y[3];
112 bool resize;
113 unsigned char buf[JPEG_READ_BUF_SIZE];
114 struct img_part part;
115 };
116
117 #ifdef JPEG_FROM_MEM
118 static struct jpeg jpeg;
119 #endif
120
121 INLINE unsigned range_limit(int value)
122 {
123 #if CONFIG_CPU == SH7034
124 unsigned tmp;
125 asm ( /* Note: Uses knowledge that only low byte of result is used */
126 "mov #-128,%[t] \n"
127 "sub %[t],%[v] \n" /* value -= -128; equals value += 128; */
128 "extu.b %[v],%[t] \n"
129 "cmp/eq %[v],%[t] \n" /* low byte == whole number ? */
130 "bt 1f \n" /* yes: no overflow */
131 "cmp/pz %[v] \n" /* overflow: positive? */
132 "subc %[v],%[v] \n" /* %[r] now either 0 or 0xffffffff */
133 "1: \n"
134 : /* outputs */
135 [v]"+r"(value),
136 [t]"=&r"(tmp)
137 );
138 return value;
139 #elif defined(CPU_COLDFIRE)
140 /* Note: Uses knowledge that only the low byte of the result is used */
141 asm (
142 "add.l #128,%[v] \n" /* value += 128; */
143 "cmp.l #255,%[v] \n" /* overflow? */
144 "bls.b 1f \n" /* no: return value */
145 /* yes: set low byte to appropriate boundary */
146 "spl.b %[v] \n"
147 "1: \n"
148 : /* outputs */
149 [v]"+d"(value)
150 );
151 return value;
152 #elif defined(CPU_ARM)
153 /* Note: Uses knowledge that only the low byte of the result is used */
154 asm (
155 "add %[v], %[v], #128 \n" /* value += 128 */
156 "cmp %[v], #255 \n" /* out of range 0..255? */
157 "mvnhi %[v], %[v], asr #31 \n" /* yes: set all bits to ~(sign_bit) */
158 : /* outputs */
159 [v]"+r"(value)
160 );
161 return value;
162 #else
163 value += 128;
164
165 if ((unsigned)value <= 255)
166 return value;
167
168 if (value < 0)
169 return 0;
170
171 return 255;
172 #endif
173 }
174
175 /* IDCT implementation */
176
177
178 #define CONST_BITS 13
179 #define PASS1_BITS 2
180
181
182 /* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
183 * causing a lot of useless floating-point operations at run time.
184 * To get around this we use the following pre-calculated constants.
185 * If you change CONST_BITS you may want to add appropriate values.
186 * (With a reasonable C compiler, you can just rely on the FIX() macro...)
187 */
188 #define FIX_0_298631336 2446 /* FIX(0.298631336) */
189 #define FIX_0_390180644 3196 /* FIX(0.390180644) */
190 #define FIX_0_541196100 4433 /* FIX(0.541196100) */
191 #define FIX_0_765366865 6270 /* FIX(0.765366865) */
192 #define FIX_0_899976223 7373 /* FIX(0.899976223) */
193 #define FIX_1_175875602 9633 /* FIX(1.175875602) */
194 #define FIX_1_501321110 12299 /* FIX(1.501321110) */
195 #define FIX_1_847759065 15137 /* FIX(1.847759065) */
196 #define FIX_1_961570560 16069 /* FIX(1.961570560) */
197 #define FIX_2_053119869 16819 /* FIX(2.053119869) */
198 #define FIX_2_562915447 20995 /* FIX(2.562915447) */
199 #define FIX_3_072711026 25172 /* FIX(3.072711026) */
200
201
202
203 /* Multiply an long variable by an long constant to yield an long result.
204 * For 8-bit samples with the recommended scaling, all the variable
205 * and constant values involved are no more than 16 bits wide, so a
206 * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
207 * For 12-bit samples, a full 32-bit multiplication will be needed.
208 */
209 #define MULTIPLY16(var,const) (((short) (var)) * ((short) (const)))
210
211 #define MULTIPLY(var1, var2) ((var1) * (var2))
212
213 /*
214 * Macros for handling fixed-point arithmetic; these are used by many
215 * but not all of the DCT/IDCT modules.
216 *
217 * All values are expected to be of type INT32.
218 * Fractional constants are scaled left by CONST_BITS bits.
219 * CONST_BITS is defined within each module using these macros,
220 * and may differ from one module to the next.
221 */
222 #define ONE ((long)1)
223 #define CONST_SCALE (ONE << CONST_BITS)
224
225 /* Convert a positive real constant to an integer scaled by CONST_SCALE.
226 * Caution: some C compilers fail to reduce "FIX(constant)" at compile time,
227 * thus causing a lot of useless floating-point operations at run time.
228 */
229 #define FIX(x) ((long) ((x) * CONST_SCALE + 0.5))
230 #define RIGHT_SHIFT(x,shft) ((x) >> (shft))
231
232 /* Descale and correctly round an int value that's scaled by N bits.
233 * We assume RIGHT_SHIFT rounds towards minus infinity, so adding
234 * the fudge factor is correct for either sign of X.
235 */
236 #define DESCALE(x,n) (((x) + (1l << ((n)-1))) >> (n))
237
238 #define DS_OUT ((CONST_BITS)+(PASS1_BITS)+3)
239
240 /*
241 * Conversion of full 0-255 range YCrCb to RGB:
242 * |R| |1.000000 -0.000001 1.402000| |Y'|
243 * |G| = |1.000000 -0.334136 -0.714136| |Pb|
244 * |B| |1.000000 1.772000 0.000000| |Pr|
245 * Scaled (yields s15-bit output):
246 * |R| |128 0 179| |Y |
247 * |G| = |128 -43 -91| |Cb - 128|
248 * |B| |128 227 0| |Cr - 128|
249 */
250 #define YFAC 128
251 #define RVFAC 179
252 #define GUFAC (-43)
253 #define GVFAC (-91)
254 #define BUFAC 227
255 #define COMPONENT_SHIFT 15
256
257 /* horizontal-pass 1-point IDCT */
258 static void idct1h(int *ws, unsigned char *out, int rows, int rowstep)
259 {
260 int row;
261 for (row = 0; row < rows; row++)
262 {
263 *out = range_limit((int) DESCALE(*ws, DS_OUT));
264 out += rowstep;
265 ws += 8;
266 }
267 }
268
269 /* vertical-pass 2-point IDCT */
270 static void idct2v(int *ws, int cols)
271 {
272 int col;
273 for (col = 0; col < cols; col++)
274 {
275 int tmp1 = ws[0];
276 int tmp2 = ws[8];
277 ws[0] = tmp1 + tmp2;
278 ws[8] = tmp1 - tmp2;
279 ws++;
280 }
281 }
282
283 /* horizontal-pass 2-point IDCT */
284 static void idct2h(int *ws, unsigned char *out, int rows, int rowstep)
285 {
286 int row;
287 for (row = 0; row < rows; row++)
288 {
289 int tmp1 = ws[0] + (ONE << (DS_OUT - 1));
290 int tmp2 = ws[1];
291 out[JPEG_PIX_SZ*0] = range_limit((int) RIGHT_SHIFT(tmp1 + tmp2,
292 DS_OUT));
293 out[JPEG_PIX_SZ*1] = range_limit((int) RIGHT_SHIFT(tmp1 - tmp2,
294 DS_OUT));
295 out += rowstep;
296 ws += 8;
297 }
298 }
299
300 /* vertical-pass 4-point IDCT */
301 static void idct4v(int *ws, int cols)
302 {
303 int tmp0, tmp2, tmp10, tmp12;
304 int z1, z2, z3;
305 int col;
306 for (col = 0; col < cols; col++, ws++)
307 {
308 /* Even part */
309
310 tmp0 = ws[8*0];
311 tmp2 = ws[8*2];
312
313 tmp10 = (tmp0 + tmp2) << PASS1_BITS;
314 tmp12 = (tmp0 - tmp2) << PASS1_BITS;
315
316 /* Odd part */
317 /* Same rotation as in the even part of the 8x8 LL&M IDCT */
318
319 z2 = ws[8*1];
320 z3 = ws[8*3];
321
322 z1 = MULTIPLY16(z2 + z3, FIX_0_541196100) +
323 (ONE << (CONST_BITS - PASS1_BITS - 1));
324 tmp0 = RIGHT_SHIFT(z1 + MULTIPLY16(z3, - FIX_1_847759065),
325 CONST_BITS-PASS1_BITS);
326 tmp2 = RIGHT_SHIFT(z1 + MULTIPLY16(z2, FIX_0_765366865),
327 CONST_BITS-PASS1_BITS);
328
329 /* Final output stage */
330
331 ws[8*0] = (int) (tmp10 + tmp2);
332 ws[8*3] = (int) (tmp10 - tmp2);
333 ws[8*1] = (int) (tmp12 + tmp0);
334 ws[8*2] = (int) (tmp12 - tmp0);
335 }
336 }
337
338 /* horizontal-pass 4-point IDCT */
339 static void idct4h(int *ws, unsigned char *out, int rows, int rowstep)
340 {
341 int tmp0, tmp2, tmp10, tmp12;
342 int z1, z2, z3;
343 int row;
344 for (row = 0; row < rows; row++, out += rowstep, ws += 8)
345 {
346 /* Even part */
347
348 tmp0 = (int) ws[0] + (ONE << (PASS1_BITS + 2));
349 tmp2 = (int) ws[2];
350
351 tmp10 = (tmp0 + tmp2) << CONST_BITS;
352 tmp12 = (tmp0 - tmp2) << CONST_BITS;
353
354 /* Odd part */
355 /* Same rotation as in the even part of the 8x8 LL&M IDCT */
356
357 z2 = (int) ws[1];
358 z3 = (int) ws[3];
359
360 z1 = MULTIPLY16(z2 + z3, FIX_0_541196100);
361 tmp0 = z1 + MULTIPLY16(z3, - FIX_1_847759065);
362 tmp2 = z1 + MULTIPLY16(z2, FIX_0_765366865);
363
364 /* Final output stage */
365
366 out[JPEG_PIX_SZ*0] = range_limit((int) RIGHT_SHIFT(tmp10 + tmp2,
367 DS_OUT));
368 out[JPEG_PIX_SZ*3] = range_limit((int) RIGHT_SHIFT(tmp10 - tmp2,
369 DS_OUT));
370 out[JPEG_PIX_SZ*1] = range_limit((int) RIGHT_SHIFT(tmp12 + tmp0,
371 DS_OUT));
372 out[JPEG_PIX_SZ*2] = range_limit((int) RIGHT_SHIFT(tmp12 - tmp0,
373 DS_OUT));
374 }
375 }
376
377 /* vertical-pass 8-point IDCT */
378 static void idct8v(int *ws, int cols)
379 {
380 long tmp0, tmp1, tmp2, tmp3;
381 long tmp10, tmp11, tmp12, tmp13;
382 long z1, z2, z3, z4, z5;
383 int col;
384 for (col = 0; col < cols; col++, ws++)
385 {
386 /* Due to quantization, we will usually find that many of the input
387 * coefficients are zero, especially the AC terms. We can exploit this
388 * by short-circuiting the IDCT calculation for any column in which all
389 * the AC terms are zero. In that case each output is equal to the
390 * DC coefficient (with scale factor as needed).
391 * With typical images and quantization tables, half or more of the
392 * column DCT calculations can be simplified this way.
393 */
394 if ((ws[8*1] | ws[8*2] | ws[8*3]
395 | ws[8*4] | ws[8*5] | ws[8*6] | ws[8*7]) == 0)
396 {
397 /* AC terms all zero */
398 int dcval = ws[8*0] << PASS1_BITS;
399
400 ws[8*0] = ws[8*1] = ws[8*2] = ws[8*3] = ws[8*4]
401 = ws[8*5] = ws[8*6] = ws[8*7] = dcval;
402 continue;
403 }
404
405 /* Even part: reverse the even part of the forward DCT. */
406 /* The rotator is sqrt(2)*c(-6). */
407
408 z2 = ws[8*2];
409 z3 = ws[8*6];
410
411 z1 = MULTIPLY16(z2 + z3, FIX_0_541196100);
412 tmp2 = z1 + MULTIPLY16(z3, - FIX_1_847759065);
413 tmp3 = z1 + MULTIPLY16(z2, FIX_0_765366865);
414
415 z2 = ws[8*0] << CONST_BITS;
416 z2 += ONE << (CONST_BITS - PASS1_BITS - 1);
417 z3 = ws[8*4] << CONST_BITS;
418
419 tmp0 = (z2 + z3);
420 tmp1 = (z2 - z3);
421
422 tmp10 = tmp0 + tmp3;
423 tmp13 = tmp0 - tmp3;
424 tmp11 = tmp1 + tmp2;
425 tmp12 = tmp1 - tmp2;
426
427 /* Odd part per figure 8; the matrix is unitary and hence its
428 transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively. */
429
430 tmp0 = ws[8*7];
431 tmp1 = ws[8*5];
432 tmp2 = ws[8*3];
433 tmp3 = ws[8*1];
434
435 z1 = tmp0 + tmp3;
436 z2 = tmp1 + tmp2;
437 z3 = tmp0 + tmp2;
438 z4 = tmp1 + tmp3;
439 z5 = MULTIPLY16(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
440
441 tmp0 = MULTIPLY16(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
442 tmp1 = MULTIPLY16(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
443 tmp2 = MULTIPLY16(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
444 tmp3 = MULTIPLY16(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
445 z1 = MULTIPLY16(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
446 z2 = MULTIPLY16(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
447 z3 = MULTIPLY16(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
448 z4 = MULTIPLY16(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
449
450 z3 += z5;
451 z4 += z5;
452
453 tmp0 += z1 + z3;
454 tmp1 += z2 + z4;
455 tmp2 += z2 + z3;
456 tmp3 += z1 + z4;
457
458 /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
459
460 ws[8*0] = (int) RIGHT_SHIFT(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
461 ws[8*7] = (int) RIGHT_SHIFT(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
462 ws[8*1] = (int) RIGHT_SHIFT(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
463 ws[8*6] = (int) RIGHT_SHIFT(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
464 ws[8*2] = (int) RIGHT_SHIFT(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
465 ws[8*5] = (int) RIGHT_SHIFT(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
466 ws[8*3] = (int) RIGHT_SHIFT(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
467 ws[8*4] = (int) RIGHT_SHIFT(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
468 }
469 }
470
471 /* horizontal-pass 8-point IDCT */
472 static void idct8h(int *ws, unsigned char *out, int rows, int rowstep)
473 {
474 long tmp0, tmp1, tmp2, tmp3;
475 long tmp10, tmp11, tmp12, tmp13;
476 long z1, z2, z3, z4, z5;
477 int row;
478 for (row = 0; row < rows; row++, out += rowstep, ws += 8)
479 {
480 /* Rows of zeroes can be exploited in the same way as we did with
481 * columns. However, the column calculation has created many nonzero AC
482 * terms, so the simplification applies less often (typically 5% to 10%
483 * of the time). On machines with very fast multiplication, it's
484 * possible that the test takes more time than it's worth. In that
485 * case this section may be commented out.
486 */
487
488 #ifndef NO_ZERO_ROW_TEST
489 if ((ws[1] | ws[2] | ws[3]
490 | ws[4] | ws[5] | ws[6] | ws[7]) == 0)
491 {
492 /* AC terms all zero */
493 unsigned char dcval = range_limit((int) DESCALE((long) ws[0],
494 PASS1_BITS+3));
495
496 out[JPEG_PIX_SZ*0] = dcval;
497 out[JPEG_PIX_SZ*1] = dcval;
498 out[JPEG_PIX_SZ*2] = dcval;
499 out[JPEG_PIX_SZ*3] = dcval;
500 out[JPEG_PIX_SZ*4] = dcval;
501 out[JPEG_PIX_SZ*5] = dcval;
502 out[JPEG_PIX_SZ*6] = dcval;
503 out[JPEG_PIX_SZ*7] = dcval;
504 continue;
505 }
506 #endif
507
508 /* Even part: reverse the even part of the forward DCT. */
509 /* The rotator is sqrt(2)*c(-6). */
510
511 z2 = (long) ws[2];
512 z3 = (long) ws[6];
513
514 z1 = MULTIPLY16(z2 + z3, FIX_0_541196100);
515 tmp2 = z1 + MULTIPLY16(z3, - FIX_1_847759065);
516 tmp3 = z1 + MULTIPLY16(z2, FIX_0_765366865);
517
518 z4 = (long) ws[0] + (ONE << (PASS1_BITS + 2));
519 z4 <<= CONST_BITS;
520 z5 = (long) ws[4] << CONST_BITS;
521 tmp0 = z4 + z5;
522 tmp1 = z4 - z5;
523
524 tmp10 = tmp0 + tmp3;
525 tmp13 = tmp0 - tmp3;
526 tmp11 = tmp1 + tmp2;
527 tmp12 = tmp1 - tmp2;
528
529 /* Odd part per figure 8; the matrix is unitary and hence its
530 * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively. */
531
532 tmp0 = (long) ws[7];
533 tmp1 = (long) ws[5];
534 tmp2 = (long) ws[3];
535 tmp3 = (long) ws[1];
536
537 z1 = tmp0 + tmp3;
538 z2 = tmp1 + tmp2;
539 z3 = tmp0 + tmp2;
540 z4 = tmp1 + tmp3;
541 z5 = MULTIPLY16(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
542
543 tmp0 = MULTIPLY16(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
544 tmp1 = MULTIPLY16(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
545 tmp2 = MULTIPLY16(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
546 tmp3 = MULTIPLY16(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
547 z1 = MULTIPLY16(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
548 z2 = MULTIPLY16(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
549 z3 = MULTIPLY16(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
550 z4 = MULTIPLY16(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
551
552 z3 += z5;
553 z4 += z5;
554
555 tmp0 += z1 + z3;
556 tmp1 += z2 + z4;
557 tmp2 += z2 + z3;
558 tmp3 += z1 + z4;
559
560 /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
561
562 out[JPEG_PIX_SZ*0] = range_limit((int) RIGHT_SHIFT(tmp10 + tmp3,
563 DS_OUT));
564 out[JPEG_PIX_SZ*7] = range_limit((int) RIGHT_SHIFT(tmp10 - tmp3,
565 DS_OUT));
566 out[JPEG_PIX_SZ*1] = range_limit((int) RIGHT_SHIFT(tmp11 + tmp2,
567 DS_OUT));
568 out[JPEG_PIX_SZ*6] = range_limit((int) RIGHT_SHIFT(tmp11 - tmp2,
569 DS_OUT));
570 out[JPEG_PIX_SZ*2] = range_limit((int) RIGHT_SHIFT(tmp12 + tmp1,
571 DS_OUT));
572 out[JPEG_PIX_SZ*5] = range_limit((int) RIGHT_SHIFT(tmp12 - tmp1,
573 DS_OUT));
574 out[JPEG_PIX_SZ*3] = range_limit((int) RIGHT_SHIFT(tmp13 + tmp0,
575 DS_OUT));
576 out[JPEG_PIX_SZ*4] = range_limit((int) RIGHT_SHIFT(tmp13 - tmp0,
577 DS_OUT));
578 }
579 }
580
581 /* vertical-pass 16-point IDCT */
582 static void idct16v(int *ws, int cols)
583 {
584 long tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
585 long tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
586 long z1, z2, z3, z4;
587 int col;
588 for (col = 0; col < cols; col++, ws++)
589 {
590 /* Even part */
591
592 tmp0 = ws[8*0] << CONST_BITS;
593 /* Add fudge factor here for final descale. */
594 tmp0 += 1 << (CONST_BITS-PASS1_BITS-1);
595
596 z1 = ws[8*4];
597 tmp1 = MULTIPLY(z1, FIX(1.306562965)); /* c4[16] = c2[8] */
598 tmp2 = MULTIPLY(z1, FIX_0_541196100); /* c12[16] = c6[8] */
599
600 tmp10 = tmp0 + tmp1;
601 tmp11 = tmp0 - tmp1;
602 tmp12 = tmp0 + tmp2;
603 tmp13 = tmp0 - tmp2;
604
605 z1 = ws[8*2];
606 z2 = ws[8*6];
607 z3 = z1 - z2;
608 z4 = MULTIPLY(z3, FIX(0.275899379)); /* c14[16] = c7[8] */
609 z3 = MULTIPLY(z3, FIX(1.387039845)); /* c2[16] = c1[8] */
610
611 /* (c6+c2)[16] = (c3+c1)[8] */
612 tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447);
613 /* (c6-c14)[16] = (c3-c7)[8] */
614 tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223);
615 /* (c2-c10)[16] = (c1-c5)[8] */
616 tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887));
617 /* (c10-c14)[16] = (c5-c7)[8] */
618 tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579));
619
620 tmp20 = tmp10 + tmp0;
621 tmp27 = tmp10 - tmp0;
622 tmp21 = tmp12 + tmp1;
623 tmp26 = tmp12 - tmp1;
624 tmp22 = tmp13 + tmp2;
625 tmp25 = tmp13 - tmp2;
626 tmp23 = tmp11 + tmp3;
627 tmp24 = tmp11 - tmp3;
628
629 /* Odd part */
630
631 z1 = ws[8*1];
632 z2 = ws[8*3];
633 z3 = ws[8*5];
634 z4 = ws[8*7];
635
636 tmp11 = z1 + z3;
637
638 tmp1 = MULTIPLY(z1 + z2, FIX(1.353318001)); /* c3 */
639 tmp2 = MULTIPLY(tmp11, FIX(1.247225013)); /* c5 */
640 tmp3 = MULTIPLY(z1 + z4, FIX(1.093201867)); /* c7 */
641 tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586)); /* c9 */
642 tmp11 = MULTIPLY(tmp11, FIX(0.666655658)); /* c11 */
643 tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528)); /* c13 */
644 tmp0 = tmp1 + tmp2 + tmp3 -
645 MULTIPLY(z1, FIX(2.286341144)); /* c7+c5+c3-c1 */
646 tmp13 = tmp10 + tmp11 + tmp12 -
647 MULTIPLY(z1, FIX(1.835730603)); /* c9+c11+c13-c15 */
648 z1 = MULTIPLY(z2 + z3, FIX(0.138617169)); /* c15 */
649 tmp1 += z1 + MULTIPLY(z2, FIX(0.071888074)); /* c9+c11-c3-c15 */
650 tmp2 += z1 - MULTIPLY(z3, FIX(1.125726048)); /* c5+c7+c15-c3 */
651 z1 = MULTIPLY(z3 - z2, FIX(1.407403738)); /* c1 */
652 tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282)); /* c1+c11-c9-c13 */
653 tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411)); /* c1+c5+c13-c7 */
654 z2 += z4;
655 z1 = MULTIPLY(z2, - FIX(0.666655658)); /* -c11 */
656 tmp1 += z1;
657 tmp3 += z1 + MULTIPLY(z4, FIX(1.065388962)); /* c3+c11+c15-c7 */
658 z2 = MULTIPLY(z2, - FIX(1.247225013)); /* -c5 */
659 tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809)); /* c1+c5+c9-c13 */
660 tmp12 += z2;
661 z2 = MULTIPLY(z3 + z4, - FIX(1.353318001)); /* -c3 */
662 tmp2 += z2;
663 tmp3 += z2;
664 z2 = MULTIPLY(z4 - z3, FIX(0.410524528)); /* c13 */
665 tmp10 += z2;
666 tmp11 += z2;
667
668 /* Final output stage */
669 ws[8*0] = (int) RIGHT_SHIFT(tmp20 + tmp0, CONST_BITS-PASS1_BITS);
670 ws[8*15] = (int) RIGHT_SHIFT(tmp20 - tmp0, CONST_BITS-PASS1_BITS);
671 ws[8*1] = (int) RIGHT_SHIFT(tmp21 + tmp1, CONST_BITS-PASS1_BITS);
672 ws[8*14] = (int) RIGHT_SHIFT(tmp21 - tmp1, CONST_BITS-PASS1_BITS);
673 ws[8*2] = (int) RIGHT_SHIFT(tmp22 + tmp2, CONST_BITS-PASS1_BITS);
674 ws[8*13] = (int) RIGHT_SHIFT(tmp22 - tmp2, CONST_BITS-PASS1_BITS);
675 ws[8*3] = (int) RIGHT_SHIFT(tmp23 + tmp3, CONST_BITS-PASS1_BITS);
676 ws[8*12] = (int) RIGHT_SHIFT(tmp23 - tmp3, CONST_BITS-PASS1_BITS);
677 ws[8*4] = (int) RIGHT_SHIFT(tmp24 + tmp10, CONST_BITS-PASS1_BITS);
678 ws[8*11] = (int) RIGHT_SHIFT(tmp24 - tmp10, CONST_BITS-PASS1_BITS);
679 ws[8*5] = (int) RIGHT_SHIFT(tmp25 + tmp11, CONST_BITS-PASS1_BITS);
680 ws[8*10] = (int) RIGHT_SHIFT(tmp25 - tmp11, CONST_BITS-PASS1_BITS);
681 ws[8*6] = (int) RIGHT_SHIFT(tmp26 + tmp12, CONST_BITS-PASS1_BITS);
682 ws[8*9] = (int) RIGHT_SHIFT(tmp26 - tmp12, CONST_BITS-PASS1_BITS);
683 ws[8*7] = (int) RIGHT_SHIFT(tmp27 + tmp13, CONST_BITS-PASS1_BITS);
684 ws[8*8] = (int) RIGHT_SHIFT(tmp27 - tmp13, CONST_BITS-PASS1_BITS);
685 }
686 }
687
688 /* horizontal-pass 16-point IDCT */
689 static void idct16h(int *ws, unsigned char *out, int rows, int rowstep)
690 {
691 long tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
692 long tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
693 long z1, z2, z3, z4;
694 int row;
695 for (row = 0; row < rows; row++, out += rowstep, ws += 8)
696 {
697 /* Even part */
698
699 /* Add fudge factor here for final descale. */
700 tmp0 = (long) ws[0] + (ONE << (PASS1_BITS+2));
701 tmp0 <<= CONST_BITS;
702
703 z1 = (long) ws[4];
704 tmp1 = MULTIPLY(z1, FIX(1.306562965)); /* c4[16] = c2[8] */
705 tmp2 = MULTIPLY(z1, FIX_0_541196100); /* c12[16] = c6[8] */
706
707 tmp10 = tmp0 + tmp1;
708 tmp11 = tmp0 - tmp1;
709 tmp12 = tmp0 + tmp2;
710 tmp13 = tmp0 - tmp2;
711
712 z1 = (long) ws[2];
713 z2 = (long) ws[6];
714 z3 = z1 - z2;
715 z4 = MULTIPLY(z3, FIX(0.275899379)); /* c14[16] = c7[8] */
716 z3 = MULTIPLY(z3, FIX(1.387039845)); /* c2[16] = c1[8] */
717
718 /* (c6+c2)[16] = (c3+c1)[8] */
719 tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447);
720 /* (c6-c14)[16] = (c3-c7)[8] */
721 tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223);
722 /* (c2-c10)[16] = (c1-c5)[8] */
723 tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887));
724 /* (c10-c14)[16] = (c5-c7)[8] */
725 tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579));
726
727 tmp20 = tmp10 + tmp0;
728 tmp27 = tmp10 - tmp0;
729 tmp21 = tmp12 + tmp1;
730 tmp26 = tmp12 - tmp1;
731 tmp22 = tmp13 + tmp2;
732 tmp25 = tmp13 - tmp2;
733 tmp23 = tmp11 + tmp3;
734 tmp24 = tmp11 - tmp3;
735
736 /* Odd part */
737
738 z1 = (long) ws[1];
739 z2 = (long) ws[3];
740 z3 = (long) ws[5];
741 z4 = (long) ws[7];
742
743 tmp11 = z1 + z3;
744
745 tmp1 = MULTIPLY(z1 + z2, FIX(1.353318001)); /* c3 */
746 tmp2 = MULTIPLY(tmp11, FIX(1.247225013)); /* c5 */
747 tmp3 = MULTIPLY(z1 + z4, FIX(1.093201867)); /* c7 */
748 tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586)); /* c9 */
749 tmp11 = MULTIPLY(tmp11, FIX(0.666655658)); /* c11 */
750 tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528)); /* c13 */
751 tmp0 = tmp1 + tmp2 + tmp3 -
752 MULTIPLY(z1, FIX(2.286341144)); /* c7+c5+c3-c1 */
753 tmp13 = tmp10 + tmp11 + tmp12 -
754 MULTIPLY(z1, FIX(1.835730603)); /* c9+c11+c13-c15 */
755 z1 = MULTIPLY(z2 + z3, FIX(0.138617169)); /* c15 */
756 tmp1 += z1 + MULTIPLY(z2, FIX(0.071888074)); /* c9+c11-c3-c15 */
757 tmp2 += z1 - MULTIPLY(z3, FIX(1.125726048)); /* c5+c7+c15-c3 */
758 z1 = MULTIPLY(z3 - z2, FIX(1.407403738)); /* c1 */
759 tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282)); /* c1+c11-c9-c13 */
760 tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411)); /* c1+c5+c13-c7 */
761 z2 += z4;
762 z1 = MULTIPLY(z2, - FIX(0.666655658)); /* -c11 */
763 tmp1 += z1;
764 tmp3 += z1 + MULTIPLY(z4, FIX(1.065388962)); /* c3+c11+c15-c7 */
765 z2 = MULTIPLY(z2, - FIX(1.247225013)); /* -c5 */
766 tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809)); /* c1+c5+c9-c13 */
767 tmp12 += z2;
768 z2 = MULTIPLY(z3 + z4, - FIX(1.353318001)); /* -c3 */
769 tmp2 += z2;
770 tmp3 += z2;
771 z2 = MULTIPLY(z4 - z3, FIX(0.410524528)); /* c13 */
772 tmp10 += z2;
773 tmp11 += z2;
774
775 /* Final output stage */
776
777 out[JPEG_PIX_SZ*0] = range_limit((int) RIGHT_SHIFT(tmp20 + tmp0,
778 DS_OUT));
779 out[JPEG_PIX_SZ*15] = range_limit((int) RIGHT_SHIFT(tmp20 - tmp0,
780 DS_OUT));
781 out[JPEG_PIX_SZ*1] = range_limit((int) RIGHT_SHIFT(tmp21 + tmp1,
782 DS_OUT));
783 out[JPEG_PIX_SZ*14] = range_limit((int) RIGHT_SHIFT(tmp21 - tmp1,
784 DS_OUT));
785 out[JPEG_PIX_SZ*2] = range_limit((int) RIGHT_SHIFT(tmp22 + tmp2,
786 DS_OUT));
787 out[JPEG_PIX_SZ*13] = range_limit((int) RIGHT_SHIFT(tmp22 - tmp2,
788 DS_OUT));
789 out[JPEG_PIX_SZ*3] = range_limit((int) RIGHT_SHIFT(tmp23 + tmp3,
790 DS_OUT));
791 out[JPEG_PIX_SZ*12] = range_limit((int) RIGHT_SHIFT(tmp23 - tmp3,
792 DS_OUT));
793 out[JPEG_PIX_SZ*4] = range_limit((int) RIGHT_SHIFT(tmp24 + tmp10,
794 DS_OUT));
795 out[JPEG_PIX_SZ*11] = range_limit((int) RIGHT_SHIFT(tmp24 - tmp10,
796 DS_OUT));
797 out[JPEG_PIX_SZ*5] = range_limit((int) RIGHT_SHIFT(tmp25 + tmp11,
798 DS_OUT));
799 out[JPEG_PIX_SZ*10] = range_limit((int) RIGHT_SHIFT(tmp25 - tmp11,
800 DS_OUT));
801 out[JPEG_PIX_SZ*6] = range_limit((int) RIGHT_SHIFT(tmp26 + tmp12,
802 DS_OUT));
803 out[JPEG_PIX_SZ*9] = range_limit((int) RIGHT_SHIFT(tmp26 - tmp12,
804 DS_OUT));
805 out[JPEG_PIX_SZ*7] = range_limit((int) RIGHT_SHIFT(tmp27 + tmp13,
806 DS_OUT));
807 out[JPEG_PIX_SZ*8] = range_limit((int) RIGHT_SHIFT(tmp27 - tmp13,
808 DS_OUT));
809 }
810 }
811
812 struct idct_entry {
813 int v_scale;
814 int h_scale;
815 void (*v_idct)(int *ws, int cols);
816 void (*h_idct)(int *ws, unsigned char *out, int rows, int rowstep);
817 };
818
819 struct idct_entry idct_tbl[] = {
820 { PASS1_BITS, CONST_BITS, NULL, idct1h },
821 { PASS1_BITS, CONST_BITS, idct2v, idct2h },
822 { 0, 0, idct4v, idct4h },
823 { 0, 0, idct8v, idct8h },
824 { 0, 0, idct16v, idct16h },
825 };
826
827 /* JPEG decoder implementation */
828
829 #ifdef JPEG_FROM_MEM
830 INLINE unsigned char *getc(struct jpeg* p_jpeg)
831 {
832 if (p_jpeg->len)
833 {
834 p_jpeg->len--;
835 return p_jpeg->data++;
836 } else
837 return NULL;
838 }
839
840 INLINE bool skip_bytes(struct jpeg* p_jpeg, int count)
841 {
842 if (p_jpeg->len >= (unsigned)count)
843 {
844 p_jpeg->len -= count;
845 p_jpeg->data += count;
846 return true;
847 } else {
848 p_jpeg->data += p_jpeg->len;
849 p_jpeg->len = 0;
850 return false;
851 }
852 }
853
854 INLINE void putc(struct jpeg* p_jpeg)
855 {
856 p_jpeg->len++;
857 p_jpeg->data--;
858 }
859 #else
860 INLINE void fill_buf(struct jpeg* p_jpeg)
861 {
862 p_jpeg->buf_left = read(p_jpeg->fd, p_jpeg->buf, JPEG_READ_BUF_SIZE);
863 p_jpeg->buf_index = p_jpeg->buf;
864 }
865
866 static unsigned char *getc(struct jpeg* p_jpeg)
867 {
868 if (p_jpeg->buf_left < 1)
869 fill_buf(p_jpeg);
870 if (p_jpeg->buf_left < 1)
871 return NULL;
872 p_jpeg->buf_left--;
873 return p_jpeg->buf_index++;
874 }
875
876 INLINE bool skip_bytes_seek(struct jpeg* p_jpeg)
877 {
878 if (lseek(p_jpeg->fd, -p_jpeg->buf_left, SEEK_CUR) < 0)
879 return false;
880 p_jpeg->buf_left = 0;
881 return true;
882 }
883
884 static bool skip_bytes(struct jpeg* p_jpeg, int count)
885 {
886 p_jpeg->buf_left -= count;
887 p_jpeg->buf_index += count;
888 return p_jpeg->buf_left >= 0 || skip_bytes_seek(p_jpeg);
889 }
890
891 static void putc(struct jpeg* p_jpeg)
892 {
893 p_jpeg->buf_left++;
894 p_jpeg->buf_index--;
895 }
896 #endif
897
898 #define e_skip_bytes(jpeg, count) \
899 do {\
900 if (!skip_bytes((jpeg),(count))) \
901 return -1; \
902 } while (0)
903
904 #define e_getc(jpeg, code) \
905 ({ \
906 unsigned char *c; \
907 if (!(c = getc(jpeg))) \
908 return (code); \
909 *c; \
910 })
911
912 #define d_getc(jpeg, def) \
913 ({ \
914 unsigned char *cp = getc(jpeg); \
915 unsigned char c = cp ? *cp : (def); \
916 c; \
917 })
918
919 /* Preprocess the JPEG JFIF file */
920 static int process_markers(struct jpeg* p_jpeg)
921 {
922 unsigned char c;
923 int marker_size; /* variable length of marker segment */
924 int i, j, n;
925 int ret = 0; /* returned flags */
926
927 while ((c = e_getc(p_jpeg, -1)))
928 {
929 if (c != 0xFF) /* no marker? */
930 {
931 JDEBUGF("Non-marker data\n");
932 putc(p_jpeg);
933 break; /* exit marker processing */
934 }
935
936 c = e_getc(p_jpeg, -1);
937 JDEBUGF("marker value %X\n",c);
938 switch (c)
939 {
940 case 0xFF: /* Fill byte */
941 ret |= FILL_FF;
942 case 0x00: /* Zero stuffed byte - entropy data */
943 putc(p_jpeg);
944 continue;
945
946 case 0xC0: /* SOF Huff - Baseline DCT */
947 {
948 JDEBUGF("SOF marker ");
949 ret |= SOF0;
950 marker_size = e_getc(p_jpeg, -1) << 8; /* Highbyte */
951 marker_size |= e_getc(p_jpeg, -1); /* Lowbyte */
952 JDEBUGF("len: %d\n", marker_size);
953 n = e_getc(p_jpeg, -1); /* sample precision (= 8 or 12) */
954 if (n != 8)
955 {
956 return(-1); /* Unsupported sample precision */
957 }
958 p_jpeg->y_size = e_getc(p_jpeg, -1) << 8; /* Highbyte */
959 p_jpeg->y_size |= e_getc(p_jpeg, -1); /* Lowbyte */
960 p_jpeg->x_size = e_getc(p_jpeg, -1) << 8; /* Highbyte */
961 p_jpeg->x_size |= e_getc(p_jpeg, -1); /* Lowbyte */
962 JDEBUGF(" dimensions: %dx%d\n", p_jpeg->x_size,
963 p_jpeg->y_size);
964
965 n = (marker_size-2-6)/3;
966 if (e_getc(p_jpeg, -1) != n || (n != 1 && n != 3))
967 {
968 return(-2); /* Unsupported SOF0 component specification */
969 }
970 for (i=0; i<n; i++)
971 {
972 /* Component info */
973 p_jpeg->frameheader[i].ID = e_getc(p_jpeg, -1);
974 p_jpeg->frameheader[i].horizontal_sampling =
975 (c = e_getc(p_jpeg, -1)) >> 4;
976 p_jpeg->frameheader[i].vertical_sampling = c & 0x0F;
977 p_jpeg->frameheader[i].quanttable_select =
978 e_getc(p_jpeg, -1);
979 if (p_jpeg->frameheader[i].horizontal_sampling > 2
980 || p_jpeg->frameheader[i].vertical_sampling > 2)
981 return -3; /* Unsupported SOF0 subsampling */
982 }
983 p_jpeg->blocks = n;
984 }
985 break;
986
987 case 0xC1: /* SOF Huff - Extended sequential DCT*/
988 case 0xC2: /* SOF Huff - Progressive DCT*/
989 case 0xC3: /* SOF Huff - Spatial (sequential) lossless*/
990 case 0xC5: /* SOF Huff - Differential sequential DCT*/
991 case 0xC6: /* SOF Huff - Differential progressive DCT*/
992 case 0xC7: /* SOF Huff - Differential spatial*/
993 case 0xC8: /* SOF Arith - Reserved for JPEG extensions*/
994 case 0xC9: /* SOF Arith - Extended sequential DCT*/
995 case 0xCA: /* SOF Arith - Progressive DCT*/
996 case 0xCB: /* SOF Arith - Spatial (sequential) lossless*/
997 case 0xCD: /* SOF Arith - Differential sequential DCT*/
998 case 0xCE: /* SOF Arith - Differential progressive DCT*/
999 case 0xCF: /* SOF Arith - Differential spatial*/
1000 {
1001 return (-4); /* other DCT model than baseline not implemented */
1002 }
1003
1004 case 0xC4: /* Define Huffman Table(s) */
1005 {
1006 ret |= DHT;
1007 marker_size = e_getc(p_jpeg, -1) << 8; /* Highbyte */
1008 marker_size |= e_getc(p_jpeg, -1); /* Lowbyte */
1009 marker_size -= 2;
1010
1011 while (marker_size > 17) /* another table */
1012 {
1013 c = e_getc(p_jpeg, -1);
1014 marker_size--;
1015 int sum = 0;
1016 i = c & 0x0F; /* table index */
1017 if (i > 1)
1018 {
1019 return (-5); /* Huffman table index out of range */
1020 } else {
1021 if (c & 0xF0) /* AC table */
1022 {
1023 for (j=0; j<16; j++)
1024 {
1025 p_jpeg->hufftable[i].huffmancodes_ac[j] =
1026 (c = e_getc(p_jpeg, -1));
1027 sum += c;
1028 marker_size -= 1;
1029 }
1030 if(16 + sum > AC_LEN)
1031 return -10; /* longer than allowed */
1032
1033 for (; j < 16 + sum; j++)
1034 {
1035 p_jpeg->hufftable[i].huffmancodes_ac[j] =
1036 e_getc(p_jpeg, -1);
1037 marker_size--;
1038 }
1039 }
1040 else /* DC table */
1041 {
1042 for (j=0; j<16; j++)
1043 {
1044 p_jpeg->hufftable[i].huffmancodes_dc[j] =
1045 (c = e_getc(p_jpeg, -1));
1046 sum += c;
1047 marker_size--;
1048 }
1049 if(16 + sum > DC_LEN)
1050 return -11; /* longer than allowed */
1051
1052 for (; j < 16 + sum; j++)
1053 {
1054 p_jpeg->hufftable[i].huffmancodes_dc[j] =
1055 e_getc(p_jpeg, -1);
1056 marker_size--;
1057 }
1058 }
1059 }
1060 } /* while */
1061 e_skip_bytes(p_jpeg, marker_size);
1062 }
1063 break;
1064
1065 case 0xCC: /* Define Arithmetic coding conditioning(s) */
1066 return(-6); /* Arithmetic coding not supported */
1067
1068 case 0xD8: /* Start of Image */
1069 JDEBUGF("SOI\n");
1070 break;
1071 case 0xD9: /* End of Image */
1072 JDEBUGF("EOI\n");
1073 break;
1074 case 0x01: /* for temp private use arith code */
1075 JDEBUGF("private\n");
1076 break; /* skip parameterless marker */
1077
1078
1079 case 0xDA: /* Start of Scan */
1080 {
1081 ret |= SOS;
1082 marker_size = e_getc(p_jpeg, -1) << 8; /* Highbyte */
1083 marker_size |= e_getc(p_jpeg, -1); /* Lowbyte */
1084 marker_size -= 2;
1085
1086 n = (marker_size-1-3)/2;
1087 if (e_getc(p_jpeg, -1) != n || (n != 1 && n != 3))
1088 {
1089 return (-7); /* Unsupported SOS component specification */
1090 }
1091 marker_size--;
1092 for (i=0; i<n; i++)
1093 {
1094 p_jpeg->scanheader[i].ID = e_getc(p_jpeg, -1);
1095 p_jpeg->scanheader[i].DC_select = (c = e_getc(p_jpeg, -1))
1096 >> 4;
1097 p_jpeg->scanheader[i].AC_select = c & 0x0F;
1098 marker_size -= 2;
1099 }
1100 /* skip spectral information */
1101 e_skip_bytes(p_jpeg, marker_size);
1102 }
1103 break;
1104
1105 case 0xDB: /* Define quantization Table(s) */
1106 {
1107 ret |= DQT;
1108 marker_size = e_getc(p_jpeg, -1) << 8; /* Highbyte */
1109 marker_size |= e_getc(p_jpeg, -1); /* Lowbyte */
1110 marker_size -= 2;
1111
1112 n = (marker_size)/(QUANT_TABLE_LENGTH+1); /* # of tables */
1113 for (i=0; i<n; i++)
1114 {
1115 int id = e_getc(p_jpeg, -1); /* ID */
1116 marker_size--;
1117 if (id >= 4)
1118 {
1119 return (-8); /* Unsupported quantization table */
1120 }
1121 /* Read Quantisation table: */
1122 for (j=0; j<QUANT_TABLE_LENGTH; j++)
1123 {
1124 p_jpeg->quanttable[id][j] = e_getc(p_jpeg, -1);
1125 marker_size--;
1126 }
1127 }
1128 e_skip_bytes(p_jpeg, marker_size);
1129 }
1130 break;
1131
1132 case 0xDD: /* Define Restart Interval */
1133 {
1134 marker_size = e_getc(p_jpeg, -1) << 8; /* Highbyte */
1135 marker_size |= e_getc(p_jpeg, -1); /* Lowbyte */
1136 marker_size -= 4;
1137 /* Highbyte */
1138 p_jpeg->restart_interval = e_getc(p_jpeg, -1) << 8;
1139 p_jpeg->restart_interval |= e_getc(p_jpeg, -1); /* Lowbyte */
1140 e_skip_bytes(p_jpeg, marker_size); /* skip segment */
1141 }
1142 break;
1143
1144 case 0xDC: /* Define Number of Lines */
1145 case 0xDE: /* Define Hierarchical progression */
1146 case 0xDF: /* Expand Reference Component(s) */
1147 case 0xE0: /* Application Field 0*/
1148 case 0xE1: /* Application Field 1*/
1149 case 0xE2: /* Application Field 2*/
1150 case 0xE3: /* Application Field 3*/
1151 case 0xE4: /* Application Field 4*/
1152 case 0xE5: /* Application Field 5*/
1153 case 0xE6: /* Application Field 6*/
1154 case 0xE7: /* Application Field 7*/
1155 case 0xE8: /* Application Field 8*/
1156 case 0xE9: /* Application Field 9*/
1157 case 0xEA: /* Application Field 10*/
1158 case 0xEB: /* Application Field 11*/
1159 case 0xEC: /* Application Field 12*/
1160 case 0xED: /* Application Field 13*/
1161 case 0xEE: /* Application Field 14*/
1162 case 0xEF: /* Application Field 15*/
1163 case 0xFE: /* Comment */
1164 {
1165 marker_size = e_getc(p_jpeg, -1) << 8; /* Highbyte */
1166 marker_size |= e_getc(p_jpeg, -1); /* Lowbyte */
1167 marker_size -= 2;
1168 JDEBUGF("unhandled marker len %d\n", marker_size);
1169 e_skip_bytes(p_jpeg, marker_size); /* skip segment */
1170 }
1171 break;
1172
1173 case 0xF0: /* Reserved for JPEG extensions */
1174 case 0xF1: /* Reserved for JPEG extensions */
1175 case 0xF2: /* Reserved for JPEG extensions */
1176 case 0xF3: /* Reserved for JPEG extensions */
1177 case 0xF4: /* Reserved for JPEG extensions */
1178 case 0xF5: /* Reserved for JPEG extensions */
1179 case 0xF6: /* Reserved for JPEG extensions */
1180 case 0xF7: /* Reserved for JPEG extensions */
1181 case 0xF8: /* Reserved for JPEG extensions */
1182 case 0xF9: /* Reserved for JPEG extensions */
1183 case 0xFA: /* Reserved for JPEG extensions */
1184 case 0xFB: /* Reserved for JPEG extensions */
1185 case 0xFC: /* Reserved for JPEG extensions */
1186 case 0xFD: /* Reserved for JPEG extensions */
1187 case 0x02: /* Reserved */
1188 default:
1189 return (-9); /* Unknown marker */
1190 } /* switch */
1191 } /* while */
1192
1193 return (ret); /* return flags with seen markers */
1194 }
1195
1196 static const struct huffman_table luma_table =
1197 {
1198 {
1199 0x00,0x01,0x05,0x01,0x01,0x01,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
1200 0x00,0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B
1201 },
1202 {
1203 0x00,0x02,0x01,0x03,0x03,0x02,0x04,0x03,0x05,0x05,0x04,0x04,0x00,0x00,
1204 0x01,0x7D,0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,
1205 0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xA1,0x08,0x23,0x42,
1206 0xB1,0xC1,0x15,0x52,0xD1,0xF0,0x24,0x33,0x62,0x72,0x82,0x09,0x0A,0x16,
1207 0x17,0x18,0x19,0x1A,0x25,0x26,0x27,0x28,0x29,0x2A,0x34,0x35,0x36,0x37,
1208 0x38,0x39,0x3A,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x53,0x54,0x55,
1209 0x56,0x57,0x58,0x59,0x5A,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x73,
1210 0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x83,0x84,0x85,0x86,0x87,0x88,0x89,
1211 0x8A,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0xA2,0xA3,0xA4,0xA5,
1212 0xA6,0xA7,0xA8,0xA9,0xAA,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,
1213 0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xD2,0xD3,0xD4,0xD5,0xD6,
1214 0xD7,0xD8,0xD9,0xDA,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,
1215 0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA
1216 }
1217 };
1218
1219 static const struct huffman_table chroma_table =
1220 {
1221 {
1222 0x00,0x03,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x00,0x00,0x00,
1223 0x00,0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B
1224 },
1225 {
1226 0x00,0x02,0x01,0x02,0x04,0x04,0x03,0x04,0x07,0x05,0x04,0x04,0x00,0x01,
1227 0x02,0x77,0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,
1228 0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91,0xA1,0xB1,
1229 0xC1,0x09,0x23,0x33,0x52,0xF0,0x15,0x62,0x72,0xD1,0x0A,0x16,0x24,0x34,
1230 0xE1,0x25,0xF1,0x17,0x18,0x19,0x1A,0x26,0x27,0x28,0x29,0x2A,0x35,0x36,
1231 0x37,0x38,0x39,0x3A,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x53,0x54,
1232 0x55,0x56,0x57,0x58,0x59,0x5A,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,
1233 0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x82,0x83,0x84,0x85,0x86,0x87,
1234 0x88,0x89,0x8A,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0xA2,0xA3,
1235 0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,
1236 0xB9,0xBA,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xD2,0xD3,0xD4,
1237 0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,
1238 0xEA,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA
1239 }
1240 };
1241
1242 static void default_huff_tbl(struct jpeg* p_jpeg)
1243 {
1244
1245 MEMCPY(&p_jpeg->hufftable[0], &luma_table, sizeof(luma_table));
1246 MEMCPY(&p_jpeg->hufftable[1], &chroma_table, sizeof(chroma_table));
1247
1248 return;
1249 }
1250
1251 /* Compute the derived values for a Huffman table */
1252 static void fix_huff_tbl(int* htbl, struct derived_tbl* dtbl)
1253 {
1254 int p, i, l, si;
1255 int lookbits, ctr;
1256 char huffsize[257];
1257 unsigned int huffcode[257];
1258 unsigned int code;
1259
1260 dtbl->pub = htbl; /* fill in back link */
1261
1262 /* Figure C.1: make table of Huffman code length for each symbol */
1263 /* Note that this is in code-length order. */
1264
1265 p = 0;
1266 for (l = 1; l <= 16; l++)
1267 { /* all possible code length */
1268 for (i = 1; i <= (int) htbl[l-1]; i++) /* all codes per length */
1269 huffsize[p++] = (char) l;
1270 }
1271 huffsize[p] = 0;
1272
1273 /* Figure C.2: generate the codes themselves */
1274 /* Note that this is in code-length order. */
1275
1276 code = 0;
1277 si = huffsize[0];
1278 p = 0;
1279 while (huffsize[p])
1280 {
1281 while (((int) huffsize[p]) == si)
1282 {
1283 huffcode[p++] = code;
1284 code++;
1285 }
1286 code <<= 1;
1287 si++;
1288 }
1289
1290 /* Figure F.15: generate decoding tables for bit-sequential decoding */
1291
1292 p = 0;
1293 for (l = 1; l <= 16; l++)
1294 {
1295 if (htbl[l-1])
1296 {
1297 /* huffval[] index of 1st symbol of code length l */
1298 dtbl->valptr[l] = p;
1299 dtbl->mincode[l] = huffcode[p]; /* minimum code of length l */
1300 p += htbl[l-1];
1301 dtbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */
1302 }
1303 else
1304 {
1305 dtbl->maxcode[l] = -1; /* -1 if no codes of this length */
1306 }
1307 }
1308 dtbl->maxcode[17] = 0xFFFFFL; /* ensures huff_DECODE terminates */
1309
1310 /* Compute lookahead tables to speed up decoding.
1311 * First we set all the table entries to 0, indicating "too long";
1312 * then we iterate through the Huffman codes that are short enough and
1313 * fill in all the entries that correspond to bit sequences starting
1314 * with that code.
1315 */
1316
1317 MEMSET(dtbl->look_nbits, 0, sizeof(dtbl->look_nbits));
1318
1319 p = 0;
1320 for (l = 1; l <= HUFF_LOOKAHEAD; l++)
1321 {
1322 for (i = 1; i <= (int) htbl[l-1]; i++, p++)
1323 {
1324 /* l = current code's length, p = its index in huffcode[] &
1325 * huffval[]. Generate left-justified code followed by all possible
1326 * bit sequences
1327 */
1328 lookbits = huffcode[p] << (HUFF_LOOKAHEAD-l);
1329 for (ctr = 1 << (HUFF_LOOKAHEAD-l); ctr > 0; ctr--)
1330 {
1331 dtbl->look_nbits[lookbits] = l;
1332 dtbl->look_sym[lookbits] = htbl[16+p];
1333 lookbits++;
1334 }
1335 }
1336 }
1337 }
1338
1339
1340 /* zag[i] is the natural-order position of the i'th element of zigzag order.
1341 * If the incoming data is corrupted, decode_mcu could attempt to
1342 * reference values beyond the end of the array. To avoid a wild store,
1343 * we put some extra zeroes after the real entries.
1344 */
1345 static const unsigned char zag[] =
1346 {
1347 0, 1, 8, 16, 9, 2, 3, 10,
1348 17, 24, 32, 25, 18, 11, 4, 5,
1349 12, 19, 26, 33, 40, 48, 41, 34,
1350 27, 20, 13, 6, 7, 14, 21, 28,
1351 35, 42, 49, 56, 57, 50, 43, 36,
1352 29, 22, 15, 23, 30, 37, 44, 51,
1353 58, 59, 52, 45, 38, 31, 39, 46,
1354 53, 60, 61, 54, 47, 55, 62, 63,
1355 0, 0, 0, 0, 0, 0, 0, 0, /* extra entries in case k>63 below */
1356 0, 0, 0, 0, 0, 0, 0, 0
1357 };
1358
1359 /* zig[i] is the the zig-zag order position of the i'th element of natural
1360 * order, reading left-to-right then top-to-bottom.
1361 */
1362 static const unsigned char zig[] =
1363 {
1364 0, 1, 5, 6, 14, 15, 27, 28,
1365 2, 4, 7, 13, 16, 26, 29, 42,
1366 3, 8, 12, 17, 25, 30, 41, 43,
1367 9, 11, 18, 24, 31, 40, 44, 53,
1368 10, 19, 23, 32, 39, 45, 52, 54,
1369 20, 22, 33, 38, 46, 51, 55, 60,
1370 21, 34, 37, 47, 50, 56, 59, 61,
1371 35, 36, 48, 49, 57, 58, 62, 63
1372 };
1373
1374 /* Reformat some image header data so that the decoder can use it properly. */
1375 INLINE void fix_headers(struct jpeg* p_jpeg)
1376 {
1377 int i;
1378
1379 for (i=0; i<4; i++)
1380 p_jpeg->store_pos[i] = i; /* default ordering */
1381
1382 /* assignments for the decoding of blocks */
1383 if (p_jpeg->frameheader[0].horizontal_sampling == 2
1384 && p_jpeg->frameheader[0].vertical_sampling == 1)
1385 { /* 4:2:2 */
1386 p_jpeg->blocks = 4;
1387 p_jpeg->x_mbl = (p_jpeg->x_size+15) / 16;
1388 p_jpeg->x_phys = p_jpeg->x_mbl * 16;
1389 p_jpeg->y_mbl = (p_jpeg->y_size+7) / 8;
1390 p_jpeg->y_phys = p_jpeg->y_mbl * 8;
1391 p_jpeg->mcu_membership[0] = 0; /* Y1=Y2=0, U=1, V=2 */
1392 p_jpeg->mcu_membership[1] = 0;
1393 p_jpeg->mcu_membership[2] = 1;
1394 p_jpeg->mcu_membership[3] = 2;
1395 p_jpeg->tab_membership[0] = 0; /* DC, DC, AC, AC */
1396 p_jpeg->tab_membership[1] = 0;
1397 p_jpeg->tab_membership[2] = 1;
1398 p_jpeg->tab_membership[3] = 1;
1399 p_jpeg->subsample_x[0] = 1;
1400 p_jpeg->subsample_x[1] = 2;
1401 p_jpeg->subsample_x[2] = 2;
1402 p_jpeg->subsample_y[0] = 1;
1403 p_jpeg->subsample_y[1] = 1;
1404 p_jpeg->subsample_y[2] = 1;
1405 }
1406 if (p_jpeg->frameheader[0].horizontal_sampling == 1
1407 && p_jpeg->frameheader[0].vertical_sampling == 2)
1408 { /* 4:2:2 vertically subsampled */
1409 p_jpeg->store_pos[1] = 2; /* block positions are mirrored */
1410 p_jpeg->store_pos[2] = 1;
1411 p_jpeg->blocks = 4;
1412 p_jpeg->x_mbl = (p_jpeg->x_size+7) / 8;
1413 p_jpeg->x_phys = p_jpeg->x_mbl * 8;
1414 p_jpeg->y_mbl = (p_jpeg->y_size+15) / 16;
1415 p_jpeg->y_phys = p_jpeg->y_mbl * 16;
1416 p_jpeg->mcu_membership[0] = 0; /* Y1=Y2=0, U=1, V=2 */
1417 p_jpeg->mcu_membership[1] = 0;
1418 p_jpeg->mcu_membership[2] = 1;
1419 p_jpeg->mcu_membership[3] = 2;
1420 p_jpeg->tab_membership[0] = 0; /* DC, DC, AC, AC */
1421 p_jpeg->tab_membership[1] = 0;
1422 p_jpeg->tab_membership[2] = 1;
1423 p_jpeg->tab_membership[3] = 1;
1424 p_jpeg->subsample_x[0] = 1;
1425 p_jpeg->subsample_x[1] = 1;
1426 p_jpeg->subsample_x[2] = 1;
1427 p_jpeg->subsample_y[0] = 1;
1428 p_jpeg->subsample_y[1] = 2;
1429 p_jpeg->subsample_y[2] = 2;
1430 }
1431 else if (p_jpeg->frameheader[0].horizontal_sampling == 2
1432 && p_jpeg->frameheader[0].vertical_sampling == 2)
1433 { /* 4:2:0 */
1434 p_jpeg->blocks = 6;
1435 p_jpeg->x_mbl = (p_jpeg->x_size+15) / 16;
1436 p_jpeg->x_phys = p_jpeg->x_mbl * 16;
1437 p_jpeg->y_mbl = (p_jpeg->y_size+15) / 16;
1438 p_jpeg->y_phys = p_jpeg->y_mbl * 16;
1439 p_jpeg->mcu_membership[0] = 0;
1440 p_jpeg->mcu_membership[1] = 0;
1441 p_jpeg->mcu_membership[2] = 0;
1442 p_jpeg->mcu_membership[3] = 0;
1443 p_jpeg->mcu_membership[4] = 1;
1444 p_jpeg->mcu_membership[5] = 2;
1445 p_jpeg->tab_membership[0] = 0;
1446 p_jpeg->tab_membership[1] = 0;
1447 p_jpeg->tab_membership[2] = 0;
1448 p_jpeg->tab_membership[3] = 0;
1449 p_jpeg->tab_membership[4] = 1;
1450 p_jpeg->tab_membership[5] = 1;
1451 p_jpeg->subsample_x[0] = 1;
1452 p_jpeg->subsample_x[1] = 2;
1453 p_jpeg->subsample_x[2] = 2;
1454 p_jpeg->subsample_y[0] = 1;
1455 p_jpeg->subsample_y[1] = 2;
1456 p_jpeg->subsample_y[2] = 2;
1457 }
1458 else if (p_jpeg->frameheader[0].horizontal_sampling == 1
1459 && p_jpeg->frameheader[0].vertical_sampling == 1)
1460 { /* 4:4:4 */
1461 /* don't overwrite p_jpeg->blocks */
1462 p_jpeg->x_mbl = (p_jpeg->x_size+7) / 8;
1463 p_jpeg->x_phys = p_jpeg->x_mbl * 8;
1464 p_jpeg->y_mbl = (p_jpeg->y_size+7) / 8;
1465 p_jpeg->y_phys = p_jpeg->y_mbl * 8;
1466 p_jpeg->mcu_membership[0] = 0;
1467 p_jpeg->mcu_membership[1] = 1;
1468 p_jpeg->mcu_membership[2] = 2;
1469 p_jpeg->tab_membership[0] = 0;
1470 p_jpeg->tab_membership[1] = 1;
1471 p_jpeg->tab_membership[2] = 1;
1472 p_jpeg->subsample_x[0] = 1;
1473 p_jpeg->subsample_x[1] = 1;
1474 p_jpeg->subsample_x[2] = 1;
1475 p_jpeg->subsample_y[0] = 1;
1476 p_jpeg->subsample_y[1] = 1;
1477 p_jpeg->subsample_y[2] = 1;
1478 }
1479 else
1480 {
1481 /* error */
1482 }
1483
1484 }
1485
1486 INLINE void fix_huff_tables(struct jpeg *p_jpeg)
1487 {
1488 fix_huff_tbl(p_jpeg->hufftable[0].huffmancodes_dc,
1489 &p_jpeg->dc_derived_tbls[0]);
1490 fix_huff_tbl(p_jpeg->hufftable[0].huffmancodes_ac,
1491 &p_jpeg->ac_derived_tbls[0]);
1492 fix_huff_tbl(p_jpeg->hufftable[1].huffmancodes_dc,
1493 &p_jpeg->dc_derived_tbls[1]);
1494 fix_huff_tbl(p_jpeg->hufftable[1].huffmancodes_ac,
1495 &p_jpeg->ac_derived_tbls[1]);
1496 }
1497
1498 /* Because some of the IDCT routines never multiply by any constants, and
1499 * therefore do not produce shifted output, we add the shift into the
1500 * quantization table when one of these IDCT routines is used, rather than
1501 * have the IDCT shift each value it processes.
1502 */
1503 INLINE void fix_quant_tables(struct jpeg *p_jpeg)
1504 {
1505 int shift, i, x, y, a;
1506 for (i = 0; i < 2; i++)
1507 {
1508 shift = idct_tbl[p_jpeg->v_scale[i]].v_scale +
1509 idct_tbl[p_jpeg->h_scale[i]].h_scale;
1510 if (shift)
1511 {
1512 a = 0;
1513 for (y = 0; y < 1 << p_jpeg->h_scale[i]; y++)
1514 {
1515 for (x = 0; x < 1 << p_jpeg->v_scale[i]; x++)
1516 p_jpeg->quanttable[i][zig[a+x]] <<= shift;
1517 a += 8;
1518 }
1519 }
1520 }
1521 }
1522
1523 /*
1524 * These functions/macros provide the in-line portion of bit fetching.
1525 * Use check_bit_buffer to ensure there are N bits in get_buffer
1526 * before using get_bits, peek_bits, or drop_bits.
1527 * check_bit_buffer(state,n,action);
1528 * Ensure there are N bits in get_buffer; if suspend, take action.
1529 * val = get_bits(n);
1530 * Fetch next N bits.
1531 * val = peek_bits(n);
1532 * Fetch next N bits without removing them from the buffer.
1533 * drop_bits(n);
1534 * Discard next N bits.
1535 * The value N should be a simple variable, not an expression, because it
1536 * is evaluated multiple times.
1537 */
1538
1539 static void fill_bit_buffer(struct jpeg* p_jpeg)
1540 {
1541 unsigned char byte, marker;
1542
1543 if (p_jpeg->marker_val)
1544 p_jpeg->marker_ind += 16;
1545 byte = d_getc(p_jpeg, 0);
1546 if (byte == 0xFF) /* legal marker can be byte stuffing or RSTm */
1547 { /* simplification: just skip the (one-byte) marker code */
1548 marker = d_getc(p_jpeg, 0);
1549 if ((marker & ~7) == 0xD0)
1550 {
1551 p_jpeg->marker_val = marker;
1552 p_jpeg->marker_ind = 8;
1553 }
1554 }
1555 p_jpeg->bitbuf = (p_jpeg->bitbuf << 8) | byte;
1556
1557 byte = d_getc(p_jpeg, 0);
1558 if (byte == 0xFF) /* legal marker can be byte stuffing or RSTm */
1559 { /* simplification: just skip the (one-byte) marker code */
1560 marker = d_getc(p_jpeg, 0);
1561 if ((marker & ~7) == 0xD0)
1562 {
1563 p_jpeg->marker_val = marker;
1564 p_jpeg->marker_ind = 0;
1565 }
1566 }
1567 p_jpeg->bitbuf = (p_jpeg->bitbuf << 8) | byte;
1568 p_jpeg->bitbuf_bits += 16;
1569 #ifdef JPEG_BS_DEBUG
1570 DEBUGF("read in: %X\n", p_jpeg->bitbuf & 0xFFFF);
1571 #endif
1572 }
1573
1574 INLINE void check_bit_buffer(struct jpeg *p_jpeg, int nbits)
1575 {
1576 if (nbits > p_jpeg->bitbuf_bits)
1577 fill_bit_buffer(p_jpeg);
1578 }
1579
1580 INLINE int get_bits(struct jpeg *p_jpeg, int nbits)
1581 {
1582 #ifdef JPEG_BS_DEBUG
1583 if (nbits > p_jpeg->bitbuf_bits)
1584 DEBUGF("bitbuffer underrun\n");
1585 int mask = 1 << (p_jpeg->bitbuf_bits - 1);
1586 int i;
1587 DEBUGF("get %d bits: ", nbits);
1588 for (i = 0; i < nbits; i++)
1589 DEBUGF("%d",!!(p_jpeg->bitbuf & (mask >>= 1)));
1590 DEBUGF("\n");
1591 #endif
1592 return ((int) (p_jpeg->bitbuf >> (p_jpeg->bitbuf_bits -= nbits))) &
1593 ((1<<nbits)-1);
1594 }
1595
1596 INLINE int peek_bits(struct jpeg *p_jpeg, int nbits)
1597 {
1598 #ifdef JPEG_BS_DEBUG
1599 int mask = 1 << (p_jpeg->bitbuf_bits - 1);
1600 int i;
1601 DEBUGF("peek %d bits: ", nbits);
1602 for (i = 0; i < nbits; i++)
1603 DEBUGF("%d",!!(p_jpeg->bitbuf & (mask >>= 1)));
1604 DEBUGF("\n");
1605 #endif
1606 return ((int) (p_jpeg->bitbuf >> (p_jpeg->bitbuf_bits - nbits))) &
1607 ((1<<nbits)-1);
1608 }
1609
1610 INLINE void drop_bits(struct jpeg *p_jpeg, int nbits)
1611 {
1612 #ifdef JPEG_BS_DEBUG
1613 int mask = 1 << (p_jpeg->bitbuf_bits - 1);
1614 int i;
1615 DEBUGF("drop %d bits: ", nbits);
1616 for (i = 0; i < nbits; i++)
1617 DEBUGF("%d",!!(p_jpeg->bitbuf & (mask >>= 1)));
1618 DEBUGF("\n");
1619 #endif
1620 p_jpeg->bitbuf_bits -= nbits;
1621 }
1622
1623 /* re-synchronize to entropy data (skip restart marker) */
1624 static void search_restart(struct jpeg *p_jpeg)
1625 {
1626 if (p_jpeg->marker_val)
1627 {
1628 p_jpeg->marker_val = 0;
1629 p_jpeg->bitbuf_bits = p_jpeg->marker_ind;
1630 p_jpeg->marker_ind = 0;
1631 return;
1632 }
1633 unsigned char byte;
1634 p_jpeg->bitbuf_bits = 0;
1635 while ((byte = d_getc(p_jpeg, 0xFF)))
1636 {
1637 if (byte == 0xff)
1638 {
1639 byte = d_getc(p_jpeg, 0xD0);
1640 if ((byte & ~7) == 0xD0)
1641 {
1642 return;
1643 }
1644 else
1645 putc(p_jpeg);
1646 }
1647 }
1648 }
1649
1650 /* Figure F.12: extend sign bit. */
1651 #if CONFIG_CPU == SH7034
1652 /* SH1 lacks a variable-shift instruction */
1653 #define HUFF_EXTEND(x,s) ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
1654
1655 static const int extend_test[16] = /* entry n is 2**(n-1) */
1656 {
1657 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
1658 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000
1659 };
1660
1661 static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */
1662 {
1663 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1,
1664 ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1,
1665 ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1,
1666 ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1
1667 };
1668 #else
1669 /* This saves some code and data size, benchmarks about the same on RAM */
1670 #define HUFF_EXTEND(x,s) \
1671 ({ \
1672 int x__ = x; \
1673 int s__ = s; \
1674 x__ & (1 << (s__- 1)) ? x__ : x__ + (-1 << s__) + 1; \
1675 })
1676 #endif
1677
1678 /* Decode a single value */
1679 #define huff_decode_dc(p_jpeg, tbl, s, r) \
1680 { \
1681 int nb, look; \
1682 \
1683 check_bit_buffer((p_jpeg), HUFF_LOOKAHEAD); \
1684 look = peek_bits((p_jpeg), HUFF_LOOKAHEAD); \
1685 if ((nb = (tbl)->look_nbits[look]) != 0) \
1686 { \
1687 drop_bits((p_jpeg), nb); \
1688 s = (tbl)->look_sym[look]; \
1689 check_bit_buffer((p_jpeg), s); \
1690 r = get_bits((p_jpeg), s); \
1691 } else { \
1692 /* slow_DECODE(s, HUFF_LOOKAHEAD+1)) < 0); */ \
1693 long code; \
1694 nb=HUFF_LOOKAHEAD+1; \
1695 check_bit_buffer((p_jpeg), nb); \
1696 code = get_bits((p_jpeg), nb); \
1697 while (code > (tbl)->maxcode[nb]) \
1698 { \
1699 code <<= 1; \
1700 check_bit_buffer((p_jpeg), 1); \
1701 code |= get_bits((p_jpeg), 1); \
1702 nb++; \
1703 } \
1704 if (nb > 16) /* error in Huffman */ \
1705 { \
1706 r = 0; s = 0; /* fake a zero, this is most safe */ \
1707 } else { \
1708 s = (tbl)->pub[16 + (tbl)->valptr[nb] + \
1709 ((int) (code - (tbl)->mincode[nb]))]; \
1710 check_bit_buffer((p_jpeg), s); \
1711 r = get_bits((p_jpeg), s); \
1712 } \
1713 } /* end slow decode */ \
1714 }
1715
1716 #define huff_decode_ac(p_jpeg, tbl, s) \
1717 { \
1718 int nb, look; \
1719 \
1720 check_bit_buffer((p_jpeg), HUFF_LOOKAHEAD); \
1721 look = peek_bits((p_jpeg), HUFF_LOOKAHEAD); \
1722 if ((nb = (tbl)->look_nbits[look]) != 0) \
1723 { \
1724 drop_bits((p_jpeg), nb); \
1725 s = (tbl)->look_sym[look]; \
1726 } else { \
1727 /* slow_DECODE(s, HUFF_LOOKAHEAD+1)) < 0); */ \
1728 long code; \
1729 nb=HUFF_LOOKAHEAD+1; \
1730 check_bit_buffer((p_jpeg), nb); \
1731 code = get_bits((p_jpeg), nb); \
1732 while (code > (tbl)->maxcode[nb]) \
1733 { \
1734 code <<= 1; \
1735 check_bit_buffer((p_jpeg), 1); \
1736 code |= get_bits((p_jpeg), 1); \
1737 nb++; \
1738 } \
1739 if (nb > 16) /* error in Huffman */ \
1740 { \
1741 s = 0; /* fake a zero, this is most safe */ \
1742 } else { \
1743 s = (tbl)->pub[16 + (tbl)->valptr[nb] + \
1744 ((int) (code - (tbl)->mincode[nb]))]; \
1745 } \
1746 } /* end slow decode */ \
1747 }
1748
1749 static struct img_part *store_row_jpeg(void *jpeg_args)
1750 {
1751 struct jpeg *p_jpeg = (struct jpeg*) jpeg_args;
1752 #ifdef HAVE_LCD_COLOR
1753 int mcu_hscale = p_jpeg->h_scale[1];
1754 int mcu_vscale = p_jpeg->v_scale[1];
1755 #else
1756 int mcu_hscale = (p_jpeg->h_scale[0] +
1757 p_jpeg->frameheader[0].horizontal_sampling - 1);
1758 int mcu_vscale = (p_jpeg->v_scale[0] +
1759 p_jpeg->frameheader[0].vertical_sampling - 1);
1760 #endif
1761 unsigned int width = p_jpeg->x_mbl << mcu_hscale;
1762 unsigned int b_width = width * JPEG_PIX_SZ;
1763 int height = 1U << mcu_vscale;
1764 int x;
1765 if (!p_jpeg->mcu_row) /* Need to decode a new row of MCUs */
1766 {
1767 p_jpeg->out_ptr = (unsigned char *)p_jpeg->img_buf;
1768 int store_offs[4];
1769 #ifdef HAVE_LCD_COLOR
1770 unsigned mcu_width = 1U << mcu_hscale;
1771 #endif
1772 int mcu_offset = JPEG_PIX_SZ << mcu_hscale;
1773 unsigned char *out = p_jpeg->out_ptr;
1774 store_offs[p_jpeg->store_pos[0]] = 0;
1775 store_offs[p_jpeg->store_pos[1]] = JPEG_PIX_SZ << p_jpeg->h_scale[0];
1776 store_offs[p_jpeg->store_pos[2]] = b_width << p_jpeg->v_scale[0];
1777 store_offs[p_jpeg->store_pos[3]] = store_offs[1] + store_offs[2];
1778
1779 int block[128]; /* decoded DCT coefficients */
1780 for (x = 0; x < p_jpeg->x_mbl; x++)
1781 {
1782 int blkn;
1783 for (blkn = 0; blkn < p_jpeg->blocks; blkn++)
1784 {
1785 int k = 1; /* coefficient index */
1786 int s, r; /* huffman values */
1787 int ci = p_jpeg->mcu_membership[blkn]; /* component index */
1788 int ti = p_jpeg->tab_membership[blkn]; /* table index */
1789 struct derived_tbl* dctbl = &p_jpeg->dc_derived_tbls[ti];
1790 struct derived_tbl* actbl = &p_jpeg->ac_derived_tbls[ti];
1791
1792 /* Section F.2.2.1: decode the DC coefficient difference */
1793 huff_decode_dc(p_jpeg, dctbl, s, r);
1794
1795 #ifndef HAVE_LCD_COLOR
1796 if (!ci)
1797 #endif
1798 {
1799 s = HUFF_EXTEND(r, s);
1800 #ifdef HAVE_LCD_COLOR
1801 p_jpeg->last_dc_val[ci] += s;
1802 /* output it (assumes zag[0] = 0) */
1803 block[0] = p_jpeg->last_dc_val[ci] *
1804 p_jpeg->quanttable[!!ci][0];
1805 #else
1806 p_jpeg->last_dc_val += s;
1807 /* output it (assumes zag[0] = 0) */
1808 block[0] = p_jpeg->last_dc_val *
1809 p_jpeg->quanttable[0][0];
1810 #endif
1811 /* coefficient buffer must be cleared */
1812 MEMSET(block+1, 0, p_jpeg->zero_need[!!ci] * sizeof(int));
1813 /* Section F.2.2.2: decode the AC coefficients */
1814 for (; k < p_jpeg->k_need[!!ci]; k++)
1815 {
1816 huff_decode_ac(p_jpeg, actbl, s);
1817 r = s >> 4;
1818 s &= 15;
1819 if (s)
1820 {
1821 k += r;
1822 check_bit_buffer(p_jpeg, s);
1823 r = get_bits(p_jpeg, s);
1824 r = HUFF_EXTEND(r, s);
1825 int a = zag[k];
1826 if (a <= zag[p_jpeg->k_need[!!ci]] && (a & 7) <=
1827 (zag[p_jpeg->k_need[!!ci]] & 7))
1828 {
1829 r *= p_jpeg->quanttable[!!ci][k];
1830 block[zag[k]] = r ;
1831 }
1832 }
1833 else
1834 {
1835 if (r != 15)
1836 {
1837 k = 64;
1838 break;
1839 }
1840 k += r;
1841 }
1842 } /* for k */
1843 }
1844 for (; k < 64; k++)
1845 {
1846 huff_decode_ac(p_jpeg, actbl, s);
1847 r = s >> 4;
1848 s &= 15;
1849
1850 if (s)
1851 {
1852 k += r;
1853 check_bit_buffer(p_jpeg, s);
1854 drop_bits(p_jpeg, s);
1855 }
1856 else
1857 {
1858 if (r != 15)
1859 break;
1860 k += r;
1861 }
1862 } /* for k */
1863 #ifndef HAVE_LCD_COLOR
1864 if (!ci)
1865 #endif
1866 {
1867 int idct_cols = 1 << MIN(p_jpeg->h_scale[!!ci], 3);
1868 int idct_rows = 1 << p_jpeg->v_scale[!!ci];
1869 unsigned char *b_out = out + (ci ? ci : store_offs[blkn]);
1870 if (idct_tbl[p_jpeg->v_scale[!!ci]].v_idct)
1871 idct_tbl[p_jpeg->v_scale[!!ci]].v_idct(block, idct_cols);
1872 idct_tbl[p_jpeg->h_scale[!!ci]].h_idct(block, b_out,
1873 idct_rows, b_width);
1874 }
1875 } /* for blkn */
1876 /* don't starve other threads while an MCU row decodes */
1877 yield();
1878 #ifdef HAVE_LCD_COLOR
1879 unsigned int xp;
1880 int yp;
1881 unsigned char *row = out;
1882 if (p_jpeg->blocks == 1)
1883 {
1884 for (yp = 0; yp < height; yp++, row += b_width)
1885 {
1886 unsigned char *px = row;
1887 for (xp = 0; xp < mcu_width; xp++, px += JPEG_PIX_SZ)
1888 {
1889 px[1] = px[2] = px[0];
1890 }
1891 }
1892 }
1893 #endif
1894 out += mcu_offset;
1895 if (p_jpeg->restart_interval && --p_jpeg->restart == 0)
1896 { /* if a restart marker is due: */
1897 p_jpeg->restart = p_jpeg->restart_interval; /* count again */
1898 search_restart(p_jpeg); /* align the bitstream */
1899 #ifdef HAVE_LCD_COLOR
1900 p_jpeg->last_dc_val[0] = p_jpeg->last_dc_val[1] =
1901 p_jpeg->last_dc_val[2] = 0; /* reset decoder */
1902 #else
1903 p_jpeg->last_dc_val = 0;
1904 #endif
1905 }
1906 }
1907 } /* if !p_jpeg->mcu_row */
1908 p_jpeg->mcu_row = (p_jpeg->mcu_row + 1) & (height - 1);
1909 p_jpeg->part.len = width;
1910 p_jpeg->part.buf = (jpeg_pix_t *)p_jpeg->out_ptr;
1911 p_jpeg->out_ptr += b_width;
1912 return &(p_jpeg->part);
1913 }
1914
1915 /******************************************************************************
1916 * read_jpeg_file()
1917 *
1918 * Reads a JPEG file and puts the data in rockbox format in *bitmap.
1919 *
1920 *****************************************************************************/
1921 #ifndef JPEG_FROM_MEM
1922 int read_jpeg_file(const char* filename,
1923 struct bitmap *bm,
1924 int maxsize,
1925 int format,
1926 const struct custom_format *cformat)
1927 {
1928 int fd, ret;
1929 fd = open(filename, O_RDONLY);
1930
1931 /* Exit if file opening failed */
1932 if (fd < 0) {
1933 DEBUGF("read_jpeg_file: can't open '%s', rc: %d\n", filename, fd);
1934 return fd * 10 - 1;
1935 }
1936
1937 ret = read_jpeg_fd(fd, bm, maxsize, format, cformat);
1938 close(fd);
1939 return ret;
1940 }
1941 #endif
1942
1943 static int calc_scale(int in_size, int out_size)
1944 {
1945 int scale = 0;
1946 out_size <<= 3;
1947 for (scale = 0; scale < 3; scale++)
1948 {
1949 if (out_size <= in_size)
1950 break;
1951 else
1952 in_size <<= 1;
1953 }
1954 return scale;
1955 }
1956
1957 #ifdef JPEG_FROM_MEM
1958 int get_jpeg_dim_mem(unsigned char *data, unsigned long len,
1959 struct dim *size)
1960 {
1961 struct jpeg *p_jpeg = &jpeg;
1962 memset(p_jpeg, 0, sizeof(struct jpeg));
1963 p_jpeg->data = data;
1964 p_jpeg->len = len;
1965 int status = process_markers(p_jpeg);
1966 if (status < 0)
1967 return status;
1968 if ((status & (DQT | SOF0)) != (DQT | SOF0))
1969 return -(status * 16);
1970 size->width = p_jpeg->x_size;
1971 size->height = p_jpeg->y_size;
1972 return 0;
1973 }
1974
1975 int decode_jpeg_mem(unsigned char *data, unsigned long len,
1976 #else
1977 int read_jpeg_fd(int fd,
1978 #endif
1979 struct bitmap *bm,
1980 int maxsize,
1981 int format,
1982 const struct custom_format *cformat)
1983 {
1984 bool resize = false, dither = false;
1985 struct rowset rset;
1986 struct dim src_dim;
1987 int status;
1988 int bm_size;
1989 #ifdef JPEG_FROM_MEM
1990 struct jpeg *p_jpeg = &jpeg;
1991 #else
1992 struct jpeg *p_jpeg = (struct jpeg*)bm->data;
1993 int tmp_size = maxsize;
1994 ALIGN_BUFFER(p_jpeg, tmp_size, sizeof(int));
1995 /* not enough memory for our struct jpeg */
1996 if ((size_t)tmp_size < sizeof(struct jpeg))
1997 return -1;
1998 #endif
1999 memset(p_jpeg, 0, sizeof(struct jpeg));
2000 #ifdef JPEG_FROM_MEM
2001 p_jpeg->data = data;
2002 p_jpeg->len = len;
2003 #else
2004 p_jpeg->fd = fd;
2005 #endif
2006 status = process_markers(p_jpeg);
2007 if (status < 0)
2008 return status;
2009 if ((status & (DQT | SOF0)) != (DQT | SOF0))
2010 return -(status * 16);
2011 if (!(status & DHT)) /* if no Huffman table present: */
2012 default_huff_tbl(p_jpeg); /* use default */
2013 fix_headers(p_jpeg); /* derive Huffman and other lookup-tables */
2014 src_dim.width = p_jpeg->x_size;
2015 src_dim.height = p_jpeg->y_size;
2016 if (format & FORMAT_RESIZE)
2017 resize = true;
2018 if (format & FORMAT_DITHER)
2019 dither = true;
2020 if (resize) {
2021 struct dim resize_dim = {
2022 .width = bm->width,
2023 .height = bm->height,
2024 };
2025 if (format & FORMAT_KEEP_ASPECT)
2026 recalc_dimension(&resize_dim, &src_dim);
2027 bm->width = resize_dim.width;
2028 bm->height = resize_dim.height;
2029 } else {
2030 bm->width = p_jpeg->x_size;
2031 bm->height = p_jpeg->y_size;
2032 }
2033 p_jpeg->h_scale[0] = calc_scale(p_jpeg->x_size, bm->width);
2034 p_jpeg->v_scale[0] = calc_scale(p_jpeg->y_size, bm->height);
2035 if ((p_jpeg->x_size << p_jpeg->h_scale[0]) >> 3 &&
2036 (p_jpeg->y_size << p_jpeg->v_scale[0]) >> 3)
2037 resize = false;
2038 #ifdef HAVE_LCD_COLOR
2039 p_jpeg->h_scale[1] = p_jpeg->h_scale[0] +
2040 p_jpeg->frameheader[0].horizontal_sampling - 1;
2041 p_jpeg->v_scale[1] = p_jpeg->v_scale[0] +
2042 p_jpeg->frameheader[0].vertical_sampling - 1;
2043 #endif
2044 fix_quant_tables(p_jpeg);
2045 int decode_w = (1 << p_jpeg->h_scale[0]) - 1;
2046 int decode_h = (1 << p_jpeg->v_scale[0]) - 1;
2047 src_dim.width = (p_jpeg->x_size << p_jpeg->h_scale[0]) >> 3;
2048 src_dim.height = (p_jpeg->y_size << p_jpeg->v_scale[0]) >> 3;
2049 p_jpeg->zero_need[0] = (decode_h << 3) + decode_w;
2050 p_jpeg->k_need[0] = zig[p_jpeg->zero_need[0]];
2051 #ifdef HAVE_LCD_COLOR
2052 decode_w = (1 << MIN(p_jpeg->h_scale[1],3)) - 1;
2053 decode_h = (1 << MIN(p_jpeg->v_scale[1],3)) - 1;
2054 p_jpeg->zero_need[1] = (decode_h << 3) + decode_w;
2055 p_jpeg->k_need[1] = zig[p_jpeg->zero_need[1]];
2056 #endif
2057 if (cformat)
2058 bm_size = cformat->get_size(bm);
2059 else
2060 bm_size = BM_SIZE(bm->width,bm->height,FORMAT_NATIVE,false);
2061 if (bm_size > maxsize)
2062 return -1;
2063 char *buf_start = (char *)bm->data + bm_size;
2064 char *buf_end = (char *)bm->data + maxsize;
2065 maxsize = buf_end - buf_start;
2066 #ifndef JPEG_FROM_MEM
2067 ALIGN_BUFFER(buf_start, maxsize, sizeof(uint32_t));
2068 if (maxsize < (int)sizeof(struct jpeg))
2069 return -1;
2070 memmove(buf_start, p_jpeg, sizeof(struct jpeg));
2071 p_jpeg = (struct jpeg *)buf_start;
2072 buf_start += sizeof(struct jpeg);
2073 maxsize = buf_end - buf_start;
2074 #endif
2075 fix_huff_tables(p_jpeg);
2076 #ifdef HAVE_LCD_COLOR
2077 int decode_buf_size = (p_jpeg->x_mbl << p_jpeg->h_scale[1])
2078 << p_jpeg->v_scale[1];
2079 #else
2080 int decode_buf_size = (p_jpeg->x_mbl << p_jpeg->h_scale[0])
2081 << p_jpeg->v_scale[0];
2082 decode_buf_size <<= p_jpeg->frameheader[0].horizontal_sampling +
2083 p_jpeg->frameheader[0].vertical_sampling - 2;
2084 #endif
2085 decode_buf_size *= JPEG_PIX_SZ;
2086 p_jpeg->img_buf = (jpeg_pix_t *)buf_start;
2087 if (buf_end - buf_start < decode_buf_size)
2088 return -1;
2089 buf_start += decode_buf_size;
2090 maxsize = buf_end - buf_start;
2091 memset(p_jpeg->img_buf, 0, decode_buf_size);
2092 p_jpeg->mcu_row = 0;
2093 p_jpeg->restart = p_jpeg->restart_interval;
2094 rset.rowstart = 0;
2095 rset.rowstop = bm->height;
2096 rset.rowstep = 1;
2097 p_jpeg->resize = resize;
2098 if (resize)
2099 {
2100 if (resize_on_load(bm, dither, &src_dim, &rset, buf_start, maxsize,
2101 cformat, IF_PIX_FMT(p_jpeg->blocks == 1 ? 0 : 1,) store_row_jpeg,
2102 p_jpeg))
2103 return bm_size;
2104 } else {
2105 int row;
2106 struct scaler_context ctx = {
2107 .bm = bm,
2108 .dither = dither,
2109 };
2110 #if LCD_DEPTH > 1
2111 void (*output_row_8)(uint32_t, void*, struct scaler_context*) =
2112 output_row_8_native;
2113 #elif defined(PLUGIN)
2114 void (*output_row_8)(uint32_t, void*, struct scaler_context*) = NULL;
2115 #endif
2116 #if LCD_DEPTH > 1 || defined(PLUGIN)
2117 if (cformat)
2118 output_row_8 = cformat->output_row_8;
2119 #endif
2120 struct img_part *part;
2121 for (row = 0; row < bm->height; row++)
2122 {
2123 part = store_row_jpeg(p_jpeg);
2124 #ifdef HAVE_LCD_COLOR
2125 struct uint8_rgb *qp = part->buf;
2126 struct uint8_rgb *end = qp + bm->width;
2127 uint8_t y, u, v;
2128 unsigned r, g, b;
2129 for (; qp < end; qp++)
2130 {
2131 y = qp->blue;
2132 u = qp->green;
2133 v = qp->red;
2134 yuv_to_rgb(y, u, v, &r, &g, &b);
2135 qp->red = r;
2136 qp->blue = b;
2137 qp->green = g;
2138 }
2139 #endif
2140 output_row_8(row, part->buf, &ctx);
2141 }
2142 return bm_size;
2143 }
2144 return 0;
2145 }
2146
2147 /**************** end JPEG code ********************/
My public Rockbox git repo