source/rice_gles/src/ConvertImage.h

   1 /*
   2 Copyright (C) 2003 Rice1964
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17
  18 */
  19
  20 #ifndef __CONVERTIMAGE_H__
  21 #define __CONVERTIMAGE_H__
  22
  23 #include "typedefs.h"
  24 #include "Texture.h"
  25 #include "TextureManager.h"
  26
  27
  28 static const uint8 OneToEight[2] =
  29 {
  30     0x00,       // 0 -> 00 00 00 00
  31     0xff        // 1 -> 11 11 11 11
  32 };
  33
  34 static const uint8 OneToFour[2] =
  35 {
  36     0x00,       // 0 -> 00 00
  37     0x0f        // 1 -> 11 11
  38 };
  39
  40 static const uint8 TwoToEight[4] =
  41 {
  42     0x00,       // 00 -> 00 00 00 00
  43     0x55,       // 01 -> 01 01 01 01
  44     0xaa,       // 10 -> 10 10 10 10
  45     0xff        // 11 -> 11 11 11 11
  46 };
  47
  48 static const uint8 TwoToFour[4] =
  49 {
  50     0x0,        // 00 -> 00 00
  51     0x5,        // 01 -> 01 01
  52     0xa,        // 10 -> 10 10
  53     0xf         // 11 -> 11 11
  54 };
  55
  56 static const uint8 ThreeToEight[8] =
  57 {
  58     0x00,       // 000 -> 00 00 00 00
  59     0x24,       // 001 -> 00 10 01 00
  60     0x49,       // 010 -> 01 00 10 01
  61     0x6d,       // 011 -> 01 10 11 01
  62     0x92,       // 100 -> 10 01 00 10
  63     0xb6,       // 101 -> 10 11 01 10
  64     0xdb,       // 110 -> 11 01 10 11
  65     0xff        // 111 -> 11 11 11 11
  66 };
  67
  68 static const uint8 ThreeToFour[8] =
  69 {
  70     0x0,        // 000 -> 00 00 00 00
  71     0x2,        // 001 -> 00 10 01 00
  72     0x4,        // 010 -> 01 00 10 01
  73     0x6,        // 011 -> 01 10 11 01
  74     0x9,        // 100 -> 10 01 00 10
  75     0xb,        // 101 -> 10 11 01 10
  76     0xd,        // 110 -> 11 01 10 11
  77     0xf         // 111 -> 11 11 11 11
  78 };
  79
  80 static const uint8 FourToEight[16] =
  81 {
  82     0x00, 0x11, 0x22, 0x33,
  83     0x44, 0x55, 0x66, 0x77,
  84     0x88, 0x99, 0xaa, 0xbb,
  85     0xcc, 0xdd, 0xee, 0xff
  86 };
  87
  88 static const uint16 FourToSixteen[16] =
  89 {
  90     0x0000, 0x1111, 0x2222, 0x3333,
  91     0x4444, 0x5555, 0x6666, 0x7777,
  92     0x8888, 0x9999, 0xaaaa, 0xbbbb,
  93     0xcccc, 0xdddd, 0xeeee, 0xffff
  94 };
  95
  96 static const uint8 FiveToEight[32] =
  97 {
  98     0x00, // 00000 -> 00000000
  99     0x08, // 00001 -> 00001000
 100     0x10, // 00010 -> 00010000
 101     0x18, // 00011 -> 00011000
 102     0x21, // 00100 -> 00100001
 103     0x29, // 00101 -> 00101001
 104     0x31, // 00110 -> 00110001
 105     0x39, // 00111 -> 00111001
 106     0x42, // 01000 -> 01000010
 107     0x4a, // 01001 -> 01001010
 108     0x52, // 01010 -> 01010010
 109     0x5a, // 01011 -> 01011010
 110     0x63, // 01100 -> 01100011
 111     0x6b, // 01101 -> 01101011
 112     0x73, // 01110 -> 01110011
 113     0x7b, // 01111 -> 01111011
 114
 115     0x84, // 10000 -> 10000100
 116     0x8c, // 10001 -> 10001100
 117     0x94, // 10010 -> 10010100
 118     0x9c, // 10011 -> 10011100
 119     0xa5, // 10100 -> 10100101
 120     0xad, // 10101 -> 10101101
 121     0xb5, // 10110 -> 10110101
 122     0xbd, // 10111 -> 10111101
 123     0xc6, // 11000 -> 11000110
 124     0xce, // 11001 -> 11001110
 125     0xd6, // 11010 -> 11010110
 126     0xde, // 11011 -> 11011110
 127     0xe7, // 11100 -> 11100111
 128     0xef, // 11101 -> 11101111
 129     0xf7, // 11110 -> 11110111
 130     0xff  // 11111 -> 11111111
 131 };
 132
 133
 134 #ifdef HAVE_GLES0
 135 #define RGBA5551_BlueMask2   (0xF800)
 136 #define RGBA5551_GreenMask2 (0x07C0)
 137 #define RGBA5551_RedMask2  (0x003E)
 138 #define RGBA5551_AlphaMask2 (0x0001)
 139
 140
 141 #define RGBA5551_BlueShift2   11
 142 #define RGBA5551_GreenShift2 6
 143 #define RGBA5551_RedShift2  1
 144 #define RGBA5551_AlphaShift2 0
 145
 146 #define RGBA565_BlueMask2     (0xF800)
 147 #define RGBA565_GreenMask2   (0x07E0)
 148 #define RGBA565_RedMask2    (0x001F)
 149
 150 #define RGBA565_BlueShift2    11
 151 #define RGBA565_GreenShift2  5
 152 #define RGBA565_RedShift2   0
 153 #else
 154 #define RGBA5551_RedMask2   (0xF800)
 155 #define RGBA5551_GreenMask2 (0x07C0)
 156 #define RGBA5551_BlueMask2  (0x003E)
 157 #define RGBA5551_AlphaMask2 (0x0001)
 158
 159
 160 #define RGBA5551_RedShift2   11
 161 #define RGBA5551_GreenShift2 6
 162 #define RGBA5551_BlueShift2  1
 163 #define RGBA5551_AlphaShift2 0
 164
 165 #define RGBA565_RedMask2     (0xF800)
 166 #define RGBA565_GreenMask2   (0x07E0)
 167 #define RGBA565_BlueMask2    (0x001F)
 168
 169 #define RGBA565_RedShift2    11
 170 #define RGBA565_GreenShift2  5
 171 #define RGBA565_BlueShift2   0
 172 #endif
 173 #define RGBA5551_RedMask   (0xF800)
 174 #define RGBA5551_GreenMask (0x07C0)
 175 #define RGBA5551_BlueMask  (0x003E)
 176 #define RGBA5551_AlphaMask (0x0001)
 177
 178
 179 #define RGBA5551_RedShift   11
 180 #define RGBA5551_GreenShift 6
 181 #define RGBA5551_BlueShift  1
 182 #define RGBA5551_AlphaShift 0
 183
 184 #define RGBA565_RedMask     (0xF800)
 185 #define RGBA565_GreenMask   (0x07E0)
 186 #define RGBA565_BlueMask    (0x001F)
 187
 188 #define RGBA565_RedShift    11
 189 #define RGBA565_GreenShift  5
 190 #define RGBA565_BlueShift   0
 191 inline uint16 ConvertRGBTo555(uint8 red, uint8 grn, uint8 blu)
 192 {
 193     return (uint16)(((uint16)(red >> 3) << RGBA5551_RedShift) |
 194                   ((uint16)(grn >> 3) << RGBA5551_GreenShift) |
 195                   ((uint16)(blu >> 3) << RGBA5551_BlueShift) |
 196                   ((uint16)(1)        << RGBA5551_AlphaShift));
 197 }
 198
 199 inline uint16 ConvertRGBTo565(uint8 red, uint8 grn, uint8 blu)
 200 {
 201     return (uint16)(((uint16)(red >> 3) << RGBA565_RedShift) |
 202                   ((uint16)(grn >> 2) << RGBA565_GreenShift) |
 203                   ((uint16)(blu >> 3) << RGBA565_BlueShift));
 204 }
 205 inline uint16 Convert555To565(uint16 w555)
 206 {
 207     // Probably a faster method by fudging the low bits..
 208
 209     uint8 red = FiveToEight[(w555&RGBA5551_RedMask)  >> RGBA5551_RedShift];
 210     uint8 grn = FiveToEight[(w555&RGBA5551_GreenMask)>> RGBA5551_GreenShift];
 211     uint8 blu = FiveToEight[(w555&RGBA5551_BlueMask) >> RGBA5551_BlueShift];
 212
 213     return ConvertRGBTo565(red, grn, blu);
 214 }
 215
 216 #define R4G4B4A4_MAKE(r,g,b,a)  ((uint16)(((a) << 12) | ((r)<< 8) | ((g)<<4) | (b)))
 217
 218 inline uint32 Convert555ToRGBA(uint16 w555)
 219 {
 220     uint32 dwRed   = FiveToEight[(w555&RGBA5551_RedMask2)  >> RGBA5551_RedShift2];
 221     uint32 dwGreen = FiveToEight[(w555&RGBA5551_GreenMask2)>> RGBA5551_GreenShift2];
 222     uint32 dwBlue  = FiveToEight[(w555&RGBA5551_BlueMask2) >> RGBA5551_BlueShift2];
 223     uint32 dwAlpha =             (w555&RGBA5551_AlphaMask2) ? 0xFF : 0x00;
 224     return COLOR_RGBA(dwRed, dwGreen, dwBlue, dwAlpha);
 225
 226 }
 227 inline uint16 Convert555ToR4G4B4A4(uint16 w555)
 228 {
 229     uint8 dwRed   = ((w555&RGBA5551_RedMask)  >> RGBA5551_RedShift)>>1;
 230     uint8 dwGreen = ((w555&RGBA5551_GreenMask)>> RGBA5551_GreenShift)>>1;
 231     uint8 dwBlue  = ((w555&RGBA5551_BlueMask) >> RGBA5551_BlueShift)>>1;
 232     uint8 dwAlpha =             (w555&RGBA5551_AlphaMask) ? 0xF : 0x0;
 233
 234     return R4G4B4A4_MAKE(dwRed, dwGreen, dwBlue, dwAlpha);
 235 }
 236
 237 inline uint32 ConvertIA4ToRGBA(uint8 IA4)
 238 {
 239     uint32 I = ThreeToEight[(IA4 & 0x0F) >> 1];
 240     uint32 A = OneToEight[(IA4 & 0x01)];
 241     return COLOR_RGBA(I, I, I, A);
 242 }
 243
 244 inline uint16 ConvertIA4ToR4G4B4A4(uint8 IA4)
 245 {
 246     uint32 I = ThreeToFour[(IA4 & 0x0F) >> 1];
 247     uint32 A = OneToFour[(IA4 & 0x01)];
 248     return R4G4B4A4_MAKE(I, I, I, A);
 249 }
 250 inline uint32 ConvertI4ToRGBA(uint8 I4)
 251 {
 252     uint32 I = FourToEight[I4 & 0x0F];
 253     return COLOR_RGBA(I, I, I, I);
 254 }
 255
 256 inline uint16 ConvertI4ToR4G4B4A4(uint8 I4)
 257 {
 258     return FourToSixteen[I4 & 0x0F];
 259 }
 260
 261 inline uint32 ConvertIA16ToRGBA(uint16 wIA)
 262 {
 263     uint32 dwIntensity = (wIA >> 8) & 0xFF;
 264     uint32 dwAlpha     = (wIA     ) & 0xFF;
 265     return COLOR_RGBA(dwIntensity, dwIntensity, dwIntensity, dwAlpha);
 266 }
 267
 268 inline uint16 ConvertIA16ToR4G4B4A4(uint16 wIA)
 269 {
 270     uint16 dwIntensity = (wIA >> 12) & 0x0F;
 271     uint16 dwAlpha     = (wIA >> 4) & 0x0F;
 272
 273     return R4G4B4A4_MAKE(dwIntensity, dwIntensity, dwIntensity, dwAlpha);
 274 }
 275
 276 extern int g_convk0,g_convk1,g_convk2,g_convk3,g_convk4,g_convk5;
 277 extern float g_convc0,g_convc1,g_convc2,g_convc3,g_convc4,g_convc5;
 278
 279 uint32 ConvertYUV16ToR8G8B8(int Y, int U, int V);
 280 uint16 ConvertYUV16ToR4G4B4(int Y, int U, int V);
 281
 282
 283 typedef void    ( * ConvertFunction )( CTexture * p_texture, const TxtrInfo & ti );
 284
 285 void ConvertRGBA16(CTexture *pTexture, const TxtrInfo &tinfo);
 286 void ConvertRGBA32(CTexture *pTexture, const TxtrInfo &tinfo);
 287
 288
 289 void ConvertIA4(CTexture *pTexture, const TxtrInfo &tinfo);
 290 void ConvertIA8(CTexture *pTexture, const TxtrInfo &tinfo);
 291 void ConvertIA16(CTexture *pTexture, const TxtrInfo &tinfo);
 292
 293 void ConvertI4(CTexture *pTexture, const TxtrInfo &tinfo);
 294 void ConvertI8(CTexture *pTexture, const TxtrInfo &tinfo);
 295
 296 void ConvertCI4( CTexture *pTexture, const TxtrInfo & ti );
 297 void ConvertCI8( CTexture *pTexture, const TxtrInfo & ti );
 298
 299 void ConvertCI4_RGBA16(CTexture *pTexture, const TxtrInfo &tinfo);
 300 void ConvertCI4_IA16(CTexture *pTexture, const TxtrInfo &tinfo);
 301 void ConvertCI8_RGBA16(CTexture *pTexture, const TxtrInfo &tinfo);
 302 void ConvertCI8_IA16(CTexture *pTexture, const TxtrInfo &tinfo);
 303
 304 void ConvertYUV(CTexture *pTexture, const TxtrInfo &tinfo);
 305
 306 // 16 a4r4g4b4
 307 void ConvertRGBA16_16(CTexture *pTexture, const TxtrInfo &tinfo);
 308 void ConvertRGBA32_16(CTexture *pTexture, const TxtrInfo &tinfo);
 309
 310
 311 void ConvertIA4_16(CTexture *pTexture, const TxtrInfo &tinfo);
 312 void ConvertIA8_16(CTexture *pTexture, const TxtrInfo &tinfo);
 313 void ConvertIA16_16(CTexture *pTexture, const TxtrInfo &tinfo);
 314
 315 void ConvertI4_16(CTexture *pTexture, const TxtrInfo &tinfo);
 316 void ConvertI8_16(CTexture *pTexture, const TxtrInfo &tinfo);
 317
 318 void ConvertCI4_16( CTexture *pTexture, const TxtrInfo & ti );
 319 void ConvertCI8_16( CTexture *pTexture, const TxtrInfo & ti );
 320
 321 void ConvertCI4_RGBA16_16(CTexture *pTexture, const TxtrInfo &tinfo);
 322 void ConvertCI4_IA16_16(CTexture *pTexture, const TxtrInfo &tinfo);
 323 void ConvertCI8_RGBA16_16(CTexture *pTexture, const TxtrInfo &tinfo);
 324 void ConvertCI8_IA16_16(CTexture *pTexture, const TxtrInfo &tinfo);
 325
 326 void ConvertYUV_16(CTexture *pTexture, const TxtrInfo &tinfo);
 327
 328 void Convert4b(CTexture *pTexture, const TxtrInfo &tinfo);
 329 void Convert8b(CTexture *pTexture, const TxtrInfo &tinfo);
 330 void Convert16b(CTexture *pTexture, const TxtrInfo &tinfo);
 331
 332 void Convert4b_16(CTexture *pTexture, const TxtrInfo &tinfo);
 333 void Convert8b_16(CTexture *pTexture, const TxtrInfo &tinfo);
 334 void Convert16b_16(CTexture *pTexture, const TxtrInfo &tinfo);
 335
 336 #endif
 337