rgb.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:13k
源码类别:

Symbian

开发平台:

C/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 ***** */ 
  35. #ifndef __RGB_H__
  36. #define __RGB_H__   1
  37. #ifdef __cplusplus
  38. extern "C" {
  39. #endif
  40. #define I420_ID             0
  41. #define YV12_ID             1
  42. #define YUY2_ID             2
  43. #define UYVY_ID             3
  44. #define YUV_FORMATS         4
  45. /*
  46.  * RGB formats supported:
  47.  *
  48.  *  RGB32   - 32-bit 8:8:8 RGB
  49.  *  BGR32   - 32-bit 8:8:8 RGB (R&B swapped)
  50.  *  RGB24   - 24-bit 8:8:8 RGB
  51.  *  RGB565  - 16-bit 5:6:5 RGB
  52.  *  RGB555  - 16-bit 5:5:5 RGB
  53.  *  RGB444  - 16-bit 4:4:4 RGB (embedded devices)
  54.  *  RGB8    -  8-bit palettized RGB
  55.  */
  56. #define RGB32_ID            0
  57. #define BGR32_ID            1
  58. #define RGB24_ID            2
  59. #define RGB565_ID           3
  60. #define RGB555_ID           4
  61. #define RGB444_ID           5
  62. #define RGB8_ID             6
  63. #define RGB_FORMATS         7
  64. /*
  65.  * Generic format ID:
  66.  */
  67. #define ID(f)               f##_ID
  68. /*
  69.  * Bytes per pixel (bpp) constants:
  70.  */
  71. #define RGB32_BPP           4
  72. #define BGR32_BPP           4
  73. #define RGB24_BPP           3
  74. #define RGB565_BPP          2
  75. #define RGB555_BPP          2
  76. #define RGB444_BPP          2
  77. #define RGB8_BPP            1
  78. /*
  79.  * Generic pixel depth:
  80.  */
  81. #define BPP(f)              f##_BPP
  82. /*
  83.  * Our internal RGB8 palette tables:
  84.  */
  85. #ifndef PAL_MAIN
  86. #define PAL_EXTERN extern
  87. #else
  88. #define PAL_EXTERN /**/
  89. #endif
  90. PAL_EXTERN unsigned int  palette[1U << 8];     /* input image palette */
  91. PAL_EXTERN unsigned char pmap[1U << (4+4+4)];  /* output image palette map */ /* Flawfinder: ignore */
  92. /*
  93.  * Some palette-related macros
  94.  */
  95. #if BYTE_ORDER == LITTLE_ENDIAN
  96. #define PAL_GET_R(idx)      *((unsigned char *)(palette+idx)+0)
  97. #define PAL_GET_G(idx) *((unsigned char *)(palette+idx)+1)
  98. #define PAL_GET_B(idx)      *((unsigned char *)(palette+idx)+2)
  99. #else /* BYTE_ORDER != LITTLE_ENDIAN */
  100. #define PAL_GET_R(idx)      *((unsigned char *)(palette+idx)+3)
  101. #define PAL_GET_G(idx) *((unsigned char *)(palette+idx)+2)
  102. #define PAL_GET_B(idx)      *((unsigned char *)(palette+idx)+1)
  103. #endif
  104. #define PAL_SET(idx,r,g,b) palette[idx] = (r<<16) | (g<<8) | b
  105. #define PMAP_GET(r,g,b) pmap[(((r)&0xF0)<<4) | ((g)&0xF0) | ((b)>>4)]
  106. #define PMAP_SET(idx,r,g,b) pmap[(((r)&0xF0)<<4) | ((g)&0xF0) | ((b)>>4)] = idx
  107. /*
  108.  * Internal pixel representations.
  109.  * We will use 3 different types of temporary pixel variables
  110.  * based on the following classification:
  111.  *  1. Pixels with power of 2-aligned depth and bit-packed RGB fields:
  112.  *      RGB32,BGR32,RGB565,RGB555,RGB444 - use 1 full register to store RGB fields
  113.  *      (we will use name RGBX for generalized macros dealing
  114.  *       with these formats)
  115.  *  2. Pixels with misaligned depth:
  116.  *      RGB24 - use 3 8-bit registers to store R,G,and B components
  117.  *  3. Paletized pixels:
  118.  *      RGB8 - use 1 full register to store palette index
  119.  */
  120. #define RGBX_PIXEL(a)       register unsigned int a##_rgb
  121. #define RGB32_PIXEL(a)      RGBX_PIXEL(a)
  122. #define BGR32_PIXEL(a)      RGBX_PIXEL(a)
  123. #define RGB24_PIXEL(a)      register unsigned char a##_b, a##_g, a##_r
  124. #define RGB565_PIXEL(a)     RGBX_PIXEL(a)
  125. #define RGB555_PIXEL(a)     RGBX_PIXEL(a)
  126. #define RGB444_PIXEL(a)     RGBX_PIXEL(a)
  127. #define RGB8_PIXEL(a)       register unsigned int a##_idx
  128. /*
  129.  * Generic pixel declaration:
  130.  */
  131. #define PIXEL(f,a)          f##_PIXEL(a)
  132. /*
  133.  * Load/store/copy pixel macros:
  134.  * (s/d - source/destination pointers; sa/da - source/dest. pixel vars)
  135.  */
  136. #define RGBX_LOAD(s,a,t)    a##_rgb=*(t*)(s)
  137. #define RGBX_STORE(d,a,t)   *(t*)(d)=a##_rgb
  138. #define RGBX_COPY(da,sa)    da##_rgb=sa##_rgb
  139. #define RGB32_LOAD(s,a)     RGBX_LOAD(s,a,unsigned int)
  140. #define RGB32_STORE(d,a)    RGBX_STORE(d,a,unsigned int)
  141. #define RGB32_COPY(da,sa)   RGBX_COPY(da,sa)
  142. #define BGR32_LOAD(s,a)     RGBX_LOAD(s,a,unsigned int)
  143. #define BGR32_STORE(d,a)    RGBX_STORE(d,a,unsigned int)
  144. #define BGR32_COPY(da,sa)   RGBX_COPY(da,sa)
  145. #define RGB24_LOAD(s,a)     a##_b=(s)[0], a##_g=(s)[1], a##_r=(s)[2]
  146. #define RGB24_STORE(d,a)    (d)[0]=a##_b, (d)[1]=a##_g, (d)[2]=a##_r
  147. #define RGB24_COPY(da,sa)   da##_b=sa##_b, da##_g=sa##_g, da##_r=sa##_r
  148. #define RGB565_LOAD(s,a)    RGBX_LOAD(s,a,unsigned short)
  149. #define RGB565_STORE(d,a)   RGBX_STORE(d,a,unsigned short)
  150. #define RGB565_COPY(da,sa)  RGBX_COPY(da,sa)
  151. #define RGB555_LOAD(s,a)    RGBX_LOAD(s,a,unsigned short)
  152. #define RGB555_STORE(d,a)   RGBX_STORE(d,a,unsigned short)
  153. #define RGB555_COPY(da,sa)  RGBX_COPY(da,sa)
  154. #define RGB444_LOAD(s,a)    RGBX_LOAD(s,a,unsigned short)
  155. #define RGB444_STORE(d,a)   RGBX_STORE(d,a,unsigned short)
  156. #define RGB444_COPY(da,sa)  RGBX_COPY(da,sa)
  157. #define RGB8_LOAD(s,a)      a##_idx=(s)[0]
  158. #define RGB8_STORE(d,a)     (d)[0]=a##_idx
  159. #define RGB8_COPY(da,sa)    da##_idx=sa##_idx
  160. /*
  161.  * Generic pixel load/store/copy macros:
  162.  */
  163. #define LOAD(f,s,a)         f##_LOAD(s,a)
  164. #define STORE(f,d,a)        f##_STORE(d,a)
  165. #define COPY(f,da,sa)       f##_COPY(da,sa)
  166. /*
  167.  * R,G,B fields bit-packing:
  168.  * (RGB32,BGR32,RGB565,and RGB555 formats only)
  169.  */
  170. #define RGB32_A_START       24
  171. #define RGB32_A_BITS        8
  172. #define RGB32_R_START       16
  173. #define RGB32_R_BITS        8
  174. #define RGB32_G_START       8
  175. #define RGB32_G_BITS        8
  176. #define RGB32_B_START       0
  177. #define RGB32_B_BITS        8
  178. #define BGR32_R_START       0
  179. #define BGR32_R_BITS        8
  180. #define BGR32_G_START       8
  181. #define BGR32_G_BITS        8
  182. #define BGR32_B_START       16
  183. #define BGR32_B_BITS        8
  184. #define RGB565_R_START      11
  185. #define RGB565_R_BITS       5
  186. #define RGB565_G_START      5
  187. #define RGB565_G_BITS       6
  188. #define RGB565_B_START      0
  189. #define RGB565_B_BITS       5
  190. #define RGB555_R_START      10
  191. #define RGB555_R_BITS       5
  192. #define RGB555_G_START      5
  193. #define RGB555_G_BITS       5
  194. #define RGB555_B_START      0
  195. #define RGB555_B_BITS       5
  196. #define RGB444_R_START      8
  197. #define RGB444_R_BITS       4
  198. #define RGB444_G_START      4
  199. #define RGB444_G_BITS       4
  200. #define RGB444_B_START      0
  201. #define RGB444_B_BITS       4
  202. /*
  203.  * Generic bit-packing macros:
  204.  */
  205. #define START(f,x)          f##_##x##_START
  206. #define BITS(f,x)           f##_##x##_BITS
  207. /*
  208.  * Fields extraction/assignment macros.
  209.  *
  210.  * Here we will largely rely on compiler's ability to get rid of
  211.  * unexecuted branches and glue subsequent constant shifts and
  212.  * masks together. This assumption works well for MSVC, Watcom,
  213.  * and Zortech (Symantec) compilers, but some others may fail.
  214.  *
  215.  * If you are using compiler not listed above, please check the
  216.  * assembly output to make sure that the code is well optimized.
  217.  * If the compiler leaves comparisons and multiple shifts/masks
  218.  * in places of RGBX_GET_X() and RGBX_SET(), you would have to
  219.  * reimplement and optimize all these instances manually, using
  220.  * the appropriate pixel/field-type related constants.
  221.  */
  222. #define NORM(s) ((s) & 0x1F) /* shuts compiler up */
  223. #define RGBX_GET_X(f,x,a)   
  224.     ((START(f,x)+BITS(f,x)<8)   
  225.     ? ((a##_rgb << NORM(8-(START(f,x)+BITS(f,x)))) & (0x100-(1U<<(8-BITS(f,x))))) 
  226.     : ((a##_rgb >> NORM((START(f,x)+BITS(f,x))-8)) & (0x100-(1U<<(8-BITS(f,x))))))
  227. #define RGBX_X(f,x,v)       
  228.     ((START(f,x)+BITS(f,x)<8)   
  229.     ? (((v) & (0x100-(1U<<(8-BITS(f,x))))) >> NORM(8-(START(f,x)+BITS(f,x))))   
  230.     : (((v) & (0x100-(1U<<(8-BITS(f,x))))) << NORM((START(f,x)+BITS(f,x))-8)))
  231. #define RGBX_SET(f,a,r,g,b) 
  232.     a##_rgb = RGBX_X(f,R,r) | RGBX_X(f,G,g) | RGBX_X(f,B,b)
  233. #define RGB32_GET_A(a)      RGBX_GET_X(RGB32,A,a)
  234. #define RGB32_GET_R(a)      RGBX_GET_X(RGB32,R,a)
  235. #define RGB32_GET_G(a)      RGBX_GET_X(RGB32,G,a)
  236. #define RGB32_GET_B(a)      RGBX_GET_X(RGB32,B,a)
  237. #define RGB32_SET(a,r,g,b)  RGBX_SET(  RGB32,a,r,g,b)
  238. #define BGR32_GET_R(a)      RGBX_GET_X(BGR32,R,a)
  239. #define BGR32_GET_G(a)      RGBX_GET_X(BGR32,G,a)
  240. #define BGR32_GET_B(a)      RGBX_GET_X(BGR32,B,a)
  241. #define BGR32_SET(a,r,g,b)  RGBX_SET(  BGR32,a,r,g,b)
  242. #define RGB24_GET_R(a)      (a##_r)
  243. #define RGB24_GET_G(a)      (a##_g)
  244. #define RGB24_GET_B(a)      (a##_b)
  245. #define RGB24_SET(a,r,g,b)  a##_b=(b), a##_g=(g), a##_r=(r)
  246. #define RGB565_GET_R(a)     RGBX_GET_X(RGB565,R,a)
  247. #define RGB565_GET_G(a)     RGBX_GET_X(RGB565,G,a)
  248. #define RGB565_GET_B(a)     RGBX_GET_X(RGB565,B,a)
  249. #define RGB565_SET(a,r,g,b) RGBX_SET(  RGB565,a,r,g,b)
  250. #define RGB555_GET_R(a)     RGBX_GET_X(RGB555,R,a)
  251. #define RGB555_GET_G(a)     RGBX_GET_X(RGB555,G,a)
  252. #define RGB555_GET_B(a)     RGBX_GET_X(RGB555,B,a)
  253. #define RGB555_SET(a,r,g,b) RGBX_SET(  RGB555,a,r,g,b)
  254. #define RGB444_GET_R(a)     RGBX_GET_X(RGB444,R,a)
  255. #define RGB444_GET_G(a)     RGBX_GET_X(RGB444,G,a)
  256. #define RGB444_GET_B(a)     RGBX_GET_X(RGB444,B,a)
  257. #define RGB444_SET(a,r,g,b) RGBX_SET(  RGB444,a,r,g,b)
  258. #define RGB8_GET_R(a)       PAL_GET_R(a##_idx)
  259. #define RGB8_GET_G(a)       PAL_GET_G(a##_idx)
  260. #define RGB8_GET_B(a)       PAL_GET_B(a##_idx)
  261. #define RGB8_SET(a,r,g,b)   a##_idx=PMAP_GET(r,g,b)
  262. /*
  263.  * Generic field extraction/assignment macros:
  264.  */
  265. #define GET_A(f,a)          f##_GET_A(a)
  266. #define GET_R(f,a)          f##_GET_R(a)
  267. #define GET_G(f,a)          f##_GET_G(a)
  268. #define GET_B(f,a)          f##_GET_B(a)
  269. #define SET(f,a,r,g,b)      f##_SET(a,r,g,b)
  270. /*
  271.  * Generic pixel-format converter:
  272.  * (sf/sa - source pixel format/name; df/da - dest. pixel format/name)
  273.  */
  274. #define CONVERT(df,da,sf,sa) SET(df,da,GET_R(sf,sa),GET_G(sf,sa),GET_B(sf,sa))
  275. /*
  276.  * Generic pixel load and convert macro:
  277.  */
  278. #define LOAD_CONVERT(df,da,sf,s)            
  279.     /* do we have the same format? */       
  280.     if (ID(df) == ID(sf)) {                 
  281.         /* just load pixel */               
  282.         LOAD(df,s,da);                      
  283.     } else {                                
  284.         /* load & convert pixel: */         
  285.         PIXEL(sf,sa);                       
  286.         LOAD(sf,s,sa);                      
  287.         CONVERT(df,da,sf,sa);               
  288.     }
  289. /*
  290.  * Get the average value of two pixels:
  291.  * (da=(sa+sb)/2)
  292.  */
  293. #define RGBX_AVERAGE(f,da,sa,sb)    
  294.     da##_rgb = (((sa##_rgb^sb##_rgb)>>1)    
  295.         & (((1U<<(START(f,R)+BITS(f,R)-1))-(1U<<START(f,R)))  
  296.           |((1U<<(START(f,G)+BITS(f,G)-1))-(1U<<START(f,G)))  
  297.           |((1U<<(START(f,B)+BITS(f,B)-1))-(1U<<START(f,B)))))
  298.         + (sa##_rgb&sb##_rgb)
  299. #define RGB32_AVERAGE(da,sa,sb) RGBX_AVERAGE(RGB32,da,sa,sb)
  300. #define BGR32_AVERAGE(da,sa,sb) RGBX_AVERAGE(BGR32,da,sa,sb)
  301. #define RGB24_AVERAGE(da,sa,sb) 
  302.     SET(RGB24,da,((GET_R(RGB24,sa)+GET_R(RGB24,sb))>>1),    
  303.                  ((GET_G(RGB24,sa)+GET_G(RGB24,sb))>>1),    
  304.                  ((GET_B(RGB24,sa)+GET_B(RGB24,sb))>>1))
  305. #define RGB565_AVERAGE(da,sa,sb) RGBX_AVERAGE(RGB565,da,sa,sb)
  306. #define RGB555_AVERAGE(da,sa,sb) RGBX_AVERAGE(RGB555,da,sa,sb)
  307. #define RGB444_AVERAGE(da,sa,sb) RGBX_AVERAGE(RGB444,da,sa,sb)
  308. #define RGB8_AVERAGE(da,sa,sb)  
  309.     SET(RGB8,da,((GET_R(RGB8,sa)+GET_R(RGB8,sb))>>1),       
  310.                 ((GET_G(RGB8,sa)+GET_G(RGB8,sb))>>1),       
  311.                 ((GET_B(RGB8,sa)+GET_B(RGB8,sb))>>1))
  312. /*
  313.  * Generic two pixels' average:
  314.  */
  315. #define AVERAGE(f,da,sa,sb) f##_AVERAGE(da,sa,sb)
  316. /*
  317.  * Loads a pixel and averages it with another one:
  318.  * (da = (sa+[s])/2)
  319.  */
  320. #define LOAD_AVERAGE(f,da,sa,s)             
  321.     {                                       
  322.         /* load & convert pixel: */         
  323.         PIXEL(f,sb);                        
  324.         LOAD(f,s,sb);                       
  325.         AVERAGE(f,da,sa,sb);                
  326.     }
  327. #ifdef __cplusplus
  328. }
  329. #endif
  330. #endif /* __RGB_H__ */