src/jpeg.c

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