1 /*
2 * Copyright (C) 2001, Novell Inc.
3 * Copyright (C) 2010 Kevin O'Connor <kevin@koconnor.net>
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * 3. Neither the name of Novell nor the names of the contributors may
18 * be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
25 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
27 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
29 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
30 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 * POSSIBILITY OF SUCH DAMAGE.
32 *
33 */
34
35 /*
36 * a tiny jpeg decoder.
37 *
38 * written in August 2001 by Michael Schroeder <mls@suse.de>
39 *
40 */
41
42 #define __LITTLE_ENDIAN
43 #include "malloc.h"
44 #include "string.h"
45 #include "util.h"
46 #define ISHIFT 11
47
48 #define IFIX(a) ((int)((a) * (1 << ISHIFT) + .5))
49 #define IMULT(a, b) (((a) * (b)) >> ISHIFT)
50 #define ITOINT(a) ((a) >> ISHIFT)
51
52 #ifndef __P
53 # define __P(x) x
54 #endif
55
56 /* special markers */
57 #define M_BADHUFF -1
58 #define M_EOF 0x80
59
60 struct in {
61 unsigned char *p;
62 unsigned int bits;
63 int left;
64 int marker;
65
66 int (*func) __P((void *));
67 void *data;
68 };
69
70 /*********************************/
71 struct dec_hufftbl;
72 struct enc_hufftbl;
73
74 union hufftblp {
75 struct dec_hufftbl *dhuff;
76 struct enc_hufftbl *ehuff;
77 };
78
79 struct scan {
80 int dc; /* old dc value */
81
82 union hufftblp hudc;
83 union hufftblp huac;
84 int next; /* when to switch to next scan */
85
86 int cid; /* component id */
87 int hv; /* horiz/vert, copied from comp */
88 int tq; /* quant tbl, copied from comp */
89 };
90
91 /*********************************/
92
93 #define DECBITS 10 /* seems to be the optimum */
94
95 struct dec_hufftbl {
96 int maxcode[17];
97 int valptr[16];
98 unsigned char vals[256];
99 unsigned int llvals[1 << DECBITS];
100 };
101
102 static void decode_mcus __P((struct in *, int *, int, struct scan *, int *));
103 static int dec_readmarker __P((struct in *));
104 static void dec_makehuff __P((struct dec_hufftbl *, int *, unsigned char *));
105
106 static void setinput __P((struct in *, unsigned char *));
107 /*********************************/
108
109 #undef PREC
110 #define PREC int
111
112 static void idctqtab __P((unsigned char *, PREC *));
113 static void idct __P((int *, int *, PREC *, PREC, int));
114 static void scaleidctqtab __P((PREC *, PREC));
115
116 /*********************************/
117
118 static void initcol __P((PREC[][64]));
119
120 static void col221111 __P((int *, unsigned char *, int));
121 static void col221111_16 __P((int *, unsigned char *, int));
122 static void col221111_32 __P((int *, unsigned char *, int));
123
124 /*********************************/
125
126 #define ERR_NO_SOI 1
127 #define ERR_NOT_8BIT 2
128 #define ERR_HEIGHT_MISMATCH 3
129 #define ERR_WIDTH_MISMATCH 4
130 #define ERR_BAD_WIDTH_OR_HEIGHT 5
131 #define ERR_TOO_MANY_COMPPS 6
132 #define ERR_ILLEGAL_HV 7
133 #define ERR_QUANT_TABLE_SELECTOR 8
134 #define ERR_NOT_YCBCR_221111 9
135 #define ERR_UNKNOWN_CID_IN_SCAN 10
136 #define ERR_NOT_SEQUENTIAL_DCT 11
137 #define ERR_WRONG_MARKER 12
138 #define ERR_NO_EOI 13
139 #define ERR_BAD_TABLES 14
140 #define ERR_DEPTH_MISMATCH 15
141
142 /*********************************/
143
144 #define M_SOI 0xd8
145 #define M_APP0 0xe0
146 #define M_DQT 0xdb
147 #define M_SOF0 0xc0
148 #define M_DHT 0xc4
149 #define M_DRI 0xdd
150 #define M_SOS 0xda
151 #define M_RST0 0xd0
152 #define M_EOI 0xd9
153 #define M_COM 0xfe
154
155 struct comp {
156 int cid;
157 int hv;
158 int tq;
159 };
160
161 #define MAXCOMP 4
162 struct jpginfo {
163 int nc; /* number of components */
164 int ns; /* number of scans */
165 int dri; /* restart interval */
166 int nm; /* mcus til next marker */
167 int rm; /* next restart marker */
168 };
169
170 struct jpeg_decdata {
171 int dcts[6 * 64 + 16];
172 int out[64 * 6];
173 int dquant[3][64];
174
175 unsigned char *datap;
176 struct jpginfo info;
177 struct comp comps[MAXCOMP];
178 struct scan dscans[MAXCOMP];
179 unsigned char quant[4][64];
180 struct dec_hufftbl dhuff[4];
181 struct in in;
182
183 int height, width;
184 };
185
getbyte(struct jpeg_decdata * jpeg)186 static int getbyte(struct jpeg_decdata *jpeg)
187 {
188 return *jpeg->datap++;
189 }
190
getword(struct jpeg_decdata * jpeg)191 static int getword(struct jpeg_decdata *jpeg)
192 {
193 int c1, c2;
194 c1 = *jpeg->datap++;
195 c2 = *jpeg->datap++;
196 return c1 << 8 | c2;
197 }
198
readtables(struct jpeg_decdata * jpeg,int till)199 static int readtables(struct jpeg_decdata *jpeg, int till)
200 {
201 int m, l, i, j, lq, pq, tq;
202 int tc, th, tt;
203
204 for (;;) {
205 if (getbyte(jpeg) != 0xff)
206 return -1;
207 if ((m = getbyte(jpeg)) == till)
208 break;
209
210 switch (m) {
211 case 0xc2:
212 return 0;
213
214 case M_DQT:
215 lq = getword(jpeg);
216 while (lq > 2) {
217 pq = getbyte(jpeg);
218 tq = pq & 15;
219 if (tq > 3)
220 return -1;
221 pq >>= 4;
222 if (pq != 0)
223 return -1;
224 for (i = 0; i < 64; i++)
225 jpeg->quant[tq][i] = getbyte(jpeg);
226 lq -= 64 + 1;
227 }
228 break;
229
230 case M_DHT:
231 l = getword(jpeg);
232 while (l > 2) {
233 int hufflen[16], k;
234 unsigned char huffvals[256];
235
236 tc = getbyte(jpeg);
237 th = tc & 15;
238 tc >>= 4;
239 tt = tc * 2 + th;
240 if (tc > 1 || th > 1)
241 return -1;
242 for (i = 0; i < 16; i++)
243 hufflen[i] = getbyte(jpeg);
244 l -= 1 + 16;
245 k = 0;
246 for (i = 0; i < 16; i++) {
247 for (j = 0; j < hufflen[i]; j++)
248 huffvals[k++] = getbyte(jpeg);
249 l -= hufflen[i];
250 }
251 dec_makehuff(jpeg->dhuff + tt, hufflen, huffvals);
252 }
253 break;
254
255 case M_DRI:
256 l = getword(jpeg);
257 jpeg->info.dri = getword(jpeg);
258 break;
259
260 default:
261 l = getword(jpeg);
262 while (l-- > 2)
263 getbyte(jpeg);
264 break;
265 }
266 }
267 return 0;
268 }
269
dec_initscans(struct jpeg_decdata * jpeg)270 static void dec_initscans(struct jpeg_decdata *jpeg)
271 {
272 int i;
273
274 jpeg->info.nm = jpeg->info.dri + 1;
275 jpeg->info.rm = M_RST0;
276 for (i = 0; i < jpeg->info.ns; i++)
277 jpeg->dscans[i].dc = 0;
278 }
279
dec_checkmarker(struct jpeg_decdata * jpeg)280 static int dec_checkmarker(struct jpeg_decdata *jpeg)
281 {
282 int i;
283
284 if (dec_readmarker(&jpeg->in) != jpeg->info.rm)
285 return -1;
286 jpeg->info.nm = jpeg->info.dri;
287 jpeg->info.rm = (jpeg->info.rm + 1) & ~0x08;
288 for (i = 0; i < jpeg->info.ns; i++)
289 jpeg->dscans[i].dc = 0;
290 return 0;
291 }
292
jpeg_alloc(void)293 struct jpeg_decdata *jpeg_alloc(void)
294 {
295 struct jpeg_decdata *jpeg = malloc_tmphigh(sizeof(*jpeg));
296 return jpeg;
297 }
298
jpeg_decode(struct jpeg_decdata * jpeg,unsigned char * buf)299 int jpeg_decode(struct jpeg_decdata *jpeg, unsigned char *buf)
300 {
301 int i, j, m, tac, tdc;
302
303 if (!jpeg || !buf)
304 return -1;
305 jpeg->datap = buf;
306 if (getbyte(jpeg) != 0xff)
307 return ERR_NO_SOI;
308 if (getbyte(jpeg) != M_SOI)
309 return ERR_NO_SOI;
310 if (readtables(jpeg, M_SOF0))
311 return ERR_BAD_TABLES;
312 getword(jpeg);
313 i = getbyte(jpeg);
314 if (i != 8)
315 return ERR_NOT_8BIT;
316 jpeg->height = getword(jpeg);
317 jpeg->width = getword(jpeg);
318 if ((jpeg->height & 15) || (jpeg->width & 15))
319 return ERR_BAD_WIDTH_OR_HEIGHT;
320 jpeg->info.nc = getbyte(jpeg);
321 if (jpeg->info.nc > MAXCOMP)
322 return ERR_TOO_MANY_COMPPS;
323 for (i = 0; i < jpeg->info.nc; i++) {
324 int h, v;
325 jpeg->comps[i].cid = getbyte(jpeg);
326 jpeg->comps[i].hv = getbyte(jpeg);
327 v = jpeg->comps[i].hv & 15;
328 h = jpeg->comps[i].hv >> 4;
329 jpeg->comps[i].tq = getbyte(jpeg);
330 if (h > 3 || v > 3)
331 return ERR_ILLEGAL_HV;
332 if (jpeg->comps[i].tq > 3)
333 return ERR_QUANT_TABLE_SELECTOR;
334 }
335 if (readtables(jpeg, M_SOS))
336 return ERR_BAD_TABLES;
337 getword(jpeg);
338 jpeg->info.ns = getbyte(jpeg);
339 if (jpeg->info.ns != 3)
340 return ERR_NOT_YCBCR_221111;
341 for (i = 0; i < 3; i++) {
342 jpeg->dscans[i].cid = getbyte(jpeg);
343 tdc = getbyte(jpeg);
344 tac = tdc & 15;
345 tdc >>= 4;
346 if (tdc > 1 || tac > 1)
347 return ERR_QUANT_TABLE_SELECTOR;
348 for (j = 0; j < jpeg->info.nc; j++)
349 if (jpeg->comps[j].cid == jpeg->dscans[i].cid)
350 break;
351 if (j == jpeg->info.nc)
352 return ERR_UNKNOWN_CID_IN_SCAN;
353 jpeg->dscans[i].hv = jpeg->comps[j].hv;
354 jpeg->dscans[i].tq = jpeg->comps[j].tq;
355 jpeg->dscans[i].hudc.dhuff = &jpeg->dhuff[tdc];
356 jpeg->dscans[i].huac.dhuff = &jpeg->dhuff[2 + tac];
357 }
358
359 i = getbyte(jpeg);
360 j = getbyte(jpeg);
361 m = getbyte(jpeg);
362
363 if (i != 0 || j != 63 || m != 0)
364 return ERR_NOT_SEQUENTIAL_DCT;
365
366 if (jpeg->dscans[0].cid != 1 || jpeg->dscans[1].cid != 2
367 || jpeg->dscans[2].cid != 3)
368 return ERR_NOT_YCBCR_221111;
369
370 if (jpeg->dscans[0].hv != 0x22 || jpeg->dscans[1].hv != 0x11
371 || jpeg->dscans[2].hv != 0x11)
372 return ERR_NOT_YCBCR_221111;
373
374 idctqtab(jpeg->quant[jpeg->dscans[0].tq], jpeg->dquant[0]);
375 idctqtab(jpeg->quant[jpeg->dscans[1].tq], jpeg->dquant[1]);
376 idctqtab(jpeg->quant[jpeg->dscans[2].tq], jpeg->dquant[2]);
377 initcol(jpeg->dquant);
378 setinput(&jpeg->in, jpeg->datap);
379
380 #if 0
381 /* landing zone */
382 img[len] = 0;
383 img[len + 1] = 0xff;
384 img[len + 2] = M_EOF;
385 #endif
386
387 dec_initscans(jpeg);
388
389 return 0;
390 }
391
jpeg_get_size(struct jpeg_decdata * jpeg,int * width,int * height)392 void jpeg_get_size(struct jpeg_decdata *jpeg, int *width, int *height)
393 {
394 *width = jpeg->width;
395 *height = jpeg->height;
396 }
397
jpeg_show(struct jpeg_decdata * jpeg,unsigned char * pic,int width,int height,int depth,int bytes_per_line_dest)398 int jpeg_show(struct jpeg_decdata *jpeg, unsigned char *pic, int width
399 , int height, int depth, int bytes_per_line_dest)
400 {
401 int m, mcusx, mcusy, mx, my, mloffset, jpgbpl;
402 int max[6];
403
404 if (jpeg->height != height)
405 return ERR_HEIGHT_MISMATCH;
406 if (jpeg->width != width)
407 return ERR_WIDTH_MISMATCH;
408
409 jpgbpl = width * depth / 8;
410 mloffset = bytes_per_line_dest > jpgbpl ? bytes_per_line_dest : jpgbpl;
411
412 mcusx = jpeg->width >> 4;
413 mcusy = jpeg->height >> 4;
414
415 jpeg->dscans[0].next = 6 - 4;
416 jpeg->dscans[1].next = 6 - 4 - 1;
417 jpeg->dscans[2].next = 6 - 4 - 1 - 1; /* 411 encoding */
418 for (my = 0; my < mcusy; my++) {
419 for (mx = 0; mx < mcusx; mx++) {
420 if (jpeg->info.dri && !--jpeg->info.nm)
421 if (dec_checkmarker(jpeg))
422 return ERR_WRONG_MARKER;
423
424 decode_mcus(&jpeg->in, jpeg->dcts, 6, jpeg->dscans, max);
425 idct(jpeg->dcts, jpeg->out, jpeg->dquant[0],
426 IFIX(128.5), max[0]);
427 idct(jpeg->dcts + 64, jpeg->out + 64, jpeg->dquant[0],
428 IFIX(128.5), max[1]);
429 idct(jpeg->dcts + 128, jpeg->out + 128, jpeg->dquant[0],
430 IFIX(128.5), max[2]);
431 idct(jpeg->dcts + 192, jpeg->out + 192, jpeg->dquant[0],
432 IFIX(128.5), max[3]);
433 idct(jpeg->dcts + 256, jpeg->out + 256, jpeg->dquant[1],
434 IFIX(0.5), max[4]);
435 idct(jpeg->dcts + 320, jpeg->out + 320, jpeg->dquant[2],
436 IFIX(0.5), max[5]);
437
438 switch (depth) {
439 case 32:
440 col221111_32(jpeg->out,
441 pic + (my * 16 * mloffset + mx * 16 * 4),
442 mloffset);
443 break;
444 case 24:
445 col221111(jpeg->out,
446 pic + (my * 16 * mloffset + mx * 16 * 3),
447 mloffset);
448 break;
449 case 16:
450 col221111_16(jpeg->out,
451 pic + (my * 16 * mloffset + mx * 16 * 2),
452 mloffset);
453 break;
454 default:
455 return ERR_DEPTH_MISMATCH;
456 break;
457 }
458 }
459 }
460
461 m = dec_readmarker(&jpeg->in);
462 if (m != M_EOI)
463 return ERR_NO_EOI;
464
465 return 0;
466 }
467
468 /****************************************************************/
469 /************** huffman decoder ***************/
470 /****************************************************************/
471
472 static int fillbits __P((struct in *, int, unsigned int));
473 static int dec_rec2 __P((struct in *, struct dec_hufftbl *, int *, int, int));
474
setinput(struct in * in,unsigned char * p)475 static void setinput(struct in *in, unsigned char *p)
476 {
477 in->p = p;
478 in->left = 0;
479 in->bits = 0;
480 in->marker = 0;
481 }
482
fillbits(struct in * in,int le,unsigned int bi)483 static int fillbits(struct in *in, int le, unsigned int bi)
484 {
485 int b, m;
486
487 if (in->marker) {
488 if (le <= 16)
489 in->bits = bi << 16, le += 16;
490 return le;
491 }
492 while (le <= 24) {
493 b = *in->p++;
494 if (b == 0xff && (m = *in->p++) != 0) {
495 if (m == M_EOF) {
496 if (in->func && (m = in->func(in->data)) == 0)
497 continue;
498 }
499 in->marker = m;
500 if (le <= 16)
501 bi = bi << 16, le += 16;
502 break;
503 }
504 bi = bi << 8 | b;
505 le += 8;
506 }
507 in->bits = bi; /* tmp... 2 return values needed */
508 return le;
509 }
510
dec_readmarker(struct in * in)511 static int dec_readmarker(struct in *in)
512 {
513 int m;
514
515 in->left = fillbits(in, in->left, in->bits);
516 if ((m = in->marker) == 0)
517 return 0;
518 in->left = 0;
519 in->marker = 0;
520 return m;
521 }
522
523 #define LEBI_DCL int le, bi
524 #define LEBI_GET(in) (le = in->left, bi = in->bits)
525 #define LEBI_PUT(in) (in->left = le, in->bits = bi)
526
527 #define GETBITS(in, n) ( \
528 (le < (n) ? le = fillbits(in, le, bi), bi = in->bits : 0), \
529 (le -= (n)), \
530 bi >> le & ((1 << (n)) - 1) \
531 )
532
533 #define UNGETBITS(in, n) ( \
534 le += (n) \
535 )
536
537
dec_rec2(struct in * in,struct dec_hufftbl * hu,int * runp,int c,int i)538 static int dec_rec2(struct in *in, struct dec_hufftbl *hu, int *runp,
539 int c, int i)
540 {
541 LEBI_DCL;
542
543 LEBI_GET(in);
544 if (i) {
545 UNGETBITS(in, i & 127);
546 *runp = i >> 8 & 15;
547 i >>= 16;
548 } else {
549 for (i = DECBITS;
550 (c = ((c << 1) | GETBITS(in, 1))) >= (hu->maxcode[i]); i++);
551 if (i >= 16) {
552 in->marker = M_BADHUFF;
553 return 0;
554 }
555 i = hu->vals[hu->valptr[i] + c - hu->maxcode[i - 1] * 2];
556 *runp = i >> 4;
557 i &= 15;
558 }
559 if (i == 0) { /* sigh, 0xf0 is 11 bit */
560 LEBI_PUT(in);
561 return 0;
562 }
563 /* receive part */
564 c = GETBITS(in, i);
565 if (c < (1 << (i - 1)))
566 c += (-1 << i) + 1;
567 LEBI_PUT(in);
568 return c;
569 }
570
571 #define DEC_REC(in, hu, r, i) ( \
572 r = GETBITS(in, DECBITS), \
573 i = hu->llvals[r], \
574 i & 128 ? \
575 ( \
576 UNGETBITS(in, i & 127), \
577 r = i >> 8 & 15, \
578 i >> 16 \
579 ) \
580 : \
581 ( \
582 LEBI_PUT(in), \
583 i = dec_rec2(in, hu, &r, r, i), \
584 LEBI_GET(in), \
585 i \
586 ) \
587 )
588
decode_mcus(struct in * in,int * dct,int n,struct scan * sc,int * maxp)589 static void decode_mcus(struct in *in, int *dct, int n, struct scan *sc,
590 int *maxp)
591 {
592 struct dec_hufftbl *hu;
593 int i, r, t;
594 LEBI_DCL;
595
596 memset(dct, 0, n * 64 * sizeof(*dct));
597 LEBI_GET(in);
598 while (n-- > 0) {
599 hu = sc->hudc.dhuff;
600 *dct++ = (sc->dc += DEC_REC(in, hu, r, t));
601
602 hu = sc->huac.dhuff;
603 i = 63;
604 while (i > 0) {
605 t = DEC_REC(in, hu, r, t);
606 if (t == 0 && r == 0) {
607 dct += i;
608 break;
609 }
610 dct += r;
611 *dct++ = t;
612 i -= r + 1;
613 }
614 *maxp++ = 64 - i;
615 if (n == sc->next)
616 sc++;
617 }
618 LEBI_PUT(in);
619 }
620
dec_makehuff(struct dec_hufftbl * hu,int * hufflen,unsigned char * huffvals)621 static void dec_makehuff(struct dec_hufftbl *hu, int *hufflen,
622 unsigned char *huffvals)
623 {
624 int code, k, i, j, d, x, c, v;
625 for (i = 0; i < (1 << DECBITS); i++)
626 hu->llvals[i] = 0;
627
628 /*
629 * llvals layout:
630 *
631 * value v already known, run r, backup u bits:
632 * vvvvvvvvvvvvvvvv 0000 rrrr 1 uuuuuuu
633 * value unknown, size b bits, run r, backup u bits:
634 * 000000000000bbbb 0000 rrrr 0 uuuuuuu
635 * value and size unknown:
636 * 0000000000000000 0000 0000 0 0000000
637 */
638
639 code = 0;
640 k = 0;
641 for (i = 0; i < 16; i++, code <<= 1) { /* sizes */
642 hu->valptr[i] = k;
643 for (j = 0; j < hufflen[i]; j++) {
644 hu->vals[k] = *huffvals++;
645 if (i < DECBITS) {
646 c = code << (DECBITS - 1 - i);
647 v = hu->vals[k] & 0x0f; /* size */
648 for (d = 1 << (DECBITS - 1 - i); --d >= 0;) {
649 if (v + i < DECBITS) { /* both fit in table */
650 x = d >> (DECBITS - 1 - v - i);
651 if (v && x < (1 << (v - 1)))
652 x += (-1 << v) + 1;
653 x = x << 16 | (hu->vals[k] & 0xf0) << 4 |
654 (DECBITS - (i + 1 + v)) | 128;
655 } else
656 x = v << 16 | (hu->vals[k] & 0xf0) << 4 |
657 (DECBITS - (i + 1));
658 hu->llvals[c | d] = x;
659 }
660 }
661 code++;
662 k++;
663 }
664 hu->maxcode[i] = code;
665 }
666 hu->maxcode[16] = 0x20000; /* always terminate decode */
667 }
668
669 /****************************************************************/
670 /************** idct ***************/
671 /****************************************************************/
672
673 #define ONE ((PREC)IFIX(1.))
674 #define S2 ((PREC)IFIX(0.382683432))
675 #define C2 ((PREC)IFIX(0.923879532))
676 #define C4 ((PREC)IFIX(0.707106781))
677
678 #define S22 ((PREC)IFIX(2 * 0.382683432))
679 #define C22 ((PREC)IFIX(2 * 0.923879532))
680 #define IC4 ((PREC)IFIX(1 / 0.707106781))
681
682 #define C3IC1 ((PREC)IFIX(0.847759065)) /* c3/c1 */
683 #define C5IC1 ((PREC)IFIX(0.566454497)) /* c5/c1 */
684 #define C7IC1 ((PREC)IFIX(0.198912367)) /* c7/c1 */
685
686 #define XPP(a,b) (t = a + b, b = a - b, a = t)
687 #define XMP(a,b) (t = a - b, b = a + b, a = t)
688 #define XPM(a,b) (t = a + b, b = b - a, a = t)
689
690 #define ROT(a,b,s,c) ( t = IMULT(a + b, s), \
691 a = IMULT(a, c - s) + t, \
692 b = IMULT(b, c + s) - t)
693
694 #define IDCT \
695 ( \
696 XPP(t0, t1), \
697 XMP(t2, t3), \
698 t2 = IMULT(t2, IC4) - t3, \
699 XPP(t0, t3), \
700 XPP(t1, t2), \
701 XMP(t4, t7), \
702 XPP(t5, t6), \
703 XMP(t5, t7), \
704 t5 = IMULT(t5, IC4), \
705 ROT(t4, t6, S22, C22), \
706 t6 -= t7, \
707 t5 -= t6, \
708 t4 -= t5, \
709 XPP(t0, t7), \
710 XPP(t1, t6), \
711 XPP(t2, t5), \
712 XPP(t3, t4) \
713 )
714
715 static unsigned char zig2[64] = {
716 0, 2, 3, 9, 10, 20, 21, 35,
717 14, 16, 25, 31, 39, 46, 50, 57,
718 5, 7, 12, 18, 23, 33, 37, 48,
719 27, 29, 41, 44, 52, 55, 59, 62,
720 15, 26, 30, 40, 45, 51, 56, 58,
721 1, 4, 8, 11, 19, 22, 34, 36,
722 28, 42, 43, 53, 54, 60, 61, 63,
723 6, 13, 17, 24, 32, 38, 47, 49
724 };
725
idct(int * in,int * out,PREC * quant,PREC off,int max)726 static void idct(int *in, int *out, PREC * quant, PREC off, int max)
727 {
728 PREC t0, t1, t2, t3, t4, t5, t6, t7, t;
729 PREC tmp[64], *tmpp;
730 int i, j;
731 unsigned char *zig2p;
732
733 t0 = off;
734 if (max == 1) {
735 t0 += in[0] * quant[0];
736 for (i = 0; i < 64; i++)
737 out[i] = ITOINT(t0);
738 return;
739 }
740 zig2p = zig2;
741 tmpp = tmp;
742 for (i = 0; i < 8; i++) {
743 j = *zig2p++;
744 t0 += in[j] * quant[j];
745 j = *zig2p++;
746 t5 = in[j] * quant[j];
747 j = *zig2p++;
748 t2 = in[j] * quant[j];
749 j = *zig2p++;
750 t7 = in[j] * quant[j];
751 j = *zig2p++;
752 t1 = in[j] * quant[j];
753 j = *zig2p++;
754 t4 = in[j] * quant[j];
755 j = *zig2p++;
756 t3 = in[j] * quant[j];
757 j = *zig2p++;
758 t6 = in[j] * quant[j];
759 IDCT;
760 tmpp[0 * 8] = t0;
761 tmpp[1 * 8] = t1;
762 tmpp[2 * 8] = t2;
763 tmpp[3 * 8] = t3;
764 tmpp[4 * 8] = t4;
765 tmpp[5 * 8] = t5;
766 tmpp[6 * 8] = t6;
767 tmpp[7 * 8] = t7;
768 tmpp++;
769 t0 = 0;
770 }
771 for (i = 0; i < 8; i++) {
772 t0 = tmp[8 * i + 0];
773 t1 = tmp[8 * i + 1];
774 t2 = tmp[8 * i + 2];
775 t3 = tmp[8 * i + 3];
776 t4 = tmp[8 * i + 4];
777 t5 = tmp[8 * i + 5];
778 t6 = tmp[8 * i + 6];
779 t7 = tmp[8 * i + 7];
780 IDCT;
781 out[8 * i + 0] = ITOINT(t0);
782 out[8 * i + 1] = ITOINT(t1);
783 out[8 * i + 2] = ITOINT(t2);
784 out[8 * i + 3] = ITOINT(t3);
785 out[8 * i + 4] = ITOINT(t4);
786 out[8 * i + 5] = ITOINT(t5);
787 out[8 * i + 6] = ITOINT(t6);
788 out[8 * i + 7] = ITOINT(t7);
789 }
790 }
791
792 static unsigned char zig[64] = {
793 0, 1, 5, 6, 14, 15, 27, 28,
794 2, 4, 7, 13, 16, 26, 29, 42,
795 3, 8, 12, 17, 25, 30, 41, 43,
796 9, 11, 18, 24, 31, 40, 44, 53,
797 10, 19, 23, 32, 39, 45, 52, 54,
798 20, 22, 33, 38, 46, 51, 55, 60,
799 21, 34, 37, 47, 50, 56, 59, 61,
800 35, 36, 48, 49, 57, 58, 62, 63
801 };
802
803 static PREC aaidct[8] = {
804 IFIX(0.3535533906), IFIX(0.4903926402),
805 IFIX(0.4619397663), IFIX(0.4157348062),
806 IFIX(0.3535533906), IFIX(0.2777851165),
807 IFIX(0.1913417162), IFIX(0.0975451610)
808 };
809
810
idctqtab(unsigned char * qin,PREC * qout)811 static void idctqtab(unsigned char *qin, PREC * qout)
812 {
813 int i, j;
814
815 for (i = 0; i < 8; i++)
816 for (j = 0; j < 8; j++)
817 qout[zig[i * 8 + j]] = qin[zig[i * 8 + j]] *
818 IMULT(aaidct[i], aaidct[j]);
819 }
820
scaleidctqtab(PREC * q,PREC sc)821 static void scaleidctqtab(PREC * q, PREC sc)
822 {
823 int i;
824
825 for (i = 0; i < 64; i++)
826 q[i] = IMULT(q[i], sc);
827 }
828
829 /****************************************************************/
830 /************** color decoder ***************/
831 /****************************************************************/
832
833 #define ROUND
834
835 /*
836 * YCbCr Color transformation:
837 *
838 * y:0..255 Cb:-128..127 Cr:-128..127
839 *
840 * R = Y + 1.40200 * Cr
841 * G = Y - 0.34414 * Cb - 0.71414 * Cr
842 * B = Y + 1.77200 * Cb
843 *
844 * =>
845 * Cr *= 1.40200;
846 * Cb *= 1.77200;
847 * Cg = 0.19421 * Cb + .50937 * Cr;
848 * R = Y + Cr;
849 * G = Y - Cg;
850 * B = Y + Cb;
851 *
852 * =>
853 * Cg = (50 * Cb + 130 * Cr + 128) >> 8;
854 */
855
initcol(PREC q[][64])856 static void initcol(PREC q[][64])
857 {
858 scaleidctqtab(q[1], IFIX(1.77200));
859 scaleidctqtab(q[2], IFIX(1.40200));
860 }
861
862 /* This is optimized for the stupid sun SUNWspro compiler. */
863 #define STORECLAMP(a,x) \
864 ( \
865 (a) = (x), \
866 (unsigned int)(x) >= 256 ? \
867 ((a) = (x) < 0 ? 0 : 255) \
868 : \
869 0 \
870 )
871
872 #define CLAMP(x) ((unsigned int)(x) >= 256 ? ((x) < 0 ? 0 : 255) : (x))
873
874 #ifdef ROUND
875
876 #define CBCRCG(yin, xin) \
877 ( \
878 cb = outc[0 +yin*8+xin], \
879 cr = outc[64+yin*8+xin], \
880 cg = (50 * cb + 130 * cr + 128) >> 8 \
881 )
882
883 #else
884
885 #define CBCRCG(yin, xin) \
886 ( \
887 cb = outc[0 +yin*8+xin], \
888 cr = outc[64+yin*8+xin], \
889 cg = (3 * cb + 8 * cr) >> 4 \
890 )
891
892 #endif
893
894 #ifdef __LITTLE_ENDIAN
895 #define PIC(yin, xin, p, xout) \
896 ( \
897 y = outy[(yin) * 8 + xin], \
898 STORECLAMP(p[(xout) * 3 + 2], y + cr), \
899 STORECLAMP(p[(xout) * 3 + 1], y - cg), \
900 STORECLAMP(p[(xout) * 3 + 0], y + cb) \
901 )
902 #else
903 #define PIC(yin, xin, p, xout) \
904 ( \
905 y = outy[(yin) * 8 + xin], \
906 STORECLAMP(p[(xout) * 3 + 0], y + cr), \
907 STORECLAMP(p[(xout) * 3 + 1], y - cg), \
908 STORECLAMP(p[(xout) * 3 + 2], y + cb) \
909 )
910 #endif
911
912 #ifdef __LITTLE_ENDIAN
913 #define PIC_16(yin, xin, p, xout, add) \
914 ( \
915 y = outy[(yin) * 8 + xin], \
916 y = ((CLAMP(y + cr + add*2+1) & 0xf8) << 8) | \
917 ((CLAMP(y - cg + add ) & 0xfc) << 3) | \
918 ((CLAMP(y + cb + add*2+1) ) >> 3), \
919 p[(xout) * 2 + 0] = y & 0xff, \
920 p[(xout) * 2 + 1] = y >> 8 \
921 )
922 #else
923 #ifdef CONFIG_PPC
924 #define PIC_16(yin, xin, p, xout, add) \
925 ( \
926 y = outy[(yin) * 8 + xin], \
927 y = ((CLAMP(y + cr + add*2+1) & 0xf8) << 7) | \
928 ((CLAMP(y - cg + add*2+1) & 0xf8) << 2) | \
929 ((CLAMP(y + cb + add*2+1) ) >> 3), \
930 p[(xout) * 2 + 0] = y >> 8, \
931 p[(xout) * 2 + 1] = y & 0xff \
932 )
933 #else
934 #define PIC_16(yin, xin, p, xout, add) \
935 ( \
936 y = outy[(yin) * 8 + xin], \
937 y = ((CLAMP(y + cr + add*2+1) & 0xf8) << 8) | \
938 ((CLAMP(y - cg + add ) & 0xfc) << 3) | \
939 ((CLAMP(y + cb + add*2+1) ) >> 3), \
940 p[(xout) * 2 + 0] = y >> 8, \
941 p[(xout) * 2 + 1] = y & 0xff \
942 )
943 #endif
944 #endif
945
946 #define PIC_32(yin, xin, p, xout) \
947 ( \
948 y = outy[(yin) * 8 + xin], \
949 STORECLAMP(p[(xout) * 4 + 0], y + cr), \
950 STORECLAMP(p[(xout) * 4 + 1], y - cg), \
951 STORECLAMP(p[(xout) * 4 + 2], y + cb), \
952 p[(xout) * 4 + 3] = 0 \
953 )
954
955 #define PIC221111(xin) \
956 ( \
957 CBCRCG(0, xin), \
958 PIC(xin / 4 * 8 + 0, (xin & 3) * 2 + 0, pic0, xin * 2 + 0), \
959 PIC(xin / 4 * 8 + 0, (xin & 3) * 2 + 1, pic0, xin * 2 + 1), \
960 PIC(xin / 4 * 8 + 1, (xin & 3) * 2 + 0, pic1, xin * 2 + 0), \
961 PIC(xin / 4 * 8 + 1, (xin & 3) * 2 + 1, pic1, xin * 2 + 1) \
962 )
963
964 #define PIC221111_16(xin) \
965 ( \
966 CBCRCG(0, xin), \
967 PIC_16(xin / 4 * 8 + 0, (xin & 3) * 2 + 0, pic0, xin * 2 + 0, 3), \
968 PIC_16(xin / 4 * 8 + 0, (xin & 3) * 2 + 1, pic0, xin * 2 + 1, 0), \
969 PIC_16(xin / 4 * 8 + 1, (xin & 3) * 2 + 0, pic1, xin * 2 + 0, 1), \
970 PIC_16(xin / 4 * 8 + 1, (xin & 3) * 2 + 1, pic1, xin * 2 + 1, 2) \
971 )
972
973 #define PIC221111_32(xin) \
974 ( \
975 CBCRCG(0, xin), \
976 PIC_32(xin / 4 * 8 + 0, (xin & 3) * 2 + 0, pic0, xin * 2 + 0), \
977 PIC_32(xin / 4 * 8 + 0, (xin & 3) * 2 + 1, pic0, xin * 2 + 1), \
978 PIC_32(xin / 4 * 8 + 1, (xin & 3) * 2 + 0, pic1, xin * 2 + 0), \
979 PIC_32(xin / 4 * 8 + 1, (xin & 3) * 2 + 1, pic1, xin * 2 + 1) \
980 )
981
col221111(int * out,unsigned char * pic,int width)982 static void col221111(int *out, unsigned char *pic, int width)
983 {
984 int i, j, k;
985 unsigned char *pic0, *pic1;
986 int *outy, *outc;
987 int cr, cg, cb, y;
988
989 pic0 = pic;
990 pic1 = pic + width;
991 outy = out;
992 outc = out + 64 * 4;
993 for (i = 2; i > 0; i--) {
994 for (j = 4; j > 0; j--) {
995 for (k = 0; k < 8; k++) {
996 PIC221111(k);
997 }
998 outc += 8;
999 outy += 16;
1000 pic0 += 2 * width;
1001 pic1 += 2 * width;
1002 }
1003 outy += 64 * 2 - 16 * 4;
1004 }
1005 }
1006
col221111_16(int * out,unsigned char * pic,int width)1007 static void col221111_16(int *out, unsigned char *pic, int width)
1008 {
1009 int i, j, k;
1010 unsigned char *pic0, *pic1;
1011 int *outy, *outc;
1012 int cr, cg, cb, y;
1013
1014 pic0 = pic;
1015 pic1 = pic + width;
1016 outy = out;
1017 outc = out + 64 * 4;
1018 for (i = 2; i > 0; i--) {
1019 for (j = 4; j > 0; j--) {
1020 for (k = 0; k < 8; k++) {
1021 PIC221111_16(k);
1022 }
1023 outc += 8;
1024 outy += 16;
1025 pic0 += 2 * width;
1026 pic1 += 2 * width;
1027 }
1028 outy += 64 * 2 - 16 * 4;
1029 }
1030 }
1031
col221111_32(int * out,unsigned char * pic,int width)1032 static void col221111_32(int *out, unsigned char *pic, int width)
1033 {
1034 int i, j, k;
1035 unsigned char *pic0, *pic1;
1036 int *outy, *outc;
1037 int cr, cg, cb, y;
1038
1039 pic0 = pic;
1040 pic1 = pic + width;
1041 outy = out;
1042 outc = out + 64 * 4;
1043 for (i = 2; i > 0; i--) {
1044 for (j = 4; j > 0; j--) {
1045 for (k = 0; k < 8; k++) {
1046 PIC221111_32(k);
1047 }
1048 outc += 8;
1049 outy += 16;
1050 pic0 += 2 * width;
1051 pic1 += 2 * width;
1052 }
1053 outy += 64 * 2 - 16 * 4;
1054 }
1055 }
1056