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