2 * Copyright (C) 2001, Novell Inc.
3 * Copyright (C) 2010 Kevin O'Connor <kevin@koconnor.net>
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
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.
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.
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.
36 * a tiny jpeg decoder.
38 * written in August 2001 by Michael Schroeder <mls@suse.de>
42 #define __LITTLE_ENDIAN
47 #define IFIX(a) ((int)((a) * (1 << ISHIFT) + .5))
48 #define IMULT(a, b) (((a) * (b)) >> ISHIFT)
49 #define ITOINT(a) ((a) >> ISHIFT)
65 int (*func) __P((void *));
69 /*********************************/
74 struct dec_hufftbl *dhuff;
75 struct enc_hufftbl *ehuff;
79 int dc; /* old dc value */
83 int next; /* when to switch to next scan */
85 int cid; /* component id */
86 int hv; /* horiz/vert, copied from comp */
87 int tq; /* quant tbl, copied from comp */
90 /*********************************/
92 #define DECBITS 10 /* seems to be the optimum */
97 unsigned char vals[256];
98 unsigned int llvals[1 << DECBITS];
101 static void decode_mcus __P((struct in *, int *, int, struct scan *, int *));
102 static int dec_readmarker __P((struct in *));
103 static void dec_makehuff __P((struct dec_hufftbl *, int *, unsigned char *));
105 static void setinput __P((struct in *, unsigned char *));
106 /*********************************/
111 static void idctqtab __P((unsigned char *, PREC *));
112 static void idct __P((int *, int *, PREC *, PREC, int));
113 static void scaleidctqtab __P((PREC *, PREC));
115 /*********************************/
117 static void initcol __P((PREC[][64]));
119 static void col221111 __P((int *, unsigned char *, int));
120 static void col221111_16 __P((int *, unsigned char *, int));
121 static void col221111_32 __P((int *, unsigned char *, int));
123 /*********************************/
126 #define ERR_NOT_8BIT 2
127 #define ERR_HEIGHT_MISMATCH 3
128 #define ERR_WIDTH_MISMATCH 4
129 #define ERR_BAD_WIDTH_OR_HEIGHT 5
130 #define ERR_TOO_MANY_COMPPS 6
131 #define ERR_ILLEGAL_HV 7
132 #define ERR_QUANT_TABLE_SELECTOR 8
133 #define ERR_NOT_YCBCR_221111 9
134 #define ERR_UNKNOWN_CID_IN_SCAN 10
135 #define ERR_NOT_SEQUENTIAL_DCT 11
136 #define ERR_WRONG_MARKER 12
137 #define ERR_NO_EOI 13
138 #define ERR_BAD_TABLES 14
139 #define ERR_DEPTH_MISMATCH 15
141 /*********************************/
162 int nc; /* number of components */
163 int ns; /* number of scans */
164 int dri; /* restart interval */
165 int nm; /* mcus til next marker */
166 int rm; /* next restart marker */
169 struct jpeg_decdata {
170 int dcts[6 * 64 + 16];
174 unsigned char *datap;
176 struct comp comps[MAXCOMP];
177 struct scan dscans[MAXCOMP];
178 unsigned char quant[4][64];
179 struct dec_hufftbl dhuff[4];
185 static int getbyte(struct jpeg_decdata *jpeg)
187 return *jpeg->datap++;
190 static int getword(struct jpeg_decdata *jpeg)
198 static int readtables(struct jpeg_decdata *jpeg, int till)
200 int m, l, i, j, lq, pq, tq;
204 if (getbyte(jpeg) != 0xff)
206 if ((m = getbyte(jpeg)) == till)
223 for (i = 0; i < 64; i++)
224 jpeg->quant[tq][i] = getbyte(jpeg);
233 unsigned char huffvals[256];
239 if (tc > 1 || th > 1)
241 for (i = 0; i < 16; i++)
242 hufflen[i] = getbyte(jpeg);
245 for (i = 0; i < 16; i++) {
246 for (j = 0; j < hufflen[i]; j++)
247 huffvals[k++] = getbyte(jpeg);
250 dec_makehuff(jpeg->dhuff + tt, hufflen, huffvals);
256 jpeg->info.dri = getword(jpeg);
269 static void dec_initscans(struct jpeg_decdata *jpeg)
273 jpeg->info.nm = jpeg->info.dri + 1;
274 jpeg->info.rm = M_RST0;
275 for (i = 0; i < jpeg->info.ns; i++)
276 jpeg->dscans[i].dc = 0;
279 static int dec_checkmarker(struct jpeg_decdata *jpeg)
283 if (dec_readmarker(&jpeg->in) != jpeg->info.rm)
285 jpeg->info.nm = jpeg->info.dri;
286 jpeg->info.rm = (jpeg->info.rm + 1) & ~0x08;
287 for (i = 0; i < jpeg->info.ns; i++)
288 jpeg->dscans[i].dc = 0;
292 struct jpeg_decdata *jpeg_alloc(void)
294 struct jpeg_decdata *jpeg = malloc_tmphigh(sizeof(*jpeg));
298 int jpeg_decode(struct jpeg_decdata *jpeg, unsigned char *buf)
300 int i, j, m, tac, tdc;
305 if (getbyte(jpeg) != 0xff)
307 if (getbyte(jpeg) != M_SOI)
309 if (readtables(jpeg, M_SOF0))
310 return ERR_BAD_TABLES;
315 jpeg->height = getword(jpeg);
316 jpeg->width = getword(jpeg);
317 if ((jpeg->height & 15) || (jpeg->width & 15))
318 return ERR_BAD_WIDTH_OR_HEIGHT;
319 jpeg->info.nc = getbyte(jpeg);
320 if (jpeg->info.nc > MAXCOMP)
321 return ERR_TOO_MANY_COMPPS;
322 for (i = 0; i < jpeg->info.nc; i++) {
324 jpeg->comps[i].cid = getbyte(jpeg);
325 jpeg->comps[i].hv = getbyte(jpeg);
326 v = jpeg->comps[i].hv & 15;
327 h = jpeg->comps[i].hv >> 4;
328 jpeg->comps[i].tq = getbyte(jpeg);
330 return ERR_ILLEGAL_HV;
331 if (jpeg->comps[i].tq > 3)
332 return ERR_QUANT_TABLE_SELECTOR;
334 if (readtables(jpeg, M_SOS))
335 return ERR_BAD_TABLES;
337 jpeg->info.ns = getbyte(jpeg);
338 if (jpeg->info.ns != 3)
339 return ERR_NOT_YCBCR_221111;
340 for (i = 0; i < 3; i++) {
341 jpeg->dscans[i].cid = getbyte(jpeg);
345 if (tdc > 1 || tac > 1)
346 return ERR_QUANT_TABLE_SELECTOR;
347 for (j = 0; j < jpeg->info.nc; j++)
348 if (jpeg->comps[j].cid == jpeg->dscans[i].cid)
350 if (j == jpeg->info.nc)
351 return ERR_UNKNOWN_CID_IN_SCAN;
352 jpeg->dscans[i].hv = jpeg->comps[j].hv;
353 jpeg->dscans[i].tq = jpeg->comps[j].tq;
354 jpeg->dscans[i].hudc.dhuff = &jpeg->dhuff[tdc];
355 jpeg->dscans[i].huac.dhuff = &jpeg->dhuff[2 + tac];
362 if (i != 0 || j != 63 || m != 0)
363 return ERR_NOT_SEQUENTIAL_DCT;
365 if (jpeg->dscans[0].cid != 1 || jpeg->dscans[1].cid != 2
366 || jpeg->dscans[2].cid != 3)
367 return ERR_NOT_YCBCR_221111;
369 if (jpeg->dscans[0].hv != 0x22 || jpeg->dscans[1].hv != 0x11
370 || jpeg->dscans[2].hv != 0x11)
371 return ERR_NOT_YCBCR_221111;
373 idctqtab(jpeg->quant[jpeg->dscans[0].tq], jpeg->dquant[0]);
374 idctqtab(jpeg->quant[jpeg->dscans[1].tq], jpeg->dquant[1]);
375 idctqtab(jpeg->quant[jpeg->dscans[2].tq], jpeg->dquant[2]);
376 initcol(jpeg->dquant);
377 setinput(&jpeg->in, jpeg->datap);
383 img[len + 2] = M_EOF;
391 void jpeg_get_size(struct jpeg_decdata *jpeg, int *width, int *height)
393 *width = jpeg->width;
394 *height = jpeg->height;
397 int jpeg_show(struct jpeg_decdata *jpeg, unsigned char *pic, int width
398 , int height, int depth, int bytes_per_line_dest)
400 int m, mcusx, mcusy, mx, my, mloffset, jpgbpl;
403 if (jpeg->height != height)
404 return ERR_HEIGHT_MISMATCH;
405 if (jpeg->width != width)
406 return ERR_WIDTH_MISMATCH;
408 jpgbpl = width * depth / 8;
409 mloffset = bytes_per_line_dest > jpgbpl ? bytes_per_line_dest : jpgbpl;
411 mcusx = jpeg->width >> 4;
412 mcusy = jpeg->height >> 4;
414 jpeg->dscans[0].next = 6 - 4;
415 jpeg->dscans[1].next = 6 - 4 - 1;
416 jpeg->dscans[2].next = 6 - 4 - 1 - 1; /* 411 encoding */
417 for (my = 0; my < mcusy; my++) {
418 for (mx = 0; mx < mcusx; mx++) {
419 if (jpeg->info.dri && !--jpeg->info.nm)
420 if (dec_checkmarker(jpeg))
421 return ERR_WRONG_MARKER;
423 decode_mcus(&jpeg->in, jpeg->dcts, 6, jpeg->dscans, max);
424 idct(jpeg->dcts, jpeg->out, jpeg->dquant[0],
425 IFIX(128.5), max[0]);
426 idct(jpeg->dcts + 64, jpeg->out + 64, jpeg->dquant[0],
427 IFIX(128.5), max[1]);
428 idct(jpeg->dcts + 128, jpeg->out + 128, jpeg->dquant[0],
429 IFIX(128.5), max[2]);
430 idct(jpeg->dcts + 192, jpeg->out + 192, jpeg->dquant[0],
431 IFIX(128.5), max[3]);
432 idct(jpeg->dcts + 256, jpeg->out + 256, jpeg->dquant[1],
434 idct(jpeg->dcts + 320, jpeg->out + 320, jpeg->dquant[2],
439 col221111_32(jpeg->out,
440 pic + (my * 16 * mloffset + mx * 16 * 4),
445 pic + (my * 16 * mloffset + mx * 16 * 3),
449 col221111_16(jpeg->out,
450 pic + (my * 16 * mloffset + mx * 16 * 2),
454 return ERR_DEPTH_MISMATCH;
460 m = dec_readmarker(&jpeg->in);
467 /****************************************************************/
468 /************** huffman decoder ***************/
469 /****************************************************************/
471 static int fillbits __P((struct in *, int, unsigned int));
472 static int dec_rec2 __P((struct in *, struct dec_hufftbl *, int *, int, int));
474 static void setinput(struct in *in, unsigned char *p)
482 static int fillbits(struct in *in, int le, unsigned int bi)
488 in->bits = bi << 16, le += 16;
493 if (b == 0xff && (m = *in->p++) != 0) {
495 if (in->func && (m = in->func(in->data)) == 0)
500 bi = bi << 16, le += 16;
506 in->bits = bi; /* tmp... 2 return values needed */
510 static int dec_readmarker(struct in *in)
514 in->left = fillbits(in, in->left, in->bits);
515 if ((m = in->marker) == 0)
522 #define LEBI_DCL int le, bi
523 #define LEBI_GET(in) (le = in->left, bi = in->bits)
524 #define LEBI_PUT(in) (in->left = le, in->bits = bi)
526 #define GETBITS(in, n) ( \
527 (le < (n) ? le = fillbits(in, le, bi), bi = in->bits : 0), \
529 bi >> le & ((1 << (n)) - 1) \
532 #define UNGETBITS(in, n) ( \
537 static int dec_rec2(struct in *in, struct dec_hufftbl *hu, int *runp,
544 UNGETBITS(in, i & 127);
549 (c = ((c << 1) | GETBITS(in, 1))) >= (hu->maxcode[i]); i++);
551 in->marker = M_BADHUFF;
554 i = hu->vals[hu->valptr[i] + c - hu->maxcode[i - 1] * 2];
558 if (i == 0) { /* sigh, 0xf0 is 11 bit */
564 if (c < (1 << (i - 1)))
570 #define DEC_REC(in, hu, r, i) ( \
571 r = GETBITS(in, DECBITS), \
575 UNGETBITS(in, i & 127), \
582 i = dec_rec2(in, hu, &r, r, i), \
588 static void decode_mcus(struct in *in, int *dct, int n, struct scan *sc,
591 struct dec_hufftbl *hu;
595 memset(dct, 0, n * 64 * sizeof(*dct));
599 *dct++ = (sc->dc += DEC_REC(in, hu, r, t));
604 t = DEC_REC(in, hu, r, t);
605 if (t == 0 && r == 0) {
620 static void dec_makehuff(struct dec_hufftbl *hu, int *hufflen,
621 unsigned char *huffvals)
623 int code, k, i, j, d, x, c, v;
624 for (i = 0; i < (1 << DECBITS); i++)
630 * value v already known, run r, backup u bits:
631 * vvvvvvvvvvvvvvvv 0000 rrrr 1 uuuuuuu
632 * value unknown, size b bits, run r, backup u bits:
633 * 000000000000bbbb 0000 rrrr 0 uuuuuuu
634 * value and size unknown:
635 * 0000000000000000 0000 0000 0 0000000
640 for (i = 0; i < 16; i++, code <<= 1) { /* sizes */
642 for (j = 0; j < hufflen[i]; j++) {
643 hu->vals[k] = *huffvals++;
645 c = code << (DECBITS - 1 - i);
646 v = hu->vals[k] & 0x0f; /* size */
647 for (d = 1 << (DECBITS - 1 - i); --d >= 0;) {
648 if (v + i < DECBITS) { /* both fit in table */
649 x = d >> (DECBITS - 1 - v - i);
650 if (v && x < (1 << (v - 1)))
652 x = x << 16 | (hu->vals[k] & 0xf0) << 4 |
653 (DECBITS - (i + 1 + v)) | 128;
655 x = v << 16 | (hu->vals[k] & 0xf0) << 4 |
657 hu->llvals[c | d] = x;
663 hu->maxcode[i] = code;
665 hu->maxcode[16] = 0x20000; /* always terminate decode */
668 /****************************************************************/
669 /************** idct ***************/
670 /****************************************************************/
672 #define ONE ((PREC)IFIX(1.))
673 #define S2 ((PREC)IFIX(0.382683432))
674 #define C2 ((PREC)IFIX(0.923879532))
675 #define C4 ((PREC)IFIX(0.707106781))
677 #define S22 ((PREC)IFIX(2 * 0.382683432))
678 #define C22 ((PREC)IFIX(2 * 0.923879532))
679 #define IC4 ((PREC)IFIX(1 / 0.707106781))
681 #define C3IC1 ((PREC)IFIX(0.847759065)) /* c3/c1 */
682 #define C5IC1 ((PREC)IFIX(0.566454497)) /* c5/c1 */
683 #define C7IC1 ((PREC)IFIX(0.198912367)) /* c7/c1 */
685 #define XPP(a,b) (t = a + b, b = a - b, a = t)
686 #define XMP(a,b) (t = a - b, b = a + b, a = t)
687 #define XPM(a,b) (t = a + b, b = b - a, a = t)
689 #define ROT(a,b,s,c) ( t = IMULT(a + b, s), \
690 a = IMULT(a, c - s) + t, \
691 b = IMULT(b, c + s) - t)
697 t2 = IMULT(t2, IC4) - t3, \
703 t5 = IMULT(t5, IC4), \
704 ROT(t4, t6, S22, C22), \
714 static unsigned char zig2[64] = {
715 0, 2, 3, 9, 10, 20, 21, 35,
716 14, 16, 25, 31, 39, 46, 50, 57,
717 5, 7, 12, 18, 23, 33, 37, 48,
718 27, 29, 41, 44, 52, 55, 59, 62,
719 15, 26, 30, 40, 45, 51, 56, 58,
720 1, 4, 8, 11, 19, 22, 34, 36,
721 28, 42, 43, 53, 54, 60, 61, 63,
722 6, 13, 17, 24, 32, 38, 47, 49
725 static void idct(int *in, int *out, PREC * quant, PREC off, int max)
727 PREC t0, t1, t2, t3, t4, t5, t6, t7, t;
730 unsigned char *zig2p;
734 t0 += in[0] * quant[0];
735 for (i = 0; i < 64; i++)
741 for (i = 0; i < 8; i++) {
743 t0 += in[j] * quant[j];
745 t5 = in[j] * quant[j];
747 t2 = in[j] * quant[j];
749 t7 = in[j] * quant[j];
751 t1 = in[j] * quant[j];
753 t4 = in[j] * quant[j];
755 t3 = in[j] * quant[j];
757 t6 = in[j] * quant[j];
770 for (i = 0; i < 8; i++) {
780 out[8 * i + 0] = ITOINT(t0);
781 out[8 * i + 1] = ITOINT(t1);
782 out[8 * i + 2] = ITOINT(t2);
783 out[8 * i + 3] = ITOINT(t3);
784 out[8 * i + 4] = ITOINT(t4);
785 out[8 * i + 5] = ITOINT(t5);
786 out[8 * i + 6] = ITOINT(t6);
787 out[8 * i + 7] = ITOINT(t7);
791 static unsigned char zig[64] = {
792 0, 1, 5, 6, 14, 15, 27, 28,
793 2, 4, 7, 13, 16, 26, 29, 42,
794 3, 8, 12, 17, 25, 30, 41, 43,
795 9, 11, 18, 24, 31, 40, 44, 53,
796 10, 19, 23, 32, 39, 45, 52, 54,
797 20, 22, 33, 38, 46, 51, 55, 60,
798 21, 34, 37, 47, 50, 56, 59, 61,
799 35, 36, 48, 49, 57, 58, 62, 63
802 static PREC aaidct[8] = {
803 IFIX(0.3535533906), IFIX(0.4903926402),
804 IFIX(0.4619397663), IFIX(0.4157348062),
805 IFIX(0.3535533906), IFIX(0.2777851165),
806 IFIX(0.1913417162), IFIX(0.0975451610)
810 static void idctqtab(unsigned char *qin, PREC * qout)
814 for (i = 0; i < 8; i++)
815 for (j = 0; j < 8; j++)
816 qout[zig[i * 8 + j]] = qin[zig[i * 8 + j]] *
817 IMULT(aaidct[i], aaidct[j]);
820 static void scaleidctqtab(PREC * q, PREC sc)
824 for (i = 0; i < 64; i++)
825 q[i] = IMULT(q[i], sc);
828 /****************************************************************/
829 /************** color decoder ***************/
830 /****************************************************************/
835 * YCbCr Color transformation:
837 * y:0..255 Cb:-128..127 Cr:-128..127
839 * R = Y + 1.40200 * Cr
840 * G = Y - 0.34414 * Cb - 0.71414 * Cr
841 * B = Y + 1.77200 * Cb
846 * Cg = 0.19421 * Cb + .50937 * Cr;
852 * Cg = (50 * Cb + 130 * Cr + 128) >> 8;
855 static void initcol(PREC q[][64])
857 scaleidctqtab(q[1], IFIX(1.77200));
858 scaleidctqtab(q[2], IFIX(1.40200));
861 /* This is optimized for the stupid sun SUNWspro compiler. */
862 #define STORECLAMP(a,x) \
865 (unsigned int)(x) >= 256 ? \
866 ((a) = (x) < 0 ? 0 : 255) \
871 #define CLAMP(x) ((unsigned int)(x) >= 256 ? ((x) < 0 ? 0 : 255) : (x))
875 #define CBCRCG(yin, xin) \
877 cb = outc[0 +yin*8+xin], \
878 cr = outc[64+yin*8+xin], \
879 cg = (50 * cb + 130 * cr + 128) >> 8 \
884 #define CBCRCG(yin, xin) \
886 cb = outc[0 +yin*8+xin], \
887 cr = outc[64+yin*8+xin], \
888 cg = (3 * cb + 8 * cr) >> 4 \
893 #ifdef __LITTLE_ENDIAN
894 #define PIC(yin, xin, p, xout) \
896 y = outy[(yin) * 8 + xin], \
897 STORECLAMP(p[(xout) * 3 + 2], y + cr), \
898 STORECLAMP(p[(xout) * 3 + 1], y - cg), \
899 STORECLAMP(p[(xout) * 3 + 0], y + cb) \
902 #define PIC(yin, xin, p, xout) \
904 y = outy[(yin) * 8 + xin], \
905 STORECLAMP(p[(xout) * 3 + 0], y + cr), \
906 STORECLAMP(p[(xout) * 3 + 1], y - cg), \
907 STORECLAMP(p[(xout) * 3 + 2], y + cb) \
911 #ifdef __LITTLE_ENDIAN
912 #define PIC_16(yin, xin, p, xout, add) \
914 y = outy[(yin) * 8 + xin], \
915 y = ((CLAMP(y + cr + add*2+1) & 0xf8) << 8) | \
916 ((CLAMP(y - cg + add ) & 0xfc) << 3) | \
917 ((CLAMP(y + cb + add*2+1) ) >> 3), \
918 p[(xout) * 2 + 0] = y & 0xff, \
919 p[(xout) * 2 + 1] = y >> 8 \
923 #define PIC_16(yin, xin, p, xout, add) \
925 y = outy[(yin) * 8 + xin], \
926 y = ((CLAMP(y + cr + add*2+1) & 0xf8) << 7) | \
927 ((CLAMP(y - cg + add*2+1) & 0xf8) << 2) | \
928 ((CLAMP(y + cb + add*2+1) ) >> 3), \
929 p[(xout) * 2 + 0] = y >> 8, \
930 p[(xout) * 2 + 1] = y & 0xff \
933 #define PIC_16(yin, xin, p, xout, add) \
935 y = outy[(yin) * 8 + xin], \
936 y = ((CLAMP(y + cr + add*2+1) & 0xf8) << 8) | \
937 ((CLAMP(y - cg + add ) & 0xfc) << 3) | \
938 ((CLAMP(y + cb + add*2+1) ) >> 3), \
939 p[(xout) * 2 + 0] = y >> 8, \
940 p[(xout) * 2 + 1] = y & 0xff \
945 #define PIC_32(yin, xin, p, xout) \
947 y = outy[(yin) * 8 + xin], \
948 STORECLAMP(p[(xout) * 4 + 0], y + cr), \
949 STORECLAMP(p[(xout) * 4 + 1], y - cg), \
950 STORECLAMP(p[(xout) * 4 + 2], y + cb), \
951 p[(xout) * 4 + 3] = 0 \
954 #define PIC221111(xin) \
957 PIC(xin / 4 * 8 + 0, (xin & 3) * 2 + 0, pic0, xin * 2 + 0), \
958 PIC(xin / 4 * 8 + 0, (xin & 3) * 2 + 1, pic0, xin * 2 + 1), \
959 PIC(xin / 4 * 8 + 1, (xin & 3) * 2 + 0, pic1, xin * 2 + 0), \
960 PIC(xin / 4 * 8 + 1, (xin & 3) * 2 + 1, pic1, xin * 2 + 1) \
963 #define PIC221111_16(xin) \
966 PIC_16(xin / 4 * 8 + 0, (xin & 3) * 2 + 0, pic0, xin * 2 + 0, 3), \
967 PIC_16(xin / 4 * 8 + 0, (xin & 3) * 2 + 1, pic0, xin * 2 + 1, 0), \
968 PIC_16(xin / 4 * 8 + 1, (xin & 3) * 2 + 0, pic1, xin * 2 + 0, 1), \
969 PIC_16(xin / 4 * 8 + 1, (xin & 3) * 2 + 1, pic1, xin * 2 + 1, 2) \
972 #define PIC221111_32(xin) \
975 PIC_32(xin / 4 * 8 + 0, (xin & 3) * 2 + 0, pic0, xin * 2 + 0), \
976 PIC_32(xin / 4 * 8 + 0, (xin & 3) * 2 + 1, pic0, xin * 2 + 1), \
977 PIC_32(xin / 4 * 8 + 1, (xin & 3) * 2 + 0, pic1, xin * 2 + 0), \
978 PIC_32(xin / 4 * 8 + 1, (xin & 3) * 2 + 1, pic1, xin * 2 + 1) \
981 static void col221111(int *out, unsigned char *pic, int width)
984 unsigned char *pic0, *pic1;
992 for (i = 2; i > 0; i--) {
993 for (j = 4; j > 0; j--) {
994 for (k = 0; k < 8; k++) {
1002 outy += 64 * 2 - 16 * 4;
1006 static void col221111_16(int *out, unsigned char *pic, int width)
1009 unsigned char *pic0, *pic1;
1016 outc = out + 64 * 4;
1017 for (i = 2; i > 0; i--) {
1018 for (j = 4; j > 0; j--) {
1019 for (k = 0; k < 8; k++) {
1027 outy += 64 * 2 - 16 * 4;
1031 static void col221111_32(int *out, unsigned char *pic, int width)
1034 unsigned char *pic0, *pic1;
1041 outc = out + 64 * 4;
1042 for (i = 2; i > 0; i--) {
1043 for (j = 4; j > 0; j--) {
1044 for (k = 0; k < 8; k++) {
1052 outy += 64 * 2 - 16 * 4;