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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
rgb2yuv.c
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：36k
源码类别：

Symbian

开发平台：

Visual C++

rgb2yuv.c：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: rgb2yuv.c,v 1.2.48.1 2004/07/09 02:00:18 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  52. /*** #includes: ********************************************/
  54. #include "env.h"
  55. #include "rgb.h"    /* basic RGB-data definitions & macros */
  56. #include "yuv.h"    /* YUV-to-RGB conversion tables & macros */
  57. #include "clip.h"   /* macros for clipping & dithering */
  58. #include "scale.h"  /* scale algorithms */
  59. #include "colorlib.h"
  61. /*** RGB to YUV color converters: **************************/
  63. /*
  64.  * These functions were borrowed from our "old" color conversion library,
  65.  * and they do not support things like stretching or color adjustments.
  66.  * Given some more time this module should be completely rewritten.
  67.  *
  68.  ***************/
  70. /*-----------------2/24/2002 7:45AM-----------------
  71.  * Replaced the old code with macros.
  72.  * In-place resizing and color adjustments are not added since nobody
  73.  * really asked for it, and it would have blown the code by factor of 6 (at least).
  74.  * Yuriy.
  75.  * --------------------------------------------------*/
  78. /*-----------------9/19/2002 2:06PM-----------------
  79.  * Added support for byte-swapped RGB32 (BGR_32) and BGR24 input formats.
  80.  * To avoid changes (table reordering) in other modules, the definitions
  81.  * related to these formats are placed here, instead of "rgb.h".
  82.  * Yuriy.
  83.  * --------------------------------------------------*/
  86. /* new RGB format IDs: */
  87. #define BGR_32_ID           RGB_FORMATS
  88. #define BGR24_ID            (RGB_FORMATS + 1)
  91. /* bytes per pixel: */
  92. #define BGR_32_BPP          4
  93. #define BGR24_BPP           3
  96. /* local pixel representations: */
  97. #define BGR_32_PIXEL(a)     RGBX_PIXEL(a)
  98. #define BGR24_PIXEL(a)      RGB24_PIXEL(a)
  101. /* load/store/copy pixel macros: */
  102. #define BGR_32_LOAD(s,a)    RGBX_LOAD(s,a,unsigned int)
  103. #define BGR_32_STORE(d,a)   RGBX_STORE(d,a,unsigned int)
  104. #define BGR_32_COPY(da,sa)  RGBX_COPY(da,sa)
  107. #define BGR24_LOAD(s,a)     a##_r=(s)[0], a##_g=(s)[1], a##_b=(s)[2]
  108. #define BGR24_STORE(d,a)    (d)[0]=a##_r, (d)[1]=a##_g, (d)[2]=a##_b
  109. #define BGR24_COPY(da,sa)   da##_r=sa##_r, da##_g=sa##_g, da##_b=sa##_b
  112. /* BGR_32 bit fields: 0xBBGGRR00: */
  113. #define BGR_32_R_START      8
  114. #define BGR_32_R_BITS       8
  115. #define BGR_32_G_START      16
  116. #define BGR_32_G_BITS       8
  117. #define BGR_32_B_START      24
  118. #define BGR_32_B_BITS       8
  121. /* fields extraction/assignment macros: */
  122. #define BGR_32_GET_R(a)     RGBX_GET_X(BGR_32,R,a)
  123. #define BGR_32_GET_G(a)     RGBX_GET_X(BGR_32,G,a)
  124. #define BGR_32_GET_B(a)     RGBX_GET_X(BGR_32,B,a)
  125. #define BGR_32_SET(a,r,g,b) RGBX_SET(  BGR_32,a,r,g,b)
  128. #define BGR24_GET_R(a)      (a##_r)
  129. #define BGR24_GET_G(a)      (a##_g)
  130. #define BGR24_GET_B(a)      (a##_b)
  131. #define BGR24_SET(a,r,g,b)  a##_b=(b), a##_g=(g), a##_r=(r)
  134. /***************************************************************/
  137. /*
  138.  * YUV 4:2:0 chroma resampling modes:
  139.  * Input chroma     a b
  140.  *  samples:        c d
  141.  *
  142.  * CRM_11_11:       (a+b+c+d) / 4
  143.  * CRM_11_00:       (a+b) / 2
  144.  * CRM_00_11:       (c+d) / 2
  145.  */
  146. #define CHROMA_RESAMPLING_MODES     3
  149. /*
  150.  * 2x2-block load-convert-store macros:
  151.  */
  154. /* CRM_11_11 (both lines) chroma resampling: */
  155. #define CONVERT_2x2_CHROMA_11_11(dy1,dy2,du,dv,sf,s1,s2)            
  156.     {                                                               
  157.         /* local variables: */                                      
  158.         PIXEL(sf,x);                                                
  159.         register unsigned int r, b, y;                              
  160.         register unsigned int r4, b4, y4;   /* combined quant-s */  
  161.                                                                     
  162.         /* process lumas: */                                        
  163.         LOAD(sf,s1,x);              /* [0,0] */                     
  164.         r4 = (r = GET_R(sf,x));                                     
  165.         b4 = (b = GET_B(sf,x));                                     
  166.         y4 = (y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b]);     
  167.         dy1[0] = yytab [y];                                         
  168.                                                                     
  169.         LOAD(sf,s1+BPP(sf),x);      /* [0,1] */                     
  170.         r4 += (r = GET_R(sf,x));                                    
  171.         b4 += (b = GET_B(sf,x));                                    
  172.         y4 += (y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b]);    
  173.         dy1[1] = yytab [y];                                         
  174.                                                                     
  175.         LOAD(sf,s2,x);              /* [1,0] */                     
  176.         r4 += (r = GET_R(sf,x));                                    
  177.         b4 += (b = GET_B(sf,x));                                    
  178.         y4 += (y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b]);    
  179.         dy2[0] = yytab [y];                                         
  180.                                                                     
  181.         LOAD(sf,s2+BPP(sf),x);      /* [1,1] */                     
  182.         r4 += (r = GET_R(sf,x));                                    
  183.         b4 += (b = GET_B(sf,x));                                    
  184.         y4 += (y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b]);    
  185.         dy2[1] = yytab [y];                                         
  186.                                                                     
  187.         /* average chromas: */                                      
  188.         dv[0] = vrytab [VMIN+(r4-y4)/4];                            
  189.         du[0] = ubytab [UMIN+(b4-y4)/4];                            
  190.     }
  193. /* CRM_11_00 (upper line) chroma resampling: */
  194. #define CONVERT_2x2_CHROMA_11_00(dy1,dy2,du,dv,sf,s1,s2)            
  195.     {                                                               
  196.         /* local variables: */                                      
  197.         PIXEL(sf,x);                                                
  198.         register unsigned int r, b, y;                              
  199.         register unsigned int r2, b2, y2;   /* 1st line combined */ 
  200.                                                                     
  201.         /* process lumas: */                                        
  202.         LOAD(sf,s1,x);              /* [0,0] */                     
  203.         r2 = (r = GET_R(sf,x));                                     
  204.         b2 = (b = GET_B(sf,x));                                     
  205.         y2 = (y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b]);     
  206.         dy1[0] = yytab [y];                                         
  207.                                                                     
  208.         LOAD(sf,s1+BPP(sf),x);      /* [0,1] */                     
  209.         r2 += (r = GET_R(sf,x));                                    
  210.         b2 += (b = GET_B(sf,x));                                    
  211.         y2 += (y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b]);    
  212.         dy1[1] = yytab [y];                                         
  213.                                                                     
  214.         LOAD(sf,s2,x);              /* [1,0] */                     
  215.         r = GET_R(sf,x);                                            
  216.         b = GET_B(sf,x);                                            
  217.         y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b];            
  218.         dy2[0] = yytab [y];                                         
  219.                                                                     
  220.         LOAD(sf,s2+BPP(sf),x);      /* [1,1] */                     
  221.         r = GET_R(sf,x);                                            
  222.         b = GET_B(sf,x);                                            
  223.         y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b];            
  224.         dy2[1] = yytab [y];                                         
  225.                                                                     
  226.         /* average chromas: */                                      
  227.         dv[0] = vrytab [VMIN+(r2-y2)/2];                            
  228.         du[0] = ubytab [UMIN+(b2-y2)/2];                            
  229.     }
  233. /* CRM_00_11 (lower line) chroma resampling: */
  234. #define CONVERT_2x2_CHROMA_00_11(dy1,dy2,du,dv,sf,s1,s2)            
  235.     {                                                               
  236.         /* local variables: */                                      
  237.         PIXEL(sf,x);                                                
  238.         register unsigned int r, b, y;                              
  239.         register unsigned int r2, b2, y2;   /* 2nd line combined */ 
  240.                                                                     
  241.         /* process lumas: */                                        
  242.         LOAD(sf,s1,x);              /* [0,0] */                     
  243.         r = GET_R(sf,x);                                            
  244.         b = GET_B(sf,x);                                            
  245.         y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b];            
  246.         dy1[0] = yytab [y];                                         
  247.                                                                     
  248.         LOAD(sf,s1+BPP(sf),x);      /* [0,1] */                     
  249.         r = GET_R(sf,x);                                            
  250.         b = GET_B(sf,x);                                            
  251.         y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b];            
  252.         dy1[1] = yytab [y];                                         
  253.                                                                     
  254.         LOAD(sf,s2,x);              /* [1,0] */                     
  255.         r2 = (r = GET_R(sf,x));                                     
  256.         b2 = (b = GET_B(sf,x));                                     
  257.         y2 = (y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b]);     
  258.         dy2[0] = yytab [y];                                         
  259.                                                                     
  260.         LOAD(sf,s2+BPP(sf),x);      /* [1,1] */                     
  261.         r2 += (r = GET_R(sf,x));                                    
  262.         b2 += (b = GET_B(sf,x));                                    
  263.         y2 += (y = yrtab [r] + ygtab [GET_G(sf,x)] + ybtab [b]);    
  264.         dy2[1] = yytab [y];                                         
  265.                                                                     
  266.         /* average chromas: */                                      
  267.         dv[0] = vrytab [VMIN+(r2-y2)/2];                            
  268.         du[0] = ubytab [UMIN+(b2-y2)/2];                            
  269.     }
  272. /*
  273.  * Generic 2x2 block converter:
  274.  */
  275. #define CONVERT_2x2(dy1,dy2,du,dv,sf,s1,s2,crm)                     
  276.     CONVERT_2x2_##crm(dy1,dy2,du,dv,sf,s1,s2)
  279. /*
  280.  * Generic RGBtoYUV double-row converter:
  281.  *
  282.  *  YUV-image pointers are assumed to be 2x2-block aligned, as well as
  283.  *  n -- the number of pixels to be converter, is assumed to be multiple of 2.
  284.  */
  285. #define DBLROW(dy1,dy2,du,dv,sf,s1,s2,n,crm)                        
  286.     {                                                               
  287.         register int n2 = n/2;                                      
  288.         /* convert 2x2 blocks: */                                   
  289.         while (n2) {                                                
  290.             CONVERT_2x2(dy1,dy2,du,dv,sf,s1,s2,crm);                
  291.             dy1 += 2; dy2 += 2; du ++; dv ++;                       
  292.             s1 += BPP(sf) * 2; s2 += BPP(sf) * 2;                   
  293.             n2 --;                                                  
  294.         }                                                           
  295.     }
  298. /*
  299.  * Function names:
  300.  */
  301. #define FN(df,sf)               sf##to##df
  302. #define DBLROW_FN(df,sf,crm)    sf##to##df##_DBLROW_##crm
  305. /*
  306.  * Function replication macros:
  307.  *  (dblrow converters)
  308.  */
  309. #define DBLROW_FUNC(df,sf,crm)                                      
  310.     static void DBLROW_FN(df,sf,crm) (                              
  311.         unsigned char *dy1, unsigned char *dy2,                     
  312.         unsigned char *du, unsigned char *dv,                       
  313.         unsigned char *s1, unsigned char *s2, int n)                
  314.         DBLROW(dy1,dy2,du,dv,sf,s1,s2,n,crm)
  318. /***********************************************************/
  321. /*
  322.  * Actual double-row converters:
  323.  */
  324. DBLROW_FUNC(I420, RGB32,  CHROMA_11_11)
  325. DBLROW_FUNC(I420, RGB32,  CHROMA_11_00)
  326. DBLROW_FUNC(I420, RGB32,  CHROMA_00_11)
  329. DBLROW_FUNC(I420, BGR_32, CHROMA_11_11)
  330. DBLROW_FUNC(I420, BGR_32, CHROMA_11_00)
  331. DBLROW_FUNC(I420, BGR_32, CHROMA_00_11)
  334. DBLROW_FUNC(I420, RGB24,  CHROMA_11_11)
  335. DBLROW_FUNC(I420, RGB24,  CHROMA_11_00)
  336. DBLROW_FUNC(I420, RGB24,  CHROMA_00_11)
  339. DBLROW_FUNC(I420, BGR24,  CHROMA_11_11)
  340. DBLROW_FUNC(I420, BGR24,  CHROMA_11_00)
  341. DBLROW_FUNC(I420, BGR24,  CHROMA_00_11)
  344. DBLROW_FUNC(I420, RGB565, CHROMA_11_11)
  345. DBLROW_FUNC(I420, RGB565, CHROMA_11_00)
  346. DBLROW_FUNC(I420, RGB565, CHROMA_00_11)
  349. DBLROW_FUNC(I420, RGB555, CHROMA_11_11)
  350. DBLROW_FUNC(I420, RGB555, CHROMA_11_00)
  351. DBLROW_FUNC(I420, RGB555, CHROMA_00_11)
  354. DBLROW_FUNC(I420, RGB8,   CHROMA_11_11)
  355. DBLROW_FUNC(I420, RGB8,   CHROMA_11_00)
  356. DBLROW_FUNC(I420, RGB8,   CHROMA_00_11)
  360. /*
  361.  * Double-row scale function selection tables:
  362.  *  [source format][chroma resampling type]
  363.  */
  364. static void (* DblRowFuncs [RGB_FORMATS+2][CHROMA_RESAMPLING_MODES]) (
  365.     unsigned char *, unsigned char *, unsigned char *, unsigned char *,
  366.     unsigned char *, unsigned char *, int) =
  367. {
  368.     {
  369.         DBLROW_FN(I420, RGB32,  CHROMA_11_11),
  370.         DBLROW_FN(I420, RGB32,  CHROMA_11_00),
  371.         DBLROW_FN(I420, RGB32,  CHROMA_00_11)
  372.     },
  373.     {   /* BGR32: */
  374.         0, 0, 0
  375.     },
  376.     {
  377.         DBLROW_FN(I420, RGB24,  CHROMA_11_11),
  378.         DBLROW_FN(I420, RGB24,  CHROMA_11_00),
  379.         DBLROW_FN(I420, RGB24,  CHROMA_00_11)
  380.     },
  381.     {
  382.         DBLROW_FN(I420, RGB565, CHROMA_11_11),
  383.         DBLROW_FN(I420, RGB565, CHROMA_11_00),
  384.         DBLROW_FN(I420, RGB565, CHROMA_00_11)
  385.     },
  386.     {
  387.         DBLROW_FN(I420, RGB555, CHROMA_11_11),
  388.         DBLROW_FN(I420, RGB555, CHROMA_11_00),
  389.         DBLROW_FN(I420, RGB555, CHROMA_00_11)
  390.     },
  391.     {   /* RGB444: */
  392.         0, 0, 0
  393.     },
  394.     {
  395.         DBLROW_FN(I420, RGB8,   CHROMA_11_11),
  396.         DBLROW_FN(I420, RGB8,   CHROMA_11_00),
  397.         DBLROW_FN(I420, RGB8,   CHROMA_00_11)
  398.     },
  399.     {
  400.         DBLROW_FN(I420, BGR_32,  CHROMA_11_11),
  401.         DBLROW_FN(I420, BGR_32,  CHROMA_11_00),
  402.         DBLROW_FN(I420, BGR_32,  CHROMA_00_11)
  403.     },
  404.     {
  405.         DBLROW_FN(I420, BGR24,  CHROMA_11_11),
  406.         DBLROW_FN(I420, BGR24,  CHROMA_11_00),
  407.         DBLROW_FN(I420, BGR24,  CHROMA_00_11)
  408.     }
  409. };
  412. /*
  413.  * Bytes per pixel (bpp) table:
  414.  */
  415. static int bpp [RGB_FORMATS+2] =
  416. {
  417.     BPP(RGB32),
  418.     BPP(BGR32),
  419.     BPP(RGB24),
  420.     BPP(RGB565),
  421.     BPP(RGB555),
  422.     BPP(RGB444),
  423.     BPP(RGB8),
  424.     BPP(BGR_32),
  425.     BPP(BGR24)
  426. };
  429. /*
  430.  * The main RGBtoYUV converter:
  431.  */
  432. static int RGBtoYUV (
  433.     /* destination image parameters: */
  434.     unsigned char *dest_ptr, int dest_width, int dest_height,
  435.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  436.     /* source format: */
  437.     int src_format,
  438.     /* source image parametersBto: */
  439.     unsigned char *src_ptr, int src_width, int src_height,
  440.     int src_pitch, int src_x, int src_y, int src_dx, int src_dy)
  441. {
  442.     /* pointer to a double-row converter to use: */
  443.     void (*dblrow_proc) (unsigned char *, unsigned char *,
  444.         unsigned char *, unsigned char *, unsigned char *, unsigned char *, int);
  447.     /* pointers and source pixel depth: */
  448.     register unsigned char *dy1, *dy2, *du, *dv, *s1, *s2;
  449.     register int src_bpp, i;
  452.     /* check arguments: */
  453.     if (
  454.         /* alignments: */
  455.         ((unsigned)dest_ptr & 3) || (dest_pitch & 3) ||
  456.         ((unsigned)src_ptr  & 3) || (src_pitch  & 3) ||
  457.         /* image sizes: */
  458.         dest_width <= 0 || dest_height <= 0 ||
  459.         src_width  <= 0 || src_height  <= 0 ||
  460.         /* rectangles: */
  461.         dest_x < 0 || dest_y < 0 || dest_dx <= 0 || dest_dy <= 0 ||
  462.         src_x  < 0 || src_y  < 0 || src_dx  <= 0 || src_dy  <= 0 ||
  463.         /* overlaps: */
  464.         dest_width < dest_x + dest_dx || dest_height < dest_y + dest_dy ||
  465.         src_width  < src_x  + src_dx  || src_height  < src_y  + src_dy)
  466.     {
  467. fail:   /* fail: */
  468.         return -1;
  469.     }
  472.     /* check scale factors: */
  473.     if (dest_dx != src_dx || dest_dy != src_dy)
  474.         /* no in-place resizing !!! */
  475.         goto fail;
  478.     /* skip odd start column: */
  479.     if (dest_x & 1) { dest_x ++; dest_dx --; src_x ++; src_dx --; }
  480.     /* clip horisontal range: */
  481.     if (dest_dx & 1) { dest_dx --; src_dx --; if (dest_dx <= 0) goto fail;}
  484.     /* skip odd start row: */
  485.     if (dest_y & 1) { dest_y ++; dest_dy --; src_y ++; src_dy --; }
  486.     /* clip vertical range: */
  487.     if (dest_dy & 1) { dest_dy --; src_dy --; if (dest_dy <= 0) goto fail;}
  490.     /* select row and image converters: */
  491.     dblrow_proc = DblRowFuncs [src_format] [chroma_resampling_mode];
  494.     /* get source pixel depth: */
  495.     src_bpp = bpp [src_format];
  498.     /* check if bottop-up images: */
  499.     if (src_pitch < 0) src_ptr -= (src_height-1) * src_pitch;
  500.     if (dest_pitch <= 0) return -1;                     /* not supported */
  503.     /* get pointers: */
  504.     s1  = src_ptr + src_x * src_bpp + src_y * src_pitch;
  505.     s2  = s1 + src_pitch;
  506.     dy1 = dest_ptr + dest_x + dest_y * dest_pitch;      /* luma offsets  */
  507.     dy2 = dy1 + dest_pitch;
  508.     du  = dest_ptr + dest_height * dest_pitch
  509.           + (dest_x/2 + dest_y/2 * dest_pitch / 2);     /* chroma offset */
  510.     dv  = du + dest_height * dest_pitch / 4;
  513.     /* the main loop (processes 2 lines a time): */
  514.     for (i = 0; i < dest_dy/2; i ++) {
  517.         (*dblrow_proc) (dy1, dy2, du, dv, s1, s2, dest_dx);
  520.         /* switch to the next two lines: */
  521.         s1 += src_pitch * 2;    s2 += src_pitch * 2;
  522.         dy1 += dest_pitch * 2;  dy2 += dest_pitch * 2;
  523.         du += dest_pitch / 2;   dv += dest_pitch / 2;
  524.     }
  527.     /* success: */
  528.     return 0;
  529. }
  533. /*
  534.  * Public format-conversion routines.
  535.  * Use:
  536.  *  int XXXXtoYYYY (unsigned char *dest_ptr, int dest_width, int dest_height,
  537.  *      int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  538.  *      unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  539.  *      int src_x, int src_y, int src_dx, int src_dy);
  540.  * Input:
  541.  *  dest_ptr - pointer to a destination buffer
  542.  *  dest_width, dest_height - width/height of the destination image (pixels)
  543.  *  dest_pitch - pitch of the dest. buffer (in bytes; <0 - if bottom up image)
  544.  *  dest_x, dest_y, dest_dx, dest_dy - destination rectangle (pixels)
  545.  *  src_ptr - pointer to an input image
  546.  *  src_width, src_height - width/height of the input image (pixels)
  547.  *  src_pitch - pitch of the source buffer (in bytes; <0 - if bottom up image)
  548.  *  src_x, src_y, src_dx, src_dy - source rectangle (pixels)
  549.  * Returns:
  550.  *  0 - if success; -1 if failure.
  551.  * Note:
  552.  *  Both source and destination buffers must be 4-bytes aligned,
  553.  *  and their pitches (#of bytes in row) shall be multiple of 4!!!
  554.  */
  557. #define RGBTOYUV_FUNC(sf)                                   
  558.     int FN(I420,sf) (unsigned char *dest_ptr,               
  559.         int dest_width, int dest_height, int dest_pitch,    
  560.         int dest_x, int dest_y, int dest_dx, int dest_dy,   
  561.         unsigned char *src_ptr,                             
  562.         int src_width, int src_height, int src_pitch,       
  563.         int src_x, int src_y, int src_dx, int src_dy)       
  564.     {                                                       
  565.         return RGBtoYUV(                                  
  566.             dest_ptr, dest_width, dest_height,              
  567.             dest_pitch, dest_x, dest_y, dest_dx, dest_dy,   
  568.             ID(sf), src_ptr, src_width, src_height,         
  569.             src_pitch, src_x, src_y, src_dx, src_dy);       
  570.     }
  573. RGBTOYUV_FUNC(RGB32 )
  574. RGBTOYUV_FUNC(RGB24 )
  575. RGBTOYUV_FUNC(RGB565)
  576. RGBTOYUV_FUNC(RGB555)
  577. RGBTOYUV_FUNC(RGB8)
  580. RGBTOYUV_FUNC(BGR_32 )
  581. RGBTOYUV_FUNC(BGR24 )
  583. /*********************************
  584.  * Back to the old stuff: */
  586.  /*
  587.  * Checks format conversion parameters.
  588.  * Use:
  589.  *  int chk_args (unsigned char *dest_ptr, int dest_width, int dest_height,
  590.  *      int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  591.  *      unsigned char *src_ptr, int src_width, int src_height,
  592.  *      int src_pitch, int src_x, int src_y, int src_dx, int src_dy,
  593.  *      int *p_scale_x, int *p_scale_y);
  594.  * Input:
  595.  *  dest_ptr - pointer to a destination buffer
  596.  *  dest_width, dest_height - width/height of the destination image (pixels)
  597.  *  dest_pitch - pitch of the dest. buffer (in bytes; <0 - if bottom up image)
  598.  *  dest_x, dest_y, dest_dx, dest_dy - destination rectangle (pixels)
  599.  *  src_ptr - pointer to an input image
  600.  *  src_width, src_height - width/height of the input image (pixels)
  601.  *  src_pitch - pitch of the source buffer (in bytes; <0 - if bottom up image)
  602.  *  src_x, src_y, src_dx, src_dy - source rectangle (pixels)
  603.  * Output:
  604.  *  p_scale_x, p_scale_y - scale factors for x,y axes
  605.  *      (currently only 1:1, and 2:1 scale factors are allowed)
  606.  * Returns:
  607.  *  0 - if success; -1 if failure.
  608.  */
  609. static int
  610. chk_args (unsigned char *dest_ptr, int dest_width, int dest_height,
  611.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  612.     unsigned char *src_ptr, int src_width, int src_height,
  613.     int src_pitch, int src_x, int src_y, int src_dx, int src_dy,
  614.     int *p_scale_x, int *p_scale_y)
  615. {
  616.     /* alignments: */
  617.     if (((unsigned)dest_ptr & 3) || (dest_pitch & 3) ||
  618.         ((unsigned)src_ptr  & 3) || (src_pitch  & 3) ||
  619.     /* image sizes: */
  620.         dest_width <= 0 || dest_height <= 0 ||
  621.         src_width  <= 0 || src_height  <= 0 ||
  622.     /* rectangles: */
  623.         dest_x < 0 || dest_y < 0 || dest_dx <= 0 || dest_dy <= 0 ||
  624.         src_x  < 0 || src_y  < 0 || src_dx  <= 0 || src_dy  <= 0 ||
  625.     /* overlaps: */
  626.         dest_width < dest_x + dest_dx || dest_height < dest_y + dest_dy ||
  627.         src_width  < src_x  + src_dx  || src_height  < src_y  + src_dy)
  628.         goto fail;
  630.     /* scale factors: */
  631.     if (dest_dx == src_dx)          *p_scale_x = 1;
  632.     else if (dest_dx == 2 * src_dx) *p_scale_x = 2;
  633.     else goto fail;
  634.     if (dest_dy == src_dy)          *p_scale_y = 1;
  635.     else if (dest_dy == 2 * src_dy) *p_scale_y = 2;
  636.     else goto fail;
  638.     /* success: */
  639.     return 1;
  641.     /* failure: */
  642. fail:
  643.     return 0;
  644. }
  646. static int adjust_range (int *z1, int *dz1, int *z2, int *dz2, int inc2)
  647. {
  648.     /* skip odd start pixel: */
  649.     if (*z1 & 1) {
  650.         *z1 += 1;
  651.         *dz1 -= 1;
  652.         *z2 += inc2;
  653.         *dz2 -= inc2;
  654.     }
  655.     /* clip the range: */
  656.     if (*dz1 & 1) {
  657.         *dz1 -= 1;
  658.         *dz2 -= inc2;
  659.     }
  660.     return (*dz1 > 0 && *dz2 > 0);
  661. }
  663. //////////////////////////////////////////////////////
  664. //
  665. // ARGBtoYUVA
  666. //
  667. // Note: YUVA is identical to I420 but has an additional
  668. //   planar field at the end the contains "alpha" info.
  669. //   This "alpha" field is the size of the Y component
  670. //
  671. //////////////////////////////////////////////////////
  673. int ARGBtoYUVA (unsigned char *dest_ptr, int dest_width, int dest_height,
  674.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  675.     unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  676.     int src_x, int src_y, int src_dx, int src_dy)
  677. {
  678.     /* scale factors: */
  679.     int scale_x, scale_y;
  681.     /* check arguments: */
  682.     if (!chk_args (dest_ptr, dest_width, dest_height, dest_pitch,
  683.         dest_x, dest_y, dest_dx, dest_dy, src_ptr, src_width, src_height,
  684.         src_pitch, src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
  685.         return -1;
  687.     /* align destination rectangle: */
  688.     if (!adjust_range (&dest_x, &dest_dx, &src_x, &src_dx, scale_x) ||
  689.         !adjust_range (&dest_y, &dest_dy, &src_y, &src_dy, scale_y))
  690.         return 0;
  692.     /* check if bottom-up bitmaps: */
  693.     if (src_pitch < 0)  src_ptr -= (src_height-1) * src_pitch;
  694.     if (dest_pitch <= 0) return -1;     /* not supported */
  696. /*
  697.  *  if (!is_dest_alpha && !is_dest_beta && !is_dest_gamma && !is_dest_kappa)
  698.  */
  699.     {
  700.         /* just move data in, no color adjustments: */
  701.         unsigned char *s1, *s2, *d1, *d2, *dv, *du, *d3, *d4;
  702.         register int i, j;
  704.         /* get pointers: */
  705.         s1 = src_ptr + src_x * BPP(RGB32) + src_y * src_pitch; /* 3 bytes/pixel */
  706.         s2 = s1 + src_pitch;
  707.         d1 = dest_ptr + dest_x + dest_y * dest_pitch;    /* luma offsets  */
  708.         d2 = d1 + dest_pitch;
  709.         du = dest_ptr + dest_height * dest_pitch + (dest_x/2 + dest_y/2 * dest_pitch/2); /* chroma offset */
  710.         dv = du + dest_height * dest_pitch/4;
  711.         d3 = dv + dest_height * dest_pitch/4;
  712.         d4 = d3 + dest_pitch;
  714.         switch (chroma_resampling_mode)
  715.         {
  716.             case CRM_00_11:
  718.                 /* the main loop (processes 2 lines a time): */
  719.                 for (i = 0; i < dest_dy/2; i ++) {
  721.                     /* convert 2x2 block: */
  722.                     for (j = 0; j < dest_dx/2; j ++) {
  724.                         int r2, b2, y2;
  726.                         /* process lumas: */
  727.                         {
  728.                             PIXEL(RGB32,x);
  729.                             register unsigned int r, b, y;
  731.                             LOAD(RGB32,s1,x);               /* [0,0] */
  732.                             r = GET_R(RGB32,x);
  733.                             b = GET_B(RGB32,x);
  734.                             y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b];
  735.                             d1[0] = yytab [y];
  736. d3[0] = GET_A(RGB32,x);
  738.                             LOAD(RGB32,s1+BPP(RGB32),x);    /* [0,1] */
  739.                             r = GET_R(RGB32,x);
  740.                             b = GET_B(RGB32,x);
  741.                             y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b];
  742.                             d1[1] = yytab [y];
  743. d3[1] = GET_A(RGB32,x);
  745.                             LOAD(RGB32,s2,x);               /* [1,0] */
  746.                             r2 = (r = GET_R(RGB32,x));
  747.                             b2 = (b = GET_B(RGB32,x));
  748.                             y2 = (y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b]);
  749.                             d2[0] = yytab [y];
  750. d4[0] = GET_A(RGB32,x);
  752.                             LOAD(RGB32,s2+BPP(RGB32),x);    /* [1,1] */
  753.                             r2 += (r = GET_R(RGB32,x));
  754.                             b2 += (b = GET_B(RGB32,x));
  755.                             y2 += (y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b]);
  756.                             d2[1] = yytab [y];
  757. d4[1] = GET_A(RGB32,x);
  758.                         }
  760.                         /* average chromas: */
  761.                         dv[0] = vrytab [VMIN+(r2-y2)/2];
  762.                         du[0] = ubytab [UMIN+(b2-y2)/2];
  764.                         /* go to the next block: */
  765.                         s1 += 2 * BPP(RGB32); s2 += 2 * BPP(RGB32);
  766.                         d1 += 2; d2 += 2;
  767.                         d3 += 2; d4 += 2;
  768.                         du += 1; dv += 1;
  769.                     }
  771.                     /* switch to the next two lines: */
  772.                     s1 += src_pitch * 2 - dest_dx * BPP(RGB32);
  773.                     s2 += src_pitch * 2 - dest_dx * BPP(RGB32);
  774.                     d1 += dest_pitch * 2 - dest_dx;
  775.                     d2 += dest_pitch * 2 - dest_dx;
  776.                     d3 += dest_pitch * 2 - dest_dx;
  777.                     d4 += dest_pitch * 2 - dest_dx;
  778.                     du += (dest_pitch - dest_dx)/2;
  779.                     dv += (dest_pitch - dest_dx)/2;
  780.                 }
  781.                 break;
  783.             case CRM_11_00:
  785.                 /* the main loop (processes 2 lines a time): */
  786.                 for (i = 0; i < dest_dy/2; i ++) {
  788.                     /* convert 2x2 block: */
  789.                     for (j = 0; j < dest_dx/2; j ++) {
  791.                         int r2, b2, y2;
  793.                         /* process lumas: */
  794.                         {
  795.                             PIXEL(RGB32,x);
  796.                             register unsigned int r, b, y;
  798.                             LOAD(RGB32,s1,x);               /* [0,0] */
  799.                             r2 = (r = GET_R(RGB32,x));
  800.                             b2 = (b = GET_B(RGB32,x));
  801.                             y2 = (y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b]);
  802.                             d1[0] = yytab [y];
  803. d3[0] = GET_A(RGB32,x);
  805.                             LOAD(RGB32,s1+BPP(RGB32),x);    /* [0,1] */
  806.                             r2 += (r = GET_R(RGB32,x));
  807.                             b2 += (b = GET_B(RGB32,x));
  808.                             y2 += (y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b]);
  809.                             d1[1] = yytab [y];
  810. d3[1] = GET_A(RGB32,x);
  812.                             LOAD(RGB32,s2,x);               /* [1,0] */
  813.                             r = GET_R(RGB32,x);
  814.                             b = GET_B(RGB32,x);
  815.                             y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b];
  816.                             d2[0] = yytab [y];
  817. d4[0] = GET_A(RGB32,x);
  819.                             LOAD(RGB32,s2+BPP(RGB32),x);    /* [1,1] */
  820.                             r = GET_R(RGB32,x);
  821.                             b = GET_B(RGB32,x);
  822.                             y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b];
  823.                             d2[1] = yytab [y];
  824.   d4[1] = GET_A(RGB32,x);
  825.                        }
  827.                         /* average chromas: */
  828.                         dv[0] = vrytab [VMIN+(r2-y2)/2];
  829.                         du[0] = ubytab [UMIN+(b2-y2)/2];
  831.                         /* go to the next block: */
  832.                         s1 += 2 * BPP(RGB32); s2 += 2 * BPP(RGB32);
  833.                         d1 += 2; d2 += 2;
  834.                         d3 += 2; d4 += 2;
  835.                         du += 1; dv += 1;
  836.                     }
  838.                     /* switch to the next two lines: */
  839.                     s1 += src_pitch * 2 - dest_dx * BPP(RGB32);
  840.                     s2 += src_pitch * 2 - dest_dx * BPP(RGB32);
  841.                     d1 += dest_pitch * 2 - dest_dx;
  842.                     d2 += dest_pitch * 2 - dest_dx;
  843.                     d3 += dest_pitch * 2 - dest_dx;
  844.                     d4 += dest_pitch * 2 - dest_dx;
  845.                     du += (dest_pitch - dest_dx)/2;
  846.                     dv += (dest_pitch - dest_dx)/2;
  847.                 }
  848.                 break;
  850.             case CRM_11_11:
  851.             default:
  853.                 /* the main loop (processes 2 lines a time): */
  854.                 for (i = 0; i < dest_dy/2; i ++) {
  856.                     /* convert 2x2 block: */
  857.                     for (j = 0; j < dest_dx/2; j ++) {
  859.                         int r4, b4, y4;
  861.                         /* process lumas: */
  862.                         {
  863.                             PIXEL(RGB32,x);
  864.                             register unsigned int r, b, y;
  866.                             LOAD(RGB32,s1,x);               /* [0,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.                             d1[0] = yytab [y];
  871. d3[0] = GET_A(RGB32,x);
  873.                             LOAD(RGB32,s1+BPP(RGB32),x);    /* [0,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.                             d1[1] = yytab [y];
  878. d3[1] = GET_A(RGB32,x);
  880.                             LOAD(RGB32,s2,x);               /* [1,0] */
  881.                             r4 += (r = GET_R(RGB32,x));
  882.                             b4 += (b = GET_B(RGB32,x));
  883.                             y4 += (y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b]);
  884.                             d2[0] = yytab [y];
  885. d4[0] = GET_A(RGB32,x);
  887.                             LOAD(RGB32,s2+BPP(RGB32),x);    /* [1,1] */
  888.                             r4 += (r = GET_R(RGB32,x));
  889.                             b4 += (b = GET_B(RGB32,x));
  890.                             y4 += (y = yrtab [r] + ygtab [GET_G(RGB32,x)] + ybtab [b]);
  891.                             d2[1] = yytab [y];
  892. d4[1] = GET_A(RGB32,x);
  893.                         }
  895.                         /* average chromas: */
  896.                         dv[0] = vrytab [VMIN+(r4-y4)/4];
  897.                         du[0] = ubytab [UMIN+(b4-y4)/4];
  899.                         /* go to the next block: */
  900.                         s1 += 2 * BPP(RGB32); s2 += 2 * BPP(RGB32);
  901.                         d1 += 2; d2 += 2;
  902.                         d3 += 2; d4 += 2;
  903.                         du += 1; dv += 1;
  904.                     }
  906.                     /* switch to the next two lines: */
  907.                     s1 += src_pitch * 2 - dest_dx * BPP(RGB32);
  908.                     s2 += src_pitch * 2 - dest_dx * BPP(RGB32);
  909.                     d1 += dest_pitch * 2 - dest_dx;
  910.                     d2 += dest_pitch * 2 - dest_dx;
  911.                     d3 += dest_pitch * 2 - dest_dx;
  912.                     d4 += dest_pitch * 2 - dest_dx;
  913.                     du += (dest_pitch - dest_dx)/2;
  914.                     dv += (dest_pitch - dest_dx)/2;
  915.                 }
  916.         }
  918.     }
  919. /*
  920.  *  else {
  921.  *      put all the color-dependent stuff here ...
  922.  *  }
  923.  */
  924.     return 0;
  925. }
  927. /* rgb2yuv.c -- end of file */