annotate postproc/yuv2rgb.c @ 12372:31c2bf041150

sync + wording

申鐃緒申     1 /*
申鐃緒申     2  * yuv2rgb.c, Software YUV to RGB coverter
申鐃緒申     3  *
申鐃緒申     4  *  Copyright (C) 1999, Aaron Holtzman <[e-mail]>
申鐃緒申     5  *  All Rights Reserved.
申鐃緒申     6  *
申鐃緒申     7  *  Functions broken out from display_x11.c and several new modes
申鐃緒申     8  *  added by H�kan Hjort <[e-mail]>
申鐃緒申     9  *
申鐃緒申    10  *  15 & 16 bpp support by Franck Sicard <[e-mail]>
申鐃緒申    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 ([e-mail]) (needed for fast movntq support)
申鐃緒申    29  * 1,4,8bpp support by Michael Niedermayer ([e-mail])
申鐃緒申    30  * context / deglobalize stuff by Michael Niedermayer
申鐃緒申    31  */
申鐃緒申    32 
申鐃緒申    33 #include <stdio.h>
申鐃緒申    34 #include <stdlib.h>
申鐃緒申    35 #include <inttypes.h>
申鐃緒申    36 #include <assert.h>
申鐃緒申    37 
申鐃緒申    38 #include "config.h"
申鐃緒申    39 //#include "video_out.h"
申鐃緒申    40 #include "rgb2rgb.h"
申鐃緒申    41 #include "swscale.h"
申鐃緒申    42 #include "swscale_internal.h"
申鐃緒申    43 #include "../mangle.h"
申鐃緒申    44 #include "../libvo/img_format.h" //FIXME try to reduce dependency of such stuff
申鐃緒申    45 
申鐃緒申    46 #ifdef HAVE_MLIB
申鐃緒申    47 #include "yuv2rgb_mlib.c"
申鐃緒申    48 #endif
申鐃緒申    49 
申鐃緒申    50 #define DITHER1XBPP // only for mmx
申鐃緒申    51 
申鐃緒申    52 const uint8_t  __attribute__((aligned(8))) dither_2x2_4[2][8]={
申鐃緒申    53 {  1,   3,   1,   3,   1,   3,   1,   3, },
申鐃緒申    54 {  2,   0,   2,   0,   2,   0,   2,   0, },
申鐃緒申    55 };
申鐃緒申    56 
申鐃緒申    57 const uint8_t  __attribute__((aligned(8))) dither_2x2_8[2][8]={
申鐃緒申    58 {  6,   2,   6,   2,   6,   2,   6,   2, },
申鐃緒申    59 {  0,   4,   0,   4,   0,   4,   0,   4, },
申鐃緒申    60 };
申鐃緒申    61 
申鐃緒申    62 const uint8_t  __attribute__((aligned(8))) dither_8x8_32[8][8]={
申鐃緒申    63 { 17,   9,  23,  15,  16,   8,  22,  14, },
申鐃緒申    64 {  5,  29,   3,  27,   4,  28,   2,  26, },
申鐃緒申    65 { 21,  13,  19,  11,  20,  12,  18,  10, },
申鐃緒申    66 {  0,  24,   6,  30,   1,  25,   7,  31, },
申鐃緒申    67 { 16,   8,  22,  14,  17,   9,  23,  15, },
申鐃緒申    68 {  4,  28,   2,  26,   5,  29,   3,  27, },
申鐃緒申    69 { 20,  12,  18,  10,  21,  13,  19,  11, },
申鐃緒申    70 {  1,  25,   7,  31,   0,  24,   6,  30, },
申鐃緒申    71 };
申鐃緒申    72 
申鐃緒申    73 #if 0
申鐃緒申    74 const uint8_t  __attribute__((aligned(8))) dither_8x8_64[8][8]={
申鐃緒申    75 {  0,  48,  12,  60,   3,  51,  15,  63, },
申鐃緒申    76 { 32,  16,  44,  28,  35,  19,  47,  31, },
申鐃緒申    77 {  8,  56,   4,  52,  11,  59,   7,  55, },
申鐃緒申    78 { 40,  24,  36,  20,  43,  27,  39,  23, },
申鐃緒申    79 {  2,  50,  14,  62,   1,  49,  13,  61, },
申鐃緒申    80 { 34,  18,  46,  30,  33,  17,  45,  29, },
申鐃緒申    81 { 10,  58,   6,  54,   9,  57,   5,  53, },
申鐃緒申    82 { 42,  26,  38,  22,  41,  25,  37,  21, },
申鐃緒申    83 };
申鐃緒申    84 #endif
申鐃緒申    85 
申鐃緒申    86 const uint8_t  __attribute__((aligned(8))) dither_8x8_73[8][8]={
申鐃緒申    87 {  0,  55,  14,  68,   3,  58,  17,  72, },
申鐃緒申    88 { 37,  18,  50,  32,  40,  22,  54,  35, },
申鐃緒申    89 {  9,  64,   5,  59,  13,  67,   8,  63, },
申鐃緒申    90 { 46,  27,  41,  23,  49,  31,  44,  26, },
申鐃緒申    91 {  2,  57,  16,  71,   1,  56,  15,  70, },
申鐃緒申    92 { 39,  21,  52,  34,  38,  19,  51,  33, },
申鐃緒申    93 { 11,  66,   7,  62,  10,  65,   6,  60, },
申鐃緒申    94 { 48,  30,  43,  25,  47,  29,  42,  24, },
申鐃緒申    95 };
申鐃緒申    96 
申鐃緒申    97 #if 0
申鐃緒申    98 const uint8_t  __attribute__((aligned(8))) dither_8x8_128[8][8]={
申鐃緒申    99 { 68,  36,  92,  60,  66,  34,  90,  58, },
申鐃緒申   100 { 20, 116,  12, 108,  18, 114,  10, 106, },
申鐃緒申   101 { 84,  52,  76,  44,  82,  50,  74,  42, },
申鐃緒申   102 {  0,  96,  24, 120,   6, 102,  30, 126, },
申鐃緒申   103 { 64,  32,  88,  56,  70,  38,  94,  62, },
申鐃緒申   104 { 16, 112,   8, 104,  22, 118,  14, 110, },
申鐃緒申   105 { 80,  48,  72,  40,  86,  54,  78,  46, },
申鐃緒申   106 {  4, 100,  28, 124,   2,  98,  26, 122, },
申鐃緒申   107 };
申鐃緒申   108 #endif
申鐃緒申   109 
申鐃緒申   110 #if 1
申鐃緒申   111 const uint8_t  __attribute__((aligned(8))) dither_8x8_220[8][8]={
申鐃緒申   112 {117,  62, 158, 103, 113,  58, 155, 100, },
申鐃緒申   113 { 34, 199,  21, 186,  31, 196,  17, 182, },
申鐃緒申   114 {144,  89, 131,  76, 141,  86, 127,  72, },
申鐃緒申   115 {  0, 165,  41, 206,  10, 175,  52, 217, },
申鐃緒申   116 {110,  55, 151,  96, 120,  65, 162, 107, },
申鐃緒申   117 { 28, 193,  14, 179,  38, 203,  24, 189, },
申鐃緒申   118 {138,  83, 124,  69, 148,  93, 134,  79, },
申鐃緒申   119 {  7, 172,  48, 213,   3, 168,  45, 210, },
申鐃緒申   120 };
申鐃緒申   121 #elif 1
申鐃緒申   122 // tries to correct a gamma of 1.5
申鐃緒申   123 const uint8_t  __attribute__((aligned(8))) dither_8x8_220[8][8]={
申鐃緒申   124 {  0, 143,  18, 200,   2, 156,  25, 215, },
申鐃緒申   125 { 78,  28, 125,  64,  89,  36, 138,  74, },
申鐃緒申   126 { 10, 180,   3, 161,  16, 195,   8, 175, },
申鐃緒申   127 {109,  51,  93,  38, 121,  60, 105,  47, },
申鐃緒申   128 {  1, 152,  23, 210,   0, 147,  20, 205, },
申鐃緒申   129 { 85,  33, 134,  71,  81,  30, 130,  67, },
申鐃緒申   130 { 14, 190,   6, 171,  12, 185,   5, 166, },
申鐃緒申   131 {117,  57, 101,  44, 113,  54,  97,  41, },
申鐃緒申   132 };
申鐃緒申   133 #elif 1
申鐃緒申   134 // tries to correct a gamma of 2.0
申鐃緒申   135 const uint8_t  __attribute__((aligned(8))) dither_8x8_220[8][8]={
申鐃緒申   136 {  0, 124,   8, 193,   0, 140,  12, 213, },
申鐃緒申   137 { 55,  14, 104,  42,  66,  19, 119,  52, },
申鐃緒申   138 {  3, 168,   1, 145,   6, 187,   3, 162, },
申鐃緒申   139 { 86,  31,  70,  21,  99,  39,  82,  28, },
申鐃緒申   140 {  0, 134,  11, 206,   0, 129,   9, 200, },
申鐃緒申   141 { 62,  17, 114,  48,  58,  16, 109,  45, },
申鐃緒申   142 {  5, 181,   2, 157,   4, 175,   1, 151, },
申鐃緒申   143 { 95,  36,  78,  26,  90,  34,  74,  24, },
申鐃緒申   144 };
申鐃緒申   145 #else
申鐃緒申   146 // tries to correct a gamma of 2.5
申鐃緒申   147 const uint8_t  __attribute__((aligned(8))) dither_8x8_220[8][8]={
申鐃緒申   148 {  0, 107,   3, 187,   0, 125,   6, 212, },
申鐃緒申   149 { 39,   7,  86,  28,  49,  11, 102,  36, },
申鐃緒申   150 {  1, 158,   0, 131,   3, 180,   1, 151, },
申鐃緒申   151 { 68,  19,  52,  12,  81,  25,  64,  17, },
申鐃緒申   152 {  0, 119,   5, 203,   0, 113,   4, 195, },
申鐃緒申   153 { 45,   9,  96,  33,  42,   8,  91,  30, },
申鐃緒申   154 {  2, 172,   1, 144,   2, 165,   0, 137, },
申鐃緒申   155 { 77,  23,  60,  15,  72,  21,  56,  14, },
申鐃緒申   156 };
申鐃緒申   157 #endif
申鐃緒申   158 
申鐃緒申   159 #ifdef ARCH_X86
申鐃緒申   160 
申鐃緒申   161 /* hope these constant values are cache line aligned */
申鐃緒申   162 uint64_t attribute_used __attribute__((aligned(8))) mmx_00ffw = 0x00ff00ff00ff00ffULL;
申鐃緒申   163 uint64_t attribute_used __attribute__((aligned(8))) mmx_redmask = 0xf8f8f8f8f8f8f8f8ULL;
申鐃緒申   164 uint64_t attribute_used __attribute__((aligned(8))) mmx_grnmask = 0xfcfcfcfcfcfcfcfcULL;
申鐃緒申   165 
申鐃緒申   166 uint64_t attribute_used __attribute__((aligned(8))) M24A=   0x00FF0000FF0000FFULL;
申鐃緒申   167 uint64_t attribute_used __attribute__((aligned(8))) M24B=   0xFF0000FF0000FF00ULL;
申鐃緒申   168 uint64_t attribute_used __attribute__((aligned(8))) M24C=   0x0000FF0000FF0000ULL;
申鐃緒申   169 
申鐃緒申   170 // the volatile is required because gcc otherwise optimizes some writes away not knowing that these
申鐃緒申   171 // are read in the asm block
申鐃緒申   172 volatile uint64_t attribute_used __attribute__((aligned(8))) b5Dither;
申鐃緒申   173 volatile uint64_t attribute_used __attribute__((aligned(8))) g5Dither;
申鐃緒申   174 volatile uint64_t attribute_used __attribute__((aligned(8))) g6Dither;
申鐃緒申   175 volatile uint64_t attribute_used __attribute__((aligned(8))) r5Dither;
申鐃緒申   176 
申鐃緒申   177 uint64_t __attribute__((aligned(8))) dither4[2]={
申鐃緒申   178 	0x0103010301030103LL,
申鐃緒申   179 	0x0200020002000200LL,};
申鐃緒申   180 
申鐃緒申   181 uint64_t __attribute__((aligned(8))) dither8[2]={
申鐃緒申   182 	0x0602060206020602LL,
申鐃緒申   183 	0x0004000400040004LL,};
申鐃緒申   184 
申鐃緒申   185 #undef HAVE_MMX
申鐃緒申   186 #undef ARCH_X86
申鐃緒申   187 
申鐃緒申   188 //MMX versions
申鐃緒申   189 #undef RENAME
申鐃緒申   190 #define HAVE_MMX
申鐃緒申   191 #undef HAVE_MMX2
申鐃緒申   192 #undef HAVE_3DNOW
申鐃緒申   193 #define ARCH_X86
申鐃緒申   194 #define RENAME(a) a ## _MMX
申鐃緒申   195 #include "yuv2rgb_template.c"
申鐃緒申   196 
申鐃緒申   197 //MMX2 versions
申鐃緒申   198 #undef RENAME
申鐃緒申   199 #define HAVE_MMX
申鐃緒申   200 #define HAVE_MMX2
申鐃緒申   201 #undef HAVE_3DNOW
申鐃緒申   202 #define ARCH_X86
申鐃緒申   203 #define RENAME(a) a ## _MMX2
申鐃緒申   204 #include "yuv2rgb_template.c"
申鐃緒申   205 
申鐃緒申   206 #endif // CAN_COMPILE_X86_ASM
申鐃緒申   207 
申鐃緒申   208 const int32_t Inverse_Table_6_9[8][4] = {
申鐃緒申   209     {117504, 138453, 13954, 34903}, /* no sequence_display_extension */
申鐃緒申   210     {117504, 138453, 13954, 34903}, /* ITU-R Rec. 709 (1990) */
申鐃緒申   211     {104597, 132201, 25675, 53279}, /* unspecified */
申鐃緒申   212     {104597, 132201, 25675, 53279}, /* reserved */
申鐃緒申   213     {104448, 132798, 24759, 53109}, /* FCC */
申鐃緒申   214     {104597, 132201, 25675, 53279}, /* ITU-R Rec. 624-4 System B, G */
申鐃緒申   215     {104597, 132201, 25675, 53279}, /* SMPTE 170M */
申鐃緒申   216     {117579, 136230, 16907, 35559}  /* SMPTE 240M (1987) */
申鐃緒申   217 };
申鐃緒申   218 
申鐃緒申   219 #define RGB(i)					\
申鐃緒申   220 	U = pu[i];				\
申鐃緒申   221 	V = pv[i];				\
申鐃緒申   222 	r = c->table_rV[V];			\
申鐃緒申   223 	g = c->table_gU[U] + c->table_gV[V];		\
申鐃緒申   224 	b = c->table_bU[U];
申鐃緒申   225 
申鐃緒申   226 #define DST1(i)					\
申鐃緒申   227 	Y = py_1[2*i];				\
申鐃緒申   228 	dst_1[2*i] = r[Y] + g[Y] + b[Y];	\
申鐃緒申   229 	Y = py_1[2*i+1];			\
申鐃緒申   230 	dst_1[2*i+1] = r[Y] + g[Y] + b[Y];
申鐃緒申   231 
申鐃緒申   232 #define DST2(i)					\
申鐃緒申   233 	Y = py_2[2*i];				\
申鐃緒申   234 	dst_2[2*i] = r[Y] + g[Y] + b[Y];	\
申鐃緒申   235 	Y = py_2[2*i+1];			\
申鐃緒申   236 	dst_2[2*i+1] = r[Y] + g[Y] + b[Y];
申鐃緒申   237 
申鐃緒申   238 #define DST1RGB(i)							\
申鐃緒申   239 	Y = py_1[2*i];							\
申鐃緒申   240 	dst_1[6*i] = r[Y]; dst_1[6*i+1] = g[Y]; dst_1[6*i+2] = b[Y];	\
申鐃緒申   241 	Y = py_1[2*i+1];						\
申鐃緒申   242 	dst_1[6*i+3] = r[Y]; dst_1[6*i+4] = g[Y]; dst_1[6*i+5] = b[Y];
申鐃緒申   243 
申鐃緒申   244 #define DST2RGB(i)							\
申鐃緒申   245 	Y = py_2[2*i];							\
申鐃緒申   246 	dst_2[6*i] = r[Y]; dst_2[6*i+1] = g[Y]; dst_2[6*i+2] = b[Y];	\
申鐃緒申   247 	Y = py_2[2*i+1];						\
申鐃緒申   248 	dst_2[6*i+3] = r[Y]; dst_2[6*i+4] = g[Y]; dst_2[6*i+5] = b[Y];
申鐃緒申   249 
申鐃緒申   250 #define DST1BGR(i)							\
申鐃緒申   251 	Y = py_1[2*i];							\
申鐃緒申   252 	dst_1[6*i] = b[Y]; dst_1[6*i+1] = g[Y]; dst_1[6*i+2] = r[Y];	\
申鐃緒申   253 	Y = py_1[2*i+1];						\
申鐃緒申   254 	dst_1[6*i+3] = b[Y]; dst_1[6*i+4] = g[Y]; dst_1[6*i+5] = r[Y];
申鐃緒申   255 
申鐃緒申   256 #define DST2BGR(i)							\
申鐃緒申   257 	Y = py_2[2*i];							\
申鐃緒申   258 	dst_2[6*i] = b[Y]; dst_2[6*i+1] = g[Y]; dst_2[6*i+2] = r[Y];	\
申鐃緒申   259 	Y = py_2[2*i+1];						\
申鐃緒申   260 	dst_2[6*i+3] = b[Y]; dst_2[6*i+4] = g[Y]; dst_2[6*i+5] = r[Y];
申鐃緒申   261 
申鐃緒申   262 #define PROLOG(func_name, dst_type) \
申鐃緒申   263 static int func_name(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY, \
申鐃緒申   264              int srcSliceH, uint8_t* dst[], int dstStride[]){\
申鐃緒申   265     int y;\
申鐃緒申   266 \
申鐃緒申   267     if(c->srcFormat == IMGFMT_422P){\
申鐃緒申   268 	srcStride[1] *= 2;\
申鐃緒申   269 	srcStride[2] *= 2;\
申鐃緒申   270     }\
申鐃緒申   271     for(y=0; y<srcSliceH; y+=2){\
申鐃緒申   272 	dst_type *dst_1= (dst_type*)(dst[0] + (y+srcSliceY  )*dstStride[0]);\
申鐃緒申   273 	dst_type *dst_2= (dst_type*)(dst[0] + (y+srcSliceY+1)*dstStride[0]);\
申鐃緒申   274 	dst_type *r, *g, *b;\
申鐃緒申   275 	uint8_t *py_1= src[0] + y*srcStride[0];\
申鐃緒申   276 	uint8_t *py_2= py_1 + srcStride[0];\
申鐃緒申   277 	uint8_t *pu= src[1] + (y>>1)*srcStride[1];\
申鐃緒申   278 	uint8_t *pv= src[2] + (y>>1)*srcStride[2];\
申鐃緒申   279 	unsigned int h_size= c->dstW>>3;\
申鐃緒申   280 	while (h_size--) {\
申鐃緒申   281 	    int U, V, Y;\
申鐃緒申   282 
申鐃緒申   283 #define EPILOG(dst_delta)\
申鐃緒申   284 	    pu += 4;\
申鐃緒申   285 	    pv += 4;\
申鐃緒申   286 	    py_1 += 8;\
申鐃緒申   287 	    py_2 += 8;\
申鐃緒申   288 	    dst_1 += dst_delta;\
申鐃緒申   289 	    dst_2 += dst_delta;\
申鐃緒申   290 	}\
申鐃緒申   291     }\
申鐃緒申   292     return srcSliceH;\
申鐃緒申   293 }
申鐃緒申   294 
申鐃緒申   295 PROLOG(yuv2rgb_c_32, uint32_t)
申鐃緒申   296 	RGB(0);
申鐃緒申   297 	DST1(0);
申鐃緒申   298 	DST2(0);
申鐃緒申   299 
申鐃緒申   300 	RGB(1);
申鐃緒申   301 	DST2(1);
申鐃緒申   302 	DST1(1);
申鐃緒申   303 
申鐃緒申   304 	RGB(2);
申鐃緒申   305 	DST1(2);
申鐃緒申   306 	DST2(2);
申鐃緒申   307 
申鐃緒申   308 	RGB(3);
申鐃緒申   309 	DST2(3);
申鐃緒申   310 	DST1(3);
申鐃緒申   311 EPILOG(8)
申鐃緒申   312 
申鐃緒申   313 PROLOG(yuv2rgb_c_24_rgb, uint8_t)
申鐃緒申   314 	RGB(0);
申鐃緒申   315 	DST1RGB(0);
申鐃緒申   316 	DST2RGB(0);
申鐃緒申   317 
申鐃緒申   318 	RGB(1);
申鐃緒申   319 	DST2RGB(1);
申鐃緒申   320 	DST1RGB(1);
申鐃緒申   321 
申鐃緒申   322 	RGB(2);
申鐃緒申   323 	DST1RGB(2);
申鐃緒申   324 	DST2RGB(2);
申鐃緒申   325 
申鐃緒申   326 	RGB(3);
申鐃緒申   327 	DST2RGB(3);
申鐃緒申   328 	DST1RGB(3);
申鐃緒申   329 EPILOG(24)
申鐃緒申   330 
申鐃緒申   331 // only trivial mods from yuv2rgb_c_24_rgb
申鐃緒申   332 PROLOG(yuv2rgb_c_24_bgr, uint8_t)
申鐃緒申   333 	RGB(0);
申鐃緒申   334 	DST1BGR(0);
申鐃緒申   335 	DST2BGR(0);
申鐃緒申   336 
申鐃緒申   337 	RGB(1);
申鐃緒申   338 	DST2BGR(1);
申鐃緒申   339 	DST1BGR(1);
申鐃緒申   340 
申鐃緒申   341 	RGB(2);
申鐃緒申   342 	DST1BGR(2);
申鐃緒申   343 	DST2BGR(2);
申鐃緒申   344 
申鐃緒申   345 	RGB(3);
申鐃緒申   346 	DST2BGR(3);
申鐃緒申   347 	DST1BGR(3);
申鐃緒申   348 EPILOG(24)
申鐃緒申   349 
申鐃緒申   350 // This is exactly the same code as yuv2rgb_c_32 except for the types of
申鐃緒申   351 // r, g, b, dst_1, dst_2
申鐃緒申   352 PROLOG(yuv2rgb_c_16, uint16_t)
申鐃緒申   353 	RGB(0);
申鐃緒申   354 	DST1(0);
申鐃緒申   355 	DST2(0);
申鐃緒申   356 
申鐃緒申   357 	RGB(1);
申鐃緒申   358 	DST2(1);
申鐃緒申   359 	DST1(1);
申鐃緒申   360 
申鐃緒申   361 	RGB(2);
申鐃緒申   362 	DST1(2);
申鐃緒申   363 	DST2(2);
申鐃緒申   364 
申鐃緒申   365 	RGB(3);
申鐃緒申   366 	DST2(3);
申鐃緒申   367 	DST1(3);
申鐃緒申   368 EPILOG(8)
申鐃緒申   369 
申鐃緒申   370 // This is exactly the same code as yuv2rgb_c_32 except for the types of
申鐃緒申   371 // r, g, b, dst_1, dst_2
申鐃緒申   372 PROLOG(yuv2rgb_c_8, uint8_t)
申鐃緒申   373 	RGB(0);
申鐃緒申   374 	DST1(0);
申鐃緒申   375 	DST2(0);
申鐃緒申   376 
申鐃緒申   377 	RGB(1);
申鐃緒申   378 	DST2(1);
申鐃緒申   379 	DST1(1);
申鐃緒申   380 
申鐃緒申   381 	RGB(2);
申鐃緒申   382 	DST1(2);
申鐃緒申   383 	DST2(2);
申鐃緒申   384 
申鐃緒申   385 	RGB(3);
申鐃緒申   386 	DST2(3);
申鐃緒申   387 	DST1(3);
申鐃緒申   388 EPILOG(8)
申鐃緒申   389 
申鐃緒申   390 // r, g, b, dst_1, dst_2
申鐃緒申   391 PROLOG(yuv2rgb_c_8_ordered_dither, uint8_t)
申鐃緒申   392 	const uint8_t *d32= dither_8x8_32[y&7];
申鐃緒申   393 	const uint8_t *d64= dither_8x8_73[y&7];
申鐃緒申   394 #define DST1bpp8(i,o)					\
申鐃緒申   395 	Y = py_1[2*i];				\
申鐃緒申   396 	dst_1[2*i] = r[Y+d32[0+o]] + g[Y+d32[0+o]] + b[Y+d64[0+o]];	\
申鐃緒申   397 	Y = py_1[2*i+1];			\
申鐃緒申   398 	dst_1[2*i+1] = r[Y+d32[1+o]] + g[Y+d32[1+o]] + b[Y+d64[1+o]];
申鐃緒申   399 
申鐃緒申   400 #define DST2bpp8(i,o)					\
申鐃緒申   401 	Y = py_2[2*i];				\
申鐃緒申   402 	dst_2[2*i] =  r[Y+d32[8+o]] + g[Y+d32[8+o]] + b[Y+d64[8+o]];	\
申鐃緒申   403 	Y = py_2[2*i+1];			\
申鐃緒申   404 	dst_2[2*i+1] =  r[Y+d32[9+o]] + g[Y+d32[9+o]] + b[Y+d64[9+o]];
申鐃緒申   405 
申鐃緒申   406 
申鐃緒申   407 	RGB(0);
申鐃緒申   408 	DST1bpp8(0,0);
申鐃緒申   409 	DST2bpp8(0,0);
申鐃緒申   410 
申鐃緒申   411 	RGB(1);
申鐃緒申   412 	DST2bpp8(1,2);
申鐃緒申   413 	DST1bpp8(1,2);
申鐃緒申   414 
申鐃緒申   415 	RGB(2);
申鐃緒申   416 	DST1bpp8(2,4);
申鐃緒申   417 	DST2bpp8(2,4);
申鐃緒申   418 
申鐃緒申   419 	RGB(3);
申鐃緒申   420 	DST2bpp8(3,6);
申鐃緒申   421 	DST1bpp8(3,6);
申鐃緒申   422 EPILOG(8)
申鐃緒申   423 
申鐃緒申   424 
申鐃緒申   425 // This is exactly the same code as yuv2rgb_c_32 except for the types of
申鐃緒申   426 // r, g, b, dst_1, dst_2
申鐃緒申   427 PROLOG(yuv2rgb_c_4, uint8_t)
申鐃緒申   428         int acc;
申鐃緒申   429 #define DST1_4(i)					\
申鐃緒申   430 	Y = py_1[2*i];				\
申鐃緒申   431 	acc = r[Y] + g[Y] + b[Y];	\
申鐃緒申   432 	Y = py_1[2*i+1];			\
申鐃緒申   433         acc |= (r[Y] + g[Y] + b[Y])<<4;\
申鐃緒申   434 	dst_1[i] = acc; 
申鐃緒申   435 
申鐃緒申   436 #define DST2_4(i)					\
申鐃緒申   437 	Y = py_2[2*i];				\
申鐃緒申   438 	acc = r[Y] + g[Y] + b[Y];	\
申鐃緒申   439 	Y = py_2[2*i+1];			\
申鐃緒申   440 	acc |= (r[Y] + g[Y] + b[Y])<<4;\
申鐃緒申   441 	dst_2[i] = acc; 
申鐃緒申   442 	
申鐃緒申   443         RGB(0);
申鐃緒申   444 	DST1_4(0);
申鐃緒申   445 	DST2_4(0);
申鐃緒申   446 
申鐃緒申   447 	RGB(1);
申鐃緒申   448 	DST2_4(1);
申鐃緒申   449 	DST1_4(1);
申鐃緒申   450 
申鐃緒申   451 	RGB(2);
申鐃緒申   452 	DST1_4(2);
申鐃緒申   453 	DST2_4(2);
申鐃緒申   454 
申鐃緒申   455 	RGB(3);
申鐃緒申   456 	DST2_4(3);
申鐃緒申   457 	DST1_4(3);
申鐃緒申   458 EPILOG(4)
申鐃緒申   459 
申鐃緒申   460 PROLOG(yuv2rgb_c_4_ordered_dither, uint8_t)
申鐃緒申   461 	const uint8_t *d64= dither_8x8_73[y&7];
申鐃緒申   462 	const uint8_t *d128=dither_8x8_220[y&7];
申鐃緒申   463         int acc;
申鐃緒申   464 
申鐃緒申   465 #define DST1bpp4(i,o)					\
申鐃緒申   466 	Y = py_1[2*i];				\
申鐃緒申   467 	acc = r[Y+d128[0+o]] + g[Y+d64[0+o]] + b[Y+d128[0+o]];	\
申鐃緒申   468 	Y = py_1[2*i+1];			\
申鐃緒申   469 	acc |= (r[Y+d128[1+o]] + g[Y+d64[1+o]] + b[Y+d128[1+o]])<<4;\
申鐃緒申   470         dst_1[i]= acc;
申鐃緒申   471 
申鐃緒申   472 #define DST2bpp4(i,o)					\
申鐃緒申   473 	Y = py_2[2*i];				\
申鐃緒申   474 	acc =  r[Y+d128[8+o]] + g[Y+d64[8+o]] + b[Y+d128[8+o]];	\
申鐃緒申   475 	Y = py_2[2*i+1];			\
申鐃緒申   476 	acc |=  (r[Y+d128[9+o]] + g[Y+d64[9+o]] + b[Y+d128[9+o]])<<4;\
申鐃緒申   477         dst_2[i]= acc;
申鐃緒申   478 
申鐃緒申   479 
申鐃緒申   480 	RGB(0);
申鐃緒申   481 	DST1bpp4(0,0);
申鐃緒申   482 	DST2bpp4(0,0);
申鐃緒申   483 
申鐃緒申   484 	RGB(1);
申鐃緒申   485 	DST2bpp4(1,2);
申鐃緒申   486 	DST1bpp4(1,2);
申鐃緒申   487 
申鐃緒申   488 	RGB(2);
申鐃緒申   489 	DST1bpp4(2,4);
申鐃緒申   490 	DST2bpp4(2,4);
申鐃緒申   491 
申鐃緒申   492 	RGB(3);
申鐃緒申   493 	DST2bpp4(3,6);
申鐃緒申   494 	DST1bpp4(3,6);
申鐃緒申   495 EPILOG(4)
申鐃緒申   496 
申鐃緒申   497 // This is exactly the same code as yuv2rgb_c_32 except for the types of
申鐃緒申   498 // r, g, b, dst_1, dst_2
申鐃緒申   499 PROLOG(yuv2rgb_c_4b, uint8_t)
申鐃緒申   500 	RGB(0);
申鐃緒申   501 	DST1(0);
申鐃緒申   502 	DST2(0);
申鐃緒申   503 
申鐃緒申   504 	RGB(1);
申鐃緒申   505 	DST2(1);
申鐃緒申   506 	DST1(1);
申鐃緒申   507 
申鐃緒申   508 	RGB(2);
申鐃緒申   509 	DST1(2);
申鐃緒申   510 	DST2(2);
申鐃緒申   511 
申鐃緒申   512 	RGB(3);
申鐃緒申   513 	DST2(3);
申鐃緒申   514 	DST1(3);
申鐃緒申   515 EPILOG(8)
申鐃緒申   516 
申鐃緒申   517 PROLOG(yuv2rgb_c_4b_ordered_dither, uint8_t)
申鐃緒申   518 	const uint8_t *d64= dither_8x8_73[y&7];
申鐃緒申   519 	const uint8_t *d128=dither_8x8_220[y&7];
申鐃緒申   520 
申鐃緒申   521 #define DST1bpp4b(i,o)					\
申鐃緒申   522 	Y = py_1[2*i];				\
申鐃緒申   523 	dst_1[2*i] = r[Y+d128[0+o]] + g[Y+d64[0+o]] + b[Y+d128[0+o]];	\
申鐃緒申   524 	Y = py_1[2*i+1];			\
申鐃緒申   525 	dst_1[2*i+1] = r[Y+d128[1+o]] + g[Y+d64[1+o]] + b[Y+d128[1+o]];
申鐃緒申   526 
申鐃緒申   527 #define DST2bpp4b(i,o)					\
申鐃緒申   528 	Y = py_2[2*i];				\
申鐃緒申   529 	dst_2[2*i] =  r[Y+d128[8+o]] + g[Y+d64[8+o]] + b[Y+d128[8+o]];	\
申鐃緒申   530 	Y = py_2[2*i+1];			\
申鐃緒申   531 	dst_2[2*i+1] =  r[Y+d128[9+o]] + g[Y+d64[9+o]] + b[Y+d128[9+o]];
申鐃緒申   532 
申鐃緒申   533 
申鐃緒申   534 	RGB(0);
申鐃緒申   535 	DST1bpp4b(0,0);
申鐃緒申   536 	DST2bpp4b(0,0);
申鐃緒申   537 
申鐃緒申   538 	RGB(1);
申鐃緒申   539 	DST2bpp4b(1,2);
申鐃緒申   540 	DST1bpp4b(1,2);
申鐃緒申   541 
申鐃緒申   542 	RGB(2);
申鐃緒申   543 	DST1bpp4b(2,4);
申鐃緒申   544 	DST2bpp4b(2,4);
申鐃緒申   545 
申鐃緒申   546 	RGB(3);
申鐃緒申   547 	DST2bpp4b(3,6);
申鐃緒申   548 	DST1bpp4b(3,6);
申鐃緒申   549 EPILOG(8)
申鐃緒申   550 
申鐃緒申   551 PROLOG(yuv2rgb_c_1_ordered_dither, uint8_t)
申鐃緒申   552 	const uint8_t *d128=dither_8x8_220[y&7];
申鐃緒申   553 	char out_1=0, out_2=0;
申鐃緒申   554 	g= c->table_gU[128] + c->table_gV[128];
申鐃緒申   555 
申鐃緒申   556 #define DST1bpp1(i,o)					\
申鐃緒申   557 	Y = py_1[2*i];				\
申鐃緒申   558 	out_1+= out_1 + g[Y+d128[0+o]];	\
申鐃緒申   559 	Y = py_1[2*i+1];			\
申鐃緒申   560 	out_1+= out_1 + g[Y+d128[1+o]];
申鐃緒申   561 
申鐃緒申   562 #define DST2bpp1(i,o)					\
申鐃緒申   563 	Y = py_2[2*i];				\
申鐃緒申   564 	out_2+= out_2 + g[Y+d128[8+o]];	\
申鐃緒申   565 	Y = py_2[2*i+1];			\
申鐃緒申   566 	out_2+= out_2 + g[Y+d128[9+o]];
申鐃緒申   567 
申鐃緒申   568 	DST1bpp1(0,0);
申鐃緒申   569 	DST2bpp1(0,0);
申鐃緒申   570 
申鐃緒申   571 	DST2bpp1(1,2);
申鐃緒申   572 	DST1bpp1(1,2);
申鐃緒申   573 
申鐃緒申   574 	DST1bpp1(2,4);
申鐃緒申   575 	DST2bpp1(2,4);
申鐃緒申   576 
申鐃緒申   577 	DST2bpp1(3,6);
申鐃緒申   578 	DST1bpp1(3,6);
申鐃緒申   579 	
申鐃緒申   580 	dst_1[0]= out_1;
申鐃緒申   581 	dst_2[0]= out_2;
申鐃緒申   582 EPILOG(1)
申鐃緒申   583 
申鐃緒申   584 SwsFunc yuv2rgb_get_func_ptr (SwsContext *c)
申鐃緒申   585 {
申鐃緒申   586 #ifdef ARCH_X86
申鐃緒申   587     if(c->flags & SWS_CPU_CAPS_MMX2){
申鐃緒申   588 	switch(c->dstFormat){
申鐃緒申   589 	case IMGFMT_BGR32: return yuv420_rgb32_MMX2;
申鐃緒申   590 	case IMGFMT_BGR24: return yuv420_rgb24_MMX2;
申鐃緒申   591 	case IMGFMT_BGR16: return yuv420_rgb16_MMX2;
申鐃緒申   592 	case IMGFMT_BGR15: return yuv420_rgb15_MMX2;
申鐃緒申   593 	}
申鐃緒申   594     }
申鐃緒申   595     if(c->flags & SWS_CPU_CAPS_MMX){
申鐃緒申   596 	switch(c->dstFormat){
申鐃緒申   597 	case IMGFMT_BGR32: return yuv420_rgb32_MMX;
申鐃緒申   598 	case IMGFMT_BGR24: return yuv420_rgb24_MMX;
申鐃緒申   599 	case IMGFMT_BGR16: return yuv420_rgb16_MMX;
申鐃緒申   600 	case IMGFMT_BGR15: return yuv420_rgb15_MMX;
申鐃緒申   601 	}
申鐃緒申   602     }
申鐃緒申   603 #endif
申鐃緒申   604 #ifdef HAVE_MLIB
申鐃緒申   605     {
申鐃緒申   606 	SwsFunc t= yuv2rgb_init_mlib(c);
申鐃緒申   607 	if(t) return t;
申鐃緒申   608     }
申鐃緒申   609 #endif
申鐃緒申   610     MSG_WARN("No accelerated colorspace conversion found\n");
申鐃緒申   611 
申鐃緒申   612     switch(c->dstFormat){
申鐃緒申   613     case IMGFMT_RGB32:
申鐃緒申   614     case IMGFMT_BGR32: return yuv2rgb_c_32;
申鐃緒申   615     case IMGFMT_RGB24: return yuv2rgb_c_24_rgb;
申鐃緒申   616     case IMGFMT_BGR24: return yuv2rgb_c_24_bgr;
申鐃緒申   617     case IMGFMT_RGB16:
申鐃緒申   618     case IMGFMT_BGR16:
申鐃緒申   619     case IMGFMT_RGB15:
申鐃緒申   620     case IMGFMT_BGR15: return yuv2rgb_c_16;
申鐃緒申   621     case IMGFMT_RGB8:
申鐃緒申   622     case IMGFMT_BGR8:  return yuv2rgb_c_8_ordered_dither;
申鐃緒申   623     case IMGFMT_RGB4:
申鐃緒申   624     case IMGFMT_BGR4:  return yuv2rgb_c_4_ordered_dither;
申鐃緒申   625     case IMGFMT_RG4B:
申鐃緒申   626     case IMGFMT_BG4B:  return yuv2rgb_c_4b_ordered_dither;
申鐃緒申   627     case IMGFMT_RGB1:
申鐃緒申   628     case IMGFMT_BGR1:  return yuv2rgb_c_1_ordered_dither;
申鐃緒申   629     default:
申鐃緒申   630     	assert(0);
申鐃緒申   631     }
申鐃緒申   632     return NULL;
申鐃緒申   633 }
申鐃緒申   634 
申鐃緒申   635 static int div_round (int dividend, int divisor)
申鐃緒申   636 {
申鐃緒申   637     if (dividend > 0)
申鐃緒申   638 	return (dividend + (divisor>>1)) / divisor;
申鐃緒申   639     else
申鐃緒申   640 	return -((-dividend + (divisor>>1)) / divisor);
申鐃緒申   641 }
申鐃緒申   642 
申鐃緒申   643 int yuv2rgb_c_init_tables (SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation)
申鐃緒申   644 {  
申鐃緒申   645     const int isRgb = IMGFMT_IS_RGB(c->dstFormat);
申鐃緒申   646     const int bpp = isRgb?IMGFMT_RGB_DEPTH(c->dstFormat):IMGFMT_BGR_DEPTH(c->dstFormat);
申鐃緒申   647     int i;
申鐃緒申   648     uint8_t table_Y[1024];
申鐃緒申   649     uint32_t *table_32 = 0;
申鐃緒申   650     uint16_t *table_16 = 0;
申鐃緒申   651     uint8_t *table_8 = 0;
申鐃緒申   652     uint8_t *table_332 = 0;
申鐃緒申   653     uint8_t *table_121 = 0;
申鐃緒申   654     uint8_t *table_1 = 0;
申鐃緒申   655     int entry_size = 0;
申鐃緒申   656     void *table_r = 0, *table_g = 0, *table_b = 0;
申鐃緒申   657     void *table_start;
申鐃緒申   658 
申鐃緒申   659     int64_t crv =  inv_table[0];
申鐃緒申   660     int64_t cbu =  inv_table[1];
申鐃緒申   661     int64_t cgu = -inv_table[2];
申鐃緒申   662     int64_t cgv = -inv_table[3];
申鐃緒申   663     int64_t cy  = 1<<16;
申鐃緒申   664     int64_t oy  = 0;
申鐃緒申   665 
申鐃緒申   666 //printf("%lld %lld %lld %lld %lld\n", cy, crv, cbu, cgu, cgv);
申鐃緒申   667     if(!fullRange){
申鐃緒申   668 	cy= (cy*255) / 219;
申鐃緒申   669 	oy= 16<<16;
申鐃緒申   670     }
申鐃緒申   671 	
申鐃緒申   672     cy = (cy *contrast             )>>16;
申鐃緒申   673     crv= (crv*contrast * saturation)>>32;
申鐃緒申   674     cbu= (cbu*contrast * saturation)>>32;
申鐃緒申   675     cgu= (cgu*contrast * saturation)>>32;
申鐃緒申   676     cgv= (cgv*contrast * saturation)>>32;
申鐃緒申   677 //printf("%lld %lld %lld %lld %lld\n", cy, crv, cbu, cgu, cgv);
申鐃緒申   678     oy -= 256*brightness;
申鐃緒申   679 
申鐃緒申   680     for (i = 0; i < 1024; i++) {
申鐃緒申   681 	int j;
申鐃緒申   682 
申鐃緒申   683 	j= (cy*(((i - 384)<<16) - oy) + (1<<31))>>32;
申鐃緒申   684 	j = (j < 0) ? 0 : ((j > 255) ? 255 : j);
申鐃緒申   685 	table_Y[i] = j;
申鐃緒申   686     }
申鐃緒申   687 
申鐃緒申   688     switch (bpp) {
申鐃緒申   689     case 32:
申鐃緒申   690 	table_start= table_32 = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint32_t));
申鐃緒申   691 
申鐃緒申   692 	entry_size = sizeof (uint32_t);
申鐃緒申   693 	table_r = table_32 + 197;
申鐃緒申   694 	table_b = table_32 + 197 + 685;
申鐃緒申   695 	table_g = table_32 + 197 + 2*682;
申鐃緒申   696 
申鐃緒申   697 	for (i = -197; i < 256+197; i++)
申鐃緒申   698 	    ((uint32_t *)table_r)[i] = table_Y[i+384] << (isRgb ? 16 : 0);
申鐃緒申   699 	for (i = -132; i < 256+132; i++)
申鐃緒申   700 	    ((uint32_t *)table_g)[i] = table_Y[i+384] << 8;
申鐃緒申   701 	for (i = -232; i < 256+232; i++)
申鐃緒申   702 	    ((uint32_t *)table_b)[i] = table_Y[i+384] << (isRgb ? 0 : 16);
申鐃緒申   703 	break;
申鐃緒申   704 
申鐃緒申   705     case 24:
申鐃緒申   706 	table_start= table_8 = malloc ((256 + 2*232) * sizeof (uint8_t));
申鐃緒申   707 
申鐃緒申   708 	entry_size = sizeof (uint8_t);
申鐃緒申   709 	table_r = table_g = table_b = table_8 + 232;
申鐃緒申   710 
申鐃緒申   711 	for (i = -232; i < 256+232; i++)
申鐃緒申   712 	    ((uint8_t * )table_b)[i] = table_Y[i+384];
申鐃緒申   713 	break;
申鐃緒申   714 
申鐃緒申   715     case 15:
申鐃緒申   716     case 16:
申鐃緒申   717 	table_start= table_16 = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint16_t));
申鐃緒申   718 
申鐃緒申   719 	entry_size = sizeof (uint16_t);
申鐃緒申   720 	table_r = table_16 + 197;
申鐃緒申   721 	table_b = table_16 + 197 + 685;
申鐃緒申   722 	table_g = table_16 + 197 + 2*682;
申鐃緒申   723 
申鐃緒申   724 	for (i = -197; i < 256+197; i++) {
申鐃緒申   725 	    int j = table_Y[i+384] >> 3;
申鐃緒申   726 
申鐃緒申   727 	    if (isRgb)
申鐃緒申   728 		j <<= ((bpp==16) ? 11 : 10);
申鐃緒申   729 
申鐃緒申   730 	    ((uint16_t *)table_r)[i] = j;
申鐃緒申   731 	}
申鐃緒申   732 	for (i = -132; i < 256+132; i++) {
申鐃緒申   733 	    int j = table_Y[i+384] >> ((bpp==16) ? 2 : 3);
申鐃緒申   734 
申鐃緒申   735 	    ((uint16_t *)table_g)[i] = j << 5;
申鐃緒申   736 	}
申鐃緒申   737 	for (i = -232; i < 256+232; i++) {
申鐃緒申   738 	    int j = table_Y[i+384] >> 3;
申鐃緒申   739 
申鐃緒申   740 	    if (!isRgb)
申鐃緒申   741 		j <<= ((bpp==16) ? 11 : 10);
申鐃緒申   742 
申鐃緒申   743 	    ((uint16_t *)table_b)[i] = j;
申鐃緒申   744 	}
申鐃緒申   745 	break;
申鐃緒申   746 
申鐃緒申   747     case 8:
申鐃緒申   748 	table_start= table_332 = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint8_t));
申鐃緒申   749 
申鐃緒申   750 	entry_size = sizeof (uint8_t);
申鐃緒申   751 	table_r = table_332 + 197;
申鐃緒申   752 	table_b = table_332 + 197 + 685;
申鐃緒申   753 	table_g = table_332 + 197 + 2*682;
申鐃緒申   754 
申鐃緒申   755 	for (i = -197; i < 256+197; i++) {
申鐃緒申   756 	    int j = (table_Y[i+384 - 16] + 18)/36;
申鐃緒申   757 
申鐃緒申   758 	    if (isRgb)
申鐃緒申   759 		j <<= 5;
申鐃緒申   760 
申鐃緒申   761 	    ((uint8_t *)table_r)[i] = j;
申鐃緒申   762 	}
申鐃緒申   763 	for (i = -132; i < 256+132; i++) {
申鐃緒申   764 	    int j = (table_Y[i+384 - 16] + 18)/36;
申鐃緒申   765 
申鐃緒申   766 	    if (!isRgb)
申鐃緒申   767 		j <<= 1;
申鐃緒申   768 
申鐃緒申   769 	    ((uint8_t *)table_g)[i] = j << 2;
申鐃緒申   770 	}
申鐃緒申   771 	for (i = -232; i < 256+232; i++) {
申鐃緒申   772 	    int j = (table_Y[i+384 - 37] + 43)/85;
申鐃緒申   773 
申鐃緒申   774 	    if (!isRgb)
申鐃緒申   775 		j <<= 6;
申鐃緒申   776 
申鐃緒申   777 	    ((uint8_t *)table_b)[i] = j;
申鐃緒申   778 	}
申鐃緒申   779 	break;
申鐃緒申   780     case 4:
申鐃緒申   781     case 4|128:
申鐃緒申   782 	table_start= table_121 = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint8_t));
申鐃緒申   783 
申鐃緒申   784 	entry_size = sizeof (uint8_t);
申鐃緒申   785 	table_r = table_121 + 197;
申鐃緒申   786 	table_b = table_121 + 197 + 685;
申鐃緒申   787 	table_g = table_121 + 197 + 2*682;
申鐃緒申   788 
申鐃緒申   789 	for (i = -197; i < 256+197; i++) {
申鐃緒申   790 	    int j = table_Y[i+384 - 110] >> 7;
申鐃緒申   791 
申鐃緒申   792 	    if (isRgb)
申鐃緒申   793 		j <<= 3;
申鐃緒申   794 
申鐃緒申   795 	    ((uint8_t *)table_r)[i] = j;
申鐃緒申   796 	}
申鐃緒申   797 	for (i = -132; i < 256+132; i++) {
申鐃緒申   798 	    int j = (table_Y[i+384 - 37]+ 43)/85;
申鐃緒申   799 
申鐃緒申   800 	    ((uint8_t *)table_g)[i] = j << 1;
申鐃緒申   801 	}
申鐃緒申   802 	for (i = -232; i < 256+232; i++) {
申鐃緒申   803 	    int j =table_Y[i+384 - 110] >> 7;
申鐃緒申   804 
申鐃緒申   805 	    if (!isRgb)
申鐃緒申   806 		j <<= 3;
申鐃緒申   807 
申鐃緒申   808 	    ((uint8_t *)table_b)[i] = j;
申鐃緒申   809 	}
申鐃緒申   810 	break;
申鐃緒申   811 
申鐃緒申   812     case 1:
申鐃緒申   813 	table_start= table_1 = malloc (256*2 * sizeof (uint8_t));
申鐃緒申   814 
申鐃緒申   815 	entry_size = sizeof (uint8_t);
申鐃緒申   816 	table_g = table_1;
申鐃緒申   817 	table_r = table_b = NULL;
申鐃緒申   818 
申鐃緒申   819 	for (i = 0; i < 256+256; i++) {
申鐃緒申   820 	    int j = table_Y[i + 384 - 110]>>7;
申鐃緒申   821 
申鐃緒申   822 	    ((uint8_t *)table_g)[i] = j;
申鐃緒申   823 	}
申鐃緒申   824 	break;
申鐃緒申   825 
申鐃緒申   826     default:
申鐃緒申   827 	table_start= NULL;
申鐃緒申   828 	MSG_ERR("%ibpp not supported by yuv2rgb\n", bpp);
申鐃緒申   829 	//free mem?
申鐃緒申   830 	return -1;
申鐃緒申   831     }
申鐃緒申   832 
申鐃緒申   833     for (i = 0; i < 256; i++) {
申鐃緒申   834 	c->table_rV[i] = table_r + entry_size * div_round (crv * (i-128), 76309);
申鐃緒申   835 	c->table_gU[i] = table_g + entry_size * div_round (cgu * (i-128), 76309);
申鐃緒申   836 	c->table_gV[i] = entry_size * div_round (cgv * (i-128), 76309);
申鐃緒申   837 	c->table_bU[i] = table_b + entry_size * div_round (cbu * (i-128), 76309);
申鐃緒申   838     }
申鐃緒申   839 
申鐃緒申   840     if(c->yuvTable) free(c->yuvTable);
申鐃緒申   841     c->yuvTable= table_start;
申鐃緒申   842     return 0;
申鐃緒申   843 }