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