[svn] / branches / release-1_0-branch / xvidcore / src / image / colorspace.c Repository:
ViewVC logotype

Diff of /branches/release-1_0-branch/xvidcore/src/image/colorspace.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 677, Tue Nov 26 23:44:11 2002 UTC revision 851, Sat Feb 15 15:22:19 2003 UTC
# Line 1  Line 1 
1  /*****************************************************************************  /**************************************************************************
2   *   *
3   *  XVID MPEG-4 VIDEO CODEC   *  XVID MPEG-4 VIDEO CODEC
4   *  - colorspace conversion module -   *      colorspace conversions
5   *   *
6   *  Copyright(C) 2002 Peter Ross <pross@xvid.org>   *      This program is free software; you can redistribute it and/or modify
7   *               2002 Michael Militzer <isibaar@xvid.org>   *      it under the terms of the GNU General Public License as published by
  *  
  *  This file is part of XviD, a free MPEG-4 video encoder/decoder  
  *  
  *  XviD is free software; you can redistribute it and/or modify it  
  *  under the terms of the GNU General Public License as published by  
8   *  the Free Software Foundation; either version 2 of the License, or   *  the Free Software Foundation; either version 2 of the License, or
9   *  (at your option) any later version.   *  (at your option) any later version.
10   *   *
# Line 20  Line 15 
15   *   *
16   *  You should have received a copy of the GNU General Public License   *  You should have received a copy of the GNU General Public License
17   *  along with this program; if not, write to the Free Software   *  along with this program; if not, write to the Free Software
18   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA   *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *  
  *  Under section 8 of the GNU General Public License, the copyright  
  *  holders of XVID explicitly forbid distribution in the following  
  *  countries:  
  *  
  *    - Japan  
  *    - United States of America  
  *  
  *  Linking XviD statically or dynamically with other modules is making a  
  *  combined work based on XviD.  Thus, the terms and conditions of the  
  *  GNU General Public License cover the whole combination.  
19   *   *
20   *  As a special exception, the copyright holders of XviD give you   *************************************************************************/
21   *  permission to link XviD with independent modules that communicate with  
22   *  XviD solely through the VFW1.1 and DShow interfaces, regardless of the  /**************************************************************************
  *  license terms of these independent modules, and to copy and distribute  
  *  the resulting combined work under terms of your choice, provided that  
  *  every copy of the combined work is accompanied by a complete copy of  
  *  the source code of XviD (the version of XviD used to produce the  
  *  combined work), being distributed under the terms of the GNU General  
  *  Public License plus this exception.  An independent module is a module  
  *  which is not derived from or based on XviD.  
23   *   *
24   *  Note that people who make modified versions of XviD are not obligated   *      History:
  *  to grant this special exception for their modified versions; it is  
  *  their choice whether to do so.  The GNU General Public License gives  
  *  permission to release a modified version without this exception; this  
  *  exception also makes it possible to release a modified version which  
  *  carries forward this exception.  
25   *   *
26   * $Id: colorspace.c,v 1.7 2002-11-26 23:44:10 edgomez Exp $   *      14.04.2002      added user_to_yuv_c()
27     *      30.02.2002      out_yuv dst_stride2 fix
28     *      26.02.2002      rgb555, rgb565
29     *      24.11.2001      accuracy improvement to yuyv/vyuy conversion
30     *      28.10.2001      total rewrite <pross@cs.rmit.edu.au>
31   *   *
32   ****************************************************************************/   **************************************************************************/
33    
34  #include <string.h>                             /* memcpy */  #include <string.h>                             // memcpy
35    
36    #include "../global.h"
37    #include "../divx4.h"                   // DEC_PICTURE
38  #include "colorspace.h"  #include "colorspace.h"
 #include "../divx4.h"                   /* DEC_PICTURE */  
39    
40  /* function pointers */  // function pointers
41    
42  /* input */  /* input */
43  color_inputFuncPtr rgb555_to_yv12;  packedFuncPtr rgb555_to_yv12;
44  color_inputFuncPtr rgb565_to_yv12;  packedFuncPtr rgb565_to_yv12;
45  color_inputFuncPtr rgb24_to_yv12;  packedFuncPtr bgr_to_yv12;
46  color_inputFuncPtr rgb32_to_yv12;  packedFuncPtr bgra_to_yv12;
47  color_inputFuncPtr yuv_to_yv12;  packedFuncPtr abgr_to_yv12;
48  color_inputFuncPtr yuyv_to_yv12;  packedFuncPtr rgba_to_yv12;
49  color_inputFuncPtr uyvy_to_yv12;  packedFuncPtr yuv_to_yv12;
50    packedFuncPtr yuyv_to_yv12;
51    packedFuncPtr uyvy_to_yv12;
52    
53    packedFuncPtr rgb555i_to_yv12;
54    packedFuncPtr rgb565i_to_yv12;
55    packedFuncPtr bgri_to_yv12;
56    packedFuncPtr bgrai_to_yv12;
57    packedFuncPtr abgri_to_yv12;
58    packedFuncPtr rgbai_to_yv12;
59    packedFuncPtr yuyvi_to_yv12;
60    packedFuncPtr uyvyi_to_yv12;
61    
62  /* output */  /* output */
63  color_outputFuncPtr yv12_to_rgb555;  packedFuncPtr yv12_to_rgb555;
64  color_outputFuncPtr yv12_to_rgb565;  packedFuncPtr yv12_to_rgb565;
65  color_outputFuncPtr yv12_to_rgb24;  packedFuncPtr yv12_to_bgr;
66  color_outputFuncPtr yv12_to_rgb32;  packedFuncPtr yv12_to_bgra;
67  color_outputFuncPtr yv12_to_yuv;  packedFuncPtr yv12_to_abgr;
68  color_outputFuncPtr yv12_to_yuyv;  packedFuncPtr yv12_to_rgba;
69  color_outputFuncPtr yv12_to_uyvy;  packedFuncPtr yv12_to_yuv;
70    packedFuncPtr yv12_to_yuyv;
71    packedFuncPtr yv12_to_uyvy;
72    
73    packedFuncPtr yv12_to_rgb555i;
74    packedFuncPtr yv12_to_rgb565i;
75    packedFuncPtr yv12_to_bgri;
76    packedFuncPtr yv12_to_bgrai;
77    packedFuncPtr yv12_to_abgri;
78    packedFuncPtr yv12_to_rgbai;
79    packedFuncPtr yv12_to_yuyvi;
80    packedFuncPtr yv12_to_uyvyi;
81    
82    planarFuncPtr yv12_to_yv12;
83    
84    
85    int32_t RGB_Y_tab[256];
86    int32_t B_U_tab[256];
87    int32_t G_U_tab[256];
88    int32_t G_V_tab[256];
89    int32_t R_V_tab[256];
90    
91    
92    
93    /********** generic colorspace macro **********/
94    
95    
96    #define MAKE_COLORSPACE(NAME,SIZE,PIXELS,VPIXELS,FUNC,C1,C2,C3,C4) \
97    void    \
98    NAME(uint8_t * x_ptr, int x_stride,     \
99                                     uint8_t * y_ptr, uint8_t * u_ptr, uint8_t * v_ptr,     \
100                                     int y_stride, int uv_stride,   \
101                                     int width, int height, int vflip)      \
102    {       \
103            int fixed_width = (width + 1) & ~1;                             \
104            int x_dif = x_stride - (SIZE)*fixed_width;              \
105            int y_dif = y_stride - fixed_width;                             \
106            int uv_dif = uv_stride - (fixed_width / 2);             \
107            int x, y;                                                                               \
108            if (vflip) {                                                            \
109                    x_ptr += (height - 1) * x_stride;                       \
110                    x_dif = -(SIZE)*fixed_width - x_stride;         \
111                    x_stride = -x_stride;                                           \
112            }                                                                                               \
113            for (y = 0; y < height; y+=(VPIXELS)) {                 \
114                    FUNC##_ROW(SIZE,C1,C2,C3,C4);                           \
115                    for (x = 0; x < fixed_width; x+=(PIXELS)) {     \
116                            FUNC(SIZE,C1,C2,C3,C4);                         \
117                            x_ptr += (PIXELS)*(SIZE);                               \
118                            y_ptr += (PIXELS);                                              \
119                            u_ptr += (PIXELS)/2;                                    \
120                            v_ptr += (PIXELS)/2;                                    \
121                    }                                                                                       \
122                    x_ptr += x_dif + (VPIXELS-1)*x_stride;          \
123                    y_ptr += y_dif + (VPIXELS-1)*y_stride;          \
124                    u_ptr += uv_dif + ((VPIXELS/2)-1)*uv_stride;    \
125                    v_ptr += uv_dif + ((VPIXELS/2)-1)*uv_stride;    \
126            }                                                                                               \
127    }
128    
129    
130  #define MIN(A,B)        ((A)<(B)?(A):(B))  
131  #define MAX(A,B)        ((A)>(B)?(A):(B))  /********** colorspace input (xxx_to_yv12) functions **********/
132    
133  /*      rgb -> yuv def's  /*      rgb -> yuv def's
134    
# Line 112  Line 159 
159  #define FIX_IN(x)               ((uint16_t) ((x) * (1L<<SCALEBITS_IN) + 0.5))  #define FIX_IN(x)               ((uint16_t) ((x) * (1L<<SCALEBITS_IN) + 0.5))
160    
161    
162  int32_t RGB_Y_tab[256];  /* rgb16/rgb16i input */
 int32_t B_U_tab[256];  
 int32_t G_U_tab[256];  
 int32_t G_V_tab[256];  
 int32_t R_V_tab[256];  
   
   
 /* rgb555 -> yuv 4:2:0 planar */  
 void  
 rgb555_to_yv12_c(uint8_t * y_out,  
                                  uint8_t * u_out,  
                                  uint8_t * v_out,  
                                  uint8_t * src,  
                                  int width,  
                                  int height,  
                                  int y_stride)  
 {  
         int32_t src_stride = width * 2;  
         uint32_t y_dif = y_stride - width;  
         uint32_t uv_dif = (y_stride - width) / 2;  
         uint32_t x, y;  
   
         if (height < 0) {  
                 height = -height;  
                 src += (height - 1) * src_stride;  
                 src_stride = -src_stride;  
         }  
   
   
         for (y = height / 2; y; y--) {  
                 /* process one 2x2 block per iteration */  
                 for (x = 0; x < (uint32_t) width; x += 2) {  
                         int rgb, r, g, b, r4, g4, b4;  
   
                         rgb = *(uint16_t *) (src + x * 2);  
                         b4 = b = (rgb << 3) & 0xf8;  
                         g4 = g = (rgb >> 2) & 0xf8;  
                         r4 = r = (rgb >> 7) & 0xf8;  
                         y_out[0] =  
                                 (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +  
                                                         FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;  
   
                         rgb = *(uint16_t *) (src + x * 2 + src_stride);  
                         b4 += b = (rgb << 3) & 0xf8;  
                         g4 += g = (rgb >> 2) & 0xf8;  
                         r4 += r = (rgb >> 7) & 0xf8;  
                         y_out[y_stride] =  
                                 (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +  
                                                         FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;  
   
                         rgb = *(uint16_t *) (src + x * 2 + 2);  
                         b4 += b = (rgb << 3) & 0xf8;  
                         g4 += g = (rgb >> 2) & 0xf8;  
                         r4 += r = (rgb >> 7) & 0xf8;  
                         y_out[1] =  
                                 (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +  
                                                         FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;  
   
                         rgb = *(uint16_t *) (src + x * 2 + src_stride + 2);  
                         b4 += b = (rgb << 3) & 0xf8;  
                         g4 += g = (rgb >> 2) & 0xf8;  
                         r4 += r = (rgb >> 7) & 0xf8;  
                         y_out[y_stride + 1] =  
                                 (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +  
                                                         FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;  
   
                         *u_out++ =  
                                 (uint8_t) ((-FIX_IN(U_R_IN) * r4 - FIX_IN(U_G_IN) * g4 +  
                                                         FIX_IN(U_B_IN) * b4) >> (SCALEBITS_IN + 2)) +  
                                 U_ADD_IN;  
   
   
                         *v_out++ =  
                                 (uint8_t) ((FIX_IN(V_R_IN) * r4 - FIX_IN(V_G_IN) * g4 -  
                                                         FIX_IN(V_B_IN) * b4) >> (SCALEBITS_IN + 2)) +  
                                 V_ADD_IN;  
   
                         y_out += 2;  
                 }  
                 src += src_stride * 2;  
                 y_out += y_dif + y_stride;  
                 u_out += uv_dif;  
                 v_out += uv_dif;  
         }  
 }  
   
   
   
 /* rgb565_to_yuv_c  
         NOTE:   identical to rgb555 except for shift/mask  
                         not tested */  
   
 void  
 rgb565_to_yv12_c(uint8_t * y_out,  
                                  uint8_t * u_out,  
                                  uint8_t * v_out,  
                                  uint8_t * src,  
                                  int width,  
                                  int height,  
                                  int y_stride)  
 {  
         int32_t src_stride = width * 2;  
   
         uint32_t y_dif = y_stride - width;  
         uint32_t uv_dif = (y_stride - width) / 2;  
         uint32_t x, y;  
   
         if (height < 0) {  
                 height = -height;  
                 src += (height - 1) * src_stride;  
                 src_stride = -src_stride;  
         }  
   
   
         for (y = height / 2; y; y--) {  
                 /* process one 2x2 block per iteration */  
                 for (x = 0; x < (uint32_t) width; x += 2) {  
                         int rgb, r, g, b, r4, g4, b4;  
   
                         rgb = *(uint16_t *) (src + x * 2);  
                         b4 = b = (rgb << 3) & 0xf8;  
                         g4 = g = (rgb >> 3) & 0xfc;  
                         r4 = r = (rgb >> 8) & 0xf8;  
                         y_out[0] =  
                                 (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +  
                                                         FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;  
   
                         rgb = *(uint16_t *) (src + x * 2 + src_stride);  
                         b4 += b = (rgb << 3) & 0xf8;  
                         g4 += g = (rgb >> 3) & 0xfc;  
                         r4 += r = (rgb >> 8) & 0xf8;  
                         y_out[y_stride] =  
                                 (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +  
                                                         FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;  
   
                         rgb = *(uint16_t *) (src + x * 2 + 2);  
                         b4 += b = (rgb << 3) & 0xf8;  
                         g4 += g = (rgb >> 3) & 0xfc;  
                         r4 += r = (rgb >> 8) & 0xf8;  
                         y_out[1] =  
                                 (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +  
                                                         FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;  
   
                         rgb = *(uint16_t *) (src + x * 2 + src_stride + 2);  
                         b4 += b = (rgb << 3) & 0xf8;  
                         g4 += g = (rgb >> 3) & 0xfc;  
                         r4 += r = (rgb >> 8) & 0xf8;  
                         y_out[y_stride + 1] =  
                                 (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +  
                                                         FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;  
   
                         *u_out++ =  
                                 (uint8_t) ((-FIX_IN(U_R_IN) * r4 - FIX_IN(U_G_IN) * g4 +  
                                                         FIX_IN(U_B_IN) * b4) >> (SCALEBITS_IN + 2)) +  
                                 U_ADD_IN;  
   
   
                         *v_out++ =  
                                 (uint8_t) ((FIX_IN(V_R_IN) * r4 - FIX_IN(V_G_IN) * g4 -  
                                                         FIX_IN(V_B_IN) * b4) >> (SCALEBITS_IN + 2)) +  
                                 V_ADD_IN;  
   
                         y_out += 2;  
                 }  
                 src += src_stride * 2;  
                 y_out += y_dif + y_stride;  
                 u_out += uv_dif;  
                 v_out += uv_dif;  
         }  
 }  
   
   
   
   
 /*      rgb24 -> yuv 4:2:0 planar  
   
         NOTE: always flips.  
 */  
   
 void  
 rgb24_to_yv12_c(uint8_t * y_out,  
                                 uint8_t * u_out,  
                                 uint8_t * v_out,  
                                 uint8_t * src,  
                                 int width,  
                                 int height,  
                                 int stride)  
 {  
         uint32_t width3 = (width << 1) + width; /* width * 3 */  
         uint32_t src_dif = (width << 3) + width;        /* width3 * 3 */  
         uint32_t y_dif = (stride << 1) - width;  
         uint32_t uv_dif = (stride - width) >> 1;  
         uint32_t x, y;  
   
         src += (height - 2) * width3;  
   
   
         for (y = height >> 1; y; y--) {  
                 for (x = width >> 1; x; x--) {  
                         uint32_t r, g, b, r4, g4, b4;  
   
                         b4 = b = src[0];  
                         g4 = g = src[1];  
                         r4 = r = src[2];  
                         y_out[stride + 0] =  
                                 (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +  
                                                         FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;  
   
                         b4 += (b = src[3]);  
                         g4 += (g = src[4]);  
                         r4 += (r = src[5]);  
                         y_out[stride + 1] =  
                                 (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +  
                                                         FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;  
   
                         b4 += (b = src[width3 + 0]);  
                         g4 += (g = src[width3 + 1]);  
                         r4 += (r = src[width3 + 2]);  
                         y_out[0] =  
                                 (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +  
                                                         FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;  
   
                         b4 += (b = src[width3 + 3]);  
                         g4 += (g = src[width3 + 4]);  
                         r4 += (r = src[width3 + 5]);  
                         y_out[1] =  
                                 (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +  
                                                         FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;  
   
                         *u_out++ =  
                                 (uint8_t) ((-FIX_IN(U_R_IN) * r4 - FIX_IN(U_G_IN) * g4 +  
                                                         FIX_IN(U_B_IN) * b4) >> (SCALEBITS_IN + 2)) +  
                                 U_ADD_IN;  
   
   
                         *v_out++ =  
                                 (uint8_t) ((FIX_IN(V_R_IN) * r4 - FIX_IN(V_G_IN) * g4 -  
                                                         FIX_IN(V_B_IN) * b4) >> (SCALEBITS_IN + 2)) +  
                                 V_ADD_IN;  
   
   
                         src += 6;  
                         y_out += 2;  
                 }  
                 src -= src_dif;  
                 y_out += y_dif;  
                 u_out += uv_dif;  
                 v_out += uv_dif;  
         }  
 }  
   
   
 /*      rgb32 -> yuv 4:2:0 planar  
163    
164          NOTE: always flips  #define MK_RGB555_B(RGB)  ((RGB) << 3) & 0xf8
165  */  #define MK_RGB555_G(RGB)  ((RGB) >> 2) & 0xf8
166    #define MK_RGB555_R(RGB)  ((RGB) >> 7) & 0xf8
167  void  
168  rgb32_to_yv12_c(uint8_t * y_out,  #define MK_RGB565_B(RGB)  ((RGB) << 3) & 0xf8
169                                  uint8_t * u_out,  #define MK_RGB565_G(RGB)  ((RGB) >> 3) & 0xfc
170                                  uint8_t * v_out,  #define MK_RGB565_R(RGB)  ((RGB) >> 8) & 0xf8
171                                  uint8_t * src,  
172                                  int width,  
173                                  int height,  #define READ_RGB16_Y(ROW, UVID, C1,C2,C3,C4)    \
174                                  int stride)          rgb = *(uint16_t *) (x_ptr + ((ROW)*x_stride) + 0);     \
175  {          b##UVID += b = C1##_B(rgb);                             \
176          uint32_t width4 = (width << 2); /* width * 4 */          g##UVID += g = C1##_G(rgb);                             \
177          uint32_t src_dif = 3 * width4;          r##UVID += r = C1##_R(rgb);                             \
178          uint32_t y_dif = (stride << 1) - width;          y_ptr[(ROW)*y_stride+0] =                               \
179          uint32_t uv_dif = (stride - width) >> 1;                  (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +   \
180          uint32_t x, y;                                          FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;        \
181            rgb = *(uint16_t *) (x_ptr + ((ROW)*x_stride) + 2);     \
182          src += (height - 2) * width4;          b##UVID += b = C1##_B(rgb);                             \
183            g##UVID += g = C1##_G(rgb);                             \
184          for (y = height >> 1; y; y--) {          r##UVID += r = C1##_R(rgb);                             \
185                  for (x = width >> 1; x; x--) {          y_ptr[(ROW)*y_stride+1] =                               \
186                          uint32_t r, g, b, r4, g4, b4;                  (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +                   \
187                                            FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;
188                          b4 = b = src[0];  
189                          g4 = g = src[1];  #define READ_RGB16_UV(UV_ROW,UVID)      \
190                          r4 = r = src[2];          u_ptr[(UV_ROW)*uv_stride] =                                                                                                             \
191                          y_out[stride + 0] =                  (uint8_t) ((-FIX_IN(U_R_IN) * r##UVID - FIX_IN(U_G_IN) * g##UVID +                      \
192                                  (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +                                          FIX_IN(U_B_IN) * b##UVID) >> (SCALEBITS_IN + 2)) + U_ADD_IN;    \
193                                                          FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;          v_ptr[(UV_ROW)*uv_stride] =                                                                                                             \
194                    (uint8_t) ((FIX_IN(V_R_IN) * r##UVID - FIX_IN(V_G_IN) * g##UVID -                       \
195                                            FIX_IN(V_B_IN) * b##UVID) >> (SCALEBITS_IN + 2)) + V_ADD_IN;
196    
197    #define RGB16_TO_YV12_ROW(SIZE,C1,C2,C3,C4) \
198            /* nothing */
199    #define RGB16_TO_YV12(SIZE,C1,C2,C3,C4) \
200            uint32_t rgb, r, g, b, r0, g0, b0;      \
201            r0 = g0 = b0 = 0;                                       \
202            READ_RGB16_Y (0, 0, C1,C2,C3,C4)        \
203            READ_RGB16_Y (1, 0, C1,C2,C3,C4)        \
204            READ_RGB16_UV(0, 0)
205    
206    
207    #define RGB16I_TO_YV12_ROW(SIZE,C1,C2,C3,C4) \
208            /* nothing */
209    #define RGB16I_TO_YV12(SIZE,C1,C2,C3,C4)        \
210            uint32_t rgb, r, g, b, r0, g0, b0, r1, g1, b1;  \
211            r0 = g0 = b0 = r1 = g1 = b1 = 0;        \
212            READ_RGB16_Y (0, 0, C1,C2,C3,C4)        \
213            READ_RGB16_Y (1, 1, C1,C2,C3,C4)        \
214            READ_RGB16_Y (2, 0, C1,C2,C3,C4)        \
215            READ_RGB16_Y (3, 1, C1,C2,C3,C4)        \
216            READ_RGB16_UV(0, 0)                                     \
217            READ_RGB16_UV(1, 1)
218    
219    
220    /* rgb/rgbi input */
221    
222    #define READ_RGB_Y(SIZE, ROW, UVID, C1,C2,C3,C4)        \
223            r##UVID += r = x_ptr[(ROW)*x_stride+(C1)];                                              \
224            g##UVID += g = x_ptr[(ROW)*x_stride+(C2)];                                              \
225            b##UVID += b = x_ptr[(ROW)*x_stride+(C3)];                                              \
226            y_ptr[(ROW)*y_stride+0] =                                                                       \
227                    (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +   \
228                                            FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;        \
229            r##UVID += r = x_ptr[(ROW)*x_stride+(SIZE)+(C1)];                               \
230            g##UVID += g = x_ptr[(ROW)*x_stride+(SIZE)+(C2)];                               \
231            b##UVID += b = x_ptr[(ROW)*x_stride+(SIZE)+(C3)];                               \
232            y_ptr[(ROW)*y_stride+1] =                                                                       \
233                    (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +   \
234                                            FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;
235    
236    #define READ_RGB_UV(UV_ROW,UVID)        \
237            u_ptr[(UV_ROW)*uv_stride] =                                                                                                             \
238                    (uint8_t) ((-FIX_IN(U_R_IN) * r##UVID - FIX_IN(U_G_IN) * g##UVID +                      \
239                                            FIX_IN(U_B_IN) * b##UVID) >> (SCALEBITS_IN + 2)) + U_ADD_IN;    \
240            v_ptr[(UV_ROW)*uv_stride] =                                                                                                             \
241                    (uint8_t) ((FIX_IN(V_R_IN) * r##UVID - FIX_IN(V_G_IN) * g##UVID -                       \
242                                            FIX_IN(V_B_IN) * b##UVID) >> (SCALEBITS_IN + 2)) + V_ADD_IN;
243    
244    
245    #define RGB_TO_YV12_ROW(SIZE,C1,C2,C3,C4) \
246            /* nothing */
247    #define RGB_TO_YV12(SIZE,C1,C2,C3,C4)   \
248            uint32_t r, g, b, r0, g0, b0;           \
249            r0 = g0 = b0 = 0;                                       \
250            READ_RGB_Y(SIZE, 0, 0, C1,C2,C3,C4)     \
251            READ_RGB_Y(SIZE, 1, 0, C1,C2,C3,C4)     \
252            READ_RGB_UV(     0, 0)
253    
254    #define RGBI_TO_YV12_ROW(SIZE,C1,C2,C3,C4) \
255            /* nothing */
256    #define RGBI_TO_YV12(SIZE,C1,C2,C3,C4)  \
257            uint32_t r, g, b, r0, g0, b0, r1, g1, b1;       \
258            r0 = g0 = b0 = r1 = g1 = b1 = 0;        \
259            READ_RGB_Y(SIZE, 0, 0, C1,C2,C3,C4)     \
260            READ_RGB_Y(SIZE, 1, 1, C1,C2,C3,C4)     \
261            READ_RGB_Y(SIZE, 2, 0, C1,C2,C3,C4)     \
262            READ_RGB_Y(SIZE, 3, 1, C1,C2,C3,C4)     \
263            READ_RGB_UV(     0, 0)                          \
264            READ_RGB_UV(     1, 1)
265    
266    
267    /* yuyv/yuyvi input */
268    
269    #define READ_YUYV_Y(ROW,C1,C2,C3,C4)    \
270            y_ptr[(ROW)*y_stride+0] = x_ptr[(ROW)*x_stride+(C1)];   \
271            y_ptr[(ROW)*y_stride+1] = x_ptr[(ROW)*x_stride+(C3)];
272    #define READ_YUYV_UV(UV_ROW,ROW1,ROW2,C1,C2,C3,C4) \
273            u_ptr[(UV_ROW)*uv_stride] = (x_ptr[(ROW1)*x_stride+(C2)] + x_ptr[(ROW2)*x_stride+(C2)] + 1) / 2;        \
274            v_ptr[(UV_ROW)*uv_stride] = (x_ptr[(ROW1)*x_stride+(C4)] + x_ptr[(ROW2)*x_stride+(C4)] + 1) / 2;
275    
276    #define YUYV_TO_YV12_ROW(SIZE,C1,C2,C3,C4) \
277            /* nothing */
278    #define YUYV_TO_YV12(SIZE,C1,C2,C3,C4)  \
279            READ_YUYV_Y (0,      C1,C2,C3,C4)       \
280            READ_YUYV_Y (1,      C1,C2,C3,C4)       \
281            READ_YUYV_UV(0, 0,1, C1,C2,C3,C4)
282    
283    #define YUYVI_TO_YV12_ROW(SIZE,C1,C2,C3,C4) \
284            /* nothing */
285    #define YUYVI_TO_YV12(SIZE,C1,C2,C3,C4) \
286            READ_YUYV_Y (0, C1,C2,C3,C4)    \
287            READ_YUYV_Y (1, C1,C2,C3,C4)    \
288            READ_YUYV_Y (2, C1,C2,C3,C4)    \
289            READ_YUYV_Y (3, C1,C2,C3,C4)    \
290            READ_YUYV_UV(0, 0,2, C1,C2,C3,C4)       \
291            READ_YUYV_UV(1, 1,3, C1,C2,C3,C4)
292    
293    
294    MAKE_COLORSPACE(rgb555_to_yv12_c,  2,2,2, RGB16_TO_YV12,  MK_RGB555, 0,0,0)
295    MAKE_COLORSPACE(rgb565_to_yv12_c,  2,2,2, RGB16_TO_YV12,  MK_RGB565, 0,0,0)
296    MAKE_COLORSPACE(bgr_to_yv12_c,     3,2,2, RGB_TO_YV12,    2,1,0, 0)
297    MAKE_COLORSPACE(bgra_to_yv12_c,    4,2,2, RGB_TO_YV12,    2,1,0, 0)
298    MAKE_COLORSPACE(abgr_to_yv12_c,    4,2,2, RGB_TO_YV12,    3,2,1, 0)
299    MAKE_COLORSPACE(rgba_to_yv12_c,    4,2,2, RGB_TO_YV12,    0,1,2, 0)
300    MAKE_COLORSPACE(yuyv_to_yv12_c,    2,2,2, YUYV_TO_YV12,   0,1,2,3)
301    MAKE_COLORSPACE(uyvy_to_yv12_c,    2,2,2, YUYV_TO_YV12,   1,0,3,2)
302    
303    MAKE_COLORSPACE(rgb555i_to_yv12_c, 2,2,4, RGB16I_TO_YV12, MK_RGB555, 0,0,0)
304    MAKE_COLORSPACE(rgb565i_to_yv12_c, 2,2,4, RGB16I_TO_YV12, MK_RGB565, 0,0,0)
305    MAKE_COLORSPACE(bgri_to_yv12_c,    3,2,4, RGBI_TO_YV12,   2,1,0, 0)
306    MAKE_COLORSPACE(bgrai_to_yv12_c,   4,2,4, RGBI_TO_YV12,   2,1,0, 0)
307    MAKE_COLORSPACE(abgri_to_yv12_c,   4,2,4, RGBI_TO_YV12,   3,2,1, 0)
308    MAKE_COLORSPACE(rgbai_to_yv12_c,   4,2,4, RGBI_TO_YV12,   0,1,2, 0)
309    MAKE_COLORSPACE(yuyvi_to_yv12_c,   2,2,4, YUYVI_TO_YV12,  0,1,2,3)
310    MAKE_COLORSPACE(uyvyi_to_yv12_c,   2,2,4, YUYVI_TO_YV12,  1,0,3,2)
311    
                         b4 += (b = src[4]);  
                         g4 += (g = src[5]);  
                         r4 += (r = src[6]);  
                         y_out[stride + 1] =  
                                 (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +  
                                                         FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;  
   
                         b4 += (b = src[width4 + 0]);  
                         g4 += (g = src[width4 + 1]);  
                         r4 += (r = src[width4 + 2]);  
   
                         y_out[0] =  
                                 (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +  
                                                         FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;  
   
                         b4 += (b = src[width4 + 4]);  
                         g4 += (g = src[width4 + 5]);  
                         r4 += (r = src[width4 + 6]);  
                         y_out[1] =  
                                 (uint8_t) ((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g +  
                                                         FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;  
   
                         *u_out++ =  
                                 (uint8_t) ((-FIX_IN(U_R_IN) * r4 - FIX_IN(U_G_IN) * g4 +  
                                                         FIX_IN(U_B_IN) * b4) >> (SCALEBITS_IN + 2)) +  
                                 U_ADD_IN;  
   
                         *v_out++ =  
                                 (uint8_t) ((FIX_IN(V_R_IN) * r4 - FIX_IN(V_G_IN) * g4 -  
                                                         FIX_IN(V_B_IN) * b4) >> (SCALEBITS_IN + 2)) +  
                                 V_ADD_IN;  
   
                         src += 8;  
                         y_out += 2;  
                 }  
                 src -= src_dif;  
                 y_out += y_dif;  
                 u_out += uv_dif;  
                 v_out += uv_dif;  
         }  
 }  
   
 /*      yuv planar -> yuv 4:2:0 planar  
   
         NOTE: does not flip */  
   
 void  
 yuv_to_yv12_c(uint8_t * y_out,  
                           uint8_t * u_out,  
                           uint8_t * v_out,  
                           uint8_t * src,  
                           int width,  
                           int height,  
                           int stride)  
 {  
         uint32_t stride2 = stride >> 1;  
         uint32_t width2 = width >> 1;  
         uint32_t y;  
   
         for (y = height; y; y--) {  
                 memcpy(y_out, src, width);  
                 src += width;  
                 y_out += stride;  
         }  
   
         for (y = height >> 1; y; y--) {  
                 memcpy(u_out, src, width2);  
                 src += width2;  
                 u_out += stride2;  
         }  
   
         for (y = height >> 1; y; y--) {  
                 memcpy(v_out, src, width2);  
                 src += width2;  
                 v_out += stride2;  
         }  
 }  
   
   
   
 /* yuyv (yuv2) packed -> yuv 4:2:0 planar  
   
    NOTE: does not flip */  
   
 void  
 yuyv_to_yv12_c(uint8_t * y_out,  
                            uint8_t * u_out,  
                            uint8_t * v_out,  
                            uint8_t * src,  
                            int width,  
                            int height,  
                            int stride)  
 {  
         uint32_t width2 = width + width;  
         uint32_t y_dif = stride - width;  
         uint32_t uv_dif = y_dif >> 1;  
         uint32_t x, y;  
   
         for (y = height >> 1; y; y--) {  
   
                 for (x = width >> 1; x; x--) {  
                         *y_out++ = *src++;  
                         /**u_out++ = *src++; */  
                         *u_out++ = (*(src + width2) + *src) >> 1;  
                         src++;  
                         *y_out++ = *src++;  
                         /**v_out++ = *src++; */  
                         *v_out++ = (*(src + width2) + *src) >> 1;  
                         src++;  
   
                 }  
   
                 y_out += y_dif;  
                 u_out += uv_dif;  
                 v_out += uv_dif;  
   
                 for (x = width >> 1; x; x--) {  
                         *y_out++ = *src++;  
                         src++;  
                         *y_out++ = *src++;  
                         src++;  
                 }  
   
                 y_out += y_dif;  
   
         }  
   
 }  
   
   
   
 /* uyvy packed -> yuv 4:2:0 planar  
   
    NOTE: does not flip */  
   
   
 void  
 uyvy_to_yv12_c(uint8_t * y_out,  
                            uint8_t * u_out,  
                            uint8_t * v_out,  
                            uint8_t * src,  
                            int width,  
                            int height,  
                            int stride)  
 {  
         uint32_t width2 = width + width;  
         uint32_t y_dif = stride - width;  
         uint32_t uv_dif = y_dif >> 1;  
         uint32_t x, y;  
   
         for (y = height >> 1; y; y--) {  
   
                 for (x = width >> 1; x; x--) {  
                         *u_out++ = *src++;  
                         /* *u_out++ = (*(src+width2) + *src++) >> 1; */  
                         *y_out++ = *src++;  
                         /**v_out++ = *src++; */  
                         *v_out++ = (*(src + width2) + *src) >> 1;  
                         src++;  
                         *y_out++ = *src++;  
                 }  
   
                 y_out += y_dif;  
                 u_out += uv_dif;;  
                 v_out += uv_dif;;  
   
                 for (x = width >> 1; x; x--) {  
                         src++;  
                         *y_out++ = *src++;  
                         src++;  
                         *y_out++ = *src++;  
                 }  
   
                 y_out += y_dif;  
         }  
 }  
312    
313    /********** colorspace output (yv12_to_xxx) functions **********/
314    
315  /*      yuv -> rgb def's */  /*      yuv -> rgb def's */
316    
# Line 588  Line 325 
325  #define R_V_OUT                 1.596  #define R_V_OUT                 1.596
326  #define V_ADD_OUT               128  #define V_ADD_OUT               128
327    
   
328  #define SCALEBITS_OUT   13  #define SCALEBITS_OUT   13
329  #define FIX_OUT(x)              ((uint16_t) ((x) * (1L<<SCALEBITS_OUT) + 0.5))  #define FIX_OUT(x)              ((uint16_t) ((x) * (1L<<SCALEBITS_OUT) + 0.5))
330    
331    
332  /* initialize rgb lookup tables */  /* rgb16/rgb16i output */
   
 void  
 colorspace_init(void)  
 {  
         int32_t i;  
   
         for (i = 0; i < 256; i++) {  
                 RGB_Y_tab[i] = FIX_OUT(RGB_Y_OUT) * (i - Y_ADD_OUT);  
                 B_U_tab[i] = FIX_OUT(B_U_OUT) * (i - U_ADD_OUT);  
                 G_U_tab[i] = FIX_OUT(G_U_OUT) * (i - U_ADD_OUT);  
                 G_V_tab[i] = FIX_OUT(G_V_OUT) * (i - V_ADD_OUT);  
                 R_V_tab[i] = FIX_OUT(R_V_OUT) * (i - V_ADD_OUT);  
         }  
 }  
   
 /* yuv 4:2:0 planar -> rgb555 + very simple error diffusion  
 */  
333    
334  #define MK_RGB555(R,G,B)        ((MAX(0,MIN(255, R)) << 7) & 0x7c00) | \  #define MK_RGB555(R,G,B)        \
335            ((MAX(0,MIN(255, R)) << 7) & 0x7c00) | \
336                                                          ((MAX(0,MIN(255, G)) << 2) & 0x03e0) | \                                                          ((MAX(0,MIN(255, G)) << 2) & 0x03e0) | \
337                                                          ((MAX(0,MIN(255, B)) >> 3) & 0x001f)                                                          ((MAX(0,MIN(255, B)) >> 3) & 0x001f)
338    
339    #define MK_RGB565(R,G,B)        \
340  void          ((MAX(0,MIN(255, R)) << 8) & 0xf800) | \
 yv12_to_rgb555_c(uint8_t * dst,  
                                  int dst_stride,  
                                  uint8_t * y_src,  
                                  uint8_t * u_src,  
                                  uint8_t * v_src,  
                                  int y_stride,  
                                  int uv_stride,  
                                  int width,  
                                  int height)  
 {  
         const uint32_t dst_dif = 4 * dst_stride - 2 * width;  
         int32_t y_dif = 2 * y_stride - width;  
   
         uint8_t *dst2 = dst + 2 * dst_stride;  
         uint8_t *y_src2 = y_src + y_stride;  
         uint32_t x, y;  
   
         if (height < 0) {  
                 height = -height;  
                 y_src += (height - 1) * y_stride;  
                 y_src2 = y_src - y_stride;  
                 u_src += (height / 2 - 1) * uv_stride;  
                 v_src += (height / 2 - 1) * uv_stride;  
                 y_dif = -width - 2 * y_stride;  
                 uv_stride = -uv_stride;  
         }  
   
         for (y = height / 2; y; y--) {  
                 int r, g, b;  
                 int r2, g2, b2;  
   
                 r = g = b = 0;  
                 r2 = g2 = b2 = 0;  
   
                 /* process one 2x2 block per iteration */  
                 for (x = 0; x < (uint32_t) width / 2; x++) {  
                         int u, v;  
                         int b_u, g_uv, r_v, rgb_y;  
   
                         u = u_src[x];  
                         v = v_src[x];  
   
                         b_u = B_U_tab[u];  
                         g_uv = G_U_tab[u] + G_V_tab[v];  
                         r_v = R_V_tab[v];  
   
                         rgb_y = RGB_Y_tab[*y_src];  
                         b = (b & 0x7) + ((rgb_y + b_u) >> SCALEBITS_OUT);  
                         g = (g & 0x7) + ((rgb_y - g_uv) >> SCALEBITS_OUT);  
                         r = (r & 0x7) + ((rgb_y + r_v) >> SCALEBITS_OUT);  
                         *(uint16_t *) dst = MK_RGB555(r, g, b);  
   
                         y_src++;  
                         rgb_y = RGB_Y_tab[*y_src];  
                         b = (b & 0x7) + ((rgb_y + b_u) >> SCALEBITS_OUT);  
                         g = (g & 0x7) + ((rgb_y - g_uv) >> SCALEBITS_OUT);  
                         r = (r & 0x7) + ((rgb_y + r_v) >> SCALEBITS_OUT);  
                         *(uint16_t *) (dst + 2) = MK_RGB555(r, g, b);  
                         y_src++;  
   
                         rgb_y = RGB_Y_tab[*y_src2];  
                         b2 = (b2 & 0x7) + ((rgb_y + b_u) >> SCALEBITS_OUT);  
                         g2 = (g2 & 0x7) + ((rgb_y - g_uv) >> SCALEBITS_OUT);  
                         r2 = (r2 & 0x7) + ((rgb_y + r_v) >> SCALEBITS_OUT);  
                         *(uint16_t *) (dst2) = MK_RGB555(r2, g2, b2);  
                         y_src2++;  
   
                         rgb_y = RGB_Y_tab[*y_src2];  
                         b2 = (b2 & 0x7) + ((rgb_y + b_u) >> SCALEBITS_OUT);  
                         g2 = (g2 & 0x7) + ((rgb_y - g_uv) >> SCALEBITS_OUT);  
                         r2 = (r2 & 0x7) + ((rgb_y + r_v) >> SCALEBITS_OUT);  
                         *(uint16_t *) (dst2 + 2) = MK_RGB555(r2, g2, b2);  
                         y_src2++;  
   
                         dst += 4;  
                         dst2 += 4;  
                 }  
   
                 dst += dst_dif;  
                 dst2 += dst_dif;  
   
                 y_src += y_dif;  
                 y_src2 += y_dif;  
   
                 u_src += uv_stride;  
                 v_src += uv_stride;  
         }  
 }  
   
   
 /* yuv 4:2:0 planar -> rgb565 + very simple error diffusion  
         NOTE:   identical to rgb555 except for shift/mask  */  
   
   
 #define MK_RGB565(R,G,B)        ((MAX(0,MIN(255, R)) << 8) & 0xf800) | \  
341                                                          ((MAX(0,MIN(255, G)) << 3) & 0x07e0) | \                                                          ((MAX(0,MIN(255, G)) << 3) & 0x07e0) | \
342                                                          ((MAX(0,MIN(255, B)) >> 3) & 0x001f)                                                          ((MAX(0,MIN(255, B)) >> 3) & 0x001f)
343    
344  void  #define WRITE_RGB16(ROW,UV_ROW,C1)      \
345  yv12_to_rgb565_c(uint8_t * dst,          rgb_y = RGB_Y_tab[ y_ptr[y_stride + 0] ];                       \
346                                   int dst_stride,          b[ROW] = (b[ROW] & 0x7) + ((rgb_y + b_u##UV_ROW) >> SCALEBITS_OUT);     \
347                                   uint8_t * y_src,          g[ROW] = (g[ROW] & 0x7) + ((rgb_y - g_uv##UV_ROW) >> SCALEBITS_OUT);    \
348                                   uint8_t * u_src,          r[ROW] = (r[ROW] & 0x7) + ((rgb_y + r_v##UV_ROW) >> SCALEBITS_OUT);             \
349                                   uint8_t * v_src,          *(uint16_t *) (x_ptr+((ROW)*x_stride)+0) = C1(r[ROW], g[ROW], b[ROW]);  \
350                                   int y_stride,          rgb_y = RGB_Y_tab[ y_ptr[y_stride + 1] ];                               \
351                                   int uv_stride,          b[ROW] = (b[ROW] & 0x7) + ((rgb_y + b_u##UV_ROW) >> SCALEBITS_OUT);             \
352                                   int width,          g[ROW] = (g[ROW] & 0x7) + ((rgb_y - g_uv##UV_ROW) >> SCALEBITS_OUT);    \
353                                   int height)          r[ROW] = (r[ROW] & 0x7) + ((rgb_y + r_v##UV_ROW) >> SCALEBITS_OUT);             \
354  {          *(uint16_t *) (x_ptr+((ROW)*x_stride)+2) = C1(r[ROW], g[ROW], b[ROW]);
355          const uint32_t dst_dif = 4 * dst_stride - 2 * width;  
356          int32_t y_dif = 2 * y_stride - width;  #define YV12_TO_RGB16_ROW(SIZE,C1,C2,C3,C4) \
357            int r[2], g[2], b[2];                                   \
358          uint8_t *dst2 = dst + 2 * dst_stride;          r[0] = r[1] = g[0] = g[1] = b[0] = b[1] = 0;
359          uint8_t *y_src2 = y_src + y_stride;  #define YV12_TO_RGB16(SIZE,C1,C2,C3,C4)         \
360          uint32_t x, y;          int rgb_y;                                                                                              \
361            int b_u0 = B_U_tab[ u_ptr[0] ];                                                         \
362          if (height < 0) {                       /* flip image? */          int g_uv0 = G_U_tab[ u_ptr[0] ] + G_V_tab[ v_ptr[0] ];          \
363                  height = -height;          int r_v0 = R_V_tab[ v_ptr[0] ];                                                         \
364                  y_src += (height - 1) * y_stride;          WRITE_RGB16(0, 0, C1)                                                                           \
365                  y_src2 = y_src - y_stride;          WRITE_RGB16(1, 0, C1)
366                  u_src += (height / 2 - 1) * uv_stride;  
367                  v_src += (height / 2 - 1) * uv_stride;  #define YV12_TO_RGB16I_ROW(SIZE,C1,C2,C3,C4) \
368                  y_dif = -width - 2 * y_stride;          int r[4], g[4], b[4];                                   \
369                  uv_stride = -uv_stride;          r[0] = r[1] = r[2] = r[3] = 0;                  \
370          }          g[0] = g[1] = g[2] = g[3] = 0;                  \
371            b[0] = b[1] = b[2] = b[3] = 0;
372          for (y = height / 2; y; y--) {  #define YV12_TO_RGB16I(SIZE,C1,C2,C3,C4)                \
373                  int r, g, b;          int rgb_y;                                                                                                      \
374                  int r2, g2, b2;          int b_u0 = B_U_tab[ u_ptr[0] ];                                                         \
375            int g_uv0 = G_U_tab[ u_ptr[0] ] + G_V_tab[ v_ptr[0] ];          \
376                  r = g = b = 0;          int r_v0 = R_V_tab[ v_ptr[0] ];                                                         \
377                  r2 = g2 = b2 = 0;      int b_u1 = B_U_tab[ u_ptr[uv_stride] ];                                             \
378            int g_uv1 = G_U_tab[ u_ptr[uv_stride] ] + G_V_tab[ v_ptr[uv_stride] ];  \
379                  /* process one 2x2 block per iteration */          int r_v1 = R_V_tab[ v_ptr[uv_stride] ];                                         \
380                  for (x = 0; x < (uint32_t) width / 2; x++) {      WRITE_RGB16(0, 0, C1)                                                                               \
381                          int u, v;          WRITE_RGB16(1, 1, C1)                                                                           \
382                          int b_u, g_uv, r_v, rgb_y;      WRITE_RGB16(2, 0, C1)                                                                               \
383            WRITE_RGB16(3, 1, C1)                                                                           \
384                          u = u_src[x];  
385                          v = v_src[x];  
386    /* rgb/rgbi output */
387                          b_u = B_U_tab[u];  
388                          g_uv = G_U_tab[u] + G_V_tab[v];  #define WRITE_RGB(SIZE,ROW,UV_ROW,C1,C2,C3,C4)  \
389                          r_v = R_V_tab[v];          rgb_y = RGB_Y_tab[ y_ptr[(ROW)*y_stride + 0] ];                                         \
390            x_ptr[(ROW)*x_stride+(C3)] = MAX(0, MIN(255, (rgb_y + b_u##UV_ROW) >> SCALEBITS_OUT));  \
391                          rgb_y = RGB_Y_tab[*y_src];          x_ptr[(ROW)*x_stride+(C2)] = MAX(0, MIN(255, (rgb_y - g_uv##UV_ROW) >> SCALEBITS_OUT)); \
392                          b = (b & 0x7) + ((rgb_y + b_u) >> SCALEBITS_OUT);          x_ptr[(ROW)*x_stride+(C1)] = MAX(0, MIN(255, (rgb_y + r_v##UV_ROW) >> SCALEBITS_OUT));  \
393                          g = (g & 0x7) + ((rgb_y - g_uv) >> SCALEBITS_OUT);          if ((SIZE)>3) x_ptr[(ROW)*x_stride+(C4)] = 0;                                                                   \
394                          r = (r & 0x7) + ((rgb_y + r_v) >> SCALEBITS_OUT);          rgb_y = RGB_Y_tab[ y_ptr[(ROW)*y_stride + 1] ];                                                                 \
395                          *(uint16_t *) dst = MK_RGB565(r, g, b);          x_ptr[(ROW)*x_stride+(SIZE)+(C3)] = MAX(0, MIN(255, (rgb_y + b_u##UV_ROW) >> SCALEBITS_OUT));   \
396            x_ptr[(ROW)*x_stride+(SIZE)+(C2)] = MAX(0, MIN(255, (rgb_y - g_uv##UV_ROW) >> SCALEBITS_OUT));  \
397                          y_src++;          x_ptr[(ROW)*x_stride+(SIZE)+(C1)] = MAX(0, MIN(255, (rgb_y + r_v##UV_ROW) >> SCALEBITS_OUT));   \
398                          rgb_y = RGB_Y_tab[*y_src];          if ((SIZE)>3) x_ptr[(ROW)*x_stride+(SIZE)+(C4)] = 0;
399                          b = (b & 0x7) + ((rgb_y + b_u) >> SCALEBITS_OUT);  
400                          g = (g & 0x7) + ((rgb_y - g_uv) >> SCALEBITS_OUT);  
401                          r = (r & 0x7) + ((rgb_y + r_v) >> SCALEBITS_OUT);  #define YV12_TO_RGB_ROW(SIZE,C1,C2,C3,C4)       /* nothing */
402                          *(uint16_t *) (dst + 2) = MK_RGB565(r, g, b);  #define YV12_TO_RGB(SIZE,C1,C2,C3,C4)                           \
403                          y_src++;          int rgb_y;                                                                                              \
404            int b_u0 = B_U_tab[ u_ptr[0] ];                                                 \
405                          rgb_y = RGB_Y_tab[*y_src2];          int g_uv0 = G_U_tab[ u_ptr[0] ] + G_V_tab[ v_ptr[0] ];  \
406                          b2 = (b2 & 0x7) + ((rgb_y + b_u) >> SCALEBITS_OUT);          int r_v0 = R_V_tab[ v_ptr[0] ];                                                 \
407                          g2 = (g2 & 0x7) + ((rgb_y - g_uv) >> SCALEBITS_OUT);          WRITE_RGB(SIZE, 0, 0, C1,C2,C3,C4)                                              \
408                          r2 = (r2 & 0x7) + ((rgb_y + r_v) >> SCALEBITS_OUT);          WRITE_RGB(SIZE, 1, 0, C1,C2,C3,C4)
409                          *(uint16_t *) (dst2) = MK_RGB565(r2, g2, b2);  
410                          y_src2++;  #define YV12_TO_RGBI_ROW(SIZE,C1,C2,C3,C4)      /* nothing */
411    #define YV12_TO_RGBI(SIZE,C1,C2,C3,C4)                          \
412                          rgb_y = RGB_Y_tab[*y_src2];          int rgb_y;                                                                                              \
413                          b2 = (b2 & 0x7) + ((rgb_y + b_u) >> SCALEBITS_OUT);          int b_u0 = B_U_tab[ u_ptr[0] ];                                                 \
414                          g2 = (g2 & 0x7) + ((rgb_y - g_uv) >> SCALEBITS_OUT);          int g_uv0 = G_U_tab[ u_ptr[0] ] + G_V_tab[ v_ptr[0] ];  \
415                          r2 = (r2 & 0x7) + ((rgb_y + r_v) >> SCALEBITS_OUT);          int r_v0 = R_V_tab[ v_ptr[0] ];                                                 \
416                          *(uint16_t *) (dst2 + 2) = MK_RGB565(r2, g2, b2);      int b_u1 = B_U_tab[ u_ptr[uv_stride] ];                                     \
417                          y_src2++;          int g_uv1 = G_U_tab[ u_ptr[uv_stride] ] + G_V_tab[ v_ptr[uv_stride] ];  \
418            int r_v1 = R_V_tab[ v_ptr[uv_stride] ];                                 \
419                          dst += 4;          WRITE_RGB(SIZE, 0, 0, C1,C2,C3,C4)              \
420                          dst2 += 4;          WRITE_RGB(SIZE, 1, 1, C1,C2,C3,C4)              \
421                  }          WRITE_RGB(SIZE, 2, 0, C1,C2,C3,C4)              \
422            WRITE_RGB(SIZE, 3, 1, C1,C2,C3,C4)
423                  dst += dst_dif;  
424                  dst2 += dst_dif;  
425    /* yuyv/yuyvi output */
426                  y_src += y_dif;  
427                  y_src2 += y_dif;  #define WRITE_YUYV(ROW,UV_ROW,C1,C2,C3,C4)      \
428            x_ptr[(ROW)*x_stride+(C1)] = y_ptr[   (ROW)*y_stride +0];       \
429                  u_src += uv_stride;          x_ptr[(ROW)*x_stride+(C2)] = u_ptr[(UV_ROW)*uv_stride+0];       \
430                  v_src += uv_stride;          x_ptr[(ROW)*x_stride+(C3)] = y_ptr[   (ROW)*y_stride +1];       \
431          }          x_ptr[(ROW)*x_stride+(C4)] = v_ptr[(UV_ROW)*uv_stride+0];       \
432  }  
433    #define YV12_TO_YUYV_ROW(SIZE,C1,C2,C3,C4)      /* nothing */
434    #define YV12_TO_YUYV(SIZE,C1,C2,C3,C4)  \
435            WRITE_YUYV(0, 0, C1,C2,C3,C4)           \
436  /* yuv 4:2:0 planar -> rgb24 */          WRITE_YUYV(1, 0, C1,C2,C3,C4)
437    
438  void  #define YV12_TO_YUYVI_ROW(SIZE,C1,C2,C3,C4) /* nothing */
439  yv12_to_rgb24_c(uint8_t * dst,  #define YV12_TO_YUYVI(SIZE,C1,C2,C3,C4) \
440                                  int dst_stride,          WRITE_YUYV(0, 0, C1,C2,C3,C4)           \
441                                  uint8_t * y_src,          WRITE_YUYV(1, 1, C1,C2,C3,C4)           \
442                                  uint8_t * u_src,          WRITE_YUYV(2, 0, C1,C2,C3,C4)           \
443                                  uint8_t * v_src,          WRITE_YUYV(3, 1, C1,C2,C3,C4)
444                                  int y_stride,  
445                                  int uv_stride,  
446                                  int width,  MAKE_COLORSPACE(yv12_to_rgb555_c,  2,2,2, YV12_TO_RGB16,  MK_RGB555, 0,0,0)
447                                  int height)  MAKE_COLORSPACE(yv12_to_rgb565_c,  2,2,2, YV12_TO_RGB16,  MK_RGB565, 0,0,0)
448  {  MAKE_COLORSPACE(yv12_to_bgr_c,     3,2,2, YV12_TO_RGB,    2,1,0, 0)
449          const uint32_t dst_dif = 6 * dst_stride - 3 * width;  MAKE_COLORSPACE(yv12_to_bgra_c,    4,2,2, YV12_TO_RGB,    2,1,0,3)
450          int32_t y_dif = 2 * y_stride - width;  MAKE_COLORSPACE(yv12_to_abgr_c,    4,2,2, YV12_TO_RGB,    3,2,1,0)
451    MAKE_COLORSPACE(yv12_to_rgba_c,    4,2,2, YV12_TO_RGB,    0,1,2,3)
452          uint8_t *dst2 = dst + 3 * dst_stride;  MAKE_COLORSPACE(yv12_to_yuyv_c,    2,2,2, YV12_TO_YUYV,   0,1,2,3)
453          uint8_t *y_src2 = y_src + y_stride;  MAKE_COLORSPACE(yv12_to_uyvy_c,    2,2,2, YV12_TO_YUYV,   1,0,3,2)
454          uint32_t x, y;  
455    MAKE_COLORSPACE(yv12_to_rgb555i_c, 2,2,4, YV12_TO_RGB16I, MK_RGB555, 0,0,0)
456          if (height < 0) {                       /* flip image? */  MAKE_COLORSPACE(yv12_to_rgb565i_c, 2,2,4, YV12_TO_RGB16I, MK_RGB565, 0,0,0)
457                  height = -height;  MAKE_COLORSPACE(yv12_to_bgri_c,    3,2,4, YV12_TO_RGBI,   2,1,0, 0)
458                  y_src += (height - 1) * y_stride;  MAKE_COLORSPACE(yv12_to_bgrai_c,   4,2,4, YV12_TO_RGBI,   2,1,0,3)
459                  y_src2 = y_src - y_stride;  MAKE_COLORSPACE(yv12_to_abgri_c,   4,2,4, YV12_TO_RGBI,   3,2,1,0)
460                  u_src += (height / 2 - 1) * uv_stride;  MAKE_COLORSPACE(yv12_to_rgbai_c,   4,2,4, YV12_TO_RGBI,   0,1,2,3)
461                  v_src += (height / 2 - 1) * uv_stride;  MAKE_COLORSPACE(yv12_to_yuyvi_c,   2,2,4, YV12_TO_YUYVI,  0,1,2,3)
462                  y_dif = -width - 2 * y_stride;  MAKE_COLORSPACE(yv12_to_uyvyi_c,   2,2,4, YV12_TO_YUYVI,  1,0,3,2)
463                  uv_stride = -uv_stride;  
464          }  
465    
466          for (y = height / 2; y; y--) {  /* yv12 to yv12 copy function */
467                  /* process one 2x2 block per iteration */  
468                  for (x = 0; x < (uint32_t) width / 2; x++) {  void
469                          int u, v;  yv12_to_yv12_c(uint8_t * y_dst, uint8_t * u_dst, uint8_t * v_dst,
470                          int b_u, g_uv, r_v, rgb_y;                                  int y_dst_stride, int uv_dst_stride,
471                          int r, g, b;                                  uint8_t * y_src, uint8_t * u_src, uint8_t * v_src,
472                                    int y_src_stride, int uv_src_stride,
473                          u = u_src[x];                                  int width, int height, int vflip)
474                          v = v_src[x];  {
475            int width2 = width / 2;
476                          b_u = B_U_tab[u];          int height2 = height / 2;
477                          g_uv = G_U_tab[u] + G_V_tab[v];          int y;
478                          r_v = R_V_tab[v];  
479            if (vflip) {
480                          rgb_y = RGB_Y_tab[*y_src];                  y_src += (height - 1) * y_src_stride;
481                          b = (rgb_y + b_u) >> SCALEBITS_OUT;                  u_src += (height2 - 1) * uv_src_stride;
482                          g = (rgb_y - g_uv) >> SCALEBITS_OUT;                  v_src += (height2 - 1) * uv_src_stride;
483                          r = (rgb_y + r_v) >> SCALEBITS_OUT;                  y_src_stride = -y_src_stride;
484                          dst[0] = MAX(0, MIN(255, b));                  uv_src_stride = -uv_src_stride;
                         dst[1] = MAX(0, MIN(255, g));  
                         dst[2] = MAX(0, MIN(255, r));  
   
                         y_src++;  
                         rgb_y = RGB_Y_tab[*y_src];  
                         b = (rgb_y + b_u) >> SCALEBITS_OUT;  
                         g = (rgb_y - g_uv) >> SCALEBITS_OUT;  
                         r = (rgb_y + r_v) >> SCALEBITS_OUT;  
                         dst[3] = MAX(0, MIN(255, b));  
                         dst[4] = MAX(0, MIN(255, g));  
                         dst[5] = MAX(0, MIN(255, r));  
                         y_src++;  
   
                         rgb_y = RGB_Y_tab[*y_src2];  
                         b = (rgb_y + b_u) >> SCALEBITS_OUT;  
                         g = (rgb_y - g_uv) >> SCALEBITS_OUT;  
                         r = (rgb_y + r_v) >> SCALEBITS_OUT;  
                         dst2[0] = MAX(0, MIN(255, b));  
                         dst2[1] = MAX(0, MIN(255, g));  
                         dst2[2] = MAX(0, MIN(255, r));  
                         y_src2++;  
   
                         rgb_y = RGB_Y_tab[*y_src2];  
                         b = (rgb_y + b_u) >> SCALEBITS_OUT;  
                         g = (rgb_y - g_uv) >> SCALEBITS_OUT;  
                         r = (rgb_y + r_v) >> SCALEBITS_OUT;  
                         dst2[3] = MAX(0, MIN(255, b));  
                         dst2[4] = MAX(0, MIN(255, g));  
                         dst2[5] = MAX(0, MIN(255, r));  
                         y_src2++;  
   
                         dst += 6;  
                         dst2 += 6;  
                 }  
   
                 dst += dst_dif;  
                 dst2 += dst_dif;  
   
                 y_src += y_dif;  
                 y_src2 += y_dif;  
   
                 u_src += uv_stride;  
                 v_src += uv_stride;  
         }  
 }  
   
   
   
 /* yuv 4:2:0 planar -> rgb32 */  
   
 void  
 yv12_to_rgb32_c(uint8_t * dst,  
                                 int dst_stride,  
                                 uint8_t * y_src,  
                                 uint8_t * v_src,  
                                 uint8_t * u_src,  
                                 int y_stride,  
                                 int uv_stride,  
                                 int width,  
                                 int height)  
 {  
         const uint32_t dst_dif = 8 * dst_stride - 4 * width;  
         int32_t y_dif = 2 * y_stride - width;  
   
         uint8_t *dst2 = dst + 4 * dst_stride;  
         uint8_t *y_src2 = y_src + y_stride;  
         uint32_t x, y;  
   
         if (height < 0) {                       /* flip image? */  
                 height = -height;  
                 y_src += (height - 1) * y_stride;  
                 y_src2 = y_src - y_stride;  
                 u_src += (height / 2 - 1) * uv_stride;  
                 v_src += (height / 2 - 1) * uv_stride;  
                 y_dif = -width - 2 * y_stride;  
                 uv_stride = -uv_stride;  
         }  
   
         for (y = height / 2; y; y--) {  
                 /* process one 2x2 block per iteration */  
                 for (x = 0; x < (uint32_t) width / 2; x++) {  
                         int u, v;  
                         int b_u, g_uv, r_v, rgb_y;  
                         int r, g, b;  
   
                         u = u_src[x];  
                         v = v_src[x];  
   
                         b_u = B_U_tab[u];  
                         g_uv = G_U_tab[u] + G_V_tab[v];  
                         r_v = R_V_tab[v];  
   
                         rgb_y = RGB_Y_tab[*y_src];  
                         b = (rgb_y + b_u) >> SCALEBITS_OUT;  
                         g = (rgb_y - g_uv) >> SCALEBITS_OUT;  
                         r = (rgb_y + r_v) >> SCALEBITS_OUT;  
                         dst[0] = MAX(0, MIN(255, r));  
                         dst[1] = MAX(0, MIN(255, g));  
                         dst[2] = MAX(0, MIN(255, b));  
                         dst[3] = 0;  
   
                         y_src++;  
                         rgb_y = RGB_Y_tab[*y_src];  
                         b = (rgb_y + b_u) >> SCALEBITS_OUT;  
                         g = (rgb_y - g_uv) >> SCALEBITS_OUT;  
                         r = (rgb_y + r_v) >> SCALEBITS_OUT;  
                         dst[4] = MAX(0, MIN(255, r));  
                         dst[5] = MAX(0, MIN(255, g));  
                         dst[6] = MAX(0, MIN(255, b));  
                         dst[7] = 0;  
                         y_src++;  
   
                         rgb_y = RGB_Y_tab[*y_src2];  
                         b = (rgb_y + b_u) >> SCALEBITS_OUT;  
                         g = (rgb_y - g_uv) >> SCALEBITS_OUT;  
                         r = (rgb_y + r_v) >> SCALEBITS_OUT;  
                         dst2[0] = MAX(0, MIN(255, r));  
                         dst2[1] = MAX(0, MIN(255, g));  
                         dst2[2] = MAX(0, MIN(255, b));  
                         dst2[3] = 0;  
                         y_src2++;  
   
                         rgb_y = RGB_Y_tab[*y_src2];  
                         b = (rgb_y + b_u) >> SCALEBITS_OUT;  
                         g = (rgb_y - g_uv) >> SCALEBITS_OUT;  
                         r = (rgb_y + r_v) >> SCALEBITS_OUT;  
                         dst2[4] = MAX(0, MIN(255, r));  
                         dst2[5] = MAX(0, MIN(255, g));  
                         dst2[6] = MAX(0, MIN(255, b));  
                         dst2[7] = 0;  
                         y_src2++;  
   
                         dst += 8;  
                         dst2 += 8;  
                 }  
   
                 dst += dst_dif;  
                 dst2 += dst_dif;  
   
                 y_src += y_dif;  
                 y_src2 += y_dif;  
   
                 u_src += uv_stride;  
                 v_src += uv_stride;  
         }  
 }  
   
   
   
 /*      yuv 4:2:0 planar -> yuv planar */  
   
 void  
 yv12_to_yuv_c(uint8_t * dst,  
                           int dst_stride,  
                           uint8_t * y_src,  
                           uint8_t * u_src,  
                           uint8_t * v_src,  
                           int y_stride,  
                           int uv_stride,  
                           int width,  
                           int height)  
 {  
         uint32_t dst_stride2 = dst_stride >> 1;  
         uint32_t width2 = width >> 1;  
         uint32_t y;  
   
         if (height < 0) {  
                 height = -height;  
                 y_src += (height - 1) * y_stride;  
                 u_src += (height / 2 - 1) * uv_stride;  
                 v_src += (height / 2 - 1) * uv_stride;  
                 y_stride = -y_stride;  
                 uv_stride = -uv_stride;  
485          }          }
486    
487          for (y = height; y; y--) {          for (y = height; y; y--) {
488                  memcpy(dst, y_src, width);                  memcpy(y_dst, y_src, width);
489                  dst += dst_stride;                  y_src += y_src_stride;
490                  y_src += y_stride;                  y_dst += y_dst_stride;
         }  
   
         for (y = height >> 1; y; y--) {  
                 memcpy(dst, u_src, width2);  
                 dst += dst_stride2;  
                 u_src += uv_stride;  
         }  
   
         for (y = height >> 1; y; y--) {  
                 memcpy(dst, v_src, width2);  
                 dst += dst_stride2;  
                 v_src += uv_stride;  
         }  
 }  
   
   
   
   
 /* yuv 4:2:0 planar -> yuyv (yuv2) packed */  
   
 void  
 yv12_to_yuyv_c(uint8_t * dst,  
                            int dst_stride,  
                            uint8_t * y_src,  
                            uint8_t * u_src,  
                            uint8_t * v_src,  
                            int y_stride,  
                            int uv_stride,  
                            int width,  
                            int height)  
 {  
         const uint32_t dst_dif = 2 * (dst_stride - width);  
         uint32_t x, y;  
   
         if (height < 0) {  
                 height = -height;  
                 y_src += (height - 1) * y_stride;  
                 u_src += (height / 2 - 1) * uv_stride;  
                 v_src += (height / 2 - 1) * uv_stride;  
                 y_stride = -y_stride;  
                 uv_stride = -uv_stride;  
491          }          }
492    
493          for (y = 0; y < (uint32_t) height; y++) {          for (y = height2; y; y--) {
494                  for (x = 0; x < (uint32_t) width / 2; x++) {                  memcpy(u_dst, u_src, width2);
495                          dst[0] = y_src[2 * x];                  u_src += uv_src_stride;
496                          dst[1] = u_src[x];                  u_dst += uv_dst_stride;
                         dst[2] = y_src[2 * x + 1];  
                         dst[3] = v_src[x];  
                         dst += 4;  
                 }  
                 dst += dst_dif;  
                 y_src += y_stride;  
                 if (y & 1) {  
                         u_src += uv_stride;  
                         v_src += uv_stride;  
497                  }                  }
         }  
 }  
   
   
   
 /* yuv 4:2:0 planar -> uyvy packed */  
498    
499  void          for (y = height2; y; y--) {
500  yv12_to_uyvy_c(uint8_t * dst,                  memcpy(v_dst, v_src, width2);
501                             int dst_stride,                  v_src += uv_src_stride;
502                             uint8_t * y_src,                  v_dst += uv_dst_stride;
                            uint8_t * u_src,  
                            uint8_t * v_src,  
                            int y_stride,  
                            int uv_stride,  
                            int width,  
                            int height)  
 {  
         const uint32_t dst_dif = 2 * (dst_stride - width);  
         uint32_t x, y;  
   
         if (height < 0) {  
                 height = -height;  
                 y_src += (height - 1) * y_stride;  
                 u_src += (height / 2 - 1) * uv_stride;  
                 v_src += (height / 2 - 1) * uv_stride;  
                 y_stride = -y_stride;  
                 uv_stride = -uv_stride;  
         }  
   
         for (y = 0; y < (uint32_t) height; y++) {  
                 for (x = 0; x < (uint32_t) width / 2; x++) {  
                         dst[0] = u_src[x];  
                         dst[1] = y_src[2 * x];  
                         dst[2] = v_src[x];  
                         dst[3] = y_src[2 * x + 1];  
                         dst += 4;  
                 }  
                 dst += dst_dif;  
                 y_src += y_stride;  
                 if (y & 1) {  
                         u_src += uv_stride;  
                         v_src += uv_stride;  
                 }  
503          }          }
504  }  }
505    
506    
 /*      user yuv planar -> yuv 4:2:0 planar  
507    
508          NOTE: does not flip */  /* initialize rgb lookup tables */
509    
510  void  void
511  user_to_yuv_c(uint8_t * y_out,  colorspace_init(void)
                           uint8_t * u_out,  
                           uint8_t * v_out,  
                           int stride,  
                           DEC_PICTURE * picture,  
                           int width,  
                           int height)  
512  {  {
513          uint32_t stride2 = stride >> 1;          int32_t i;
         uint32_t width2 = width >> 1;  
         uint32_t y;  
         uint8_t *src;  
   
         src = picture->y;  
         for (y = height; y; y--) {  
                 memcpy(y_out, src, width);  
                 src += picture->stride_y;  
                 y_out += stride;  
         }  
   
         src = picture->u;  
         for (y = height >> 1; y; y--) {  
                 memcpy(u_out, src, width2);  
                 src += picture->stride_uv;  
                 u_out += stride2;  
         }  
514    
515          src = picture->v;          for (i = 0; i < 256; i++) {
516          for (y = height >> 1; y; y--) {                  RGB_Y_tab[i] = FIX_OUT(RGB_Y_OUT) * (i - Y_ADD_OUT);
517                  memcpy(v_out, src, width2);                  B_U_tab[i] = FIX_OUT(B_U_OUT) * (i - U_ADD_OUT);
518                  src += picture->stride_uv;                  G_U_tab[i] = FIX_OUT(G_U_OUT) * (i - U_ADD_OUT);
519                  v_out += stride2;                  G_V_tab[i] = FIX_OUT(G_V_OUT) * (i - V_ADD_OUT);
520                    R_V_tab[i] = FIX_OUT(R_V_OUT) * (i - V_ADD_OUT);
521          }          }
522  }  }

Legend:
Removed from v.677  
changed lines
  Added in v.851

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4