OLD | NEW |
| (Empty) |
1 // Copyright 2009 Google Inc. | |
2 // | |
3 // Licensed under the Apache License, Version 2.0 (the "License"); | |
4 // you may not use this file except in compliance with the License. | |
5 // You may obtain a copy of the License at | |
6 // | |
7 // http://www.apache.org/licenses/LICENSE-2.0 | |
8 // | |
9 // Unless required by applicable law or agreed to in writing, software | |
10 // distributed under the License is distributed on an "AS IS" BASIS, | |
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
12 // See the License for the specific language governing permissions and | |
13 // limitations under the License. | |
14 | |
15 ////////////////////////////////////////////////////////////////////////////////
////////// | |
16 | |
17 // This is a fork of the AOSP project ETC1 codec. The original code can be found | |
18 // at the following web site: | |
19 // https://android.googlesource.com/platform/frameworks/native/+/master/opengl/i
nclude/ETC1/ | |
20 | |
21 ////////////////////////////////////////////////////////////////////////////////
////////// | |
22 | |
23 #include "etc1.h" | |
24 | |
25 #include <cstring> | |
26 | |
27 /* From http://www.khronos.org/registry/gles/extensions/OES/OES_compressed_ETC1_
RGB8_texture.txt | |
28 | |
29 The number of bits that represent a 4x4 texel block is 64 bits if | |
30 <internalformat> is given by ETC1_RGB8_OES. | |
31 | |
32 The data for a block is a number of bytes, | |
33 | |
34 {q0, q1, q2, q3, q4, q5, q6, q7} | |
35 | |
36 where byte q0 is located at the lowest memory address and q7 at | |
37 the highest. The 64 bits specifying the block is then represented | |
38 by the following 64 bit integer: | |
39 | |
40 int64bit = 256*(256*(256*(256*(256*(256*(256*q0+q1)+q2)+q3)+q4)+q5)+q6)+q7; | |
41 | |
42 ETC1_RGB8_OES: | |
43 | |
44 a) bit layout in bits 63 through 32 if diffbit = 0 | |
45 | |
46 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 | |
47 ----------------------------------------------- | |
48 | base col1 | base col2 | base col1 | base col2 | | |
49 | R1 (4bits)| R2 (4bits)| G1 (4bits)| G2 (4bits)| | |
50 ----------------------------------------------- | |
51 | |
52 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 | |
53 --------------------------------------------------- | |
54 | base col1 | base col2 | table | table |diff|flip| | |
55 | B1 (4bits)| B2 (4bits)| cw 1 | cw 2 |bit |bit | | |
56 --------------------------------------------------- | |
57 | |
58 | |
59 b) bit layout in bits 63 through 32 if diffbit = 1 | |
60 | |
61 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 | |
62 ----------------------------------------------- | |
63 | base col1 | dcol 2 | base col1 | dcol 2 | | |
64 | R1' (5 bits) | dR2 | G1' (5 bits) | dG2 | | |
65 ----------------------------------------------- | |
66 | |
67 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 | |
68 --------------------------------------------------- | |
69 | base col 1 | dcol 2 | table | table |diff|flip| | |
70 | B1' (5 bits) | dB2 | cw 1 | cw 2 |bit |bit | | |
71 --------------------------------------------------- | |
72 | |
73 | |
74 c) bit layout in bits 31 through 0 (in both cases) | |
75 | |
76 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 | |
77 ----------------------------------------------- | |
78 | most significant pixel index bits | | |
79 | p| o| n| m| l| k| j| i| h| g| f| e| d| c| b| a| | |
80 ----------------------------------------------- | |
81 | |
82 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 | |
83 -------------------------------------------------- | |
84 | least significant pixel index bits | | |
85 | p| o| n| m| l| k| j| i| h| g| f| e| d| c | b | a | | |
86 -------------------------------------------------- | |
87 | |
88 | |
89 Add table 3.17.2: Intensity modifier sets for ETC1 compressed textures: | |
90 | |
91 table codeword modifier table | |
92 ------------------ ---------------------- | |
93 0 -8 -2 2 8 | |
94 1 -17 -5 5 17 | |
95 2 -29 -9 9 29 | |
96 3 -42 -13 13 42 | |
97 4 -60 -18 18 60 | |
98 5 -80 -24 24 80 | |
99 6 -106 -33 33 106 | |
100 7 -183 -47 47 183 | |
101 | |
102 | |
103 Add table 3.17.3 Mapping from pixel index values to modifier values for | |
104 ETC1 compressed textures: | |
105 | |
106 pixel index value | |
107 --------------- | |
108 msb lsb resulting modifier value | |
109 ----- ----- ------------------------- | |
110 1 1 -b (large negative value) | |
111 1 0 -a (small negative value) | |
112 0 0 a (small positive value) | |
113 0 1 b (large positive value) | |
114 | |
115 | |
116 */ | |
117 | |
118 static const int kModifierTable[] = { | |
119 /* 0 */2, 8, -2, -8, | |
120 /* 1 */5, 17, -5, -17, | |
121 /* 2 */9, 29, -9, -29, | |
122 /* 3 */13, 42, -13, -42, | |
123 /* 4 */18, 60, -18, -60, | |
124 /* 5 */24, 80, -24, -80, | |
125 /* 6 */33, 106, -33, -106, | |
126 /* 7 */47, 183, -47, -183 }; | |
127 | |
128 static const int kLookup[8] = { 0, 1, 2, 3, -4, -3, -2, -1 }; | |
129 | |
130 static inline etc1_byte clamp(int x) { | |
131 return (etc1_byte) (x >= 0 ? (x < 255 ? x : 255) : 0); | |
132 } | |
133 | |
134 static | |
135 inline int convert4To8(int b) { | |
136 int c = b & 0xf; | |
137 return (c << 4) | c; | |
138 } | |
139 | |
140 static | |
141 inline int convert5To8(int b) { | |
142 int c = b & 0x1f; | |
143 return (c << 3) | (c >> 2); | |
144 } | |
145 | |
146 static | |
147 inline int convert6To8(int b) { | |
148 int c = b & 0x3f; | |
149 return (c << 2) | (c >> 4); | |
150 } | |
151 | |
152 static | |
153 inline int divideBy255(int d) { | |
154 return (d + 128 + (d >> 8)) >> 8; | |
155 } | |
156 | |
157 static | |
158 inline int convert8To4(int b) { | |
159 int c = b & 0xff; | |
160 return divideBy255(c * 15); | |
161 } | |
162 | |
163 static | |
164 inline int convert8To5(int b) { | |
165 int c = b & 0xff; | |
166 return divideBy255(c * 31); | |
167 } | |
168 | |
169 static | |
170 inline int convertDiff(int base, int diff) { | |
171 return convert5To8((0x1f & base) + kLookup[0x7 & diff]); | |
172 } | |
173 | |
174 static | |
175 void decode_subblock(etc1_byte* pOut, int r, int g, int b, const int* table, | |
176 etc1_uint32 low, bool second, bool flipped) { | |
177 int baseX = 0; | |
178 int baseY = 0; | |
179 if (second) { | |
180 if (flipped) { | |
181 baseY = 2; | |
182 } else { | |
183 baseX = 2; | |
184 } | |
185 } | |
186 for (int i = 0; i < 8; i++) { | |
187 int x, y; | |
188 if (flipped) { | |
189 x = baseX + (i >> 1); | |
190 y = baseY + (i & 1); | |
191 } else { | |
192 x = baseX + (i >> 2); | |
193 y = baseY + (i & 3); | |
194 } | |
195 int k = y + (x * 4); | |
196 int offset = ((low >> k) & 1) | ((low >> (k + 15)) & 2); | |
197 int delta = table[offset]; | |
198 etc1_byte* q = pOut + 3 * (x + 4 * y); | |
199 *q++ = clamp(r + delta); | |
200 *q++ = clamp(g + delta); | |
201 *q++ = clamp(b + delta); | |
202 } | |
203 } | |
204 | |
205 // Input is an ETC1 compressed version of the data. | |
206 // Output is a 4 x 4 square of 3-byte pixels in form R, G, B | |
207 | |
208 void etc1_decode_block(const etc1_byte* pIn, etc1_byte* pOut) { | |
209 etc1_uint32 high = (pIn[0] << 24) | (pIn[1] << 16) | (pIn[2] << 8) | pIn[3]; | |
210 etc1_uint32 low = (pIn[4] << 24) | (pIn[5] << 16) | (pIn[6] << 8) | pIn[7]; | |
211 int r1, r2, g1, g2, b1, b2; | |
212 if (high & 2) { | |
213 // differential | |
214 int rBase = high >> 27; | |
215 int gBase = high >> 19; | |
216 int bBase = high >> 11; | |
217 r1 = convert5To8(rBase); | |
218 r2 = convertDiff(rBase, high >> 24); | |
219 g1 = convert5To8(gBase); | |
220 g2 = convertDiff(gBase, high >> 16); | |
221 b1 = convert5To8(bBase); | |
222 b2 = convertDiff(bBase, high >> 8); | |
223 } else { | |
224 // not differential | |
225 r1 = convert4To8(high >> 28); | |
226 r2 = convert4To8(high >> 24); | |
227 g1 = convert4To8(high >> 20); | |
228 g2 = convert4To8(high >> 16); | |
229 b1 = convert4To8(high >> 12); | |
230 b2 = convert4To8(high >> 8); | |
231 } | |
232 int tableIndexA = 7 & (high >> 5); | |
233 int tableIndexB = 7 & (high >> 2); | |
234 const int* tableA = kModifierTable + tableIndexA * 4; | |
235 const int* tableB = kModifierTable + tableIndexB * 4; | |
236 bool flipped = (high & 1) != 0; | |
237 decode_subblock(pOut, r1, g1, b1, tableA, low, false, flipped); | |
238 decode_subblock(pOut, r2, g2, b2, tableB, low, true, flipped); | |
239 } | |
240 | |
241 typedef struct { | |
242 etc1_uint32 high; | |
243 etc1_uint32 low; | |
244 etc1_uint32 score; // Lower is more accurate | |
245 } etc_compressed; | |
246 | |
247 static | |
248 inline void take_best(etc_compressed* a, const etc_compressed* b) { | |
249 if (a->score > b->score) { | |
250 *a = *b; | |
251 } | |
252 } | |
253 | |
254 static | |
255 void etc_average_colors_subblock(const etc1_byte* pIn, etc1_uint32 inMask, | |
256 etc1_byte* pColors, bool flipped, bool second) { | |
257 int r = 0; | |
258 int g = 0; | |
259 int b = 0; | |
260 | |
261 if (flipped) { | |
262 int by = 0; | |
263 if (second) { | |
264 by = 2; | |
265 } | |
266 for (int y = 0; y < 2; y++) { | |
267 int yy = by + y; | |
268 for (int x = 0; x < 4; x++) { | |
269 int i = x + 4 * yy; | |
270 if (inMask & (1 << i)) { | |
271 const etc1_byte* p = pIn + i * 3; | |
272 r += *(p++); | |
273 g += *(p++); | |
274 b += *(p++); | |
275 } | |
276 } | |
277 } | |
278 } else { | |
279 int bx = 0; | |
280 if (second) { | |
281 bx = 2; | |
282 } | |
283 for (int y = 0; y < 4; y++) { | |
284 for (int x = 0; x < 2; x++) { | |
285 int xx = bx + x; | |
286 int i = xx + 4 * y; | |
287 if (inMask & (1 << i)) { | |
288 const etc1_byte* p = pIn + i * 3; | |
289 r += *(p++); | |
290 g += *(p++); | |
291 b += *(p++); | |
292 } | |
293 } | |
294 } | |
295 } | |
296 pColors[0] = (etc1_byte)((r + 4) >> 3); | |
297 pColors[1] = (etc1_byte)((g + 4) >> 3); | |
298 pColors[2] = (etc1_byte)((b + 4) >> 3); | |
299 } | |
300 | |
301 static | |
302 inline int square(int x) { | |
303 return x * x; | |
304 } | |
305 | |
306 static etc1_uint32 chooseModifier(const etc1_byte* pBaseColors, | |
307 const etc1_byte* pIn, etc1_uint32 *pLow, int bitIndex, | |
308 const int* pModifierTable) { | |
309 etc1_uint32 bestScore = ~0; | |
310 int bestIndex = 0; | |
311 int pixelR = pIn[0]; | |
312 int pixelG = pIn[1]; | |
313 int pixelB = pIn[2]; | |
314 int r = pBaseColors[0]; | |
315 int g = pBaseColors[1]; | |
316 int b = pBaseColors[2]; | |
317 for (int i = 0; i < 4; i++) { | |
318 int modifier = pModifierTable[i]; | |
319 int decodedG = clamp(g + modifier); | |
320 etc1_uint32 score = (etc1_uint32) (6 * square(decodedG - pixelG)); | |
321 if (score >= bestScore) { | |
322 continue; | |
323 } | |
324 int decodedR = clamp(r + modifier); | |
325 score += (etc1_uint32) (3 * square(decodedR - pixelR)); | |
326 if (score >= bestScore) { | |
327 continue; | |
328 } | |
329 int decodedB = clamp(b + modifier); | |
330 score += (etc1_uint32) square(decodedB - pixelB); | |
331 if (score < bestScore) { | |
332 bestScore = score; | |
333 bestIndex = i; | |
334 } | |
335 } | |
336 etc1_uint32 lowMask = (((bestIndex >> 1) << 16) | (bestIndex & 1)) | |
337 << bitIndex; | |
338 *pLow |= lowMask; | |
339 return bestScore; | |
340 } | |
341 | |
342 static | |
343 void etc_encode_subblock_helper(const etc1_byte* pIn, etc1_uint32 inMask, | |
344 etc_compressed* pCompressed, bool flipped, bool second, | |
345 const etc1_byte* pBaseColors, const int* pModifierTable) { | |
346 int score = pCompressed->score; | |
347 if (flipped) { | |
348 int by = 0; | |
349 if (second) { | |
350 by = 2; | |
351 } | |
352 for (int y = 0; y < 2; y++) { | |
353 int yy = by + y; | |
354 for (int x = 0; x < 4; x++) { | |
355 int i = x + 4 * yy; | |
356 if (inMask & (1 << i)) { | |
357 score += chooseModifier(pBaseColors, pIn + i * 3, | |
358 &pCompressed->low, yy + x * 4, pModifierTable); | |
359 } | |
360 } | |
361 } | |
362 } else { | |
363 int bx = 0; | |
364 if (second) { | |
365 bx = 2; | |
366 } | |
367 for (int y = 0; y < 4; y++) { | |
368 for (int x = 0; x < 2; x++) { | |
369 int xx = bx + x; | |
370 int i = xx + 4 * y; | |
371 if (inMask & (1 << i)) { | |
372 score += chooseModifier(pBaseColors, pIn + i * 3, | |
373 &pCompressed->low, y + xx * 4, pModifierTable); | |
374 } | |
375 } | |
376 } | |
377 } | |
378 pCompressed->score = score; | |
379 } | |
380 | |
381 static bool inRange4bitSigned(int color) { | |
382 return color >= -4 && color <= 3; | |
383 } | |
384 | |
385 static void etc_encodeBaseColors(etc1_byte* pBaseColors, | |
386 const etc1_byte* pColors, etc_compressed* pCompressed) { | |
387 int r1, g1, b1, r2, g2, b2; // 8 bit base colors for sub-blocks | |
388 bool differential; | |
389 { | |
390 int r51 = convert8To5(pColors[0]); | |
391 int g51 = convert8To5(pColors[1]); | |
392 int b51 = convert8To5(pColors[2]); | |
393 int r52 = convert8To5(pColors[3]); | |
394 int g52 = convert8To5(pColors[4]); | |
395 int b52 = convert8To5(pColors[5]); | |
396 | |
397 r1 = convert5To8(r51); | |
398 g1 = convert5To8(g51); | |
399 b1 = convert5To8(b51); | |
400 | |
401 int dr = r52 - r51; | |
402 int dg = g52 - g51; | |
403 int db = b52 - b51; | |
404 | |
405 differential = inRange4bitSigned(dr) && inRange4bitSigned(dg) | |
406 && inRange4bitSigned(db); | |
407 if (differential) { | |
408 r2 = convert5To8(r51 + dr); | |
409 g2 = convert5To8(g51 + dg); | |
410 b2 = convert5To8(b51 + db); | |
411 pCompressed->high |= (r51 << 27) | ((7 & dr) << 24) | (g51 << 19) | |
412 | ((7 & dg) << 16) | (b51 << 11) | ((7 & db) << 8) | 2; | |
413 } | |
414 } | |
415 | |
416 if (!differential) { | |
417 int r41 = convert8To4(pColors[0]); | |
418 int g41 = convert8To4(pColors[1]); | |
419 int b41 = convert8To4(pColors[2]); | |
420 int r42 = convert8To4(pColors[3]); | |
421 int g42 = convert8To4(pColors[4]); | |
422 int b42 = convert8To4(pColors[5]); | |
423 r1 = convert4To8(r41); | |
424 g1 = convert4To8(g41); | |
425 b1 = convert4To8(b41); | |
426 r2 = convert4To8(r42); | |
427 g2 = convert4To8(g42); | |
428 b2 = convert4To8(b42); | |
429 pCompressed->high |= (r41 << 28) | (r42 << 24) | (g41 << 20) | (g42 | |
430 << 16) | (b41 << 12) | (b42 << 8); | |
431 } | |
432 pBaseColors[0] = r1; | |
433 pBaseColors[1] = g1; | |
434 pBaseColors[2] = b1; | |
435 pBaseColors[3] = r2; | |
436 pBaseColors[4] = g2; | |
437 pBaseColors[5] = b2; | |
438 } | |
439 | |
440 static | |
441 void etc_encode_block_helper(const etc1_byte* pIn, etc1_uint32 inMask, | |
442 const etc1_byte* pColors, etc_compressed* pCompressed, bool flipped) { | |
443 pCompressed->score = ~0; | |
444 pCompressed->high = (flipped ? 1 : 0); | |
445 pCompressed->low = 0; | |
446 | |
447 etc1_byte pBaseColors[6]; | |
448 | |
449 etc_encodeBaseColors(pBaseColors, pColors, pCompressed); | |
450 | |
451 int originalHigh = pCompressed->high; | |
452 | |
453 const int* pModifierTable = kModifierTable; | |
454 for (int i = 0; i < 8; i++, pModifierTable += 4) { | |
455 etc_compressed temp; | |
456 temp.score = 0; | |
457 temp.high = originalHigh | (i << 5); | |
458 temp.low = 0; | |
459 etc_encode_subblock_helper(pIn, inMask, &temp, flipped, false, | |
460 pBaseColors, pModifierTable); | |
461 take_best(pCompressed, &temp); | |
462 } | |
463 pModifierTable = kModifierTable; | |
464 etc_compressed firstHalf = *pCompressed; | |
465 for (int i = 0; i < 8; i++, pModifierTable += 4) { | |
466 etc_compressed temp; | |
467 temp.score = firstHalf.score; | |
468 temp.high = firstHalf.high | (i << 2); | |
469 temp.low = firstHalf.low; | |
470 etc_encode_subblock_helper(pIn, inMask, &temp, flipped, true, | |
471 pBaseColors + 3, pModifierTable); | |
472 if (i == 0) { | |
473 *pCompressed = temp; | |
474 } else { | |
475 take_best(pCompressed, &temp); | |
476 } | |
477 } | |
478 } | |
479 | |
480 static void writeBigEndian(etc1_byte* pOut, etc1_uint32 d) { | |
481 pOut[0] = (etc1_byte)(d >> 24); | |
482 pOut[1] = (etc1_byte)(d >> 16); | |
483 pOut[2] = (etc1_byte)(d >> 8); | |
484 pOut[3] = (etc1_byte) d; | |
485 } | |
486 | |
487 // Input is a 4 x 4 square of 3-byte pixels in form R, G, B | |
488 // inmask is a 16-bit mask where bit (1 << (x + y * 4)) tells whether the corres
ponding (x,y) | |
489 // pixel is valid or not. Invalid pixel color values are ignored when compressin
g. | |
490 // Output is an ETC1 compressed version of the data. | |
491 | |
492 void etc1_encode_block(const etc1_byte* pIn, etc1_uint32 inMask, | |
493 etc1_byte* pOut) { | |
494 etc1_byte colors[6]; | |
495 etc1_byte flippedColors[6]; | |
496 etc_average_colors_subblock(pIn, inMask, colors, false, false); | |
497 etc_average_colors_subblock(pIn, inMask, colors + 3, false, true); | |
498 etc_average_colors_subblock(pIn, inMask, flippedColors, true, false); | |
499 etc_average_colors_subblock(pIn, inMask, flippedColors + 3, true, true); | |
500 | |
501 etc_compressed a, b; | |
502 etc_encode_block_helper(pIn, inMask, colors, &a, false); | |
503 etc_encode_block_helper(pIn, inMask, flippedColors, &b, true); | |
504 take_best(&a, &b); | |
505 writeBigEndian(pOut, a.high); | |
506 writeBigEndian(pOut + 4, a.low); | |
507 } | |
508 | |
509 // Return the size of the encoded image data (does not include size of PKM heade
r). | |
510 | |
511 etc1_uint32 etc1_get_encoded_data_size(etc1_uint32 width, etc1_uint32 height) { | |
512 return (((width + 3) & ~3) * ((height + 3) & ~3)) >> 1; | |
513 } | |
514 | |
515 // Encode an entire image. | |
516 // pIn - pointer to the image data. Formatted such that the Red component of | |
517 // pixel (x,y) is at pIn + pixelSize * x + stride * y + redOffset; | |
518 // pOut - pointer to encoded data. Must be large enough to store entire encoded
image. | |
519 | |
520 int etc1_encode_image(const etc1_byte* pIn, etc1_uint32 width, etc1_uint32 heigh
t, | |
521 etc1_uint32 pixelSize, etc1_uint32 stride, etc1_byte* pOut) { | |
522 if (pixelSize < 2 || pixelSize > 3) { | |
523 return -1; | |
524 } | |
525 static const unsigned short kYMask[] = { 0x0, 0xf, 0xff, 0xfff, 0xffff }; | |
526 static const unsigned short kXMask[] = { 0x0, 0x1111, 0x3333, 0x7777, | |
527 0xffff }; | |
528 etc1_byte block[ETC1_DECODED_BLOCK_SIZE]; | |
529 etc1_byte encoded[ETC1_ENCODED_BLOCK_SIZE]; | |
530 | |
531 etc1_uint32 encodedWidth = (width + 3) & ~3; | |
532 etc1_uint32 encodedHeight = (height + 3) & ~3; | |
533 | |
534 for (etc1_uint32 y = 0; y < encodedHeight; y += 4) { | |
535 etc1_uint32 yEnd = height - y; | |
536 if (yEnd > 4) { | |
537 yEnd = 4; | |
538 } | |
539 int ymask = kYMask[yEnd]; | |
540 for (etc1_uint32 x = 0; x < encodedWidth; x += 4) { | |
541 etc1_uint32 xEnd = width - x; | |
542 if (xEnd > 4) { | |
543 xEnd = 4; | |
544 } | |
545 int mask = ymask & kXMask[xEnd]; | |
546 for (etc1_uint32 cy = 0; cy < yEnd; cy++) { | |
547 etc1_byte* q = block + (cy * 4) * 3; | |
548 const etc1_byte* p = pIn + pixelSize * x + stride * (y + cy); | |
549 if (pixelSize == 3) { | |
550 memcpy(q, p, xEnd * 3); | |
551 } else { | |
552 for (etc1_uint32 cx = 0; cx < xEnd; cx++) { | |
553 int pixel = (p[1] << 8) | p[0]; | |
554 *q++ = convert5To8(pixel >> 11); | |
555 *q++ = convert6To8(pixel >> 5); | |
556 *q++ = convert5To8(pixel); | |
557 p += pixelSize; | |
558 } | |
559 } | |
560 } | |
561 etc1_encode_block(block, mask, encoded); | |
562 memcpy(pOut, encoded, sizeof(encoded)); | |
563 pOut += sizeof(encoded); | |
564 } | |
565 } | |
566 return 0; | |
567 } | |
568 | |
569 // Decode an entire image. | |
570 // pIn - pointer to encoded data. | |
571 // pOut - pointer to the image data. Will be written such that the Red component
of | |
572 // pixel (x,y) is at pIn + pixelSize * x + stride * y + redOffset. Must be | |
573 // large enough to store entire image. | |
574 | |
575 | |
576 int etc1_decode_image(const etc1_byte* pIn, etc1_byte* pOut, | |
577 etc1_uint32 width, etc1_uint32 height, | |
578 etc1_uint32 pixelSize, etc1_uint32 stride) { | |
579 if (pixelSize < 2 || pixelSize > 3) { | |
580 return -1; | |
581 } | |
582 etc1_byte block[ETC1_DECODED_BLOCK_SIZE]; | |
583 | |
584 etc1_uint32 encodedWidth = (width + 3) & ~3; | |
585 etc1_uint32 encodedHeight = (height + 3) & ~3; | |
586 | |
587 for (etc1_uint32 y = 0; y < encodedHeight; y += 4) { | |
588 etc1_uint32 yEnd = height - y; | |
589 if (yEnd > 4) { | |
590 yEnd = 4; | |
591 } | |
592 for (etc1_uint32 x = 0; x < encodedWidth; x += 4) { | |
593 etc1_uint32 xEnd = width - x; | |
594 if (xEnd > 4) { | |
595 xEnd = 4; | |
596 } | |
597 etc1_decode_block(pIn, block); | |
598 pIn += ETC1_ENCODED_BLOCK_SIZE; | |
599 for (etc1_uint32 cy = 0; cy < yEnd; cy++) { | |
600 const etc1_byte* q = block + (cy * 4) * 3; | |
601 etc1_byte* p = pOut + pixelSize * x + stride * (y + cy); | |
602 if (pixelSize == 3) { | |
603 memcpy(p, q, xEnd * 3); | |
604 } else { | |
605 for (etc1_uint32 cx = 0; cx < xEnd; cx++) { | |
606 etc1_byte r = *q++; | |
607 etc1_byte g = *q++; | |
608 etc1_byte b = *q++; | |
609 etc1_uint32 pixel = ((r >> 3) << 11) | ((g >> 2) << 5) |
(b >> 3); | |
610 *p++ = (etc1_byte) pixel; | |
611 *p++ = (etc1_byte) (pixel >> 8); | |
612 } | |
613 } | |
614 } | |
615 } | |
616 } | |
617 return 0; | |
618 } | |
619 | |
620 static const char kMagic[] = { 'P', 'K', 'M', ' ', '1', '0' }; | |
621 | |
622 static const etc1_uint32 ETC1_PKM_FORMAT_OFFSET = 6; | |
623 static const etc1_uint32 ETC1_PKM_ENCODED_WIDTH_OFFSET = 8; | |
624 static const etc1_uint32 ETC1_PKM_ENCODED_HEIGHT_OFFSET = 10; | |
625 static const etc1_uint32 ETC1_PKM_WIDTH_OFFSET = 12; | |
626 static const etc1_uint32 ETC1_PKM_HEIGHT_OFFSET = 14; | |
627 | |
628 static const etc1_uint32 ETC1_RGB_NO_MIPMAPS = 0; | |
629 | |
630 static void writeBEUint16(etc1_byte* pOut, etc1_uint32 data) { | |
631 pOut[0] = (etc1_byte) (data >> 8); | |
632 pOut[1] = (etc1_byte) data; | |
633 } | |
634 | |
635 static etc1_uint32 readBEUint16(const etc1_byte* pIn) { | |
636 return (pIn[0] << 8) | pIn[1]; | |
637 } | |
638 | |
639 // Format a PKM header | |
640 | |
641 void etc1_pkm_format_header(etc1_byte* pHeader, etc1_uint32 width, etc1_uint32 h
eight) { | |
642 memcpy(pHeader, kMagic, sizeof(kMagic)); | |
643 etc1_uint32 encodedWidth = (width + 3) & ~3; | |
644 etc1_uint32 encodedHeight = (height + 3) & ~3; | |
645 writeBEUint16(pHeader + ETC1_PKM_FORMAT_OFFSET, ETC1_RGB_NO_MIPMAPS); | |
646 writeBEUint16(pHeader + ETC1_PKM_ENCODED_WIDTH_OFFSET, encodedWidth); | |
647 writeBEUint16(pHeader + ETC1_PKM_ENCODED_HEIGHT_OFFSET, encodedHeight); | |
648 writeBEUint16(pHeader + ETC1_PKM_WIDTH_OFFSET, width); | |
649 writeBEUint16(pHeader + ETC1_PKM_HEIGHT_OFFSET, height); | |
650 } | |
651 | |
652 // Check if a PKM header is correctly formatted. | |
653 | |
654 etc1_bool etc1_pkm_is_valid(const etc1_byte* pHeader) { | |
655 if (memcmp(pHeader, kMagic, sizeof(kMagic))) { | |
656 return false; | |
657 } | |
658 etc1_uint32 format = readBEUint16(pHeader + ETC1_PKM_FORMAT_OFFSET); | |
659 etc1_uint32 encodedWidth = readBEUint16(pHeader + ETC1_PKM_ENCODED_WIDTH_OFF
SET); | |
660 etc1_uint32 encodedHeight = readBEUint16(pHeader + ETC1_PKM_ENCODED_HEIGHT_O
FFSET); | |
661 etc1_uint32 width = readBEUint16(pHeader + ETC1_PKM_WIDTH_OFFSET); | |
662 etc1_uint32 height = readBEUint16(pHeader + ETC1_PKM_HEIGHT_OFFSET); | |
663 return format == ETC1_RGB_NO_MIPMAPS && | |
664 encodedWidth >= width && encodedWidth - width < 4 && | |
665 encodedHeight >= height && encodedHeight - height < 4; | |
666 } | |
667 | |
668 // Read the image width from a PKM header | |
669 | |
670 etc1_uint32 etc1_pkm_get_width(const etc1_byte* pHeader) { | |
671 return readBEUint16(pHeader + ETC1_PKM_WIDTH_OFFSET); | |
672 } | |
673 | |
674 // Read the image height from a PKM header | |
675 | |
676 etc1_uint32 etc1_pkm_get_height(const etc1_byte* pHeader){ | |
677 return readBEUint16(pHeader + ETC1_PKM_HEIGHT_OFFSET); | |
678 } | |
OLD | NEW |