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/include/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 corresponding (x,y) 489 // pixel is valid or not. Invalid pixel color values are ignored when compressing. 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 header). 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 height, 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 height) { 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_OFFSET); 660 etc1_uint32 encodedHeight = readBEUint16(pHeader + ETC1_PKM_ENCODED_HEIGHT_OFFSET); 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 } 679
