blob: 238c81fae93e571f65cc8ef2402de43c10d4a55a [file] [log] [blame]
 /* libs/opengles/dxt.cpp ** ** Copyright 2007, The Android Open Source Project ** ** Licensed under the Apache License, Version 2.0 (the "License"); ** you may not use this file except in compliance with the License. ** You may obtain a copy of the License at ** ** http://www.apache.org/licenses/LICENSE-2.0 ** ** Unless required by applicable law or agreed to in writing, software ** distributed under the License is distributed on an "AS IS" BASIS, ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** See the License for the specific language governing permissions and ** limitations under the License. */ #define TIMING 0 #if TIMING #include // for optimization timing #include #include #endif #include #include #include "context.h" #define TIMING 0 namespace android { static uint8_t avg23tab[64*64]; static volatile int tables_initialized = 0; // Definitions below are equivalent to these over the valid range of arguments // #define div5(x) ((x)/5) // #define div7(x) ((x)/7) // Use fixed-point to divide by 5 and 7 // 3277 = 2^14/5 + 1 // 2341 = 2^14/7 + 1 #define div5(x) (((x)*3277) >> 14) #define div7(x) (((x)*2341) >> 14) // Table with entry [a << 6 | b] = (2*a + b)/3 for 0 <= a,b < 64 #define avg23(x0,x1) avg23tab[((x0) << 6) | (x1)] // Extract 5/6/5 RGB #define red(x) (((x) >> 11) & 0x1f) #define green(x) (((x) >> 5) & 0x3f) #define blue(x) ( (x) & 0x1f) /* * Convert 5/6/5 RGB (as 3 ints) to 8/8/8 * * Operation count: 8 <<, 0 &, 5 | */ inline static int rgb565SepTo888(int r, int g, int b) { return ((((r << 3) | (r >> 2)) << 16) | (((g << 2) | (g >> 4)) << 8) | ((b << 3) | (b >> 2))); } /* * Convert 5/6/5 RGB (as a single 16-bit word) to 8/8/8 * * r4r3r2r1 r0g5g4g3 g2g1g0b4 b3b2b1b0 rgb * r4r3r2 r1r0g5g4 g3g2g1g0 b4b3b2b1 b0 0 0 0 rgb << 3 * r4r3r2r1 r0r4r3r2 g5g4g3g2 g1g0g5g4 b4b3b2b1 b0b4b3b2 desired result * * Construct the 24-bit RGB word as: * * r4r3r2r1 r0------ -------- -------- -------- -------- (rgb << 8) & 0xf80000 * r4r3r2 -------- -------- -------- -------- (rgb << 3) & 0x070000 * g5g4g3g2 g1g0---- -------- -------- (rgb << 5) & 0x00fc00 * g5g4 -------- -------- (rgb >> 1) & 0x000300 * b4b3b2b1 b0------ (rgb << 3) & 0x0000f8 * b4b3b2 (rgb >> 2) & 0x000007 * * Operation count: 5 <<, 6 &, 5 | (n.b. rgb >> 3 is used twice) */ inline static int rgb565To888(int rgb) { int rgb3 = rgb >> 3; return (((rgb << 8) & 0xf80000) | ( rgb3 & 0x070000) | ((rgb << 5) & 0x00fc00) | ((rgb >> 1) & 0x000300) | ( rgb3 & 0x0000f8) | ((rgb >> 2) & 0x000007)); } #if __BYTE_ORDER == __BIG_ENDIAN static uint32_t swap(uint32_t x) { int b0 = (x >> 24) & 0xff; int b1 = (x >> 16) & 0xff; int b2 = (x >> 8) & 0xff; int b3 = (x ) & 0xff; return (uint32_t)((b3 << 24) | (b2 << 16) | (b1 << 8) | b0); } #endif static void init_tables() { if (tables_initialized) { return; } for (int i = 0; i < 64; i++) { for (int j = 0; j < 64; j++) { int avg = (2*i + j)/3; avg23tab[(i << 6) | j] = avg; } } asm volatile ("" : : : "memory"); tables_initialized = 1; } /* * Utility to scan a DXT1 compressed texture to determine whether it * contains a transparent pixel (color0 < color1, code == 3). This * may be useful if the application lacks information as to whether * the true format is GL_COMPRESSED_RGB_S3TC_DXT1_EXT or * GL_COMPRESSED_RGBA_S3TC_DXT1_EXT. */ bool DXT1HasAlpha(const GLvoid *data, int width, int height) { #if TIMING struct timeval start_t, end_t; struct timezone tz; gettimeofday(&start_t, &tz); #endif bool hasAlpha = false; int xblocks = (width + 3)/4; int yblocks = (height + 3)/4; int numblocks = xblocks*yblocks; uint32_t const *d32 = (uint32_t *)data; for (int b = 0; b < numblocks; b++) { uint32_t colors = *d32++; #if __BYTE_ORDER == __BIG_ENDIAN colors = swap(colors); #endif uint16_t color0 = colors & 0xffff; uint16_t color1 = colors >> 16; if (color0 < color1) { // There's no need to endian-swap within 'bits' // since we don't care which pixel is the transparent one uint32_t bits = *d32++; // Detect if any (odd, even) pair of bits are '11' // bits: b31 b30 b29 ... b3 b2 b1 b0 // bits >> 1: b31 b31 b30 ... b4 b3 b2 b1 // &: b31 (b31 & b30) (b29 & b28) ... (b2 & b1) (b1 & b0) // & 0x55..: 0 (b31 & b30) 0 ... 0 (b1 & b0) if (((bits & (bits >> 1)) & 0x55555555) != 0) { hasAlpha = true; goto done; } } else { // Skip 4 bytes ++d32; } } done: #if TIMING gettimeofday(&end_t, &tz); long usec = (end_t.tv_sec - start_t.tv_sec)*1000000 + (end_t.tv_usec - start_t.tv_usec); printf("Scanned w=%d h=%d in %ld usec\n", width, height, usec); #endif return hasAlpha; } static void decodeDXT1(const GLvoid *data, int width, int height, void *surface, int stride, bool hasAlpha) { init_tables(); uint32_t const *d32 = (uint32_t *)data; // Color table for the current block uint16_t c[4]; c[0] = c[1] = c[2] = c[3] = 0; // Specified colors from the previous block uint16_t prev_color0 = 0x0000; uint16_t prev_color1 = 0x0000; uint16_t* rowPtr = (uint16_t*)surface; for (int base_y = 0; base_y < height; base_y += 4, rowPtr += 4*stride) { uint16_t *blockPtr = rowPtr; for (int base_x = 0; base_x < width; base_x += 4, blockPtr += 4) { uint32_t colors = *d32++; uint32_t bits = *d32++; #if __BYTE_ORDER == __BIG_ENDIAN colors = swap(colors); bits = swap(bits); #endif // Raw colors uint16_t color0 = colors & 0xffff; uint16_t color1 = colors >> 16; // If the new block has the same base colors as the // previous one, we don't need to recompute the color // table c[] if (color0 != prev_color0 || color1 != prev_color1) { // Store raw colors for comparison with next block prev_color0 = color0; prev_color1 = color1; int r0 = red(color0); int g0 = green(color0); int b0 = blue(color0); int r1 = red(color1); int g1 = green(color1); int b1 = blue(color1); if (hasAlpha) { c[0] = (r0 << 11) | ((g0 >> 1) << 6) | (b0 << 1) | 0x1; c[1] = (r1 << 11) | ((g1 >> 1) << 6) | (b1 << 1) | 0x1; } else { c[0] = color0; c[1] = color1; } int r2, g2, b2, r3, g3, b3, a3; int bbits = bits >> 1; bool has2 = ((bbits & ~bits) & 0x55555555) != 0; bool has3 = ((bbits & bits) & 0x55555555) != 0; if (has2 || has3) { if (color0 > color1) { r2 = avg23(r0, r1); g2 = avg23(g0, g1); b2 = avg23(b0, b1); r3 = avg23(r1, r0); g3 = avg23(g1, g0); b3 = avg23(b1, b0); a3 = 1; } else { r2 = (r0 + r1) >> 1; g2 = (g0 + g1) >> 1; b2 = (b0 + b1) >> 1; r3 = g3 = b3 = a3 = 0; } if (hasAlpha) { c[2] = (r2 << 11) | ((g2 >> 1) << 6) | (b2 << 1) | 0x1; c[3] = (r3 << 11) | ((g3 >> 1) << 6) | (b3 << 1) | a3; } else { c[2] = (r2 << 11) | (g2 << 5) | b2; c[3] = (r3 << 11) | (g3 << 5) | b3; } } } uint16_t* blockRowPtr = blockPtr; for (int y = 0; y < 4; y++, blockRowPtr += stride) { // Don't process rows past the botom if (base_y + y >= height) { break; } int w = min(width - base_x, 4); for (int x = 0; x < w; x++) { int code = bits & 0x3; bits >>= 2; blockRowPtr[x] = c[code]; } } } } } // Output data as internalformat=GL_RGBA, type=GL_UNSIGNED_BYTE static void decodeDXT3(const GLvoid *data, int width, int height, void *surface, int stride) { init_tables(); uint32_t const *d32 = (uint32_t *)data; // Specified colors from the previous block uint16_t prev_color0 = 0x0000; uint16_t prev_color1 = 0x0000; // Color table for the current block uint32_t c[4]; c[0] = c[1] = c[2] = c[3] = 0; uint32_t* rowPtr = (uint32_t*)surface; for (int base_y = 0; base_y < height; base_y += 4, rowPtr += 4*stride) { uint32_t *blockPtr = rowPtr; for (int base_x = 0; base_x < width; base_x += 4, blockPtr += 4) { #if __BYTE_ORDER == __BIG_ENDIAN uint32_t alphahi = *d32++; uint32_t alphalo = *d32++; alphahi = swap(alphahi); alphalo = swap(alphalo); #else uint32_t alphalo = *d32++; uint32_t alphahi = *d32++; #endif uint32_t colors = *d32++; uint32_t bits = *d32++; #if __BYTE_ORDER == __BIG_ENDIAN colors = swap(colors); bits = swap(bits); #endif uint64_t alpha = ((uint64_t)alphahi << 32) | alphalo; // Raw colors uint16_t color0 = colors & 0xffff; uint16_t color1 = colors >> 16; // If the new block has the same base colors as the // previous one, we don't need to recompute the color // table c[] if (color0 != prev_color0 || color1 != prev_color1) { // Store raw colors for comparison with next block prev_color0 = color0; prev_color1 = color1; int bbits = bits >> 1; bool has2 = ((bbits & ~bits) & 0x55555555) != 0; bool has3 = ((bbits & bits) & 0x55555555) != 0; if (has2 || has3) { int r0 = red(color0); int g0 = green(color0); int b0 = blue(color0); int r1 = red(color1); int g1 = green(color1); int b1 = blue(color1); int r2 = avg23(r0, r1); int g2 = avg23(g0, g1); int b2 = avg23(b0, b1); int r3 = avg23(r1, r0); int g3 = avg23(g1, g0); int b3 = avg23(b1, b0); c[0] = rgb565SepTo888(r0, g0, b0); c[1] = rgb565SepTo888(r1, g1, b1); c[2] = rgb565SepTo888(r2, g2, b2); c[3] = rgb565SepTo888(r3, g3, b3); } else { // Convert to 8 bits c[0] = rgb565To888(color0); c[1] = rgb565To888(color1); } } uint32_t* blockRowPtr = blockPtr; for (int y = 0; y < 4; y++, blockRowPtr += stride) { // Don't process rows past the botom if (base_y + y >= height) { break; } int w = min(width - base_x, 4); for (int x = 0; x < w; x++) { int a = alpha & 0xf; alpha >>= 4; int code = bits & 0x3; bits >>= 2; blockRowPtr[x] = c[code] | (a << 28) | (a << 24); } } } } } // Output data as internalformat=GL_RGBA, type=GL_UNSIGNED_BYTE static void decodeDXT5(const GLvoid *data, int width, int height, void *surface, int stride) { init_tables(); uint32_t const *d32 = (uint32_t *)data; // Specified alphas from the previous block uint8_t prev_alpha0 = 0x00; uint8_t prev_alpha1 = 0x00; // Specified colors from the previous block uint16_t prev_color0 = 0x0000; uint16_t prev_color1 = 0x0000; // Alpha table for the current block uint8_t a[8]; a[0] = a[1] = a[2] = a[3] = a[4] = a[5] = a[6] = a[7] = 0; // Color table for the current block uint32_t c[4]; c[0] = c[1] = c[2] = c[3] = 0; int good_a5 = 0; int bad_a5 = 0; int good_a6 = 0; int bad_a6 = 0; int good_a7 = 0; int bad_a7 = 0; uint32_t* rowPtr = (uint32_t*)surface; for (int base_y = 0; base_y < height; base_y += 4, rowPtr += 4*stride) { uint32_t *blockPtr = rowPtr; for (int base_x = 0; base_x < width; base_x += 4, blockPtr += 4) { #if __BYTE_ORDER == __BIG_ENDIAN uint32_t alphahi = *d32++; uint32_t alphalo = *d32++; alphahi = swap(alphahi); alphalo = swap(alphalo); #else uint32_t alphalo = *d32++; uint32_t alphahi = *d32++; #endif uint32_t colors = *d32++; uint32_t bits = *d32++; #if __BYTE_ORDER == __BIG_ENDIANx colors = swap(colors); bits = swap(bits); #endif uint64_t alpha = ((uint64_t)alphahi << 32) | alphalo; uint64_t alpha0 = alpha & 0xff; alpha >>= 8; uint64_t alpha1 = alpha & 0xff; alpha >>= 8; if (alpha0 != prev_alpha0 || alpha1 != prev_alpha1) { prev_alpha0 = alpha0; prev_alpha1 = alpha1; a[0] = alpha0; a[1] = alpha1; int a01 = alpha0 + alpha1 - 1; if (alpha0 > alpha1) { a[2] = div7(6*alpha0 + alpha1); a[4] = div7(4*alpha0 + 3*alpha1); a[6] = div7(2*alpha0 + 5*alpha1); // Use symmetry to derive half of the values // A few values will be off by 1 (~.5%) // Alternate which values are computed directly // and which are derived to try to reduce bias a[3] = a01 - a[6]; a[5] = a01 - a[4]; a[7] = a01 - a[2]; } else { a[2] = div5(4*alpha0 + alpha1); a[4] = div5(2*alpha0 + 3*alpha1); a[3] = a01 - a[4]; a[5] = a01 - a[2]; a[6] = 0x00; a[7] = 0xff; } } // Raw colors uint16_t color0 = colors & 0xffff; uint16_t color1 = colors >> 16; // If the new block has the same base colors as the // previous one, we don't need to recompute the color // table c[] if (color0 != prev_color0 || color1 != prev_color1) { // Store raw colors for comparison with next block prev_color0 = color0; prev_color1 = color1; int bbits = bits >> 1; bool has2 = ((bbits & ~bits) & 0x55555555) != 0; bool has3 = ((bbits & bits) & 0x55555555) != 0; if (has2 || has3) { int r0 = red(color0); int g0 = green(color0); int b0 = blue(color0); int r1 = red(color1); int g1 = green(color1); int b1 = blue(color1); int r2 = avg23(r0, r1); int g2 = avg23(g0, g1); int b2 = avg23(b0, b1); int r3 = avg23(r1, r0); int g3 = avg23(g1, g0); int b3 = avg23(b1, b0); c[0] = rgb565SepTo888(r0, g0, b0); c[1] = rgb565SepTo888(r1, g1, b1); c[2] = rgb565SepTo888(r2, g2, b2); c[3] = rgb565SepTo888(r3, g3, b3); } else { // Convert to 8 bits c[0] = rgb565To888(color0); c[1] = rgb565To888(color1); } } uint32_t* blockRowPtr = blockPtr; for (int y = 0; y < 4; y++, blockRowPtr += stride) { // Don't process rows past the botom if (base_y + y >= height) { break; } int w = min(width - base_x, 4); for (int x = 0; x < w; x++) { int acode = alpha & 0x7; alpha >>= 3; int code = bits & 0x3; bits >>= 2; blockRowPtr[x] = c[code] | (a[acode] << 24); } } } } } /* * Decode a DXT-compressed texture into memory. DXT textures consist of * a series of 4x4 pixel blocks in left-to-right, top-down order. * The number of blocks is given by ceil(width/4)*ceil(height/4). * * 'data' points to the texture data. 'width' and 'height' indicate the * dimensions of the texture. We assume width and height are >= 0 but * do not require them to be powers of 2 or divisible by any factor. * * The output is written to 'surface' with each scanline separated by * 'stride' 2- or 4-byte words. * * 'format' indicates the type of compression and must be one of the following: * * GL_COMPRESSED_RGB_S3TC_DXT1_EXT: * The output is written as 5/6/5 opaque RGB (16 bit words). * 8 bytes are read from 'data' for each block. * * GL_COMPRESSED_RGBA_S3TC_DXT1_EXT * The output is written as 5/5/5/1 RGBA (16 bit words) * 8 bytes are read from 'data' for each block. * * GL_COMPRESSED_RGBA_S3TC_DXT3_EXT * GL_COMPRESSED_RGBA_S3TC_DXT5_EXT * The output is written as 8/8/8/8 ARGB (32 bit words) * 16 bytes are read from 'data' for each block. */ void decodeDXT(const GLvoid *data, int width, int height, void *surface, int stride, int format) { #if TIMING struct timeval start_t, end_t; struct timezone tz; gettimeofday(&start_t, &tz); #endif switch (format) { case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: decodeDXT1(data, width, height, surface, stride, false); break; case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: decodeDXT1(data, width, height, surface, stride, true); break; case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: decodeDXT3(data, width, height, surface, stride); break; case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: decodeDXT5(data, width, height, surface, stride); break; } #if TIMING gettimeofday(&end_t, &tz); long usec = (end_t.tv_sec - start_t.tv_sec)*1000000 + (end_t.tv_usec - start_t.tv_usec); printf("Loaded w=%d h=%d in %ld usec\n", width, height, usec); #endif } } // namespace android