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 #include "../../Graphics/image_convert.h"
28
29 static const uint8_t OneToEight[2] =
30 {
31 0x00, // 0 -> 00 00 00 00
32 0xff // 1 -> 11 11 11 11
33 };
34
35 static const uint8_t OneToFour[2] =
36 {
37 0x00, // 0 -> 00 00
38 0x0f // 1 -> 11 11
39 };
40
41 static const uint8_t TwoToEight[4] =
42 {
43 0x00, // 00 -> 00 00 00 00
44 0x55, // 01 -> 01 01 01 01
45 0xaa, // 10 -> 10 10 10 10
46 0xff // 11 -> 11 11 11 11
47 };
48
49 static const uint8_t TwoToFour[4] =
50 {
51 0x0, // 00 -> 00 00
52 0x5, // 01 -> 01 01
53 0xa, // 10 -> 10 10
54 0xf // 11 -> 11 11
55 };
56
57 static const uint8_t ThreeToEight[8] =
58 {
59 0x00, // 000 -> 00 00 00 00
60 0x24, // 001 -> 00 10 01 00
61 0x49, // 010 -> 01 00 10 01
62 0x6d, // 011 -> 01 10 11 01
63 0x92, // 100 -> 10 01 00 10
64 0xb6, // 101 -> 10 11 01 10
65 0xdb, // 110 -> 11 01 10 11
66 0xff // 111 -> 11 11 11 11
67 };
68
69 static const uint8_t ThreeToFour[8] =
70 {
71 0x0, // 000 -> 00 00 00 00
72 0x2, // 001 -> 00 10 01 00
73 0x4, // 010 -> 01 00 10 01
74 0x6, // 011 -> 01 10 11 01
75 0x9, // 100 -> 10 01 00 10
76 0xb, // 101 -> 10 11 01 10
77 0xd, // 110 -> 11 01 10 11
78 0xf // 111 -> 11 11 11 11
79 };
80
81 static const uint8_t FourToEight[16] =
82 {
83 0x00, 0x11, 0x22, 0x33,
84 0x44, 0x55, 0x66, 0x77,
85 0x88, 0x99, 0xaa, 0xbb,
86 0xcc, 0xdd, 0xee, 0xff
87 };
88
89 static const uint16_t FourToSixteen[16] =
90 {
91 0x0000, 0x1111, 0x2222, 0x3333,
92 0x4444, 0x5555, 0x6666, 0x7777,
93 0x8888, 0x9999, 0xaaaa, 0xbbbb,
94 0xcccc, 0xdddd, 0xeeee, 0xffff
95 };
96
97 static const uint8_t FiveToEight[32] =
98 {
99 0x00, // 00000 -> 00000000
100 0x08, // 00001 -> 00001000
101 0x10, // 00010 -> 00010000
102 0x18, // 00011 -> 00011000
103 0x21, // 00100 -> 00100001
104 0x29, // 00101 -> 00101001
105 0x31, // 00110 -> 00110001
106 0x39, // 00111 -> 00111001
107 0x42, // 01000 -> 01000010
108 0x4a, // 01001 -> 01001010
109 0x52, // 01010 -> 01010010
110 0x5a, // 01011 -> 01011010
111 0x63, // 01100 -> 01100011
112 0x6b, // 01101 -> 01101011
113 0x73, // 01110 -> 01110011
114 0x7b, // 01111 -> 01111011
115
116 0x84, // 10000 -> 10000100
117 0x8c, // 10001 -> 10001100
118 0x94, // 10010 -> 10010100
119 0x9c, // 10011 -> 10011100
120 0xa5, // 10100 -> 10100101
121 0xad, // 10101 -> 10101101
122 0xb5, // 10110 -> 10110101
123 0xbd, // 10111 -> 10111101
124 0xc6, // 11000 -> 11000110
125 0xce, // 11001 -> 11001110
126 0xd6, // 11010 -> 11010110
127 0xde, // 11011 -> 11011110
128 0xe7, // 11100 -> 11100111
129 0xef, // 11101 -> 11101111
130 0xf7, // 11110 -> 11110111
131 0xff // 11111 -> 11111111
132 };
133
134
135 #define RGBA5551_RedMask (0xF800)
136 #define RGBA5551_GreenMask (0x07C0)
137 #define RGBA5551_BlueMask (0x003E)
138 #define RGBA5551_AlphaMask (0x0001)
139
140
141 #define RGBA5551_RedShift 11
142 #define RGBA5551_GreenShift 6
143 #define RGBA5551_BlueShift 1
144 #define RGBA5551_AlphaShift 0
145
146 #define RGBA565_RedMask (0xF800)
147 #define RGBA565_GreenMask (0x07E0)
148 #define RGBA565_BlueMask (0x001F)
149
150 #define RGBA565_RedShift 11
151 #define RGBA565_GreenShift 5
152 #define RGBA565_BlueShift 0
153
Convert555To565(uint16_t w555)154 inline uint16_t Convert555To565(uint16_t w555)
155 {
156 // Probably a faster method by fudging the low bits..
157
158 uint8_t red = FiveToEight[(w555&RGBA5551_RedMask) >> RGBA5551_RedShift];
159 uint8_t grn = FiveToEight[(w555&RGBA5551_GreenMask)>> RGBA5551_GreenShift];
160 uint8_t blu = FiveToEight[(w555&RGBA5551_BlueMask) >> RGBA5551_BlueShift];
161
162 return PAL8toRGB565(red, grn, blu, 0);
163 }
164
Convert555ToRGBA(uint16_t w555)165 inline uint32_t Convert555ToRGBA(uint16_t w555)
166 {
167 uint32_t dwRed = FiveToEight[(w555&RGBA5551_RedMask) >> RGBA5551_RedShift];
168 uint32_t dwGreen = FiveToEight[(w555&RGBA5551_GreenMask)>> RGBA5551_GreenShift];
169 uint32_t dwBlue = FiveToEight[(w555&RGBA5551_BlueMask) >> RGBA5551_BlueShift];
170 uint32_t dwAlpha = (w555&RGBA5551_AlphaMask) ? 0xFF : 0x00;
171 return COLOR_RGBA(dwRed, dwGreen, dwBlue, dwAlpha);
172
173 }
Convert555ToR4G4B4A4(uint16_t w555)174 inline uint16_t Convert555ToR4G4B4A4(uint16_t w555)
175 {
176 uint8_t dwRed = ((w555&RGBA5551_RedMask) >> RGBA5551_RedShift)>>1;
177 uint8_t dwGreen = ((w555&RGBA5551_GreenMask)>> RGBA5551_GreenShift)>>1;
178 uint8_t dwBlue = ((w555&RGBA5551_BlueMask) >> RGBA5551_BlueShift)>>1;
179 uint8_t dwAlpha = (w555&RGBA5551_AlphaMask) ? 0xF : 0x0;
180
181 return PAL8toR4G4B4A4(dwRed, dwGreen, dwBlue, dwAlpha);
182 }
183
ConvertIA4ToRGBA(uint8_t IA4)184 inline uint32_t ConvertIA4ToRGBA(uint8_t IA4)
185 {
186 uint32_t I = ThreeToEight[(IA4 & 0x0F) >> 1];
187 uint32_t A = OneToEight[(IA4 & 0x01)];
188 return COLOR_RGBA(I, I, I, A);
189 }
190
ConvertIA4ToR4G4B4A4(uint8_t IA4)191 inline uint16_t ConvertIA4ToR4G4B4A4(uint8_t IA4)
192 {
193 uint32_t I = ThreeToFour[(IA4 & 0x0F) >> 1];
194 uint32_t A = OneToFour[(IA4 & 0x01)];
195 return PAL8toR4G4B4A4(I, I, I, A);
196 }
ConvertI4ToRGBA(uint8_t I4)197 inline uint32_t ConvertI4ToRGBA(uint8_t I4)
198 {
199 uint32_t I = FourToEight[I4 & 0x0F];
200 return COLOR_RGBA(I, I, I, I);
201 }
202
ConvertI4ToR4G4B4A4(uint8_t I4)203 inline uint16_t ConvertI4ToR4G4B4A4(uint8_t I4)
204 {
205 return FourToSixteen[I4 & 0x0F];
206 }
207
ConvertIA16ToRGBA(uint16_t wIA)208 inline uint32_t ConvertIA16ToRGBA(uint16_t wIA)
209 {
210 uint32_t dwIntensity = (wIA >> 8) & 0xFF;
211 uint32_t dwAlpha = (wIA ) & 0xFF;
212 return COLOR_RGBA(dwIntensity, dwIntensity, dwIntensity, dwAlpha);
213 }
214
ConvertIA16ToR4G4B4A4(uint16_t wIA)215 inline uint16_t ConvertIA16ToR4G4B4A4(uint16_t wIA)
216 {
217 uint16_t dwIntensity = (wIA >> 12) & 0x0F;
218 uint16_t dwAlpha = (wIA >> 4) & 0x0F;
219
220 return PAL8toR4G4B4A4(dwIntensity, dwIntensity, dwIntensity, dwAlpha);
221 }
222
223 extern int g_convk0,g_convk1,g_convk2,g_convk3,g_convk4,g_convk5;
224 extern float g_convc0,g_convc1,g_convc2,g_convc3,g_convc4,g_convc5;
225
226 uint32_t ConvertYUV16ToR8G8B8(int Y, int U, int V);
227 uint16_t ConvertYUV16ToR4G4B4(int Y, int U, int V);
228
229
230 typedef void ( * ConvertFunction )( CTexture * p_texture, const TxtrInfo & ti );
231
232 void ConvertRGBA16(CTexture *pTexture, const TxtrInfo &tinfo);
233 void ConvertRGBA32(CTexture *pTexture, const TxtrInfo &tinfo);
234
235
236 void ConvertIA4(CTexture *pTexture, const TxtrInfo &tinfo);
237 void ConvertIA8(CTexture *pTexture, const TxtrInfo &tinfo);
238 void ConvertIA16(CTexture *pTexture, const TxtrInfo &tinfo);
239
240 void ConvertI4(CTexture *pTexture, const TxtrInfo &tinfo);
241 void ConvertI8(CTexture *pTexture, const TxtrInfo &tinfo);
242
243 void ConvertCI4( CTexture *pTexture, const TxtrInfo & ti );
244 void ConvertCI8( CTexture *pTexture, const TxtrInfo & ti );
245
246 void ConvertCI4_RGBA16(CTexture *pTexture, const TxtrInfo &tinfo);
247 void ConvertCI4_IA16(CTexture *pTexture, const TxtrInfo &tinfo);
248 void ConvertCI8_RGBA16(CTexture *pTexture, const TxtrInfo &tinfo);
249 void ConvertCI8_IA16(CTexture *pTexture, const TxtrInfo &tinfo);
250
251 void ConvertYUV(CTexture *pTexture, const TxtrInfo &tinfo);
252
253 // 16 a4r4g4b4
254 void ConvertRGBA16_16(CTexture *pTexture, const TxtrInfo &tinfo);
255 void ConvertRGBA32_16(CTexture *pTexture, const TxtrInfo &tinfo);
256
257
258 void ConvertIA4_16(CTexture *pTexture, const TxtrInfo &tinfo);
259 void ConvertIA8_16(CTexture *pTexture, const TxtrInfo &tinfo);
260 void ConvertIA16_16(CTexture *pTexture, const TxtrInfo &tinfo);
261
262 void ConvertI4_16(CTexture *pTexture, const TxtrInfo &tinfo);
263 void ConvertI8_16(CTexture *pTexture, const TxtrInfo &tinfo);
264
265 void ConvertCI4_16( CTexture *pTexture, const TxtrInfo & ti );
266 void ConvertCI8_16( CTexture *pTexture, const TxtrInfo & ti );
267
268 void ConvertCI4_RGBA16_16(CTexture *pTexture, const TxtrInfo &tinfo);
269 void ConvertCI4_IA16_16(CTexture *pTexture, const TxtrInfo &tinfo);
270 void ConvertCI8_RGBA16_16(CTexture *pTexture, const TxtrInfo &tinfo);
271 void ConvertCI8_IA16_16(CTexture *pTexture, const TxtrInfo &tinfo);
272
273 void ConvertYUV_16(CTexture *pTexture, const TxtrInfo &tinfo);
274
275 void Convert4b(CTexture *pTexture, const TxtrInfo &tinfo);
276 void Convert8b(CTexture *pTexture, const TxtrInfo &tinfo);
277 void Convert16b(CTexture *pTexture, const TxtrInfo &tinfo);
278
279 void Convert4b_16(CTexture *pTexture, const TxtrInfo &tinfo);
280 void Convert8b_16(CTexture *pTexture, const TxtrInfo &tinfo);
281 void Convert16b_16(CTexture *pTexture, const TxtrInfo &tinfo);
282
283 #endif
284
285