开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
rgb2yuv.c
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：35k
源码类别：

Symbian

开发平台：

C/C++

rgb2yuv.c：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  38. /*** #includes: ********************************************/
  40. #include "env.h"
  41. #include "rgb.h"    /* basic RGB-data definitions & macros */
  42. #include "yuv.h"    /* YUV-to-RGB conversion tables & macros */
  43. #include "clip.h"   /* macros for clipping & dithering */
  44. #include "scale.h"  /* scale algorithms */
  45. #include "colorlib.h"
  47. /*** RGB to YUV color converters: **************************/
  49. /*
  50.  * These functions were borrowed from our "old" color conversion library,
  51.  * and they do not support things like stretching or color adjustments.
  52.  * Given some more time this module should be completely rewritten.
  53.  *
  54.  ***************/
  56. /*-----------------2/24/2002 7:45AM-----------------
  57.  * Replaced the old code with macros.
  58.  * In-place resizing and color adjustments are not added since nobody
  59.  * really asked for it, and it would have blown the code by factor of 6 (at least).
  60.  * Yuriy.
  61.  * --------------------------------------------------*/
  64. /*-----------------9/19/2002 2:06PM-----------------
  65.  * Added support for byte-swapped RGB32 (BGR_32) and BGR24 input formats.
  66.  * To avoid changes (table reordering) in other modules, the definitions
  67.  * related to these formats are placed here, instead of "rgb.h".
  68.  * Yuriy.
  69.  * --------------------------------------------------*/
  72. /* new RGB format IDs: */
  73. #define BGR_32_ID           RGB_FORMATS
  74. #define BGR24_ID            (RGB_FORMATS + 1)
  77. /* bytes per pixel: */
  78. #define BGR_32_BPP          4
  79. #define BGR24_BPP           3
  82. /* local pixel representations: */
  83. #define BGR_32_PIXEL(a)     RGBX_PIXEL(a)
  84. #define BGR24_PIXEL(a)      RGB24_PIXEL(a)
  87. /* load/store/copy pixel macros: */
  88. #define BGR_32_LOAD(s,a)    RGBX_LOAD(s,a,unsigned int)
  89. #define BGR_32_STORE(d,a)   RGBX_STORE(d,a,unsigned int)
  90. #define BGR_32_COPY(da,sa)  RGBX_COPY(da,sa)
  93. #define BGR24_LOAD(s,a)     a##_r=(s)[0], a##_g=(s)[1], a##_b=(s)[2]
  94. #define BGR24_STORE(d,a)    (d)[0]=a##_r, (d)[1]=a##_g, (d)[2]=a##_b
  95. #define BGR24_COPY(da,sa)   da##_r=sa##_r, da##_g=sa##_g, da##_b=sa##_b
  98. /* BGR_32 bit fields: 0xBBGGRR00: */
  99. #define BGR_32_R_START      8
  100. #define BGR_32_R_BITS       8
  101. #define BGR_32_G_START      16
  102. #define BGR_32_G_BITS       8
  103. #define BGR_32_B_START      24
  104. #define BGR_32_B_BITS       8
  107. /* fields extraction/assignment macros: */
  108. #define BGR_32_GET_R(a)     RGBX_GET_X(BGR_32,R,a)
  109. #define BGR_32_GET_G(a)     RGBX_GET_X(BGR_32,G,a)
  110. #define BGR_32_GET_B(a)     RGBX_GET_X(BGR_32,B,a)
  111. #define BGR_32_SET(a,r,g,b) RGBX_SET(  BGR_32,a,r,g,b)
  114. #define BGR24_GET_R(a)      (a##_r)
  115. #define BGR24_GET_G(a)      (a##_g)
  116. #define BGR24_GET_B(a)      (a##_b)
  117. #define BGR24_SET(a,r,g,b)  a##_b=(b), a##_g=(g), a##_r=(r)
  120. /***************************************************************/
  123. /*
  124.  * YUV 4:2:0 chroma resampling modes:
  125.  * Input chroma     a b
  126.  *  samples:        c d
  127.  *
  128.  * CRM_11_11:       (a+b+c+d) / 4
  129.  * CRM_11_00:       (a+b) / 2
  130.  * CRM_00_11:       (c+d) / 2
  131.  */
  132. #define CHROMA_RESAMPLING_MODES     3
  135. /*
  136.  * 2x2-block load-convert-store macros:
  137.  */
  140. /* CRM_11_11 (both lines) chroma resampling: */
  141. #define CONVERT_2x2_CHROMA_11_11(dy1,dy2,du,dv,sf,s1,s2)            
  142.     {                                                               
  143.         /* local variables: */                                      
  144.         PIXEL(sf,x);                                                
  145.         register unsigned int r, b, y;                              
  146.         register unsigned int r4, b4, y4;   /* combined quant-s */  
  147.                                                                     
  148.         /* process lumas: */                                        
  149.         LOAD(sf,s1,x);              /* [0,0] */                     
  150.         r4 = (r = GET_R(sf,x));                                     
  151.         b4 = (b = GET_B(sf,x));                                     
  152.         y4 = (y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b]);     
  153.         dy1[0] = yytab [y];                                         
  154.                                                                     
  155.         LOAD(sf,s1+BPP(sf),x);      /* [0,1] */                     
  156.         r4 += (r = GET_R(sf,x));                                    
  157.         b4 += (b = GET_B(sf,x));                                    
  158.         y4 += (y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b]);    
  159.         dy1[1] = yytab [y];                                         
  160.                                                                     
  161.         LOAD(sf,s2,x);              /* [1,0] */                     
  162.         r4 += (r = GET_R(sf,x));                                    
  163.         b4 += (b = GET_B(sf,x));                                    
  164.         y4 += (y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b]);    
  165.         dy2[0] = yytab [y];                                         
  166.                                                                     
  167.         LOAD(sf,s2+BPP(sf),x);      /* [1,1] */                     
  168.         r4 += (r = GET_R(sf,x));                                    
  169.         b4 += (b = GET_B(sf,x));                                    
  170.         y4 += (y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b]);    
  171.         dy2[1] = yytab [y];                                         
  172.                                                                     
  173.         /* average chromas: */                                      
  174.         dv[0] = vrytab [VMIN+(r4-y4)/4];                            
  175.         du[0] = ubytab [UMIN+(b4-y4)/4];                            
  176.     }
  179. /* CRM_11_00 (upper line) chroma resampling: */
  180. #define CONVERT_2x2_CHROMA_11_00(dy1,dy2,du,dv,sf,s1,s2)            
  181.     {                                                               
  182.         /* local variables: */                                      
  183.         PIXEL(sf,x);                                                
  184.         register unsigned int r, b, y;                              
  185.         register unsigned int r2, b2, y2;   /* 1st line combined */ 
  186.                                                                     
  187.         /* process lumas: */                                        
  188.         LOAD(sf,s1,x);              /* [0,0] */                     
  189.         r2 = (r = GET_R(sf,x));                                     
  190.         b2 = (b = GET_B(sf,x));                                     
  191.         y2 = (y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b]);     
  192.         dy1[0] = yytab [y];                                         
  193.                                                                     
  194.         LOAD(sf,s1+BPP(sf),x);      /* [0,1] */                     
  195.         r2 += (r = GET_R(sf,x));                                    
  196.         b2 += (b = GET_B(sf,x));                                    
  197.         y2 += (y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b]);    
  198.         dy1[1] = yytab [y];                                         
  199.                                                                     
  200.         LOAD(sf,s2,x);              /* [1,0] */                     
  201.         r = GET_R(sf,x);                                            
  202.         b = GET_B(sf,x);                                            
  203.         y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b];            
  204.         dy2[0] = yytab [y];                                         
  205.                                                                     
  206.         LOAD(sf,s2+BPP(sf),x);      /* [1,1] */                     
  207.         r = GET_R(sf,x);                                            
  208.         b = GET_B(sf,x);                                            
  209.         y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b];            
  210.         dy2[1] = yytab [y];                                         
  211.                                                                     
  212.         /* average chromas: */                                      
  213.         dv[0] = vrytab [VMIN+(r2-y2)/2];                            
  214.         du[0] = ubytab [UMIN+(b2-y2)/2];                            
  215.     }
  219. /* CRM_00_11 (lower line) chroma resampling: */
  220. #define CONVERT_2x2_CHROMA_00_11(dy1,dy2,du,dv,sf,s1,s2)            
  221.     {                                                               
  222.         /* local variables: */                                      
  223.         PIXEL(sf,x);                                                
  224.         register unsigned int r, b, y;                              
  225.         register unsigned int r2, b2, y2;   /* 2nd line combined */ 
  226.                                                                     
  227.         /* process lumas: */                                        
  228.         LOAD(sf,s1,x);              /* [0,0] */                     
  229.         r = GET_R(sf,x);                                            
  230.         b = GET_B(sf,x);                                            
  231.         y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b];            
  232.         dy1[0] = yytab [y];                                         
  233.                                                                     
  234.         LOAD(sf,s1+BPP(sf),x);      /* [0,1] */                     
  235.         r = GET_R(sf,x);                                            
  236.         b = GET_B(sf,x);                                            
  237.         y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b];            
  238.         dy1[1] = yytab [y];                                         
  239.                                                                     
  240.         LOAD(sf,s2,x);              /* [1,0] */                     
  241.         r2 = (r = GET_R(sf,x));                                     
  242.         b2 = (b = GET_B(sf,x));                                     
  243.         y2 = (y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b]);     
  244.         dy2[0] = yytab [y];                                         
  245.                                                                     
  246.         LOAD(sf,s2+BPP(sf),x);      /* [1,1] */                     
  247.         r2 += (r = GET_R(sf,x));                                    
  248.         b2 += (b = GET_B(sf,x));                                    
  249.         y2 += (y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b]);    
  250.         dy2[1] = yytab [y];                                         
  251.                                                                     
  252.         /* average chromas: */                                      
  253.         dv[0] = vrytab [VMIN+(r2-y2)/2];                            
  254.         du[0] = ubytab [UMIN+(b2-y2)/2];                            
  255.     }
  258. /*
  259.  * Generic 2x2 block converter:
  260.  */
  261. #define CONVERT_2x2(dy1,dy2,du,dv,sf,s1,s2,crm)                     
  262.     CONVERT_2x2_##crm(dy1,dy2,du,dv,sf,s1,s2)
  265. /*
  266.  * Generic RGBtoYUV double-row converter:
  267.  *
  268.  *  YUV-image pointers are assumed to be 2x2-block aligned, as well as
  269.  *  n -- the number of pixels to be converter, is assumed to be multiple of 2.
  270.  */
  271. #define DBLROW(dy1,dy2,du,dv,sf,s1,s2,n,crm)                        
  272.     {                                                               
  273.         register int n2 = n/2;                                      
  274.         /* convert 2x2 blocks: */                                   
  275.         while (n2) {                                                
  276.             CONVERT_2x2(dy1,dy2,du,dv,sf,s1,s2,crm);                
  277.             dy1 += 2; dy2 += 2; du ++; dv ++;                       
  278.             s1 += BPP(sf) * 2; s2 += BPP(sf) * 2;                   
  279.             n2 --;                                                  
  280.         }                                                           
  281.     }
  284. /*
  285.  * Function names:
  286.  */
  287. #define FN(df,sf)               sf##to##df
  288. #define DBLROW_FN(df,sf,crm)    sf##to##df##_DBLROW_##crm
  291. /*
  292.  * Function replication macros:
  293.  *  (dblrow converters)
  294.  */
  295. #define DBLROW_FUNC(df,sf,crm)                                      
  296.     static void DBLROW_FN(df,sf,crm) (                              
  297.         unsigned char *dy1, unsigned char *dy2,                     
  298.         unsigned char *du, unsigned char *dv,                       
  299.         unsigned char *s1, unsigned char *s2, int n)                
  300.         DBLROW(dy1,dy2,du,dv,sf,s1,s2,n,crm)
  304. /***********************************************************/
  307. /*
  308.  * Actual double-row converters:
  309.  */
  310. DBLROW_FUNC(I420, RGB32,  CHROMA_11_11)
  311. DBLROW_FUNC(I420, RGB32,  CHROMA_11_00)
  312. DBLROW_FUNC(I420, RGB32,  CHROMA_00_11)
  315. DBLROW_FUNC(I420, BGR_32, CHROMA_11_11)
  316. DBLROW_FUNC(I420, BGR_32, CHROMA_11_00)
  317. DBLROW_FUNC(I420, BGR_32, CHROMA_00_11)
  320. DBLROW_FUNC(I420, RGB24,  CHROMA_11_11)
  321. DBLROW_FUNC(I420, RGB24,  CHROMA_11_00)
  322. DBLROW_FUNC(I420, RGB24,  CHROMA_00_11)
  325. DBLROW_FUNC(I420, BGR24,  CHROMA_11_11)
  326. DBLROW_FUNC(I420, BGR24,  CHROMA_11_00)
  327. DBLROW_FUNC(I420, BGR24,  CHROMA_00_11)
  330. DBLROW_FUNC(I420, RGB565, CHROMA_11_11)
  331. DBLROW_FUNC(I420, RGB565, CHROMA_11_00)
  332. DBLROW_FUNC(I420, RGB565, CHROMA_00_11)
  335. DBLROW_FUNC(I420, RGB555, CHROMA_11_11)
  336. DBLROW_FUNC(I420, RGB555, CHROMA_11_00)
  337. DBLROW_FUNC(I420, RGB555, CHROMA_00_11)
  340. DBLROW_FUNC(I420, RGB8,   CHROMA_11_11)
  341. DBLROW_FUNC(I420, RGB8,   CHROMA_11_00)
  342. DBLROW_FUNC(I420, RGB8,   CHROMA_00_11)
  346. /*
  347.  * Double-row scale function selection tables:
  348.  *  [source format][chroma resampling type]
  349.  */
  350. static void (* DblRowFuncs [RGB_FORMATS+2][CHROMA_RESAMPLING_MODES]) (
  351.     unsigned char *, unsigned char *, unsigned char *, unsigned char *,
  352.     unsigned char *, unsigned char *, int) =
  353. {
  354.     {
  355.         DBLROW_FN(I420, RGB32,  CHROMA_11_11),
  356.         DBLROW_FN(I420, RGB32,  CHROMA_11_00),
  357.         DBLROW_FN(I420, RGB32,  CHROMA_00_11)
  358.     },
  359.     {   /* BGR32: */
  360.         0, 0, 0
  361.     },
  362.     {
  363.         DBLROW_FN(I420, RGB24,  CHROMA_11_11),
  364.         DBLROW_FN(I420, RGB24,  CHROMA_11_00),
  365.         DBLROW_FN(I420, RGB24,  CHROMA_00_11)
  366.     },
  367.     {
  368.         DBLROW_FN(I420, RGB565, CHROMA_11_11),
  369.         DBLROW_FN(I420, RGB565, CHROMA_11_00),
  370.         DBLROW_FN(I420, RGB565, CHROMA_00_11)
  371.     },
  372.     {
  373.         DBLROW_FN(I420, RGB555, CHROMA_11_11),
  374.         DBLROW_FN(I420, RGB555, CHROMA_11_00),
  375.         DBLROW_FN(I420, RGB555, CHROMA_00_11)
  376.     },
  377.     {   /* RGB444: */
  378.         0, 0, 0
  379.     },
  380.     {
  381.         DBLROW_FN(I420, RGB8,   CHROMA_11_11),
  382.         DBLROW_FN(I420, RGB8,   CHROMA_11_00),
  383.         DBLROW_FN(I420, RGB8,   CHROMA_00_11)
  384.     },
  385.     {
  386.         DBLROW_FN(I420, BGR_32,  CHROMA_11_11),
  387.         DBLROW_FN(I420, BGR_32,  CHROMA_11_00),
  388.         DBLROW_FN(I420, BGR_32,  CHROMA_00_11)
  389.     },
  390.     {
  391.         DBLROW_FN(I420, BGR24,  CHROMA_11_11),
  392.         DBLROW_FN(I420, BGR24,  CHROMA_11_00),
  393.         DBLROW_FN(I420, BGR24,  CHROMA_00_11)
  394.     }
  395. };
  398. /*
  399.  * Bytes per pixel (bpp) table:
  400.  */
  401. static int bpp [RGB_FORMATS+2] =
  402. {
  403.     BPP(RGB32),
  404.     BPP(BGR32),
  405.     BPP(RGB24),
  406.     BPP(RGB565),
  407.     BPP(RGB555),
  408.     BPP(RGB444),
  409.     BPP(RGB8),
  410.     BPP(BGR_32),
  411.     BPP(BGR24)
  412. };
  415. /*
  416.  * The main RGBtoYUV converter:
  417.  */
  418. static int RGBtoYUV (
  419.     /* destination image parameters: */
  420.     unsigned char *dest_ptr, int dest_width, int dest_height,
  421.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  422.     /* source format: */
  423.     int src_format,
  424.     /* source image parametersBto: */
  425.     unsigned char *src_ptr, int src_width, int src_height,
  426.     int src_pitch, int src_x, int src_y, int src_dx, int src_dy)
  427. {
  428.     /* pointer to a double-row converter to use: */
  429.     void (*dblrow_proc) (unsigned char *, unsigned char *,
  430.         unsigned char *, unsigned char *, unsigned char *, unsigned char *, int);
  433.     /* pointers and source pixel depth: */
  434.     register unsigned char *dy1, *dy2, *du, *dv, *s1, *s2;
  435.     register int src_bpp, i;
  438.     /* check arguments: */
  439.     if (
  440.         /* alignments: */
  441.         ((unsigned)dest_ptr & 3) || (dest_pitch & 3) ||
  442.         ((unsigned)src_ptr  & 3) || (src_pitch  & 3) ||
  443.         /* image sizes: */
  444.         dest_width <= 0 || dest_height <= 0 ||
  445.         src_width  <= 0 || src_height  <= 0 ||
  446.         /* rectangles: */
  447.         dest_x < 0 || dest_y < 0 || dest_dx <= 0 || dest_dy <= 0 ||
  448.         src_x  < 0 || src_y  < 0 || src_dx  <= 0 || src_dy  <= 0 ||
  449.         /* overlaps: */
  450.         dest_width < dest_x + dest_dx || dest_height < dest_y + dest_dy ||
  451.         src_width  < src_x  + src_dx  || src_height  < src_y  + src_dy)
  452.     {
  453. fail:   /* fail: */
  454.         return -1;
  455.     }
  458.     /* check scale factors: */
  459.     if (dest_dx != src_dx || dest_dy != src_dy)
  460.         /* no in-place resizing !!! */
  461.         goto fail;
  464.     /* skip odd start column: */
  465.     if (dest_x & 1) { dest_x ++; dest_dx --; src_x ++; src_dx --; }
  466.     /* clip horisontal range: */
  467.     if (dest_dx & 1) { dest_dx --; src_dx --; if (dest_dx <= 0) goto fail;}
  470.     /* skip odd start row: */
  471.     if (dest_y & 1) { dest_y ++; dest_dy --; src_y ++; src_dy --; }
  472.     /* clip vertical range: */
  473.     if (dest_dy & 1) { dest_dy --; src_dy --; if (dest_dy <= 0) goto fail;}
  476.     /* select row and image converters: */
  477.     dblrow_proc = DblRowFuncs [src_format] [chroma_resampling_mode];
  480.     /* get source pixel depth: */
  481.     src_bpp = bpp [src_format];
  484.     /* check if bottop-up images: */
  485.     if (src_pitch < 0) src_ptr -= (src_height-1) * src_pitch;
  486.     if (dest_pitch <= 0) return -1;                     /* not supported */
  489.     /* get pointers: */
  490.     s1  = src_ptr + src_x * src_bpp + src_y * src_pitch;
  491.     s2  = s1 + src_pitch;
  492.     dy1 = dest_ptr + dest_x + dest_y * dest_pitch;      /* luma offsets  */
  493.     dy2 = dy1 + dest_pitch;
  494.     du  = dest_ptr + dest_height * dest_pitch
  495.           + (dest_x/2 + dest_y/2 * dest_pitch / 2);     /* chroma offset */
  496.     dv  = du + dest_height * dest_pitch / 4;
  499.     /* the main loop (processes 2 lines a time): */
  500.     for (i = 0; i < dest_dy/2; i ++) {
  503.         (*dblrow_proc) (dy1, dy2, du, dv, s1, s2, dest_dx);
  506.         /* switch to the next two lines: */
  507.         s1 += src_pitch * 2;    s2 += src_pitch * 2;
  508.         dy1 += dest_pitch * 2;  dy2 += dest_pitch * 2;
  509.         du += dest_pitch / 2;   dv += dest_pitch / 2;
  510.     }
  513.     /* success: */
  514.     return 0;
  515. }
  519. /*
  520.  * Public format-conversion routines.
  521.  * Use:
  522.  *  int XXXXtoYYYY (unsigned char *dest_ptr, int dest_width, int dest_height,
  523.  *      int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  524.  *      unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  525.  *      int src_x, int src_y, int src_dx, int src_dy);
  526.  * Input:
  527.  *  dest_ptr - pointer to a destination buffer
  528.  *  dest_width, dest_height - width/height of the destination image (pixels)
  529.  *  dest_pitch - pitch of the dest. buffer (in bytes; <0 - if bottom up image)
  530.  *  dest_x, dest_y, dest_dx, dest_dy - destination rectangle (pixels)
  531.  *  src_ptr - pointer to an input image
  532.  *  src_width, src_height - width/height of the input image (pixels)
  533.  *  src_pitch - pitch of the source buffer (in bytes; <0 - if bottom up image)
  534.  *  src_x, src_y, src_dx, src_dy - source rectangle (pixels)
  535.  * Returns:
  536.  *  0 - if success; -1 if failure.
  537.  * Note:
  538.  *  Both source and destination buffers must be 4-bytes aligned,
  539.  *  and their pitches (#of bytes in row) shall be multiple of 4!!!
  540.  */
  543. #define RGBTOYUV_FUNC(sf)                                   
  544.     int FN(I420,sf) (unsigned char *dest_ptr,               
  545.         int dest_width, int dest_height, int dest_pitch,    
  546.         int dest_x, int dest_y, int dest_dx, int dest_dy,   
  547.         unsigned char *src_ptr,                             
  548.         int src_width, int src_height, int src_pitch,       
  549.         int src_x, int src_y, int src_dx, int src_dy)       
  550.     {                                                       
  551.         return RGBtoYUV(                                  
  552.             dest_ptr, dest_width, dest_height,              
  553.             dest_pitch, dest_x, dest_y, dest_dx, dest_dy,   
  554.             ID(sf), src_ptr, src_width, src_height,         
  555.             src_pitch, src_x, src_y, src_dx, src_dy);       
  556.     }
  559. RGBTOYUV_FUNC(RGB32 )
  560. RGBTOYUV_FUNC(RGB24 )
  561. RGBTOYUV_FUNC(RGB565)
  562. RGBTOYUV_FUNC(RGB555)
  563. RGBTOYUV_FUNC(RGB8)
  566. RGBTOYUV_FUNC(BGR_32 )
  567. RGBTOYUV_FUNC(BGR24 )
  569. /*********************************
  570.  * Back to the old stuff: */
  572.  /*
  573.  * Checks format conversion parameters.
  574.  * Use:
  575.  *  int chk_args (unsigned char *dest_ptr, int dest_width, int dest_height,
  576.  *      int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  577.  *      unsigned char *src_ptr, int src_width, int src_height,
  578.  *      int src_pitch, int src_x, int src_y, int src_dx, int src_dy,
  579.  *      int *p_scale_x, int *p_scale_y);
  580.  * Input:
  581.  *  dest_ptr - pointer to a destination buffer
  582.  *  dest_width, dest_height - width/height of the destination image (pixels)
  583.  *  dest_pitch - pitch of the dest. buffer (in bytes; <0 - if bottom up image)
  584.  *  dest_x, dest_y, dest_dx, dest_dy - destination rectangle (pixels)
  585.  *  src_ptr - pointer to an input image
  586.  *  src_width, src_height - width/height of the input image (pixels)
  587.  *  src_pitch - pitch of the source buffer (in bytes; <0 - if bottom up image)
  588.  *  src_x, src_y, src_dx, src_dy - source rectangle (pixels)
  589.  * Output:
  590.  *  p_scale_x, p_scale_y - scale factors for x,y axes
  591.  *      (currently only 1:1, and 2:1 scale factors are allowed)
  592.  * Returns:
  593.  *  0 - if success; -1 if failure.
  594.  */
  595. static int
  596. chk_args (unsigned char *dest_ptr, int dest_width, int dest_height,
  597.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  598.     unsigned char *src_ptr, int src_width, int src_height,
  599.     int src_pitch, int src_x, int src_y, int src_dx, int src_dy,
  600.     int *p_scale_x, int *p_scale_y)
  601. {
  602.     /* alignments: */
  603.     if (((unsigned)dest_ptr & 3) || (dest_pitch & 3) ||
  604.         ((unsigned)src_ptr  & 3) || (src_pitch  & 3) ||
  605.     /* image sizes: */
  606.         dest_width <= 0 || dest_height <= 0 ||
  607.         src_width  <= 0 || src_height  <= 0 ||
  608.     /* rectangles: */
  609.         dest_x < 0 || dest_y < 0 || dest_dx <= 0 || dest_dy <= 0 ||
  610.         src_x  < 0 || src_y  < 0 || src_dx  <= 0 || src_dy  <= 0 ||
  611.     /* overlaps: */
  612.         dest_width < dest_x + dest_dx || dest_height < dest_y + dest_dy ||
  613.         src_width  < src_x  + src_dx  || src_height  < src_y  + src_dy)
  614.         goto fail;
  616.     /* scale factors: */
  617.     if (dest_dx == src_dx)          *p_scale_x = 1;
  618.     else if (dest_dx == 2 * src_dx) *p_scale_x = 2;
  619.     else goto fail;
  620.     if (dest_dy == src_dy)          *p_scale_y = 1;
  621.     else if (dest_dy == 2 * src_dy) *p_scale_y = 2;
  622.     else goto fail;
  624.     /* success: */
  625.     return 1;
  627.     /* failure: */
  628. fail:
  629.     return 0;
  630. }
  632. static int adjust_range (int *z1, int *dz1, int *z2, int *dz2, int inc2)
  633. {
  634.     /* skip odd start pixel: */
  635.     if (*z1 & 1) {
  636.         *z1 += 1;
  637.         *dz1 -= 1;
  638.         *z2 += inc2;
  639.         *dz2 -= inc2;
  640.     }
  641.     /* clip the range: */
  642.     if (*dz1 & 1) {
  643.         *dz1 -= 1;
  644.         *dz2 -= inc2;
  645.     }
  646.     return (*dz1 > 0 && *dz2 > 0);
  647. }
  649. //////////////////////////////////////////////////////
  650. //
  651. // ARGBtoYUVA
  652. //
  653. // Note: YUVA is identical to I420 but has an additional
  654. //   planar field at the end the contains "alpha" info.
  655. //   This "alpha" field is the size of the Y component
  656. //
  657. //////////////////////////////////////////////////////
  659. int ARGBtoYUVA (unsigned char *dest_ptr, int dest_width, int dest_height,
  660.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  661.     unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  662.     int src_x, int src_y, int src_dx, int src_dy)
  663. {
  664.     /* scale factors: */
  665.     int scale_x, scale_y;
  667.     /* check arguments: */
  668.     if (!chk_args (dest_ptr, dest_width, dest_height, dest_pitch,
  669.         dest_x, dest_y, dest_dx, dest_dy, src_ptr, src_width, src_height,
  670.         src_pitch, src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
  671.         return -1;
  673.     /* align destination rectangle: */
  674.     if (!adjust_range (&dest_x, &dest_dx, &src_x, &src_dx, scale_x) ||
  675.         !adjust_range (&dest_y, &dest_dy, &src_y, &src_dy, scale_y))
  676.         return 0;
  678.     /* check if bottom-up bitmaps: */
  679.     if (src_pitch < 0)  src_ptr -= (src_height-1) * src_pitch;
  680.     if (dest_pitch <= 0) return -1;     /* not supported */
  682. /*
  683.  *  if (!is_dest_alpha && !is_dest_beta && !is_dest_gamma && !is_dest_kappa)
  684.  */
  685.     {
  686.         /* just move data in, no color adjustments: */
  687.         unsigned char *s1, *s2, *d1, *d2, *dv, *du, *d3, *d4;
  688.         register int i, j;
  690.         /* get pointers: */
  691.         s1 = src_ptr + src_x * BPP(RGB32) + src_y * src_pitch; /* 3 bytes/pixel */
  692.         s2 = s1 + src_pitch;
  693.         d1 = dest_ptr + dest_x + dest_y * dest_pitch;    /* luma offsets  */
  694.         d2 = d1 + dest_pitch;
  695.         du = dest_ptr + dest_height * dest_pitch + (dest_x/2 + dest_y/2 * dest_pitch/2); /* chroma offset */
  696.         dv = du + dest_height * dest_pitch/4;
  697.         d3 = dv + dest_height * dest_pitch/4;
  698.         d4 = d3 + dest_pitch;
  700.         switch (chroma_resampling_mode)
  701.         {
  702.             case CRM_00_11:
  704.                 /* the main loop (processes 2 lines a time): */
  705.                 for (i = 0; i < dest_dy/2; i ++) {
  707.                     /* convert 2x2 block: */
  708.                     for (j = 0; j < dest_dx/2; j ++) {
  710.                         int r2, b2, y2;
  712.                         /* process lumas: */
  713.                         {
  714.                             PIXEL(RGB32,x);
  715.                             register unsigned int r, b, y;
  717.                             LOAD(RGB32,s1,x);               /* [0,0] */
  718.                             r = GET_R(RGB32,x);
  719.                             b = GET_B(RGB32,x);
  720.                             y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b];
  721.                             d1[0] = yytab [y];
  722. d3[0] = GET_A(RGB32,x);
  724.                             LOAD(RGB32,s1+BPP(RGB32),x);    /* [0,1] */
  725.                             r = GET_R(RGB32,x);
  726.                             b = GET_B(RGB32,x);
  727.                             y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b];
  728.                             d1[1] = yytab [y];
  729. d3[1] = GET_A(RGB32,x);
  731.                             LOAD(RGB32,s2,x);               /* [1,0] */
  732.                             r2 = (r = GET_R(RGB32,x));
  733.                             b2 = (b = GET_B(RGB32,x));
  734.                             y2 = (y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b]);
  735.                             d2[0] = yytab [y];
  736. d4[0] = GET_A(RGB32,x);
  738.                             LOAD(RGB32,s2+BPP(RGB32),x);    /* [1,1] */
  739.                             r2 += (r = GET_R(RGB32,x));
  740.                             b2 += (b = GET_B(RGB32,x));
  741.                             y2 += (y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b]);
  742.                             d2[1] = yytab [y];
  743. d4[1] = GET_A(RGB32,x);
  744.                         }
  746.                         /* average chromas: */
  747.                         dv[0] = vrytab [VMIN+(r2-y2)/2];
  748.                         du[0] = ubytab [UMIN+(b2-y2)/2];
  750.                         /* go to the next block: */
  751.                         s1 += 2 * BPP(RGB32); s2 += 2 * BPP(RGB32);
  752.                         d1 += 2; d2 += 2;
  753.                         d3 += 2; d4 += 2;
  754.                         du += 1; dv += 1;
  755.                     }
  757.                     /* switch to the next two lines: */
  758.                     s1 += src_pitch * 2 - dest_dx * BPP(RGB32);
  759.                     s2 += src_pitch * 2 - dest_dx * BPP(RGB32);
  760.                     d1 += dest_pitch * 2 - dest_dx;
  761.                     d2 += dest_pitch * 2 - dest_dx;
  762.                     d3 += dest_pitch * 2 - dest_dx;
  763.                     d4 += dest_pitch * 2 - dest_dx;
  764.                     du += (dest_pitch - dest_dx)/2;
  765.                     dv += (dest_pitch - dest_dx)/2;
  766.                 }
  767.                 break;
  769.             case CRM_11_00:
  771.                 /* the main loop (processes 2 lines a time): */
  772.                 for (i = 0; i < dest_dy/2; i ++) {
  774.                     /* convert 2x2 block: */
  775.                     for (j = 0; j < dest_dx/2; j ++) {
  777.                         int r2, b2, y2;
  779.                         /* process lumas: */
  780.                         {
  781.                             PIXEL(RGB32,x);
  782.                             register unsigned int r, b, y;
  784.                             LOAD(RGB32,s1,x);               /* [0,0] */
  785.                             r2 = (r = GET_R(RGB32,x));
  786.                             b2 = (b = GET_B(RGB32,x));
  787.                             y2 = (y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b]);
  788.                             d1[0] = yytab [y];
  789. d3[0] = GET_A(RGB32,x);
  791.                             LOAD(RGB32,s1+BPP(RGB32),x);    /* [0,1] */
  792.                             r2 += (r = GET_R(RGB32,x));
  793.                             b2 += (b = GET_B(RGB32,x));
  794.                             y2 += (y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b]);
  795.                             d1[1] = yytab [y];
  796. d3[1] = GET_A(RGB32,x);
  798.                             LOAD(RGB32,s2,x);               /* [1,0] */
  799.                             r = GET_R(RGB32,x);
  800.                             b = GET_B(RGB32,x);
  801.                             y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b];
  802.                             d2[0] = yytab [y];
  803. d4[0] = GET_A(RGB32,x);
  805.                             LOAD(RGB32,s2+BPP(RGB32),x);    /* [1,1] */
  806.                             r = GET_R(RGB32,x);
  807.                             b = GET_B(RGB32,x);
  808.                             y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b];
  809.                             d2[1] = yytab [y];
  810.   d4[1] = GET_A(RGB32,x);
  811.                        }
  813.                         /* average chromas: */
  814.                         dv[0] = vrytab [VMIN+(r2-y2)/2];
  815.                         du[0] = ubytab [UMIN+(b2-y2)/2];
  817.                         /* go to the next block: */
  818.                         s1 += 2 * BPP(RGB32); s2 += 2 * BPP(RGB32);
  819.                         d1 += 2; d2 += 2;
  820.                         d3 += 2; d4 += 2;
  821.                         du += 1; dv += 1;
  822.                     }
  824.                     /* switch to the next two lines: */
  825.                     s1 += src_pitch * 2 - dest_dx * BPP(RGB32);
  826.                     s2 += src_pitch * 2 - dest_dx * BPP(RGB32);
  827.                     d1 += dest_pitch * 2 - dest_dx;
  828.                     d2 += dest_pitch * 2 - dest_dx;
  829.                     d3 += dest_pitch * 2 - dest_dx;
  830.                     d4 += dest_pitch * 2 - dest_dx;
  831.                     du += (dest_pitch - dest_dx)/2;
  832.                     dv += (dest_pitch - dest_dx)/2;
  833.                 }
  834.                 break;
  836.             case CRM_11_11:
  837.             default:
  839.                 /* the main loop (processes 2 lines a time): */
  840.                 for (i = 0; i < dest_dy/2; i ++) {
  842.                     /* convert 2x2 block: */
  843.                     for (j = 0; j < dest_dx/2; j ++) {
  845.                         int r4, b4, y4;
  847.                         /* process lumas: */
  848.                         {
  849.                             PIXEL(RGB32,x);
  850.                             register unsigned int r, b, y;
  852.                             LOAD(RGB32,s1,x);               /* [0,0] */
  853.                             r4 = (r = GET_R(RGB32,x));
  854.                             b4 = (b = GET_B(RGB32,x));
  855.                             y4 = (y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b]);
  856.                             d1[0] = yytab [y];
  857. d3[0] = GET_A(RGB32,x);
  859.                             LOAD(RGB32,s1+BPP(RGB32),x);    /* [0,1] */
  860.                             r4 += (r = GET_R(RGB32,x));
  861.                             b4 += (b = GET_B(RGB32,x));
  862.                             y4 += (y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b]);
  863.                             d1[1] = yytab [y];
  864. d3[1] = GET_A(RGB32,x);
  866.                             LOAD(RGB32,s2,x);               /* [1,0] */
  867.                             r4 += (r = GET_R(RGB32,x));
  868.                             b4 += (b = GET_B(RGB32,x));
  869.                             y4 += (y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b]);
  870.                             d2[0] = yytab [y];
  871. d4[0] = GET_A(RGB32,x);
  873.                             LOAD(RGB32,s2+BPP(RGB32),x);    /* [1,1] */
  874.                             r4 += (r = GET_R(RGB32,x));
  875.                             b4 += (b = GET_B(RGB32,x));
  876.                             y4 += (y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b]);
  877.                             d2[1] = yytab [y];
  878. d4[1] = GET_A(RGB32,x);
  879.                         }
  881.                         /* average chromas: */
  882.                         dv[0] = vrytab [VMIN+(r4-y4)/4];
  883.                         du[0] = ubytab [UMIN+(b4-y4)/4];
  885.                         /* go to the next block: */
  886.                         s1 += 2 * BPP(RGB32); s2 += 2 * BPP(RGB32);
  887.                         d1 += 2; d2 += 2;
  888.                         d3 += 2; d4 += 2;
  889.                         du += 1; dv += 1;
  890.                     }
  892.                     /* switch to the next two lines: */
  893.                     s1 += src_pitch * 2 - dest_dx * BPP(RGB32);
  894.                     s2 += src_pitch * 2 - dest_dx * BPP(RGB32);
  895.                     d1 += dest_pitch * 2 - dest_dx;
  896.                     d2 += dest_pitch * 2 - dest_dx;
  897.                     d3 += dest_pitch * 2 - dest_dx;
  898.                     d4 += dest_pitch * 2 - dest_dx;
  899.                     du += (dest_pitch - dest_dx)/2;
  900.                     dv += (dest_pitch - dest_dx)/2;
  901.                 }
  902.         }
  904.     }
  905. /*
  906.  *  else {
  907.  *      put all the color-dependent stuff here ...
  908.  *  }
  909.  */
  910.     return 0;
  911. }
  913. /* rgb2yuv.c -- end of file */