rgb.h
上传用户:dangjiwu
上传日期:2013-07-19
资源大小:42019k
文件大小:12k
源码类别:

Symbian

开发平台:

Visual C++

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