* resync without endless loop
[ffmpeg.git] / postproc / yuv2rgb.c
1 /*
2  * yuv2rgb.c, Software YUV to RGB coverter
3  *
4  *  Copyright (C) 1999, Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
5  *  All Rights Reserved.
6  *
7  *  Functions broken out from display_x11.c and several new modes
8  *  added by HÃ¥kan Hjort <d95hjort@dtek.chalmers.se>
9  *
10  *  15 & 16 bpp support by Franck Sicard <Franck.Sicard@solsoft.fr>
11  *
12  *  This file is part of mpeg2dec, a free MPEG-2 video decoder
13  *
14  *  mpeg2dec is free software; you can redistribute it and/or modify
15  *  it under the terms of the GNU General Public License as published by
16  *  the Free Software Foundation; either version 2, or (at your option)
17  *  any later version.
18  *
19  *  mpeg2dec is distributed in the hope that it will be useful,
20  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
21  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  *  GNU General Public License for more details.
23  *
24  *  You should have received a copy of the GNU General Public License
25  *  along with GNU Make; see the file COPYING.  If not, write to
26  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
27  *
28  * MMX/MMX2 Template stuff from Michael Niedermayer (michaelni@gmx.at) (needed for fast movntq support)
29  * 1,4,8bpp support by Michael Niedermayer (michaelni@gmx.at)
30  */
31
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <inttypes.h>
35
36 #include "config.h"
37 //#include "video_out.h"
38 #include "rgb2rgb.h"
39 #include "../cpudetect.h"
40 #include "../mangle.h"
41 #include "../mp_msg.h"
42
43 #ifdef HAVE_MLIB
44 #include "yuv2rgb_mlib.c"
45 #endif
46
47 #define DITHER1XBPP // only for mmx
48
49 #ifdef ARCH_X86
50 #define CAN_COMPILE_X86_ASM
51 #endif
52
53 const uint8_t  __attribute__((aligned(8))) dither_2x2_4[2][8]={
54 {  1,   3,   1,   3,   1,   3,   1,   3, },
55 {  2,   0,   2,   0,   2,   0,   2,   0, },
56 };
57
58 const uint8_t  __attribute__((aligned(8))) dither_2x2_8[2][8]={
59 {  6,   2,   6,   2,   6,   2,   6,   2, },
60 {  0,   4,   0,   4,   0,   4,   0,   4, },
61 };
62
63 const uint8_t  __attribute__((aligned(8))) dither_8x8_32[8][8]={
64 { 17,   9,  23,  15,  16,   8,  22,  14, },
65 {  5,  29,   3,  27,   4,  28,   2,  26, },
66 { 21,  13,  19,  11,  20,  12,  18,  10, },
67 {  0,  24,   6,  30,   1,  25,   7,  31, },
68 { 16,   8,  22,  14,  17,   9,  23,  15, },
69 {  4,  28,   2,  26,   5,  29,   3,  27, },
70 { 20,  12,  18,  10,  21,  13,  19,  11, },
71 {  1,  25,   7,  31,   0,  24,   6,  30, },
72 };
73
74 #if 0
75 const uint8_t  __attribute__((aligned(8))) dither_8x8_64[8][8]={
76 {  0,  48,  12,  60,   3,  51,  15,  63, },
77 { 32,  16,  44,  28,  35,  19,  47,  31, },
78 {  8,  56,   4,  52,  11,  59,   7,  55, },
79 { 40,  24,  36,  20,  43,  27,  39,  23, },
80 {  2,  50,  14,  62,   1,  49,  13,  61, },
81 { 34,  18,  46,  30,  33,  17,  45,  29, },
82 { 10,  58,   6,  54,   9,  57,   5,  53, },
83 { 42,  26,  38,  22,  41,  25,  37,  21, },
84 };
85 #endif
86
87 const uint8_t  __attribute__((aligned(8))) dither_8x8_73[8][8]={
88 {  0,  55,  14,  68,   3,  58,  17,  72, },
89 { 37,  18,  50,  32,  40,  22,  54,  35, },
90 {  9,  64,   5,  59,  13,  67,   8,  63, },
91 { 46,  27,  41,  23,  49,  31,  44,  26, },
92 {  2,  57,  16,  71,   1,  56,  15,  70, },
93 { 39,  21,  52,  34,  38,  19,  51,  33, },
94 { 11,  66,   7,  62,  10,  65,   6,  60, },
95 { 48,  30,  43,  25,  47,  29,  42,  24, },
96 };
97
98 #if 0
99 const uint8_t  __attribute__((aligned(8))) dither_8x8_128[8][8]={
100 { 68,  36,  92,  60,  66,  34,  90,  58, },
101 { 20, 116,  12, 108,  18, 114,  10, 106, },
102 { 84,  52,  76,  44,  82,  50,  74,  42, },
103 {  0,  96,  24, 120,   6, 102,  30, 126, },
104 { 64,  32,  88,  56,  70,  38,  94,  62, },
105 { 16, 112,   8, 104,  22, 118,  14, 110, },
106 { 80,  48,  72,  40,  86,  54,  78,  46, },
107 {  4, 100,  28, 124,   2,  98,  26, 122, },
108 };
109 #endif
110
111 #if 1
112 const uint8_t  __attribute__((aligned(8))) dither_8x8_220[8][8]={
113 {117,  62, 158, 103, 113,  58, 155, 100, },
114 { 34, 199,  21, 186,  31, 196,  17, 182, },
115 {144,  89, 131,  76, 141,  86, 127,  72, },
116 {  0, 165,  41, 206,  10, 175,  52, 217, },
117 {110,  55, 151,  96, 120,  65, 162, 107, },
118 { 28, 193,  14, 179,  38, 203,  24, 189, },
119 {138,  83, 124,  69, 148,  93, 134,  79, },
120 {  7, 172,  48, 213,   3, 168,  45, 210, },
121 };
122 #elif 1
123 // tries to correct a gamma of 1.5
124 const uint8_t  __attribute__((aligned(8))) dither_8x8_220[8][8]={
125 {  0, 143,  18, 200,   2, 156,  25, 215, },
126 { 78,  28, 125,  64,  89,  36, 138,  74, },
127 { 10, 180,   3, 161,  16, 195,   8, 175, },
128 {109,  51,  93,  38, 121,  60, 105,  47, },
129 {  1, 152,  23, 210,   0, 147,  20, 205, },
130 { 85,  33, 134,  71,  81,  30, 130,  67, },
131 { 14, 190,   6, 171,  12, 185,   5, 166, },
132 {117,  57, 101,  44, 113,  54,  97,  41, },
133 };
134 #elif 1
135 // tries to correct a gamma of 2.0
136 const uint8_t  __attribute__((aligned(8))) dither_8x8_220[8][8]={
137 {  0, 124,   8, 193,   0, 140,  12, 213, },
138 { 55,  14, 104,  42,  66,  19, 119,  52, },
139 {  3, 168,   1, 145,   6, 187,   3, 162, },
140 { 86,  31,  70,  21,  99,  39,  82,  28, },
141 {  0, 134,  11, 206,   0, 129,   9, 200, },
142 { 62,  17, 114,  48,  58,  16, 109,  45, },
143 {  5, 181,   2, 157,   4, 175,   1, 151, },
144 { 95,  36,  78,  26,  90,  34,  74,  24, },
145 };
146 #else
147 // tries to correct a gamma of 2.5
148 const uint8_t  __attribute__((aligned(8))) dither_8x8_220[8][8]={
149 {  0, 107,   3, 187,   0, 125,   6, 212, },
150 { 39,   7,  86,  28,  49,  11, 102,  36, },
151 {  1, 158,   0, 131,   3, 180,   1, 151, },
152 { 68,  19,  52,  12,  81,  25,  64,  17, },
153 {  0, 119,   5, 203,   0, 113,   4, 195, },
154 { 45,   9,  96,  33,  42,   8,  91,  30, },
155 {  2, 172,   1, 144,   2, 165,   0, 137, },
156 { 77,  23,  60,  15,  72,  21,  56,  14, },
157 };
158 #endif
159
160 #ifdef CAN_COMPILE_X86_ASM
161
162 /* hope these constant values are cache line aligned */
163 uint64_t __attribute__((aligned(8))) mmx_80w = 0x0080008000800080;
164 uint64_t __attribute__((aligned(8))) mmx_10w = 0x1010101010101010;
165 uint64_t __attribute__((aligned(8))) mmx_00ffw = 0x00ff00ff00ff00ff;
166 uint64_t __attribute__((aligned(8))) mmx_Y_coeff = 0x253f253f253f253f;
167
168 /* hope these constant values are cache line aligned */
169 uint64_t __attribute__((aligned(8))) mmx_U_green = 0xf37df37df37df37d;
170 uint64_t __attribute__((aligned(8))) mmx_U_blue = 0x4093409340934093;
171 uint64_t __attribute__((aligned(8))) mmx_V_red = 0x3312331233123312;
172 uint64_t __attribute__((aligned(8))) mmx_V_green = 0xe5fce5fce5fce5fc;
173
174 /* hope these constant values are cache line aligned */
175 uint64_t __attribute__((aligned(8))) mmx_redmask = 0xf8f8f8f8f8f8f8f8;
176 uint64_t __attribute__((aligned(8))) mmx_grnmask = 0xfcfcfcfcfcfcfcfc;
177
178 uint64_t __attribute__((aligned(8))) M24A=   0x00FF0000FF0000FFLL;
179 uint64_t __attribute__((aligned(8))) M24B=   0xFF0000FF0000FF00LL;
180 uint64_t __attribute__((aligned(8))) M24C=   0x0000FF0000FF0000LL;
181
182 // the volatile is required because gcc otherwise optimizes some writes away not knowing that these
183 // are read in the asm block
184 volatile uint64_t __attribute__((aligned(8))) b5Dither;
185 volatile uint64_t __attribute__((aligned(8))) g5Dither;
186 volatile uint64_t __attribute__((aligned(8))) g6Dither;
187 volatile uint64_t __attribute__((aligned(8))) r5Dither;
188
189 uint64_t __attribute__((aligned(8))) dither4[2]={
190         0x0103010301030103LL,
191         0x0200020002000200LL,};
192
193 uint64_t __attribute__((aligned(8))) dither8[2]={
194         0x0602060206020602LL,
195         0x0004000400040004LL,};
196
197 #undef HAVE_MMX
198 #undef ARCH_X86
199
200 //MMX versions
201 #undef RENAME
202 #define HAVE_MMX
203 #undef HAVE_MMX2
204 #undef HAVE_3DNOW
205 #define ARCH_X86
206 #define RENAME(a) a ## _MMX
207 #include "yuv2rgb_template.c"
208
209 //MMX2 versions
210 #undef RENAME
211 #define HAVE_MMX
212 #define HAVE_MMX2
213 #undef HAVE_3DNOW
214 #define ARCH_X86
215 #define RENAME(a) a ## _MMX2
216 #include "yuv2rgb_template.c"
217
218 #endif // CAN_COMPILE_X86_ASM
219
220 uint32_t matrix_coefficients = 6;
221
222 const int32_t Inverse_Table_6_9[8][4] = {
223     {117504, 138453, 13954, 34903}, /* no sequence_display_extension */
224     {117504, 138453, 13954, 34903}, /* ITU-R Rec. 709 (1990) */
225     {104597, 132201, 25675, 53279}, /* unspecified */
226     {104597, 132201, 25675, 53279}, /* reserved */
227     {104448, 132798, 24759, 53109}, /* FCC */
228     {104597, 132201, 25675, 53279}, /* ITU-R Rec. 624-4 System B, G */
229     {104597, 132201, 25675, 53279}, /* SMPTE 170M */
230     {117579, 136230, 16907, 35559}  /* SMPTE 240M (1987) */
231 };
232
233 void *yuv2rgb_c_init (unsigned bpp, int mode, void *table_rV[256], void *table_gU[256], int table_gV[256], void *table_bU[256]);
234
235 yuv2rgb_fun yuv2rgb;
236
237 static void (* yuv2rgb_c_internal) (uint8_t *, uint8_t *,
238                                     uint8_t *, uint8_t *,
239                                     void *, void *, int, int);
240
241 static void yuv2rgb_c (void * dst, uint8_t * py,
242                        uint8_t * pu, uint8_t * pv,
243                        unsigned h_size, unsigned v_size,
244                        unsigned rgb_stride, unsigned y_stride, unsigned uv_stride)
245 {
246     v_size >>= 1;
247
248     while (v_size--) {
249         yuv2rgb_c_internal (py, py + y_stride, pu, pv, dst, dst + rgb_stride,
250                             h_size, v_size<<1);
251
252         py += 2 * y_stride;
253         pu += uv_stride;
254         pv += uv_stride;
255         dst += 2 * rgb_stride;
256     }
257 }
258
259 void * table_rV[256];
260 void * table_gU[256];
261 int table_gV[256];
262 void * table_bU[256];
263
264 void yuv2rgb_init (unsigned bpp, int mode)
265 {
266     yuv2rgb = NULL;
267 #ifdef CAN_COMPILE_X86_ASM
268     if(gCpuCaps.hasMMX2)
269     {
270         if (yuv2rgb == NULL /*&& (config.flags & VO_MMX_ENABLE)*/) {
271                 yuv2rgb = yuv2rgb_init_MMX2 (bpp, mode);
272                 if (yuv2rgb != NULL)
273                         mp_msg(MSGT_SWS,MSGL_INFO,"Using MMX2 for colorspace transform\n");
274                 else
275                         mp_msg(MSGT_SWS,MSGL_WARN,"Cannot init MMX2 colorspace transform\n");
276         }
277     }
278     else if(gCpuCaps.hasMMX)
279     {
280         if (yuv2rgb == NULL /*&& (config.flags & VO_MMX_ENABLE)*/) {
281                 yuv2rgb = yuv2rgb_init_MMX (bpp, mode);
282                 if (yuv2rgb != NULL)
283                         mp_msg(MSGT_SWS,MSGL_INFO,"Using MMX for colorspace transform\n");
284                 else
285                         mp_msg(MSGT_SWS,MSGL_WARN,"Cannot init MMX colorspace transform\n");
286         }
287     }
288 #endif
289 #ifdef HAVE_MLIB
290     if (yuv2rgb == NULL /*&& (config.flags & VO_MLIB_ENABLE)*/) {
291         yuv2rgb = yuv2rgb_init_mlib (bpp, mode);
292         if (yuv2rgb != NULL)
293             mp_msg(MSGT_SWS,MSGL_INFO,"Using mlib for colorspace transform\n");
294     }
295 #endif
296     if (yuv2rgb == NULL) {
297         mp_msg(MSGT_SWS,MSGL_INFO,"No accelerated colorspace conversion found\n");
298         yuv2rgb_c_init (bpp, mode, table_rV, table_gU, table_gV, table_bU);
299         yuv2rgb = (yuv2rgb_fun)yuv2rgb_c;
300     }
301 }
302
303 #define RGB(i)                                  \
304         U = pu[i];                              \
305         V = pv[i];                              \
306         r = table_rV[V];                        \
307         g = table_gU[U] + table_gV[V];          \
308         b = table_bU[U];
309
310 #define DST1(i)                                 \
311         Y = py_1[2*i];                          \
312         dst_1[2*i] = r[Y] + g[Y] + b[Y];        \
313         Y = py_1[2*i+1];                        \
314         dst_1[2*i+1] = r[Y] + g[Y] + b[Y];
315
316 #define DST2(i)                                 \
317         Y = py_2[2*i];                          \
318         dst_2[2*i] = r[Y] + g[Y] + b[Y];        \
319         Y = py_2[2*i+1];                        \
320         dst_2[2*i+1] = r[Y] + g[Y] + b[Y];
321
322 #define DST1RGB(i)                                                      \
323         Y = py_1[2*i];                                                  \
324         dst_1[6*i] = r[Y]; dst_1[6*i+1] = g[Y]; dst_1[6*i+2] = b[Y];    \
325         Y = py_1[2*i+1];                                                \
326         dst_1[6*i+3] = r[Y]; dst_1[6*i+4] = g[Y]; dst_1[6*i+5] = b[Y];
327
328 #define DST2RGB(i)                                                      \
329         Y = py_2[2*i];                                                  \
330         dst_2[6*i] = r[Y]; dst_2[6*i+1] = g[Y]; dst_2[6*i+2] = b[Y];    \
331         Y = py_2[2*i+1];                                                \
332         dst_2[6*i+3] = r[Y]; dst_2[6*i+4] = g[Y]; dst_2[6*i+5] = b[Y];
333
334 #define DST1BGR(i)                                                      \
335         Y = py_1[2*i];                                                  \
336         dst_1[6*i] = b[Y]; dst_1[6*i+1] = g[Y]; dst_1[6*i+2] = r[Y];    \
337         Y = py_1[2*i+1];                                                \
338         dst_1[6*i+3] = b[Y]; dst_1[6*i+4] = g[Y]; dst_1[6*i+5] = r[Y];
339
340 #define DST2BGR(i)                                                      \
341         Y = py_2[2*i];                                                  \
342         dst_2[6*i] = b[Y]; dst_2[6*i+1] = g[Y]; dst_2[6*i+2] = r[Y];    \
343         Y = py_2[2*i+1];                                                \
344         dst_2[6*i+3] = b[Y]; dst_2[6*i+4] = g[Y]; dst_2[6*i+5] = r[Y];
345
346 static void yuv2rgb_c_32 (uint8_t * py_1, uint8_t * py_2,
347                           uint8_t * pu, uint8_t * pv,
348                           void * _dst_1, void * _dst_2, int h_size, int v_pos)
349 {
350     int U, V, Y;
351     uint32_t * r, * g, * b;
352     uint32_t * dst_1, * dst_2;
353
354     h_size >>= 3;
355     dst_1 = _dst_1;
356     dst_2 = _dst_2;
357
358     while (h_size--) {
359         RGB(0);
360         DST1(0);
361         DST2(0);
362
363         RGB(1);
364         DST2(1);
365         DST1(1);
366
367         RGB(2);
368         DST1(2);
369         DST2(2);
370
371         RGB(3);
372         DST2(3);
373         DST1(3);
374
375         pu += 4;
376         pv += 4;
377         py_1 += 8;
378         py_2 += 8;
379         dst_1 += 8;
380         dst_2 += 8;
381     }
382 }
383
384 // This is very near from the yuv2rgb_c_32 code
385 static void yuv2rgb_c_24_rgb (uint8_t * py_1, uint8_t * py_2,
386                               uint8_t * pu, uint8_t * pv,
387                               void * _dst_1, void * _dst_2, int h_size, int v_pos)
388 {
389     int U, V, Y;
390     uint8_t * r, * g, * b;
391     uint8_t * dst_1, * dst_2;
392
393     h_size >>= 3;
394     dst_1 = _dst_1;
395     dst_2 = _dst_2;
396
397     while (h_size--) {
398         RGB(0);
399         DST1RGB(0);
400         DST2RGB(0);
401
402         RGB(1);
403         DST2RGB(1);
404         DST1RGB(1);
405
406         RGB(2);
407         DST1RGB(2);
408         DST2RGB(2);
409
410         RGB(3);
411         DST2RGB(3);
412         DST1RGB(3);
413
414         pu += 4;
415         pv += 4;
416         py_1 += 8;
417         py_2 += 8;
418         dst_1 += 24;
419         dst_2 += 24;
420     }
421 }
422
423 // only trivial mods from yuv2rgb_c_24_rgb
424 static void yuv2rgb_c_24_bgr (uint8_t * py_1, uint8_t * py_2,
425                               uint8_t * pu, uint8_t * pv,
426                               void * _dst_1, void * _dst_2, int h_size, int v_pos)
427 {
428     int U, V, Y;
429     uint8_t * r, * g, * b;
430     uint8_t * dst_1, * dst_2;
431
432     h_size >>= 3;
433     dst_1 = _dst_1;
434     dst_2 = _dst_2;
435
436     while (h_size--) {
437         RGB(0);
438         DST1BGR(0);
439         DST2BGR(0);
440
441         RGB(1);
442         DST2BGR(1);
443         DST1BGR(1);
444
445         RGB(2);
446         DST1BGR(2);
447         DST2BGR(2);
448
449         RGB(3);
450         DST2BGR(3);
451         DST1BGR(3);
452
453         pu += 4;
454         pv += 4;
455         py_1 += 8;
456         py_2 += 8;
457         dst_1 += 24;
458         dst_2 += 24;
459     }
460 }
461
462 // This is exactly the same code as yuv2rgb_c_32 except for the types of
463 // r, g, b, dst_1, dst_2
464 static void yuv2rgb_c_16 (uint8_t * py_1, uint8_t * py_2,
465                           uint8_t * pu, uint8_t * pv,
466                           void * _dst_1, void * _dst_2, int h_size, int v_pos)
467 {
468     int U, V, Y;
469     uint16_t * r, * g, * b;
470     uint16_t * dst_1, * dst_2;
471
472     h_size >>= 3;
473     dst_1 = _dst_1;
474     dst_2 = _dst_2;
475
476     while (h_size--) {
477         RGB(0);
478         DST1(0);
479         DST2(0);
480
481         RGB(1);
482         DST2(1);
483         DST1(1);
484
485         RGB(2);
486         DST1(2);
487         DST2(2);
488
489         RGB(3);
490         DST2(3);
491         DST1(3);
492
493         pu += 4;
494         pv += 4;
495         py_1 += 8;
496         py_2 += 8;
497         dst_1 += 8;
498         dst_2 += 8;
499     }
500 }
501
502 // This is exactly the same code as yuv2rgb_c_32 except for the types of
503 // r, g, b, dst_1, dst_2
504 static void yuv2rgb_c_8  (uint8_t * py_1, uint8_t * py_2,
505                           uint8_t * pu, uint8_t * pv,
506                           void * _dst_1, void * _dst_2, int h_size, int v_pos)
507 {
508     int U, V, Y;
509     uint8_t * r, * g, * b;
510     uint8_t * dst_1, * dst_2;
511
512     h_size >>= 3;
513     dst_1 = _dst_1;
514     dst_2 = _dst_2;
515
516     while (h_size--) {
517         RGB(0);
518         DST1(0);
519         DST2(0);
520
521         RGB(1);
522         DST2(1);
523         DST1(1);
524
525         RGB(2);
526         DST1(2);
527         DST2(2);
528
529         RGB(3);
530         DST2(3);
531         DST1(3);
532
533         pu += 4;
534         pv += 4;
535         py_1 += 8;
536         py_2 += 8;
537         dst_1 += 8;
538         dst_2 += 8;
539     }
540 }
541
542 // r, g, b, dst_1, dst_2
543 static void yuv2rgb_c_8_ordered_dither  (uint8_t * py_1, uint8_t * py_2,
544                           uint8_t * pu, uint8_t * pv,
545                           void * _dst_1, void * _dst_2, int h_size, int v_pos)
546 {
547     int U, V, Y;
548     uint8_t * r, * g, * b;
549     uint8_t * dst_1, * dst_2;
550
551     h_size >>= 3;
552     dst_1 = _dst_1;
553     dst_2 = _dst_2;
554
555     while (h_size--) {
556         const uint8_t *d32= dither_8x8_32[v_pos&7];
557         const uint8_t *d64= dither_8x8_73[v_pos&7];
558 #define DST1bpp8(i,o)                                   \
559         Y = py_1[2*i];                          \
560         dst_1[2*i] = r[Y+d32[0+o]] + g[Y+d32[0+o]] + b[Y+d64[0+o]];     \
561         Y = py_1[2*i+1];                        \
562         dst_1[2*i+1] = r[Y+d32[1+o]] + g[Y+d32[1+o]] + b[Y+d64[1+o]];
563
564 #define DST2bpp8(i,o)                                   \
565         Y = py_2[2*i];                          \
566         dst_2[2*i] =  r[Y+d32[8+o]] + g[Y+d32[8+o]] + b[Y+d64[8+o]];    \
567         Y = py_2[2*i+1];                        \
568         dst_2[2*i+1] =  r[Y+d32[9+o]] + g[Y+d32[9+o]] + b[Y+d64[9+o]];
569
570
571         RGB(0);
572         DST1bpp8(0,0);
573         DST2bpp8(0,0);
574
575         RGB(1);
576         DST2bpp8(1,2);
577         DST1bpp8(1,2);
578
579         RGB(2);
580         DST1bpp8(2,4);
581         DST2bpp8(2,4);
582
583         RGB(3);
584         DST2bpp8(3,6);
585         DST1bpp8(3,6);
586
587         pu += 4;
588         pv += 4;
589         py_1 += 8;
590         py_2 += 8;
591         dst_1 += 8;
592         dst_2 += 8;
593     }
594 }
595
596
597 // This is exactly the same code as yuv2rgb_c_32 except for the types of
598 // r, g, b, dst_1, dst_2
599 static void yuv2rgb_c_4  (uint8_t * py_1, uint8_t * py_2,
600                           uint8_t * pu, uint8_t * pv,
601                           void * _dst_1, void * _dst_2, int h_size, int v_pos)
602 {
603     int U, V, Y, out;
604     uint8_t * r, * g, * b;
605     uint8_t * dst_1, * dst_2;
606
607     h_size >>= 3;
608     dst_1 = _dst_1;
609     dst_2 = _dst_2;
610
611     while (h_size--) {
612         RGB(0);
613         DST1(0);
614         DST2(0);
615
616         RGB(1);
617         DST2(1);
618         DST1(1);
619
620         RGB(2);
621         DST1(2);
622         DST2(2);
623
624         RGB(3);
625         DST2(3);
626         DST1(3);
627
628         pu += 4;
629         pv += 4;
630         py_1 += 8;
631         py_2 += 8;
632         dst_1 += 8;
633         dst_2 += 8;
634     }
635 }
636
637 static void yuv2rgb_c_4_ordered_dither  (uint8_t * py_1, uint8_t * py_2,
638                           uint8_t * pu, uint8_t * pv,
639                           void * _dst_1, void * _dst_2, int h_size, int v_pos)
640 {
641     int U, V, Y;
642     uint8_t * r, * g, * b;
643     uint8_t * dst_1, * dst_2;
644
645     h_size >>= 3;
646     dst_1 = _dst_1;
647     dst_2 = _dst_2;
648
649     while (h_size--) {
650         const uint8_t *d64= dither_8x8_73[v_pos&7];
651         const uint8_t *d128=dither_8x8_220[v_pos&7];
652
653 #define DST1bpp4(i,o)                                   \
654         Y = py_1[2*i];                          \
655         dst_1[2*i] = r[Y+d128[0+o]] + g[Y+d64[0+o]] + b[Y+d128[0+o]];   \
656         Y = py_1[2*i+1];                        \
657         dst_1[2*i+1] = r[Y+d128[1+o]] + g[Y+d64[1+o]] + b[Y+d128[1+o]];
658
659 #define DST2bpp4(i,o)                                   \
660         Y = py_2[2*i];                          \
661         dst_2[2*i] =  r[Y+d128[8+o]] + g[Y+d64[8+o]] + b[Y+d128[8+o]];  \
662         Y = py_2[2*i+1];                        \
663         dst_2[2*i+1] =  r[Y+d128[9+o]] + g[Y+d64[9+o]] + b[Y+d128[9+o]];
664
665
666         RGB(0);
667         DST1bpp4(0,0);
668         DST2bpp4(0,0);
669
670         RGB(1);
671         DST2bpp4(1,2);
672         DST1bpp4(1,2);
673
674         RGB(2);
675         DST1bpp4(2,4);
676         DST2bpp4(2,4);
677
678         RGB(3);
679         DST2bpp4(3,6);
680         DST1bpp4(3,6);
681
682         pu += 4;
683         pv += 4;
684         py_1 += 8;
685         py_2 += 8;
686         dst_1 += 8;
687         dst_2 += 8;
688     }
689 }
690
691 static void yuv2rgb_c_1_ordered_dither  (uint8_t * py_1, uint8_t * py_2,
692                           uint8_t * pu, uint8_t * pv,
693                           void * _dst_1, void * _dst_2, int h_size, int v_pos)
694 {
695     int U, V, Y;
696     uint8_t * r, * g, * b;
697     uint8_t * dst_1, * dst_2;
698
699     h_size >>= 3;
700     dst_1 = _dst_1;
701     dst_2 = _dst_2;
702     g= table_gU[128] + table_gV[128];
703
704     while (h_size--) {
705         const uint8_t *d128=dither_8x8_220[v_pos&7];
706         char out_1=0, out_2=0;
707
708 #define DST1bpp1(i,o)                                   \
709         Y = py_1[2*i];                          \
710         out_1+= out_1 + g[Y+d128[0+o]]; \
711         Y = py_1[2*i+1];                        \
712         out_1+= out_1 + g[Y+d128[1+o]];
713
714 #define DST2bpp1(i,o)                                   \
715         Y = py_2[2*i];                          \
716         out_2+= out_2 + g[Y+d128[8+o]]; \
717         Y = py_2[2*i+1];                        \
718         out_2+= out_2 + g[Y+d128[9+o]];
719
720         DST1bpp1(0,0);
721         DST2bpp1(0,0);
722
723         DST2bpp1(1,2);
724         DST1bpp1(1,2);
725
726         DST1bpp1(2,4);
727         DST2bpp1(2,4);
728
729         DST2bpp1(3,6);
730         DST1bpp1(3,6);
731         
732         dst_1[0]= out_1;
733         dst_2[0]= out_2;
734
735         pu += 4;
736         pv += 4;
737         py_1 += 8;
738         py_2 += 8;
739         dst_1 ++;
740         dst_2 ++;
741     }
742 }
743
744
745 static int div_round (int dividend, int divisor)
746 {
747     if (dividend > 0)
748         return (dividend + (divisor>>1)) / divisor;
749     else
750         return -((-dividend + (divisor>>1)) / divisor);
751 }
752
753 void *yuv2rgb_c_init (unsigned bpp, int mode, void *table_rV[256], void *table_gU[256], int table_gV[256], void *table_bU[256])
754 {  
755     int i;
756     uint8_t table_Y[1024];
757     uint32_t *table_32 = 0;
758     uint16_t *table_16 = 0;
759     uint8_t *table_8 = 0;
760     uint8_t *table_332 = 0;
761     uint8_t *table_121 = 0;
762     uint8_t *table_1 = 0;
763     int entry_size = 0;
764     void *table_r = 0, *table_g = 0, *table_b = 0;
765     void *table_start;
766
767     int crv = Inverse_Table_6_9[matrix_coefficients][0];
768     int cbu = Inverse_Table_6_9[matrix_coefficients][1];
769     int cgu = -Inverse_Table_6_9[matrix_coefficients][2];
770     int cgv = -Inverse_Table_6_9[matrix_coefficients][3];
771
772     for (i = 0; i < 1024; i++) {
773         int j;
774
775         j = (76309 * (i - 384 - 16) + 32768) >> 16;
776         j = (j < 0) ? 0 : ((j > 255) ? 255 : j);
777         table_Y[i] = j;
778     }
779
780     switch (bpp) {
781     case 32:
782         yuv2rgb_c_internal = yuv2rgb_c_32;
783
784         table_start= table_32 = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint32_t));
785
786         entry_size = sizeof (uint32_t);
787         table_r = table_32 + 197;
788         table_b = table_32 + 197 + 685;
789         table_g = table_32 + 197 + 2*682;
790
791         for (i = -197; i < 256+197; i++)
792             ((uint32_t *)table_r)[i] = table_Y[i+384] << ((mode==MODE_RGB) ? 16 : 0);
793         for (i = -132; i < 256+132; i++)
794             ((uint32_t *)table_g)[i] = table_Y[i+384] << 8;
795         for (i = -232; i < 256+232; i++)
796             ((uint32_t *)table_b)[i] = table_Y[i+384] << ((mode==MODE_RGB) ? 0 : 16);
797         break;
798
799     case 24:
800 //      yuv2rgb_c_internal = (mode==MODE_RGB) ? yuv2rgb_c_24_rgb : yuv2rgb_c_24_bgr;
801         yuv2rgb_c_internal = (mode!=MODE_RGB) ? yuv2rgb_c_24_rgb : yuv2rgb_c_24_bgr;
802
803         table_start= table_8 = malloc ((256 + 2*232) * sizeof (uint8_t));
804
805         entry_size = sizeof (uint8_t);
806         table_r = table_g = table_b = table_8 + 232;
807
808         for (i = -232; i < 256+232; i++)
809             ((uint8_t * )table_b)[i] = table_Y[i+384];
810         break;
811
812     case 15:
813     case 16:
814         yuv2rgb_c_internal = yuv2rgb_c_16;
815
816         table_start= table_16 = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint16_t));
817
818         entry_size = sizeof (uint16_t);
819         table_r = table_16 + 197;
820         table_b = table_16 + 197 + 685;
821         table_g = table_16 + 197 + 2*682;
822
823         for (i = -197; i < 256+197; i++) {
824             int j = table_Y[i+384] >> 3;
825
826             if (mode == MODE_RGB)
827                 j <<= ((bpp==16) ? 11 : 10);
828
829             ((uint16_t *)table_r)[i] = j;
830         }
831         for (i = -132; i < 256+132; i++) {
832             int j = table_Y[i+384] >> ((bpp==16) ? 2 : 3);
833
834             ((uint16_t *)table_g)[i] = j << 5;
835         }
836         for (i = -232; i < 256+232; i++) {
837             int j = table_Y[i+384] >> 3;
838
839             if (mode == MODE_BGR)
840                 j <<= ((bpp==16) ? 11 : 10);
841
842             ((uint16_t *)table_b)[i] = j;
843         }
844         break;
845
846     case 8:
847         yuv2rgb_c_internal = yuv2rgb_c_8_ordered_dither; //yuv2rgb_c_8;
848
849         table_start= table_332 = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint8_t));
850
851         entry_size = sizeof (uint8_t);
852         table_r = table_332 + 197;
853         table_b = table_332 + 197 + 685;
854         table_g = table_332 + 197 + 2*682;
855
856         for (i = -197; i < 256+197; i++) {
857             int j = (table_Y[i+384 - 16] + 18)/36;
858
859             if (mode == MODE_RGB)
860                 j <<= 5;
861
862             ((uint8_t *)table_r)[i] = j;
863         }
864         for (i = -132; i < 256+132; i++) {
865             int j = (table_Y[i+384 - 16] + 18)/36;
866
867             if (mode == MODE_BGR)
868                 j <<= 1;
869
870             ((uint8_t *)table_g)[i] = j << 2;
871         }
872         for (i = -232; i < 256+232; i++) {
873             int j = (table_Y[i+384 - 37] + 43)/85;
874
875             if (mode == MODE_BGR)
876                 j <<= 6;
877
878             ((uint8_t *)table_b)[i] = j;
879         }
880         break;
881     case 4:
882         yuv2rgb_c_internal = yuv2rgb_c_4_ordered_dither; //yuv2rgb_c_4;
883
884         table_start= table_121 = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint8_t));
885
886         entry_size = sizeof (uint8_t);
887         table_r = table_121 + 197;
888         table_b = table_121 + 197 + 685;
889         table_g = table_121 + 197 + 2*682;
890
891         for (i = -197; i < 256+197; i++) {
892             int j = table_Y[i+384 - 110] >> 7;
893
894             if (mode == MODE_RGB)
895                 j <<= 3;
896
897             ((uint8_t *)table_r)[i] = j;
898         }
899         for (i = -132; i < 256+132; i++) {
900             int j = (table_Y[i+384 - 37]+ 43)/85;
901
902             ((uint8_t *)table_g)[i] = j << 1;
903         }
904         for (i = -232; i < 256+232; i++) {
905             int j =table_Y[i+384 - 110] >> 7;
906
907             if (mode == MODE_BGR)
908                 j <<= 3;
909
910             ((uint8_t *)table_b)[i] = j;
911         }
912         break;
913
914     case 1:
915         yuv2rgb_c_internal = yuv2rgb_c_1_ordered_dither;
916
917         table_start= table_1 = malloc (256*2 * sizeof (uint8_t));
918
919         entry_size = sizeof (uint8_t);
920         table_g = table_1;
921         table_r = table_b = NULL;
922
923         for (i = 0; i < 256+256; i++) {
924             int j = table_Y[i + 384 - 110]>>7;
925
926             ((uint8_t *)table_g)[i] = j;
927         }
928         break;
929
930     default:
931         table_start= NULL;
932         mp_msg(MSGT_SWS,MSGL_ERR,"%ibpp not supported by yuv2rgb\n", bpp);
933         //exit (1);
934     }
935
936     for (i = 0; i < 256; i++) {
937         table_rV[i] = table_r + entry_size * div_round (crv * (i-128), 76309);
938         table_gU[i] = table_g + entry_size * div_round (cgu * (i-128), 76309);
939         table_gV[i] = entry_size * div_round (cgv * (i-128), 76309);
940         table_bU[i] = table_b + entry_size * div_round (cbu * (i-128), 76309);
941     }
942
943     return table_start; 
944 }