diff options
author | David Walter Seikel | 2013-01-13 18:54:10 +1000 |
---|---|---|
committer | David Walter Seikel | 2013-01-13 18:54:10 +1000 |
commit | 959831f4ef5a3e797f576c3de08cd65032c997ad (patch) | |
tree | e7351908be5995f0b325b2ebeaa02d5a34b82583 /libraries/irrlicht-1.8/source/Irrlicht/CColorConverter.cpp | |
parent | Add info about changes to Irrlicht. (diff) | |
download | SledjHamr-959831f4ef5a3e797f576c3de08cd65032c997ad.zip SledjHamr-959831f4ef5a3e797f576c3de08cd65032c997ad.tar.gz SledjHamr-959831f4ef5a3e797f576c3de08cd65032c997ad.tar.bz2 SledjHamr-959831f4ef5a3e797f576c3de08cd65032c997ad.tar.xz |
Remove damned ancient DOS line endings from Irrlicht. Hopefully I did not go overboard.
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/CColorConverter.cpp')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/CColorConverter.cpp | 1410 |
1 files changed, 705 insertions, 705 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/CColorConverter.cpp b/libraries/irrlicht-1.8/source/Irrlicht/CColorConverter.cpp index abc2c33..e9aad7a 100644 --- a/libraries/irrlicht-1.8/source/Irrlicht/CColorConverter.cpp +++ b/libraries/irrlicht-1.8/source/Irrlicht/CColorConverter.cpp | |||
@@ -1,705 +1,705 @@ | |||
1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt | 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt |
2 | // This file is part of the "Irrlicht Engine". | 2 | // This file is part of the "Irrlicht Engine". |
3 | // For conditions of distribution and use, see copyright notice in irrlicht.h | 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h |
4 | 4 | ||
5 | #include "CColorConverter.h" | 5 | #include "CColorConverter.h" |
6 | #include "SColor.h" | 6 | #include "SColor.h" |
7 | #include "os.h" | 7 | #include "os.h" |
8 | #include "irrString.h" | 8 | #include "irrString.h" |
9 | 9 | ||
10 | namespace irr | 10 | namespace irr |
11 | { | 11 | { |
12 | namespace video | 12 | namespace video |
13 | { | 13 | { |
14 | 14 | ||
15 | //! converts a monochrome bitmap to A1R5G5B5 data | 15 | //! converts a monochrome bitmap to A1R5G5B5 data |
16 | void CColorConverter::convert1BitTo16Bit(const u8* in, s16* out, s32 width, s32 height, s32 linepad, bool flip) | 16 | void CColorConverter::convert1BitTo16Bit(const u8* in, s16* out, s32 width, s32 height, s32 linepad, bool flip) |
17 | { | 17 | { |
18 | if (!in || !out) | 18 | if (!in || !out) |
19 | return; | 19 | return; |
20 | 20 | ||
21 | if (flip) | 21 | if (flip) |
22 | out += width * height; | 22 | out += width * height; |
23 | 23 | ||
24 | for (s32 y=0; y<height; ++y) | 24 | for (s32 y=0; y<height; ++y) |
25 | { | 25 | { |
26 | s32 shift = 7; | 26 | s32 shift = 7; |
27 | if (flip) | 27 | if (flip) |
28 | out -= width; | 28 | out -= width; |
29 | 29 | ||
30 | for (s32 x=0; x<width; ++x) | 30 | for (s32 x=0; x<width; ++x) |
31 | { | 31 | { |
32 | out[x] = *in>>shift & 0x01 ? (s16)0xffff : (s16)0x8000; | 32 | out[x] = *in>>shift & 0x01 ? (s16)0xffff : (s16)0x8000; |
33 | 33 | ||
34 | if ((--shift)<0) // 8 pixel done | 34 | if ((--shift)<0) // 8 pixel done |
35 | { | 35 | { |
36 | shift=7; | 36 | shift=7; |
37 | ++in; | 37 | ++in; |
38 | } | 38 | } |
39 | } | 39 | } |
40 | 40 | ||
41 | if (shift != 7) // width did not fill last byte | 41 | if (shift != 7) // width did not fill last byte |
42 | ++in; | 42 | ++in; |
43 | 43 | ||
44 | if (!flip) | 44 | if (!flip) |
45 | out += width; | 45 | out += width; |
46 | in += linepad; | 46 | in += linepad; |
47 | } | 47 | } |
48 | } | 48 | } |
49 | 49 | ||
50 | 50 | ||
51 | 51 | ||
52 | //! converts a 4 bit palettized image to A1R5G5B5 | 52 | //! converts a 4 bit palettized image to A1R5G5B5 |
53 | void CColorConverter::convert4BitTo16Bit(const u8* in, s16* out, s32 width, s32 height, const s32* palette, s32 linepad, bool flip) | 53 | void CColorConverter::convert4BitTo16Bit(const u8* in, s16* out, s32 width, s32 height, const s32* palette, s32 linepad, bool flip) |
54 | { | 54 | { |
55 | if (!in || !out || !palette) | 55 | if (!in || !out || !palette) |
56 | return; | 56 | return; |
57 | 57 | ||
58 | if (flip) | 58 | if (flip) |
59 | out += width*height; | 59 | out += width*height; |
60 | 60 | ||
61 | for (s32 y=0; y<height; ++y) | 61 | for (s32 y=0; y<height; ++y) |
62 | { | 62 | { |
63 | s32 shift = 4; | 63 | s32 shift = 4; |
64 | if (flip) | 64 | if (flip) |
65 | out -= width; | 65 | out -= width; |
66 | 66 | ||
67 | for (s32 x=0; x<width; ++x) | 67 | for (s32 x=0; x<width; ++x) |
68 | { | 68 | { |
69 | out[x] = X8R8G8B8toA1R5G5B5(palette[(u8)((*in >> shift) & 0xf)]); | 69 | out[x] = X8R8G8B8toA1R5G5B5(palette[(u8)((*in >> shift) & 0xf)]); |
70 | 70 | ||
71 | if (shift==0) | 71 | if (shift==0) |
72 | { | 72 | { |
73 | shift = 4; | 73 | shift = 4; |
74 | ++in; | 74 | ++in; |
75 | } | 75 | } |
76 | else | 76 | else |
77 | shift = 0; | 77 | shift = 0; |
78 | } | 78 | } |
79 | 79 | ||
80 | if (shift == 0) // odd width | 80 | if (shift == 0) // odd width |
81 | ++in; | 81 | ++in; |
82 | 82 | ||
83 | if (!flip) | 83 | if (!flip) |
84 | out += width; | 84 | out += width; |
85 | in += linepad; | 85 | in += linepad; |
86 | } | 86 | } |
87 | } | 87 | } |
88 | 88 | ||
89 | 89 | ||
90 | 90 | ||
91 | //! converts a 8 bit palettized image into A1R5G5B5 | 91 | //! converts a 8 bit palettized image into A1R5G5B5 |
92 | void CColorConverter::convert8BitTo16Bit(const u8* in, s16* out, s32 width, s32 height, const s32* palette, s32 linepad, bool flip) | 92 | void CColorConverter::convert8BitTo16Bit(const u8* in, s16* out, s32 width, s32 height, const s32* palette, s32 linepad, bool flip) |
93 | { | 93 | { |
94 | if (!in || !out || !palette) | 94 | if (!in || !out || !palette) |
95 | return; | 95 | return; |
96 | 96 | ||
97 | if (flip) | 97 | if (flip) |
98 | out += width * height; | 98 | out += width * height; |
99 | 99 | ||
100 | for (s32 y=0; y<height; ++y) | 100 | for (s32 y=0; y<height; ++y) |
101 | { | 101 | { |
102 | if (flip) | 102 | if (flip) |
103 | out -= width; // one line back | 103 | out -= width; // one line back |
104 | for (s32 x=0; x<width; ++x) | 104 | for (s32 x=0; x<width; ++x) |
105 | { | 105 | { |
106 | out[x] = X8R8G8B8toA1R5G5B5(palette[(u8)(*in)]); | 106 | out[x] = X8R8G8B8toA1R5G5B5(palette[(u8)(*in)]); |
107 | ++in; | 107 | ++in; |
108 | } | 108 | } |
109 | if (!flip) | 109 | if (!flip) |
110 | out += width; | 110 | out += width; |
111 | in += linepad; | 111 | in += linepad; |
112 | } | 112 | } |
113 | } | 113 | } |
114 | 114 | ||
115 | //! converts a 8 bit palettized or non palettized image (A8) into R8G8B8 | 115 | //! converts a 8 bit palettized or non palettized image (A8) into R8G8B8 |
116 | void CColorConverter::convert8BitTo24Bit(const u8* in, u8* out, s32 width, s32 height, const u8* palette, s32 linepad, bool flip) | 116 | void CColorConverter::convert8BitTo24Bit(const u8* in, u8* out, s32 width, s32 height, const u8* palette, s32 linepad, bool flip) |
117 | { | 117 | { |
118 | if (!in || !out ) | 118 | if (!in || !out ) |
119 | return; | 119 | return; |
120 | 120 | ||
121 | const s32 lineWidth = 3 * width; | 121 | const s32 lineWidth = 3 * width; |
122 | if (flip) | 122 | if (flip) |
123 | out += lineWidth * height; | 123 | out += lineWidth * height; |
124 | 124 | ||
125 | for (s32 y=0; y<height; ++y) | 125 | for (s32 y=0; y<height; ++y) |
126 | { | 126 | { |
127 | if (flip) | 127 | if (flip) |
128 | out -= lineWidth; // one line back | 128 | out -= lineWidth; // one line back |
129 | for (s32 x=0; x< lineWidth; x += 3) | 129 | for (s32 x=0; x< lineWidth; x += 3) |
130 | { | 130 | { |
131 | if ( palette ) | 131 | if ( palette ) |
132 | { | 132 | { |
133 | #ifdef __BIG_ENDIAN__ | 133 | #ifdef __BIG_ENDIAN__ |
134 | out[x+0] = palette[ (in[0] << 2 ) + 0]; | 134 | out[x+0] = palette[ (in[0] << 2 ) + 0]; |
135 | out[x+1] = palette[ (in[0] << 2 ) + 1]; | 135 | out[x+1] = palette[ (in[0] << 2 ) + 1]; |
136 | out[x+2] = palette[ (in[0] << 2 ) + 2]; | 136 | out[x+2] = palette[ (in[0] << 2 ) + 2]; |
137 | #else | 137 | #else |
138 | out[x+0] = palette[ (in[0] << 2 ) + 2]; | 138 | out[x+0] = palette[ (in[0] << 2 ) + 2]; |
139 | out[x+1] = palette[ (in[0] << 2 ) + 1]; | 139 | out[x+1] = palette[ (in[0] << 2 ) + 1]; |
140 | out[x+2] = palette[ (in[0] << 2 ) + 0]; | 140 | out[x+2] = palette[ (in[0] << 2 ) + 0]; |
141 | #endif | 141 | #endif |
142 | } | 142 | } |
143 | else | 143 | else |
144 | { | 144 | { |
145 | out[x+0] = in[0]; | 145 | out[x+0] = in[0]; |
146 | out[x+1] = in[0]; | 146 | out[x+1] = in[0]; |
147 | out[x+2] = in[0]; | 147 | out[x+2] = in[0]; |
148 | } | 148 | } |
149 | ++in; | 149 | ++in; |
150 | } | 150 | } |
151 | if (!flip) | 151 | if (!flip) |
152 | out += lineWidth; | 152 | out += lineWidth; |
153 | in += linepad; | 153 | in += linepad; |
154 | } | 154 | } |
155 | } | 155 | } |
156 | 156 | ||
157 | //! converts a 8 bit palettized or non palettized image (A8) into R8G8B8 | 157 | //! converts a 8 bit palettized or non palettized image (A8) into R8G8B8 |
158 | void CColorConverter::convert8BitTo32Bit(const u8* in, u8* out, s32 width, s32 height, const u8* palette, s32 linepad, bool flip) | 158 | void CColorConverter::convert8BitTo32Bit(const u8* in, u8* out, s32 width, s32 height, const u8* palette, s32 linepad, bool flip) |
159 | { | 159 | { |
160 | if (!in || !out ) | 160 | if (!in || !out ) |
161 | return; | 161 | return; |
162 | 162 | ||
163 | const u32 lineWidth = 4 * width; | 163 | const u32 lineWidth = 4 * width; |
164 | if (flip) | 164 | if (flip) |
165 | out += lineWidth * height; | 165 | out += lineWidth * height; |
166 | 166 | ||
167 | u32 x; | 167 | u32 x; |
168 | register u32 c; | 168 | register u32 c; |
169 | for (u32 y=0; y < (u32) height; ++y) | 169 | for (u32 y=0; y < (u32) height; ++y) |
170 | { | 170 | { |
171 | if (flip) | 171 | if (flip) |
172 | out -= lineWidth; // one line back | 172 | out -= lineWidth; // one line back |
173 | 173 | ||
174 | if ( palette ) | 174 | if ( palette ) |
175 | { | 175 | { |
176 | for (x=0; x < (u32) width; x += 1) | 176 | for (x=0; x < (u32) width; x += 1) |
177 | { | 177 | { |
178 | c = in[x]; | 178 | c = in[x]; |
179 | ((u32*)out)[x] = ((u32*)palette)[ c ]; | 179 | ((u32*)out)[x] = ((u32*)palette)[ c ]; |
180 | } | 180 | } |
181 | } | 181 | } |
182 | else | 182 | else |
183 | { | 183 | { |
184 | for (x=0; x < (u32) width; x += 1) | 184 | for (x=0; x < (u32) width; x += 1) |
185 | { | 185 | { |
186 | c = in[x]; | 186 | c = in[x]; |
187 | #ifdef __BIG_ENDIAN__ | 187 | #ifdef __BIG_ENDIAN__ |
188 | ((u32*)out)[x] = c << 24 | c << 16 | c << 8 | 0x000000FF; | 188 | ((u32*)out)[x] = c << 24 | c << 16 | c << 8 | 0x000000FF; |
189 | #else | 189 | #else |
190 | ((u32*)out)[x] = 0xFF000000 | c << 16 | c << 8 | c; | 190 | ((u32*)out)[x] = 0xFF000000 | c << 16 | c << 8 | c; |
191 | #endif | 191 | #endif |
192 | } | 192 | } |
193 | 193 | ||
194 | } | 194 | } |
195 | 195 | ||
196 | if (!flip) | 196 | if (!flip) |
197 | out += lineWidth; | 197 | out += lineWidth; |
198 | in += width + linepad; | 198 | in += width + linepad; |
199 | } | 199 | } |
200 | } | 200 | } |
201 | 201 | ||
202 | 202 | ||
203 | 203 | ||
204 | //! converts 16bit data to 16bit data | 204 | //! converts 16bit data to 16bit data |
205 | void CColorConverter::convert16BitTo16Bit(const s16* in, s16* out, s32 width, s32 height, s32 linepad, bool flip) | 205 | void CColorConverter::convert16BitTo16Bit(const s16* in, s16* out, s32 width, s32 height, s32 linepad, bool flip) |
206 | { | 206 | { |
207 | if (!in || !out) | 207 | if (!in || !out) |
208 | return; | 208 | return; |
209 | 209 | ||
210 | if (flip) | 210 | if (flip) |
211 | out += width * height; | 211 | out += width * height; |
212 | 212 | ||
213 | for (s32 y=0; y<height; ++y) | 213 | for (s32 y=0; y<height; ++y) |
214 | { | 214 | { |
215 | if (flip) | 215 | if (flip) |
216 | out -= width; | 216 | out -= width; |
217 | #ifdef __BIG_ENDIAN__ | 217 | #ifdef __BIG_ENDIAN__ |
218 | for (s32 x=0; x<width; ++x) | 218 | for (s32 x=0; x<width; ++x) |
219 | out[x]=os::Byteswap::byteswap(in[x]); | 219 | out[x]=os::Byteswap::byteswap(in[x]); |
220 | #else | 220 | #else |
221 | memcpy(out, in, width*sizeof(s16)); | 221 | memcpy(out, in, width*sizeof(s16)); |
222 | #endif | 222 | #endif |
223 | if (!flip) | 223 | if (!flip) |
224 | out += width; | 224 | out += width; |
225 | in += width; | 225 | in += width; |
226 | in += linepad; | 226 | in += linepad; |
227 | } | 227 | } |
228 | } | 228 | } |
229 | 229 | ||
230 | 230 | ||
231 | 231 | ||
232 | //! copies R8G8B8 24bit data to 24bit data | 232 | //! copies R8G8B8 24bit data to 24bit data |
233 | void CColorConverter::convert24BitTo24Bit(const u8* in, u8* out, s32 width, s32 height, s32 linepad, bool flip, bool bgr) | 233 | void CColorConverter::convert24BitTo24Bit(const u8* in, u8* out, s32 width, s32 height, s32 linepad, bool flip, bool bgr) |
234 | { | 234 | { |
235 | if (!in || !out) | 235 | if (!in || !out) |
236 | return; | 236 | return; |
237 | 237 | ||
238 | const s32 lineWidth = 3 * width; | 238 | const s32 lineWidth = 3 * width; |
239 | if (flip) | 239 | if (flip) |
240 | out += lineWidth * height; | 240 | out += lineWidth * height; |
241 | 241 | ||
242 | for (s32 y=0; y<height; ++y) | 242 | for (s32 y=0; y<height; ++y) |
243 | { | 243 | { |
244 | if (flip) | 244 | if (flip) |
245 | out -= lineWidth; | 245 | out -= lineWidth; |
246 | if (bgr) | 246 | if (bgr) |
247 | { | 247 | { |
248 | for (s32 x=0; x<lineWidth; x+=3) | 248 | for (s32 x=0; x<lineWidth; x+=3) |
249 | { | 249 | { |
250 | out[x+0] = in[x+2]; | 250 | out[x+0] = in[x+2]; |
251 | out[x+1] = in[x+1]; | 251 | out[x+1] = in[x+1]; |
252 | out[x+2] = in[x+0]; | 252 | out[x+2] = in[x+0]; |
253 | } | 253 | } |
254 | } | 254 | } |
255 | else | 255 | else |
256 | { | 256 | { |
257 | memcpy(out,in,lineWidth); | 257 | memcpy(out,in,lineWidth); |
258 | } | 258 | } |
259 | if (!flip) | 259 | if (!flip) |
260 | out += lineWidth; | 260 | out += lineWidth; |
261 | in += lineWidth; | 261 | in += lineWidth; |
262 | in += linepad; | 262 | in += linepad; |
263 | } | 263 | } |
264 | } | 264 | } |
265 | 265 | ||
266 | 266 | ||
267 | 267 | ||
268 | //! Resizes the surface to a new size and converts it at the same time | 268 | //! Resizes the surface to a new size and converts it at the same time |
269 | //! to an A8R8G8B8 format, returning the pointer to the new buffer. | 269 | //! to an A8R8G8B8 format, returning the pointer to the new buffer. |
270 | void CColorConverter::convert16bitToA8R8G8B8andResize(const s16* in, s32* out, s32 newWidth, s32 newHeight, s32 currentWidth, s32 currentHeight) | 270 | void CColorConverter::convert16bitToA8R8G8B8andResize(const s16* in, s32* out, s32 newWidth, s32 newHeight, s32 currentWidth, s32 currentHeight) |
271 | { | 271 | { |
272 | if (!newWidth || !newHeight) | 272 | if (!newWidth || !newHeight) |
273 | return; | 273 | return; |
274 | 274 | ||
275 | // note: this is very very slow. (i didn't want to write a fast version. | 275 | // note: this is very very slow. (i didn't want to write a fast version. |
276 | // but hopefully, nobody wants to convert surfaces every frame. | 276 | // but hopefully, nobody wants to convert surfaces every frame. |
277 | 277 | ||
278 | f32 sourceXStep = (f32)currentWidth / (f32)newWidth; | 278 | f32 sourceXStep = (f32)currentWidth / (f32)newWidth; |
279 | f32 sourceYStep = (f32)currentHeight / (f32)newHeight; | 279 | f32 sourceYStep = (f32)currentHeight / (f32)newHeight; |
280 | f32 sy; | 280 | f32 sy; |
281 | s32 t; | 281 | s32 t; |
282 | 282 | ||
283 | for (s32 x=0; x<newWidth; ++x) | 283 | for (s32 x=0; x<newWidth; ++x) |
284 | { | 284 | { |
285 | sy = 0.0f; | 285 | sy = 0.0f; |
286 | 286 | ||
287 | for (s32 y=0; y<newHeight; ++y) | 287 | for (s32 y=0; y<newHeight; ++y) |
288 | { | 288 | { |
289 | t = in[(s32)(((s32)sy)*currentWidth + x*sourceXStep)]; | 289 | t = in[(s32)(((s32)sy)*currentWidth + x*sourceXStep)]; |
290 | t = (((t >> 15)&0x1)<<31) | (((t >> 10)&0x1F)<<19) | | 290 | t = (((t >> 15)&0x1)<<31) | (((t >> 10)&0x1F)<<19) | |
291 | (((t >> 5)&0x1F)<<11) | (t&0x1F)<<3; | 291 | (((t >> 5)&0x1F)<<11) | (t&0x1F)<<3; |
292 | out[(s32)(y*newWidth + x)] = t; | 292 | out[(s32)(y*newWidth + x)] = t; |
293 | 293 | ||
294 | sy+=sourceYStep; | 294 | sy+=sourceYStep; |
295 | } | 295 | } |
296 | } | 296 | } |
297 | } | 297 | } |
298 | 298 | ||
299 | 299 | ||
300 | 300 | ||
301 | //! copies X8R8G8B8 32 bit data | 301 | //! copies X8R8G8B8 32 bit data |
302 | void CColorConverter::convert32BitTo32Bit(const s32* in, s32* out, s32 width, s32 height, s32 linepad, bool flip) | 302 | void CColorConverter::convert32BitTo32Bit(const s32* in, s32* out, s32 width, s32 height, s32 linepad, bool flip) |
303 | { | 303 | { |
304 | if (!in || !out) | 304 | if (!in || !out) |
305 | return; | 305 | return; |
306 | 306 | ||
307 | if (flip) | 307 | if (flip) |
308 | out += width * height; | 308 | out += width * height; |
309 | 309 | ||
310 | for (s32 y=0; y<height; ++y) | 310 | for (s32 y=0; y<height; ++y) |
311 | { | 311 | { |
312 | if (flip) | 312 | if (flip) |
313 | out -= width; | 313 | out -= width; |
314 | #ifdef __BIG_ENDIAN__ | 314 | #ifdef __BIG_ENDIAN__ |
315 | for (s32 x=0; x<width; ++x) | 315 | for (s32 x=0; x<width; ++x) |
316 | out[x]=os::Byteswap::byteswap(in[x]); | 316 | out[x]=os::Byteswap::byteswap(in[x]); |
317 | #else | 317 | #else |
318 | memcpy(out, in, width*sizeof(s32)); | 318 | memcpy(out, in, width*sizeof(s32)); |
319 | #endif | 319 | #endif |
320 | if (!flip) | 320 | if (!flip) |
321 | out += width; | 321 | out += width; |
322 | in += width; | 322 | in += width; |
323 | in += linepad; | 323 | in += linepad; |
324 | } | 324 | } |
325 | } | 325 | } |
326 | 326 | ||
327 | 327 | ||
328 | 328 | ||
329 | void CColorConverter::convert_A1R5G5B5toR8G8B8(const void* sP, s32 sN, void* dP) | 329 | void CColorConverter::convert_A1R5G5B5toR8G8B8(const void* sP, s32 sN, void* dP) |
330 | { | 330 | { |
331 | u16* sB = (u16*)sP; | 331 | u16* sB = (u16*)sP; |
332 | u8 * dB = (u8 *)dP; | 332 | u8 * dB = (u8 *)dP; |
333 | 333 | ||
334 | for (s32 x = 0; x < sN; ++x) | 334 | for (s32 x = 0; x < sN; ++x) |
335 | { | 335 | { |
336 | dB[2] = (*sB & 0x7c00) >> 7; | 336 | dB[2] = (*sB & 0x7c00) >> 7; |
337 | dB[1] = (*sB & 0x03e0) >> 2; | 337 | dB[1] = (*sB & 0x03e0) >> 2; |
338 | dB[0] = (*sB & 0x1f) << 3; | 338 | dB[0] = (*sB & 0x1f) << 3; |
339 | 339 | ||
340 | sB += 1; | 340 | sB += 1; |
341 | dB += 3; | 341 | dB += 3; |
342 | } | 342 | } |
343 | } | 343 | } |
344 | 344 | ||
345 | void CColorConverter::convert_A1R5G5B5toB8G8R8(const void* sP, s32 sN, void* dP) | 345 | void CColorConverter::convert_A1R5G5B5toB8G8R8(const void* sP, s32 sN, void* dP) |
346 | { | 346 | { |
347 | u16* sB = (u16*)sP; | 347 | u16* sB = (u16*)sP; |
348 | u8 * dB = (u8 *)dP; | 348 | u8 * dB = (u8 *)dP; |
349 | 349 | ||
350 | for (s32 x = 0; x < sN; ++x) | 350 | for (s32 x = 0; x < sN; ++x) |
351 | { | 351 | { |
352 | dB[0] = (*sB & 0x7c00) >> 7; | 352 | dB[0] = (*sB & 0x7c00) >> 7; |
353 | dB[1] = (*sB & 0x03e0) >> 2; | 353 | dB[1] = (*sB & 0x03e0) >> 2; |
354 | dB[2] = (*sB & 0x1f) << 3; | 354 | dB[2] = (*sB & 0x1f) << 3; |
355 | 355 | ||
356 | sB += 1; | 356 | sB += 1; |
357 | dB += 3; | 357 | dB += 3; |
358 | } | 358 | } |
359 | } | 359 | } |
360 | 360 | ||
361 | void CColorConverter::convert_A1R5G5B5toA8R8G8B8(const void* sP, s32 sN, void* dP) | 361 | void CColorConverter::convert_A1R5G5B5toA8R8G8B8(const void* sP, s32 sN, void* dP) |
362 | { | 362 | { |
363 | u16* sB = (u16*)sP; | 363 | u16* sB = (u16*)sP; |
364 | u32* dB = (u32*)dP; | 364 | u32* dB = (u32*)dP; |
365 | 365 | ||
366 | for (s32 x = 0; x < sN; ++x) | 366 | for (s32 x = 0; x < sN; ++x) |
367 | *dB++ = A1R5G5B5toA8R8G8B8(*sB++); | 367 | *dB++ = A1R5G5B5toA8R8G8B8(*sB++); |
368 | } | 368 | } |
369 | 369 | ||
370 | void CColorConverter::convert_A1R5G5B5toA1R5G5B5(const void* sP, s32 sN, void* dP) | 370 | void CColorConverter::convert_A1R5G5B5toA1R5G5B5(const void* sP, s32 sN, void* dP) |
371 | { | 371 | { |
372 | memcpy(dP, sP, sN * 2); | 372 | memcpy(dP, sP, sN * 2); |
373 | } | 373 | } |
374 | 374 | ||
375 | void CColorConverter::convert_A1R5G5B5toR5G6B5(const void* sP, s32 sN, void* dP) | 375 | void CColorConverter::convert_A1R5G5B5toR5G6B5(const void* sP, s32 sN, void* dP) |
376 | { | 376 | { |
377 | u16* sB = (u16*)sP; | 377 | u16* sB = (u16*)sP; |
378 | u16* dB = (u16*)dP; | 378 | u16* dB = (u16*)dP; |
379 | 379 | ||
380 | for (s32 x = 0; x < sN; ++x) | 380 | for (s32 x = 0; x < sN; ++x) |
381 | *dB++ = A1R5G5B5toR5G6B5(*sB++); | 381 | *dB++ = A1R5G5B5toR5G6B5(*sB++); |
382 | } | 382 | } |
383 | 383 | ||
384 | void CColorConverter::convert_A8R8G8B8toR8G8B8(const void* sP, s32 sN, void* dP) | 384 | void CColorConverter::convert_A8R8G8B8toR8G8B8(const void* sP, s32 sN, void* dP) |
385 | { | 385 | { |
386 | u8* sB = (u8*)sP; | 386 | u8* sB = (u8*)sP; |
387 | u8* dB = (u8*)dP; | 387 | u8* dB = (u8*)dP; |
388 | 388 | ||
389 | for (s32 x = 0; x < sN; ++x) | 389 | for (s32 x = 0; x < sN; ++x) |
390 | { | 390 | { |
391 | // sB[3] is alpha | 391 | // sB[3] is alpha |
392 | dB[0] = sB[2]; | 392 | dB[0] = sB[2]; |
393 | dB[1] = sB[1]; | 393 | dB[1] = sB[1]; |
394 | dB[2] = sB[0]; | 394 | dB[2] = sB[0]; |
395 | 395 | ||
396 | sB += 4; | 396 | sB += 4; |
397 | dB += 3; | 397 | dB += 3; |
398 | } | 398 | } |
399 | } | 399 | } |
400 | 400 | ||
401 | void CColorConverter::convert_A8R8G8B8toB8G8R8(const void* sP, s32 sN, void* dP) | 401 | void CColorConverter::convert_A8R8G8B8toB8G8R8(const void* sP, s32 sN, void* dP) |
402 | { | 402 | { |
403 | u8* sB = (u8*)sP; | 403 | u8* sB = (u8*)sP; |
404 | u8* dB = (u8*)dP; | 404 | u8* dB = (u8*)dP; |
405 | 405 | ||
406 | for (s32 x = 0; x < sN; ++x) | 406 | for (s32 x = 0; x < sN; ++x) |
407 | { | 407 | { |
408 | // sB[3] is alpha | 408 | // sB[3] is alpha |
409 | dB[0] = sB[0]; | 409 | dB[0] = sB[0]; |
410 | dB[1] = sB[1]; | 410 | dB[1] = sB[1]; |
411 | dB[2] = sB[2]; | 411 | dB[2] = sB[2]; |
412 | 412 | ||
413 | sB += 4; | 413 | sB += 4; |
414 | dB += 3; | 414 | dB += 3; |
415 | } | 415 | } |
416 | } | 416 | } |
417 | 417 | ||
418 | void CColorConverter::convert_A8R8G8B8toA8R8G8B8(const void* sP, s32 sN, void* dP) | 418 | void CColorConverter::convert_A8R8G8B8toA8R8G8B8(const void* sP, s32 sN, void* dP) |
419 | { | 419 | { |
420 | memcpy(dP, sP, sN * 4); | 420 | memcpy(dP, sP, sN * 4); |
421 | } | 421 | } |
422 | 422 | ||
423 | void CColorConverter::convert_A8R8G8B8toA1R5G5B5(const void* sP, s32 sN, void* dP) | 423 | void CColorConverter::convert_A8R8G8B8toA1R5G5B5(const void* sP, s32 sN, void* dP) |
424 | { | 424 | { |
425 | u32* sB = (u32*)sP; | 425 | u32* sB = (u32*)sP; |
426 | u16* dB = (u16*)dP; | 426 | u16* dB = (u16*)dP; |
427 | 427 | ||
428 | for (s32 x = 0; x < sN; ++x) | 428 | for (s32 x = 0; x < sN; ++x) |
429 | *dB++ = A8R8G8B8toA1R5G5B5(*sB++); | 429 | *dB++ = A8R8G8B8toA1R5G5B5(*sB++); |
430 | } | 430 | } |
431 | 431 | ||
432 | void CColorConverter::convert_A8R8G8B8toR5G6B5(const void* sP, s32 sN, void* dP) | 432 | void CColorConverter::convert_A8R8G8B8toR5G6B5(const void* sP, s32 sN, void* dP) |
433 | { | 433 | { |
434 | u8 * sB = (u8 *)sP; | 434 | u8 * sB = (u8 *)sP; |
435 | u16* dB = (u16*)dP; | 435 | u16* dB = (u16*)dP; |
436 | 436 | ||
437 | for (s32 x = 0; x < sN; ++x) | 437 | for (s32 x = 0; x < sN; ++x) |
438 | { | 438 | { |
439 | s32 r = sB[2] >> 3; | 439 | s32 r = sB[2] >> 3; |
440 | s32 g = sB[1] >> 2; | 440 | s32 g = sB[1] >> 2; |
441 | s32 b = sB[0] >> 3; | 441 | s32 b = sB[0] >> 3; |
442 | 442 | ||
443 | dB[0] = (r << 11) | (g << 5) | (b); | 443 | dB[0] = (r << 11) | (g << 5) | (b); |
444 | 444 | ||
445 | sB += 4; | 445 | sB += 4; |
446 | dB += 1; | 446 | dB += 1; |
447 | } | 447 | } |
448 | } | 448 | } |
449 | 449 | ||
450 | void CColorConverter::convert_A8R8G8B8toR3G3B2(const void* sP, s32 sN, void* dP) | 450 | void CColorConverter::convert_A8R8G8B8toR3G3B2(const void* sP, s32 sN, void* dP) |
451 | { | 451 | { |
452 | u8* sB = (u8*)sP; | 452 | u8* sB = (u8*)sP; |
453 | u8* dB = (u8*)dP; | 453 | u8* dB = (u8*)dP; |
454 | 454 | ||
455 | for (s32 x = 0; x < sN; ++x) | 455 | for (s32 x = 0; x < sN; ++x) |
456 | { | 456 | { |
457 | u8 r = sB[2] & 0xe0; | 457 | u8 r = sB[2] & 0xe0; |
458 | u8 g = (sB[1] & 0xe0) >> 3; | 458 | u8 g = (sB[1] & 0xe0) >> 3; |
459 | u8 b = (sB[0] & 0xc0) >> 6; | 459 | u8 b = (sB[0] & 0xc0) >> 6; |
460 | 460 | ||
461 | dB[0] = (r | g | b); | 461 | dB[0] = (r | g | b); |
462 | 462 | ||
463 | sB += 4; | 463 | sB += 4; |
464 | dB += 1; | 464 | dB += 1; |
465 | } | 465 | } |
466 | } | 466 | } |
467 | 467 | ||
468 | void CColorConverter::convert_R8G8B8toR8G8B8(const void* sP, s32 sN, void* dP) | 468 | void CColorConverter::convert_R8G8B8toR8G8B8(const void* sP, s32 sN, void* dP) |
469 | { | 469 | { |
470 | memcpy(dP, sP, sN * 3); | 470 | memcpy(dP, sP, sN * 3); |
471 | } | 471 | } |
472 | 472 | ||
473 | void CColorConverter::convert_R8G8B8toA8R8G8B8(const void* sP, s32 sN, void* dP) | 473 | void CColorConverter::convert_R8G8B8toA8R8G8B8(const void* sP, s32 sN, void* dP) |
474 | { | 474 | { |
475 | u8* sB = (u8* )sP; | 475 | u8* sB = (u8* )sP; |
476 | u32* dB = (u32*)dP; | 476 | u32* dB = (u32*)dP; |
477 | 477 | ||
478 | for (s32 x = 0; x < sN; ++x) | 478 | for (s32 x = 0; x < sN; ++x) |
479 | { | 479 | { |
480 | *dB = 0xff000000 | (sB[0]<<16) | (sB[1]<<8) | sB[2]; | 480 | *dB = 0xff000000 | (sB[0]<<16) | (sB[1]<<8) | sB[2]; |
481 | 481 | ||
482 | sB += 3; | 482 | sB += 3; |
483 | ++dB; | 483 | ++dB; |
484 | } | 484 | } |
485 | } | 485 | } |
486 | 486 | ||
487 | void CColorConverter::convert_R8G8B8toA1R5G5B5(const void* sP, s32 sN, void* dP) | 487 | void CColorConverter::convert_R8G8B8toA1R5G5B5(const void* sP, s32 sN, void* dP) |
488 | { | 488 | { |
489 | u8 * sB = (u8 *)sP; | 489 | u8 * sB = (u8 *)sP; |
490 | u16* dB = (u16*)dP; | 490 | u16* dB = (u16*)dP; |
491 | 491 | ||
492 | for (s32 x = 0; x < sN; ++x) | 492 | for (s32 x = 0; x < sN; ++x) |
493 | { | 493 | { |
494 | s32 r = sB[0] >> 3; | 494 | s32 r = sB[0] >> 3; |
495 | s32 g = sB[1] >> 3; | 495 | s32 g = sB[1] >> 3; |
496 | s32 b = sB[2] >> 3; | 496 | s32 b = sB[2] >> 3; |
497 | 497 | ||
498 | dB[0] = (0x8000) | (r << 10) | (g << 5) | (b); | 498 | dB[0] = (0x8000) | (r << 10) | (g << 5) | (b); |
499 | 499 | ||
500 | sB += 3; | 500 | sB += 3; |
501 | dB += 1; | 501 | dB += 1; |
502 | } | 502 | } |
503 | } | 503 | } |
504 | 504 | ||
505 | void CColorConverter::convert_B8G8R8toA8R8G8B8(const void* sP, s32 sN, void* dP) | 505 | void CColorConverter::convert_B8G8R8toA8R8G8B8(const void* sP, s32 sN, void* dP) |
506 | { | 506 | { |
507 | u8* sB = (u8* )sP; | 507 | u8* sB = (u8* )sP; |
508 | u32* dB = (u32*)dP; | 508 | u32* dB = (u32*)dP; |
509 | 509 | ||
510 | for (s32 x = 0; x < sN; ++x) | 510 | for (s32 x = 0; x < sN; ++x) |
511 | { | 511 | { |
512 | *dB = 0xff000000 | (sB[2]<<16) | (sB[1]<<8) | sB[0]; | 512 | *dB = 0xff000000 | (sB[2]<<16) | (sB[1]<<8) | sB[0]; |
513 | 513 | ||
514 | sB += 3; | 514 | sB += 3; |
515 | ++dB; | 515 | ++dB; |
516 | } | 516 | } |
517 | } | 517 | } |
518 | 518 | ||
519 | void CColorConverter::convert_B8G8R8A8toA8R8G8B8(const void* sP, s32 sN, void* dP) | 519 | void CColorConverter::convert_B8G8R8A8toA8R8G8B8(const void* sP, s32 sN, void* dP) |
520 | { | 520 | { |
521 | u8* sB = (u8*)sP; | 521 | u8* sB = (u8*)sP; |
522 | u8* dB = (u8*)dP; | 522 | u8* dB = (u8*)dP; |
523 | 523 | ||
524 | for (s32 x = 0; x < sN; ++x) | 524 | for (s32 x = 0; x < sN; ++x) |
525 | { | 525 | { |
526 | dB[0] = sB[3]; | 526 | dB[0] = sB[3]; |
527 | dB[1] = sB[2]; | 527 | dB[1] = sB[2]; |
528 | dB[2] = sB[1]; | 528 | dB[2] = sB[1]; |
529 | dB[3] = sB[0]; | 529 | dB[3] = sB[0]; |
530 | 530 | ||
531 | sB += 4; | 531 | sB += 4; |
532 | dB += 4; | 532 | dB += 4; |
533 | } | 533 | } |
534 | 534 | ||
535 | } | 535 | } |
536 | 536 | ||
537 | void CColorConverter::convert_R8G8B8toR5G6B5(const void* sP, s32 sN, void* dP) | 537 | void CColorConverter::convert_R8G8B8toR5G6B5(const void* sP, s32 sN, void* dP) |
538 | { | 538 | { |
539 | u8 * sB = (u8 *)sP; | 539 | u8 * sB = (u8 *)sP; |
540 | u16* dB = (u16*)dP; | 540 | u16* dB = (u16*)dP; |
541 | 541 | ||
542 | for (s32 x = 0; x < sN; ++x) | 542 | for (s32 x = 0; x < sN; ++x) |
543 | { | 543 | { |
544 | s32 r = sB[0] >> 3; | 544 | s32 r = sB[0] >> 3; |
545 | s32 g = sB[1] >> 2; | 545 | s32 g = sB[1] >> 2; |
546 | s32 b = sB[2] >> 3; | 546 | s32 b = sB[2] >> 3; |
547 | 547 | ||
548 | dB[0] = (r << 11) | (g << 5) | (b); | 548 | dB[0] = (r << 11) | (g << 5) | (b); |
549 | 549 | ||
550 | sB += 3; | 550 | sB += 3; |
551 | dB += 1; | 551 | dB += 1; |
552 | } | 552 | } |
553 | } | 553 | } |
554 | 554 | ||
555 | void CColorConverter::convert_R5G6B5toR5G6B5(const void* sP, s32 sN, void* dP) | 555 | void CColorConverter::convert_R5G6B5toR5G6B5(const void* sP, s32 sN, void* dP) |
556 | { | 556 | { |
557 | memcpy(dP, sP, sN * 2); | 557 | memcpy(dP, sP, sN * 2); |
558 | } | 558 | } |
559 | 559 | ||
560 | void CColorConverter::convert_R5G6B5toR8G8B8(const void* sP, s32 sN, void* dP) | 560 | void CColorConverter::convert_R5G6B5toR8G8B8(const void* sP, s32 sN, void* dP) |
561 | { | 561 | { |
562 | u16* sB = (u16*)sP; | 562 | u16* sB = (u16*)sP; |
563 | u8 * dB = (u8 *)dP; | 563 | u8 * dB = (u8 *)dP; |
564 | 564 | ||
565 | for (s32 x = 0; x < sN; ++x) | 565 | for (s32 x = 0; x < sN; ++x) |
566 | { | 566 | { |
567 | dB[0] = (*sB & 0xf800) >> 8; | 567 | dB[0] = (*sB & 0xf800) >> 8; |
568 | dB[1] = (*sB & 0x07e0) >> 3; | 568 | dB[1] = (*sB & 0x07e0) >> 3; |
569 | dB[2] = (*sB & 0x001f) << 3; | 569 | dB[2] = (*sB & 0x001f) << 3; |
570 | 570 | ||
571 | sB += 1; | 571 | sB += 1; |
572 | dB += 3; | 572 | dB += 3; |
573 | } | 573 | } |
574 | } | 574 | } |
575 | 575 | ||
576 | void CColorConverter::convert_R5G6B5toB8G8R8(const void* sP, s32 sN, void* dP) | 576 | void CColorConverter::convert_R5G6B5toB8G8R8(const void* sP, s32 sN, void* dP) |
577 | { | 577 | { |
578 | u16* sB = (u16*)sP; | 578 | u16* sB = (u16*)sP; |
579 | u8 * dB = (u8 *)dP; | 579 | u8 * dB = (u8 *)dP; |
580 | 580 | ||
581 | for (s32 x = 0; x < sN; ++x) | 581 | for (s32 x = 0; x < sN; ++x) |
582 | { | 582 | { |
583 | dB[2] = (*sB & 0xf800) >> 8; | 583 | dB[2] = (*sB & 0xf800) >> 8; |
584 | dB[1] = (*sB & 0x07e0) >> 3; | 584 | dB[1] = (*sB & 0x07e0) >> 3; |
585 | dB[0] = (*sB & 0x001f) << 3; | 585 | dB[0] = (*sB & 0x001f) << 3; |
586 | 586 | ||
587 | sB += 1; | 587 | sB += 1; |
588 | dB += 3; | 588 | dB += 3; |
589 | } | 589 | } |
590 | } | 590 | } |
591 | 591 | ||
592 | void CColorConverter::convert_R5G6B5toA8R8G8B8(const void* sP, s32 sN, void* dP) | 592 | void CColorConverter::convert_R5G6B5toA8R8G8B8(const void* sP, s32 sN, void* dP) |
593 | { | 593 | { |
594 | u16* sB = (u16*)sP; | 594 | u16* sB = (u16*)sP; |
595 | u32* dB = (u32*)dP; | 595 | u32* dB = (u32*)dP; |
596 | 596 | ||
597 | for (s32 x = 0; x < sN; ++x) | 597 | for (s32 x = 0; x < sN; ++x) |
598 | *dB++ = R5G6B5toA8R8G8B8(*sB++); | 598 | *dB++ = R5G6B5toA8R8G8B8(*sB++); |
599 | } | 599 | } |
600 | 600 | ||
601 | void CColorConverter::convert_R5G6B5toA1R5G5B5(const void* sP, s32 sN, void* dP) | 601 | void CColorConverter::convert_R5G6B5toA1R5G5B5(const void* sP, s32 sN, void* dP) |
602 | { | 602 | { |
603 | u16* sB = (u16*)sP; | 603 | u16* sB = (u16*)sP; |
604 | u16* dB = (u16*)dP; | 604 | u16* dB = (u16*)dP; |
605 | 605 | ||
606 | for (s32 x = 0; x < sN; ++x) | 606 | for (s32 x = 0; x < sN; ++x) |
607 | *dB++ = R5G6B5toA1R5G5B5(*sB++); | 607 | *dB++ = R5G6B5toA1R5G5B5(*sB++); |
608 | } | 608 | } |
609 | 609 | ||
610 | 610 | ||
611 | void CColorConverter::convert_viaFormat(const void* sP, ECOLOR_FORMAT sF, s32 sN, | 611 | void CColorConverter::convert_viaFormat(const void* sP, ECOLOR_FORMAT sF, s32 sN, |
612 | void* dP, ECOLOR_FORMAT dF) | 612 | void* dP, ECOLOR_FORMAT dF) |
613 | { | 613 | { |
614 | switch (sF) | 614 | switch (sF) |
615 | { | 615 | { |
616 | case ECF_A1R5G5B5: | 616 | case ECF_A1R5G5B5: |
617 | switch (dF) | 617 | switch (dF) |
618 | { | 618 | { |
619 | case ECF_A1R5G5B5: | 619 | case ECF_A1R5G5B5: |
620 | convert_A1R5G5B5toA1R5G5B5(sP, sN, dP); | 620 | convert_A1R5G5B5toA1R5G5B5(sP, sN, dP); |
621 | break; | 621 | break; |
622 | case ECF_R5G6B5: | 622 | case ECF_R5G6B5: |
623 | convert_A1R5G5B5toR5G6B5(sP, sN, dP); | 623 | convert_A1R5G5B5toR5G6B5(sP, sN, dP); |
624 | break; | 624 | break; |
625 | case ECF_A8R8G8B8: | 625 | case ECF_A8R8G8B8: |
626 | convert_A1R5G5B5toA8R8G8B8(sP, sN, dP); | 626 | convert_A1R5G5B5toA8R8G8B8(sP, sN, dP); |
627 | break; | 627 | break; |
628 | case ECF_R8G8B8: | 628 | case ECF_R8G8B8: |
629 | convert_A1R5G5B5toR8G8B8(sP, sN, dP); | 629 | convert_A1R5G5B5toR8G8B8(sP, sN, dP); |
630 | break; | 630 | break; |
631 | #ifndef _DEBUG | 631 | #ifndef _DEBUG |
632 | default: | 632 | default: |
633 | break; | 633 | break; |
634 | #endif | 634 | #endif |
635 | } | 635 | } |
636 | break; | 636 | break; |
637 | case ECF_R5G6B5: | 637 | case ECF_R5G6B5: |
638 | switch (dF) | 638 | switch (dF) |
639 | { | 639 | { |
640 | case ECF_A1R5G5B5: | 640 | case ECF_A1R5G5B5: |
641 | convert_R5G6B5toA1R5G5B5(sP, sN, dP); | 641 | convert_R5G6B5toA1R5G5B5(sP, sN, dP); |
642 | break; | 642 | break; |
643 | case ECF_R5G6B5: | 643 | case ECF_R5G6B5: |
644 | convert_R5G6B5toR5G6B5(sP, sN, dP); | 644 | convert_R5G6B5toR5G6B5(sP, sN, dP); |
645 | break; | 645 | break; |
646 | case ECF_A8R8G8B8: | 646 | case ECF_A8R8G8B8: |
647 | convert_R5G6B5toA8R8G8B8(sP, sN, dP); | 647 | convert_R5G6B5toA8R8G8B8(sP, sN, dP); |
648 | break; | 648 | break; |
649 | case ECF_R8G8B8: | 649 | case ECF_R8G8B8: |
650 | convert_R5G6B5toR8G8B8(sP, sN, dP); | 650 | convert_R5G6B5toR8G8B8(sP, sN, dP); |
651 | break; | 651 | break; |
652 | #ifndef _DEBUG | 652 | #ifndef _DEBUG |
653 | default: | 653 | default: |
654 | break; | 654 | break; |
655 | #endif | 655 | #endif |
656 | } | 656 | } |
657 | break; | 657 | break; |
658 | case ECF_A8R8G8B8: | 658 | case ECF_A8R8G8B8: |
659 | switch (dF) | 659 | switch (dF) |
660 | { | 660 | { |
661 | case ECF_A1R5G5B5: | 661 | case ECF_A1R5G5B5: |
662 | convert_A8R8G8B8toA1R5G5B5(sP, sN, dP); | 662 | convert_A8R8G8B8toA1R5G5B5(sP, sN, dP); |
663 | break; | 663 | break; |
664 | case ECF_R5G6B5: | 664 | case ECF_R5G6B5: |
665 | convert_A8R8G8B8toR5G6B5(sP, sN, dP); | 665 | convert_A8R8G8B8toR5G6B5(sP, sN, dP); |
666 | break; | 666 | break; |
667 | case ECF_A8R8G8B8: | 667 | case ECF_A8R8G8B8: |
668 | convert_A8R8G8B8toA8R8G8B8(sP, sN, dP); | 668 | convert_A8R8G8B8toA8R8G8B8(sP, sN, dP); |
669 | break; | 669 | break; |
670 | case ECF_R8G8B8: | 670 | case ECF_R8G8B8: |
671 | convert_A8R8G8B8toR8G8B8(sP, sN, dP); | 671 | convert_A8R8G8B8toR8G8B8(sP, sN, dP); |
672 | break; | 672 | break; |
673 | #ifndef _DEBUG | 673 | #ifndef _DEBUG |
674 | default: | 674 | default: |
675 | break; | 675 | break; |
676 | #endif | 676 | #endif |
677 | } | 677 | } |
678 | break; | 678 | break; |
679 | case ECF_R8G8B8: | 679 | case ECF_R8G8B8: |
680 | switch (dF) | 680 | switch (dF) |
681 | { | 681 | { |
682 | case ECF_A1R5G5B5: | 682 | case ECF_A1R5G5B5: |
683 | convert_R8G8B8toA1R5G5B5(sP, sN, dP); | 683 | convert_R8G8B8toA1R5G5B5(sP, sN, dP); |
684 | break; | 684 | break; |
685 | case ECF_R5G6B5: | 685 | case ECF_R5G6B5: |
686 | convert_R8G8B8toR5G6B5(sP, sN, dP); | 686 | convert_R8G8B8toR5G6B5(sP, sN, dP); |
687 | break; | 687 | break; |
688 | case ECF_A8R8G8B8: | 688 | case ECF_A8R8G8B8: |
689 | convert_R8G8B8toA8R8G8B8(sP, sN, dP); | 689 | convert_R8G8B8toA8R8G8B8(sP, sN, dP); |
690 | break; | 690 | break; |
691 | case ECF_R8G8B8: | 691 | case ECF_R8G8B8: |
692 | convert_R8G8B8toR8G8B8(sP, sN, dP); | 692 | convert_R8G8B8toR8G8B8(sP, sN, dP); |
693 | break; | 693 | break; |
694 | #ifndef _DEBUG | 694 | #ifndef _DEBUG |
695 | default: | 695 | default: |
696 | break; | 696 | break; |
697 | #endif | 697 | #endif |
698 | } | 698 | } |
699 | break; | 699 | break; |
700 | } | 700 | } |
701 | } | 701 | } |
702 | 702 | ||
703 | 703 | ||
704 | } // end namespace video | 704 | } // end namespace video |
705 | } // end namespace irr | 705 | } // end namespace irr |