| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES Utilities |
| * ------------------------------------------------ |
| * |
| * Copyright 2014 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. |
| * |
| */ |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief Map tcu::TextureFormat to GL pixel transfer format. |
| * |
| * Maps generic texture format description to GL pixel transfer format. |
| * If no mapping is found, throws tcu::InternalError. |
| * |
| * \param texFormat Generic texture format. |
| * \return GL pixel transfer format. |
| *//*--------------------------------------------------------------------*/ |
| 'use strict'; |
| goog.provide('framework.common.tcuCompressedTexture'); |
| goog.require('framework.common.tcuTexture'); |
| goog.require('framework.delibs.debase.deMath'); |
| |
| goog.scope(function() { |
| |
| var tcuCompressedTexture = framework.common.tcuCompressedTexture; |
| var tcuTexture = framework.common.tcuTexture; |
| var deMath = framework.delibs.debase.deMath; |
| |
| var DE_ASSERT = function(x) { |
| if (!x) |
| throw new Error('Assert failed'); |
| }; |
| |
| /** |
| * @enum |
| */ |
| tcuCompressedTexture.Format = { |
| ETC1_RGB8: 0, |
| EAC_R11: 1, |
| EAC_SIGNED_R11: 2, |
| EAC_RG11: 3, |
| EAC_SIGNED_RG11: 4, |
| ETC2_RGB8: 5, |
| ETC2_SRGB8: 6, |
| ETC2_RGB8_PUNCHTHROUGH_ALPHA1: 7, |
| ETC2_SRGB8_PUNCHTHROUGH_ALPHA1: 8, |
| ETC2_EAC_RGBA8: 9, |
| ETC2_EAC_SRGB8_ALPHA8: 10, |
| |
| ASTC_4x4_RGBA: 11, |
| ASTC_5x4_RGBA: 12, |
| ASTC_5x5_RGBA: 13, |
| ASTC_6x5_RGBA: 14, |
| ASTC_6x6_RGBA: 15, |
| ASTC_8x5_RGBA: 16, |
| ASTC_8x6_RGBA: 17, |
| ASTC_8x8_RGBA: 18, |
| ASTC_10x5_RGBA: 19, |
| ASTC_10x6_RGBA: 20, |
| ASTC_10x8_RGBA: 21, |
| ASTC_10x10_RGBA: 22, |
| ASTC_12x10_RGBA: 23, |
| ASTC_12x12_RGBA: 24, |
| ASTC_4x4_SRGB8_ALPHA8: 25, |
| ASTC_5x4_SRGB8_ALPHA8: 26, |
| ASTC_5x5_SRGB8_ALPHA8: 27, |
| ASTC_6x5_SRGB8_ALPHA8: 28, |
| ASTC_6x6_SRGB8_ALPHA8: 29, |
| ASTC_8x5_SRGB8_ALPHA8: 30, |
| ASTC_8x6_SRGB8_ALPHA8: 31, |
| ASTC_8x8_SRGB8_ALPHA8: 32, |
| ASTC_10x5_SRGB8_ALPHA8: 33, |
| ASTC_10x6_SRGB8_ALPHA8: 34, |
| ASTC_10x8_SRGB8_ALPHA8: 35, |
| ASTC_10x10_SRGB8_ALPHA8: 36, |
| ASTC_12x10_SRGB8_ALPHA8: 37, |
| ASTC_12x12_SRGB8_ALPHA8: 38 |
| }; |
| |
| tcuCompressedTexture.divRoundUp = function(a, b) { |
| return Math.floor(a / b) + ((a % b) ? 1 : 0); |
| }; |
| |
| tcuCompressedTexture.isEtcFormat = function(fmt) { |
| // WebGL2 supports ETC2 and EAC formats |
| switch (fmt) { |
| // case tcuCompressedTexture.Format.ETC1_RGB8: |
| case tcuCompressedTexture.Format.EAC_R11: |
| case tcuCompressedTexture.Format.EAC_SIGNED_R11: |
| case tcuCompressedTexture.Format.EAC_RG11: |
| case tcuCompressedTexture.Format.EAC_SIGNED_RG11: |
| case tcuCompressedTexture.Format.ETC2_RGB8: |
| case tcuCompressedTexture.Format.ETC2_SRGB8: |
| case tcuCompressedTexture.Format.ETC2_RGB8_PUNCHTHROUGH_ALPHA1: |
| case tcuCompressedTexture.Format.ETC2_SRGB8_PUNCHTHROUGH_ALPHA1: |
| case tcuCompressedTexture.Format.ETC2_EAC_RGBA8: |
| case tcuCompressedTexture.Format.ETC2_EAC_SRGB8_ALPHA8: |
| return true; |
| |
| default: |
| return false; |
| } |
| }; |
| |
| tcuCompressedTexture.etcDecompressInternal = function() { |
| |
| var ETC2_BLOCK_WIDTH = 4; |
| var ETC2_BLOCK_HEIGHT = 4; |
| var ETC2_UNCOMPRESSED_PIXEL_SIZE_A8 = 1; |
| var ETC2_UNCOMPRESSED_PIXEL_SIZE_R11 = 2; |
| var ETC2_UNCOMPRESSED_PIXEL_SIZE_RG11 = 4; |
| var ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8 = 3; |
| var ETC2_UNCOMPRESSED_PIXEL_SIZE_RGBA8 = 4; |
| var ETC2_UNCOMPRESSED_BLOCK_SIZE_A8 = ETC2_BLOCK_WIDTH * ETC2_BLOCK_HEIGHT * ETC2_UNCOMPRESSED_PIXEL_SIZE_A8; |
| var ETC2_UNCOMPRESSED_BLOCK_SIZE_R11 = ETC2_BLOCK_WIDTH * ETC2_BLOCK_HEIGHT * ETC2_UNCOMPRESSED_PIXEL_SIZE_R11; |
| var ETC2_UNCOMPRESSED_BLOCK_SIZE_RG11 = ETC2_BLOCK_WIDTH * ETC2_BLOCK_HEIGHT * ETC2_UNCOMPRESSED_PIXEL_SIZE_RG11; |
| var ETC2_UNCOMPRESSED_BLOCK_SIZE_RGB8 = ETC2_BLOCK_WIDTH * ETC2_BLOCK_HEIGHT * ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8; |
| var ETC2_UNCOMPRESSED_BLOCK_SIZE_RGBA8 = ETC2_BLOCK_WIDTH * ETC2_BLOCK_HEIGHT * ETC2_UNCOMPRESSED_PIXEL_SIZE_RGBA8; |
| |
| /** |
| * @param {ArrayBuffer} src Source ArrayBuffer |
| * @return {Uint8Array} |
| */ |
| var get64BitBlock = function(src, blockNdx) { |
| var block = new Uint8Array(src, blockNdx * 8, 8); |
| return block; |
| }; |
| |
| /** |
| * @param {ArrayBuffer} src Source ArrayBuffer |
| * Return the first 64 bits of a 128 bit block. |
| */ |
| var get128BitBlockStart = function(src, blockNdx) { |
| return get64BitBlock(src, 2 * blockNdx); |
| }; |
| |
| /** |
| * @param {ArrayBuffer} src Source ArrayBuffer |
| * Return the last 64 bits of a 128 bit block. |
| */ |
| var get128BitBlockEnd = function(src, blockNdx) { |
| return get64BitBlock(src, 2 * blockNdx + 1); |
| }; |
| |
| var mask8 = function(src, low, high) { |
| if (low > 7 || high < 0) |
| return { |
| value: 0, |
| bits: 0 |
| }; |
| |
| var numBits = high - low + 1; |
| var mask = (1 << numBits) - 1; |
| |
| return { |
| value: (src >> low) & mask, |
| bits: numBits |
| }; |
| }; |
| |
| var getBits64 = function(src, low, high) { |
| var result = 0; |
| var bits = 0; |
| var lowIndex = low; |
| var highIndex = high; |
| for (var i = 7; i >= 0; i--) { |
| var v = mask8(src[i], Math.max(0, lowIndex), Math.min(7, highIndex)); |
| lowIndex = lowIndex - 8; |
| highIndex = highIndex - 8; |
| result = result | (v.value << bits); |
| bits = v.bits; |
| } |
| return result; |
| }; |
| |
| var getBit64 = function(src, bit) { |
| return getBits64(src, bit, bit); |
| }; |
| |
| var extendSigned3To8 = function(src) { |
| var isNeg = (src & (1 << 2)) != 0; |
| var val = isNeg ? src - 8 : src; |
| return val; |
| }; |
| |
| var extend4To8 = function(src) { |
| return src * 255 / 15; |
| }; |
| |
| var extend5To8 = function(src) { |
| return src * 255 / 31; |
| }; |
| |
| var extend6To8 = function(src) { |
| return src * 255 / 63; |
| }; |
| |
| var extend7To8 = function(src) { |
| return src * 255 / 127; |
| }; |
| |
| var extend11To16 = function(src) { |
| return src * 32.015144; |
| }; |
| |
| var extend11To16WithSign = function(src) { |
| if (src < 0) |
| return -extend11To16(-src); |
| else |
| return extend11To16(src); |
| }; |
| |
| /** |
| * @param { (Uint16Array|Int16Array) } dst |
| * @param {Uint8Array} src |
| * @param {boolean} signedMode |
| */ |
| var decompressEAC11Block = function(dst, src, signedMode) { |
| var modifierTable = [ |
| [-3, -6, -9, -15, 2, 5, 8, 14], |
| [-3, -7, -10, -13, 2, 6, 9, 12], |
| [-2, -5, -8, -13, 1, 4, 7, 12], |
| [-2, -4, -6, -13, 1, 3, 5, 12], |
| [-3, -6, -8, -12, 2, 5, 7, 11], |
| [-3, -7, -9, -11, 2, 6, 8, 10], |
| [-4, -7, -8, -11, 3, 6, 7, 10], |
| [-3, -5, -8, -11, 2, 4, 7, 10], |
| [-2, -6, -8, -10, 1, 5, 7, 9], |
| [-2, -5, -8, -10, 1, 4, 7, 9], |
| [-2, -4, -8, -10, 1, 3, 7, 9], |
| [-2, -5, -7, -10, 1, 4, 6, 9], |
| [-3, -4, -7, -10, 2, 3, 6, 9], |
| [-1, -2, -3, -10, 0, 1, 2, 9], |
| [-4, -6, -8, -9, 3, 5, 7, 8], |
| [-3, -5, -7, -9, 2, 4, 6, 8] |
| ]; |
| |
| var multiplier = getBits64(src, 52, 55); |
| var tableNdx = getBits64(src, 48, 51); |
| var baseCodeword = getBits64(src, 56, 63); |
| |
| if (signedMode) { |
| if (baseCodeword > 127) |
| baseCodeword -= 256; |
| if (baseCodeword == -128) |
| baseCodeword = -127; |
| } |
| |
| var pixelNdx = 0; |
| for (var x = 0; x < ETC2_BLOCK_WIDTH; x++) { |
| for (var y = 0; y < ETC2_BLOCK_HEIGHT; y++) { |
| var dstOffset = (y * ETC2_BLOCK_WIDTH + x); |
| var pixelBitNdx = 45 - 3 * pixelNdx; |
| var modifierNdx = (getBit64(src, pixelBitNdx + 2) << 2) | (getBit64(src, pixelBitNdx + 1) << 1) | getBit64(src, pixelBitNdx); |
| var modifier = modifierTable[tableNdx][modifierNdx]; |
| |
| if (signedMode) { |
| if (multiplier != 0) |
| dst[dstOffset] = deMath.clamp(baseCodeword * 8 + multiplier * modifier * 8, -1023, 1023); |
| else |
| dst[dstOffset] = deMath.clamp(baseCodeword * 8 + modifier, -1023, 1023); |
| } else { |
| if (multiplier != 0) |
| dst[dstOffset] = deMath.clamp(baseCodeword * 8 + 4 + multiplier * modifier * 8, 0, 2047); |
| else |
| dst[dstOffset] = deMath.clamp(baseCodeword * 8 + 4 + modifier, 0, 2047); |
| } |
| pixelNdx++; |
| } |
| } |
| }; |
| |
| var decompressEAC_R11 = function(/*const tcu::PixelBufferAccess&*/ dst, width, height, src, signedMode) { |
| /** @const */ var numBlocksX = tcuCompressedTexture.divRoundUp(width, 4); |
| /** @const */ var numBlocksY = tcuCompressedTexture.divRoundUp(height, 4); |
| var dstPtr; |
| var dstRowPitch = dst.getRowPitch(); |
| var dstPixelSize = ETC2_UNCOMPRESSED_PIXEL_SIZE_R11; |
| var uncompressedBlockArray = new ArrayBuffer(ETC2_UNCOMPRESSED_BLOCK_SIZE_R11); |
| var uncompressedBlock16; |
| if (signedMode) { |
| dstPtr = new Int16Array(dst.m_data); |
| uncompressedBlock16 = new Int16Array(uncompressedBlockArray); |
| } else { |
| dstPtr = new Uint16Array(dst.m_data); |
| uncompressedBlock16 = new Uint16Array(uncompressedBlockArray); |
| } |
| |
| for (var blockY = 0; blockY < numBlocksY; blockY++) { |
| for (var blockX = 0; blockX < numBlocksX; blockX++) { |
| /*const deUint64*/ var compressedBlock = get64BitBlock(src, blockY * numBlocksX + blockX); |
| |
| // Decompress. |
| decompressEAC11Block(uncompressedBlock16, compressedBlock, signedMode); |
| |
| // Write to dst. |
| var baseX = blockX * ETC2_BLOCK_WIDTH; |
| var baseY = blockY * ETC2_BLOCK_HEIGHT; |
| for (var y = 0; y < Math.min(ETC2_BLOCK_HEIGHT, height - baseY); y++) { |
| for (var x = 0; x < Math.min(ETC2_BLOCK_WIDTH, width - baseX); x++) { |
| DE_ASSERT(ETC2_UNCOMPRESSED_PIXEL_SIZE_R11 == 2); |
| |
| if (signedMode) { |
| var srcIndex = y * ETC2_BLOCK_WIDTH + x; |
| var dstIndex = (baseY + y) * dstRowPitch / dstPixelSize + baseX + x; |
| |
| dstPtr[dstIndex] = extend11To16WithSign(uncompressedBlock16[srcIndex]); |
| } else { |
| var srcIndex = y * ETC2_BLOCK_WIDTH + x; |
| var dstIndex = (baseY + y) * dstRowPitch / dstPixelSize + baseX + x; |
| |
| dstPtr[dstIndex] = extend11To16(uncompressedBlock16[srcIndex]); |
| } |
| } |
| } |
| } |
| } |
| }; |
| |
| var decompressEAC_RG11 = function(/*const tcu::PixelBufferAccess&*/ dst, width, height, src, signedMode) { |
| /** @const */ var numBlocksX = tcuCompressedTexture.divRoundUp(width, 4); |
| /** @const */ var numBlocksY = tcuCompressedTexture.divRoundUp(height, 4); |
| var dstPtr; |
| var dstRowPitch = dst.getRowPitch(); |
| var dstPixelSize = ETC2_UNCOMPRESSED_PIXEL_SIZE_RG11; |
| var uncompressedBlockArrayR = new ArrayBuffer(ETC2_UNCOMPRESSED_BLOCK_SIZE_R11); |
| var uncompressedBlockArrayG = new ArrayBuffer(ETC2_UNCOMPRESSED_BLOCK_SIZE_R11); |
| var uncompressedBlockR16; |
| var uncompressedBlockG16; |
| if (signedMode) { |
| dstPtr = new Int16Array(dst.m_data); |
| uncompressedBlockR16 = new Int16Array(uncompressedBlockArrayR); |
| uncompressedBlockG16 = new Int16Array(uncompressedBlockArrayG); |
| } else { |
| dstPtr = new Uint16Array(dst.m_data); |
| uncompressedBlockR16 = new Uint16Array(uncompressedBlockArrayR); |
| uncompressedBlockG16 = new Uint16Array(uncompressedBlockArrayG); |
| } |
| |
| for (var blockY = 0; blockY < numBlocksY; blockY++) { |
| for (var blockX = 0; blockX < numBlocksX; blockX++) { |
| /*const deUint64*/ var compressedBlockR = get128BitBlockStart(src, blockY * numBlocksX + blockX); |
| /*const deUint64*/ var compressedBlockG = get128BitBlockEnd(src, blockY * numBlocksX + blockX); |
| |
| // Decompress. |
| decompressEAC11Block(uncompressedBlockR16, compressedBlockR, signedMode); |
| decompressEAC11Block(uncompressedBlockG16, compressedBlockG, signedMode); |
| |
| // Write to dst. |
| var baseX = blockX * ETC2_BLOCK_WIDTH; |
| var baseY = blockY * ETC2_BLOCK_HEIGHT; |
| for (var y = 0; y < Math.min(ETC2_BLOCK_HEIGHT, height - baseY); y++) { |
| for (var x = 0; x < Math.min(ETC2_BLOCK_WIDTH, width - baseX); x++) { |
| DE_ASSERT(ETC2_UNCOMPRESSED_PIXEL_SIZE_RG11 == 4); |
| |
| if (signedMode) { |
| var srcIndex = y * ETC2_BLOCK_WIDTH + x; |
| var dstIndex = 2 * ((baseY + y) * dstRowPitch / dstPixelSize + baseX + x); |
| |
| dstPtr[dstIndex] = extend11To16WithSign(uncompressedBlockR16[srcIndex]); |
| dstPtr[dstIndex + 1] = extend11To16WithSign(uncompressedBlockG16[srcIndex]); |
| } else { |
| var srcIndex = y * ETC2_BLOCK_WIDTH + x; |
| var dstIndex = 2 * ((baseY + y) * dstRowPitch / dstPixelSize + baseX + x); |
| |
| dstPtr[dstIndex] = extend11To16(uncompressedBlockR16[srcIndex]); |
| dstPtr[dstIndex + 1] = extend11To16(uncompressedBlockG16[srcIndex]); |
| } |
| } |
| } |
| } |
| } |
| }; |
| |
| // if alphaMode is true, do PUNCHTHROUGH and store alpha to alphaDst; otherwise do ordinary ETC2 RGB8. |
| /** |
| * @param {Uint8Array} dst Destination array |
| * @param {Uint8Array} src Source array |
| * @param {Uint8Array} alphaDst Optional Alpha output channel |
| */ |
| var decompressETC2Block = function(dst, src, alphaDst, alphaMode) { |
| /** |
| * enum |
| */ |
| var Etc2Mode = { |
| MODE_INDIVIDUAL: 0, |
| MODE_DIFFERENTIAL: 1, |
| MODE_T: 2, |
| MODE_H: 3, |
| MODE_PLANAR: 4 |
| }; |
| |
| var diffOpaqueBit = getBit64(src, 33); |
| var selBR = getBits64(src, 59, 63); // 5 bits. |
| var selBG = getBits64(src, 51, 55); |
| var selBB = getBits64(src, 43, 47); |
| var selDR = extendSigned3To8(getBits64(src, 56, 58)); // 3 bits. |
| var selDG = extendSigned3To8(getBits64(src, 48, 50)); |
| var selDB = extendSigned3To8(getBits64(src, 40, 42)); |
| |
| var mode; |
| |
| if (!alphaMode && diffOpaqueBit == 0) |
| mode = Etc2Mode.MODE_INDIVIDUAL; |
| else if (!deMath.deInRange32(selBR + selDR, 0, 31)) |
| mode = Etc2Mode.MODE_T; |
| else if (!deMath.deInRange32(selBG + selDG, 0, 31)) |
| mode = Etc2Mode.MODE_H; |
| else if (!deMath.deInRange32(selBB + selDB, 0, 31)) |
| mode = Etc2Mode.MODE_PLANAR; |
| else |
| mode = Etc2Mode.MODE_DIFFERENTIAL; |
| |
| if (mode == Etc2Mode.MODE_INDIVIDUAL || mode == Etc2Mode.MODE_DIFFERENTIAL) { |
| // Individual and differential modes have some steps in common, handle them here. |
| var modifierTable = [ |
| // 00 01 10 11 |
| [2, 8, -2, -8], |
| [5, 17, -5, -17], |
| [9, 29, -9, -29], |
| [13, 42, -13, -42], |
| [18, 60, -18, -60], |
| [24, 80, -24, -80], |
| [33, 106, -33, -106], |
| [47, 183, -47, -183] |
| ]; |
| |
| var flipBit = getBit64(src, 32); |
| var table = [getBits64(src, 37, 39), getBits64(src, 34, 36)]; |
| var baseR = []; |
| var baseG = []; |
| var baseB = []; |
| |
| if (mode == Etc2Mode.MODE_INDIVIDUAL) { |
| // Individual mode, initial values. |
| baseR[0] = extend4To8(getBits64(src, 60, 63)); |
| baseR[1] = extend4To8(getBits64(src, 56, 59)); |
| baseG[0] = extend4To8(getBits64(src, 52, 55)); |
| baseG[1] = extend4To8(getBits64(src, 48, 51)); |
| baseB[0] = extend4To8(getBits64(src, 44, 47)); |
| baseB[1] = extend4To8(getBits64(src, 40, 43)); |
| } else { |
| // Differential mode, initial values. |
| baseR[0] = extend5To8(selBR); |
| baseG[0] = extend5To8(selBG); |
| baseB[0] = extend5To8(selBB); |
| |
| baseR[1] = extend5To8((selBR + selDR)); |
| baseG[1] = extend5To8((selBG + selDG)); |
| baseB[1] = extend5To8((selBB + selDB)); |
| } |
| |
| // Write final pixels for individual or differential mode. |
| var pixelNdx = 0; |
| for (var x = 0; x < ETC2_BLOCK_WIDTH; x++) { |
| for (var y = 0; y < ETC2_BLOCK_HEIGHT; y++, pixelNdx++) { |
| var dstOffset = (y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8; |
| var subBlock = ((flipBit ? y : x) >= 2) ? 1 : 0; |
| var tableNdx = table[subBlock]; |
| var modifierNdx = (getBit64(src, 16 + pixelNdx) << 1) | getBit64(src, pixelNdx); |
| var alphaDstOffset = (y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_A8; // Only needed for PUNCHTHROUGH version. |
| |
| // If doing PUNCHTHROUGH version (alphaMode), opaque bit may affect colors. |
| if (alphaMode && diffOpaqueBit == 0 && modifierNdx == 2) { |
| dst[dstOffset + 0] = 0; |
| dst[dstOffset + 1] = 0; |
| dst[dstOffset + 2] = 0; |
| alphaDst[alphaDstOffset] = 0; |
| } else { |
| var modifier; |
| |
| // PUNCHTHROUGH version and opaque bit may also affect modifiers. |
| if (alphaMode && diffOpaqueBit == 0 && (modifierNdx == 0 || modifierNdx == 2)) |
| modifier = 0; |
| else |
| modifier = modifierTable[tableNdx][modifierNdx]; |
| |
| dst[dstOffset + 0] = deMath.clamp(baseR[subBlock] + modifier, 0, 255); |
| dst[dstOffset + 1] = deMath.clamp(baseG[subBlock] + modifier, 0, 255); |
| dst[dstOffset + 2] = deMath.clamp(baseB[subBlock] + modifier, 0, 255); |
| |
| if (alphaMode) |
| alphaDst[alphaDstOffset] = 255; |
| } |
| } |
| } |
| } else if (mode == Etc2Mode.MODE_T || mode == Etc2Mode.MODE_H) { |
| // T and H modes have some steps in common, handle them here. |
| var distTable = [3, 6, 11, 16, 23, 32, 41, 64]; |
| |
| var paintR = []; |
| var paintG = []; |
| var paintB = []; |
| |
| if (mode == Etc2Mode.MODE_T) { |
| // T mode, calculate paint values. |
| var R1a = getBits64(src, 59, 60); |
| var R1b = getBits64(src, 56, 57); |
| var G1 = getBits64(src, 52, 55); |
| var B1 = getBits64(src, 48, 51); |
| var R2 = getBits64(src, 44, 47); |
| var G2 = getBits64(src, 40, 43); |
| var B2 = getBits64(src, 36, 39); |
| var distNdx = (getBits64(src, 34, 35) << 1) | getBit64(src, 32); |
| var dist = distTable[distNdx]; |
| |
| paintR[0] = extend4To8((R1a << 2) | R1b); |
| paintG[0] = extend4To8(G1); |
| paintB[0] = extend4To8(B1); |
| paintR[2] = extend4To8(R2); |
| paintG[2] = extend4To8(G2); |
| paintB[2] = extend4To8(B2); |
| paintR[1] = deMath.clamp(paintR[2] + dist, 0, 255); |
| paintG[1] = deMath.clamp(paintG[2] + dist, 0, 255); |
| paintB[1] = deMath.clamp(paintB[2] + dist, 0, 255); |
| paintR[3] = deMath.clamp(paintR[2] - dist, 0, 255); |
| paintG[3] = deMath.clamp(paintG[2] - dist, 0, 255); |
| paintB[3] = deMath.clamp(paintB[2] - dist, 0, 255); |
| } else { |
| // H mode, calculate paint values. |
| var R1 = getBits64(src, 59, 62); |
| var G1a = getBits64(src, 56, 58); |
| var G1b = getBit64(src, 52); |
| var B1a = getBit64(src, 51); |
| var B1b = getBits64(src, 47, 49); |
| var R2 = getBits64(src, 43, 46); |
| var G2 = getBits64(src, 39, 42); |
| var B2 = getBits64(src, 35, 38); |
| var baseR = []; |
| var baseG = []; |
| var baseB = []; |
| var baseValue = []; |
| var distNdx; |
| var dist; |
| |
| baseR[0] = extend4To8(R1); |
| baseG[0] = extend4To8((G1a << 1) | G1b); |
| baseB[0] = extend4To8((B1a << 3) | B1b); |
| baseR[1] = extend4To8(R2); |
| baseG[1] = extend4To8(G2); |
| baseB[1] = extend4To8(B2); |
| baseValue[0] = ((baseR[0]) << 16) | ((baseG[0]) << 8) | baseB[0]; |
| baseValue[1] = ((baseR[1]) << 16) | ((baseG[1]) << 8) | baseB[1]; |
| distNdx = (getBit64(src, 34) << 2) | (getBit64(src, 32) << 1); |
| if (baseValue[0] >= baseValue[1]) |
| distNdx += 1; |
| dist = distTable[distNdx]; |
| |
| paintR[0] = deMath.clamp(baseR[0] + dist, 0, 255); |
| paintG[0] = deMath.clamp(baseG[0] + dist, 0, 255); |
| paintB[0] = deMath.clamp(baseB[0] + dist, 0, 255); |
| paintR[1] = deMath.clamp(baseR[0] - dist, 0, 255); |
| paintG[1] = deMath.clamp(baseG[0] - dist, 0, 255); |
| paintB[1] = deMath.clamp(baseB[0] - dist, 0, 255); |
| paintR[2] = deMath.clamp(baseR[1] + dist, 0, 255); |
| paintG[2] = deMath.clamp(baseG[1] + dist, 0, 255); |
| paintB[2] = deMath.clamp(baseB[1] + dist, 0, 255); |
| paintR[3] = deMath.clamp(baseR[1] - dist, 0, 255); |
| paintG[3] = deMath.clamp(baseG[1] - dist, 0, 255); |
| paintB[3] = deMath.clamp(baseB[1] - dist, 0, 255); |
| } |
| |
| // Write final pixels for T or H mode. |
| var pixelNdx = 0; |
| for (var x = 0; x < ETC2_BLOCK_WIDTH; x++) { |
| for (var y = 0; y < ETC2_BLOCK_HEIGHT; y++, pixelNdx++) { |
| var dstOffset = (y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8; |
| var paintNdx = (getBit64(src, 16 + pixelNdx) << 1) | getBit64(src, pixelNdx); |
| var alphaDstOffset = (y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_A8; // Only needed for PUNCHTHROUGH version. |
| |
| if (alphaMode && diffOpaqueBit == 0 && paintNdx == 2) { |
| dst[dstOffset + 0] = 0; |
| dst[dstOffset + 1] = 0; |
| dst[dstOffset + 2] = 0; |
| alphaDst[alphaDstOffset] = 0; |
| } else { |
| dst[dstOffset + 0] = deMath.clamp(paintR[paintNdx], 0, 255); |
| dst[dstOffset + 1] = deMath.clamp(paintG[paintNdx], 0, 255); |
| dst[dstOffset + 2] = deMath.clamp(paintB[paintNdx], 0, 255); |
| |
| if (alphaMode) |
| alphaDst[alphaDstOffset] = 255; |
| } |
| } |
| } |
| } else { |
| // Planar mode. |
| var GO1 = getBit64(src, 56); |
| var GO2 = getBits64(src, 49, 54); |
| var BO1 = getBit64(src, 48); |
| var BO2 = getBits64(src, 43, 44); |
| var BO3 = getBits64(src, 39, 41); |
| var RH1 = getBits64(src, 34, 38); |
| var RH2 = getBit64(src, 32); |
| var RO = extend6To8(getBits64(src, 57, 62)); |
| var GO = extend7To8((GO1 << 6) | GO2); |
| var BO = extend6To8((BO1 << 5) | (BO2 << 3) | BO3); |
| var RH = extend6To8((RH1 << 1) | RH2); |
| var GH = extend7To8(getBits64(src, 25, 31)); |
| var BH = extend6To8(getBits64(src, 19, 24)); |
| var RV = extend6To8(getBits64(src, 13, 18)); |
| var GV = extend7To8(getBits64(src, 6, 12)); |
| var BV = extend6To8(getBits64(src, 0, 5)); |
| |
| // Write final pixels for planar mode. |
| for (var y = 0; y < 4; y++) { |
| for (var x = 0; x < 4; x++) { |
| var dstOffset = (y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8; |
| var unclampedR = (x * (RH - RO) + y * (RV - RO) + 4 * RO + 2) / 4; |
| var unclampedG = (x * (GH - GO) + y * (GV - GO) + 4 * GO + 2) / 4; |
| var unclampedB = (x * (BH - BO) + y * (BV - BO) + 4 * BO + 2) / 4; |
| var alphaDstOffset = (y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_A8; // Only needed for PUNCHTHROUGH version. |
| |
| dst[dstOffset + 0] = deMath.clamp(unclampedR, 0, 255); |
| dst[dstOffset + 1] = deMath.clamp(unclampedG, 0, 255); |
| dst[dstOffset + 2] = deMath.clamp(unclampedB, 0, 255); |
| |
| if (alphaMode) |
| alphaDst[alphaDstOffset] = 255; |
| } |
| } |
| } |
| }; |
| |
| var decompressEAC8Block = function(dst, src) { |
| var modifierTable = [ |
| [-3, -6, -9, -15, 2, 5, 8, 14], |
| [-3, -7, -10, -13, 2, 6, 9, 12], |
| [-2, -5, -8, -13, 1, 4, 7, 12], |
| [-2, -4, -6, -13, 1, 3, 5, 12], |
| [-3, -6, -8, -12, 2, 5, 7, 11], |
| [-3, -7, -9, -11, 2, 6, 8, 10], |
| [-4, -7, -8, -11, 3, 6, 7, 10], |
| [-3, -5, -8, -11, 2, 4, 7, 10], |
| [-2, -6, -8, -10, 1, 5, 7, 9], |
| [-2, -5, -8, -10, 1, 4, 7, 9], |
| [-2, -4, -8, -10, 1, 3, 7, 9], |
| [-2, -5, -7, -10, 1, 4, 6, 9], |
| [-3, -4, -7, -10, 2, 3, 6, 9], |
| [-1, -2, -3, -10, 0, 1, 2, 9], |
| [-4, -6, -8, -9, 3, 5, 7, 8], |
| [-3, -5, -7, -9, 2, 4, 6, 8] |
| ]; |
| |
| var baseCodeword = getBits64(src, 56, 63); |
| var multiplier = getBits64(src, 52, 55); |
| var tableNdx = getBits64(src, 48, 51); |
| |
| var pixelNdx = 0; |
| for (var x = 0; x < ETC2_BLOCK_WIDTH; x++) { |
| for (var y = 0; y < ETC2_BLOCK_HEIGHT; y++, pixelNdx++) { |
| var dstOffset = (y * ETC2_BLOCK_WIDTH + x); |
| var pixelBitNdx = 45 - 3 * pixelNdx; |
| var modifierNdx = (getBit64(src, pixelBitNdx + 2) << 2) | (getBit64(src, pixelBitNdx + 1) << 1) | getBit64(src, pixelBitNdx); |
| var modifier = modifierTable[tableNdx][modifierNdx]; |
| |
| dst[dstOffset] = deMath.clamp(baseCodeword + multiplier * modifier, 0, 255); |
| } |
| } |
| }; |
| |
| var decompressETC2 = function(/*const tcu::PixelBufferAccess&*/ dst, width, height, src) { |
| var numBlocksX = tcuCompressedTexture.divRoundUp(width, 4); |
| var numBlocksY = tcuCompressedTexture.divRoundUp(height, 4); |
| var dstPtr = new Uint8Array(dst.m_data); |
| var dstRowPitch = dst.getRowPitch(); |
| var dstPixelSize = ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8; |
| var uncompressedBlockArray = new ArrayBuffer(ETC2_UNCOMPRESSED_BLOCK_SIZE_RGB8); |
| var uncompressedBlock = new Uint8Array(uncompressedBlockArray); |
| |
| for (var blockY = 0; blockY < numBlocksY; blockY++) { |
| for (var blockX = 0; blockX < numBlocksX; blockX++) { |
| var compressedBlock = get64BitBlock(src, blockY * numBlocksX + blockX); |
| |
| // Decompress. |
| decompressETC2Block(uncompressedBlock, compressedBlock, null, false); |
| |
| // Write to dst. |
| var baseX = blockX * ETC2_BLOCK_WIDTH; |
| var baseY = blockY * ETC2_BLOCK_HEIGHT; |
| for (var y = 0; y < Math.min(ETC2_BLOCK_HEIGHT, height - baseY); y++) { |
| for (var x = 0; x < Math.min(ETC2_BLOCK_WIDTH, width - baseX); x++) { |
| var srcIndex = (y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8; |
| var dstIndex = (baseY + y) * dstRowPitch + (baseX + x) * dstPixelSize; |
| |
| for (var i = 0; i < ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8; i++) |
| dstPtr[dstIndex + i] = uncompressedBlock[srcIndex + i]; |
| } |
| } |
| } |
| } |
| }; |
| |
| var decompressETC2_EAC_RGBA8 = function(/*const tcu::PixelBufferAccess&*/ dst, width, height, src) { |
| var numBlocksX = tcuCompressedTexture.divRoundUp(width, 4); |
| var numBlocksY = tcuCompressedTexture.divRoundUp(height, 4); |
| var dstPtr = new Uint8Array(dst.m_data); |
| var dstRowPitch = dst.getRowPitch(); |
| var dstPixelSize = ETC2_UNCOMPRESSED_PIXEL_SIZE_RGBA8; |
| var uncompressedBlockArray = new ArrayBuffer(ETC2_UNCOMPRESSED_BLOCK_SIZE_RGB8); |
| var uncompressedBlock = new Uint8Array(uncompressedBlockArray); |
| var uncompressedBlockAlphaArray = new ArrayBuffer(ETC2_UNCOMPRESSED_BLOCK_SIZE_A8); |
| var uncompressedBlockAlpha = new Uint8Array(uncompressedBlockAlphaArray); |
| |
| for (var blockY = 0; blockY < numBlocksY; blockY++) { |
| for (var blockX = 0; blockX < numBlocksX; blockX++) { |
| var compressedBlockAlpha = get128BitBlockStart(src, blockY * numBlocksX + blockX); |
| var compressedBlockRGB = get128BitBlockEnd(src, blockY * numBlocksX + blockX); |
| |
| // Decompress. |
| decompressETC2Block(uncompressedBlock, compressedBlockRGB, null, false); |
| decompressEAC8Block(uncompressedBlockAlpha, compressedBlockAlpha); |
| |
| // Write to dst. |
| var baseX = blockX * ETC2_BLOCK_WIDTH; |
| var baseY = blockY * ETC2_BLOCK_HEIGHT; |
| for (var y = 0; y < Math.min(ETC2_BLOCK_HEIGHT, height - baseY); y++) { |
| for (var x = 0; x < Math.min(ETC2_BLOCK_WIDTH, width - baseX); x++) { |
| var srcIndex = (y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8; |
| var srcAlphaIndex = (y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_A8; |
| var dstIndex = (baseY + y) * dstRowPitch + (baseX + x) * dstPixelSize; |
| |
| for (var i = 0; i < ETC2_UNCOMPRESSED_PIXEL_SIZE_RGBA8 - 1; i++) |
| dstPtr[dstIndex + i] = uncompressedBlock[srcIndex + i]; |
| dstPtr[dstIndex + ETC2_UNCOMPRESSED_PIXEL_SIZE_RGBA8 - 1] = uncompressedBlockAlpha[srcAlphaIndex]; |
| |
| } |
| } |
| } |
| } |
| }; |
| |
| var decompressETC2_RGB8_PUNCHTHROUGH_ALPHA1 = function(/*const tcu::PixelBufferAccess&*/ dst, width, height, src) { |
| var numBlocksX = tcuCompressedTexture.divRoundUp(width, 4); |
| var numBlocksY = tcuCompressedTexture.divRoundUp(height, 4); |
| var dstPtr = new Uint8Array(dst.m_data); |
| var dstRowPitch = dst.getRowPitch(); |
| var dstPixelSize = ETC2_UNCOMPRESSED_PIXEL_SIZE_RGBA8; |
| var uncompressedBlockArray = new ArrayBuffer(ETC2_UNCOMPRESSED_BLOCK_SIZE_RGB8); |
| var uncompressedBlock = new Uint8Array(uncompressedBlockArray); |
| var uncompressedBlockAlphaArray = new ArrayBuffer(ETC2_UNCOMPRESSED_BLOCK_SIZE_A8); |
| var uncompressedBlockAlpha = new Uint8Array(uncompressedBlockAlphaArray); |
| |
| for (var blockY = 0; blockY < numBlocksY; blockY++) { |
| for (var blockX = 0; blockX < numBlocksX; blockX++) { |
| var compressedBlock = get64BitBlock(src, blockY * numBlocksX + blockX); |
| |
| // Decompress. |
| decompressETC2Block(uncompressedBlock, compressedBlock, uncompressedBlockAlpha, true); |
| |
| // Write to dst. |
| var baseX = blockX * ETC2_BLOCK_WIDTH; |
| var baseY = blockY * ETC2_BLOCK_HEIGHT; |
| for (var y = 0; y < Math.min(ETC2_BLOCK_HEIGHT, height - baseY); y++) { |
| for (var x = 0; x < Math.min(ETC2_BLOCK_WIDTH, width - baseX); x++) { |
| var srcIndex = (y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8; |
| var srcAlphaIndex = (y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_A8; |
| var dstIndex = (baseY + y) * dstRowPitch + (baseX + x) * dstPixelSize; |
| |
| for (var i = 0; i < ETC2_UNCOMPRESSED_PIXEL_SIZE_RGBA8 - 1; i++) |
| dstPtr[dstIndex + i] = uncompressedBlock[srcIndex + i]; |
| dstPtr[dstIndex + ETC2_UNCOMPRESSED_PIXEL_SIZE_RGBA8 - 1] = uncompressedBlockAlpha[srcAlphaIndex]; |
| |
| } |
| } |
| } |
| } |
| }; |
| |
| return { |
| decompressEAC_R11: decompressEAC_R11, |
| decompressEAC_RG11: decompressEAC_RG11, |
| decompressETC2: decompressETC2, |
| decompressETC2_RGB8_PUNCHTHROUGH_ALPHA1: decompressETC2_RGB8_PUNCHTHROUGH_ALPHA1, |
| decompressETC2_EAC_RGBA8: decompressETC2_EAC_RGBA8 |
| }; |
| |
| }(); |
| |
| /** |
| * @constructor |
| * @param {tcuCompressedTexture.Format} format |
| * @param {number} width |
| * @param {number} height |
| * @param {number=} depth |
| */ |
| tcuCompressedTexture.CompressedTexture = function(format, width, height, depth) { |
| depth = depth === undefined ? 1 : depth; |
| this.setStorage(format, width, height, depth); |
| /** @type {Uint8Array} */ this.m_data; |
| }; |
| |
| /** |
| * @return {number} |
| */ |
| tcuCompressedTexture.CompressedTexture.prototype.getDataSize = function() { |
| return this.m_data.length; |
| }; |
| |
| /** |
| * @return {Uint8Array} |
| */ |
| tcuCompressedTexture.CompressedTexture.prototype.getData = function() { |
| return this.m_data; |
| }; |
| |
| /** |
| * @return {number} |
| */ |
| tcuCompressedTexture.CompressedTexture.prototype.getWidth = function() { |
| return this.m_width; |
| }; |
| |
| /** |
| * @return {number} |
| */ |
| tcuCompressedTexture.CompressedTexture.prototype.getHeight = function() { |
| return this.m_height; |
| }; |
| |
| /** |
| * @return {tcuCompressedTexture.Format} |
| */ |
| tcuCompressedTexture.CompressedTexture.prototype.getFormat = function() { |
| return this.m_format; |
| }; |
| |
| tcuCompressedTexture.CompressedTexture.prototype.setStorage = function(format, width, height, depth) { |
| depth = depth === undefined ? 1 : depth; |
| this.m_format = format; |
| this.m_width = width; |
| this.m_height = height; |
| this.m_depth = depth; |
| |
| if (tcuCompressedTexture.isEtcFormat(this.m_format)) { |
| DE_ASSERT(this.m_depth == 1); |
| |
| var blockSizeMultiplier = 0; // How many 64-bit parts each compressed block contains. |
| |
| switch (this.m_format) { |
| case tcuCompressedTexture.Format.ETC1_RGB8: blockSizeMultiplier = 1; break; |
| case tcuCompressedTexture.Format.EAC_R11: blockSizeMultiplier = 1; break; |
| case tcuCompressedTexture.Format.EAC_SIGNED_R11: blockSizeMultiplier = 1; break; |
| case tcuCompressedTexture.Format.EAC_RG11: blockSizeMultiplier = 2; break; |
| case tcuCompressedTexture.Format.EAC_SIGNED_RG11: blockSizeMultiplier = 2; break; |
| case tcuCompressedTexture.Format.ETC2_RGB8: blockSizeMultiplier = 1; break; |
| case tcuCompressedTexture.Format.ETC2_SRGB8: blockSizeMultiplier = 1; break; |
| case tcuCompressedTexture.Format.ETC2_RGB8_PUNCHTHROUGH_ALPHA1: blockSizeMultiplier = 1; break; |
| case tcuCompressedTexture.Format.ETC2_SRGB8_PUNCHTHROUGH_ALPHA1: blockSizeMultiplier = 1; break; |
| case tcuCompressedTexture.Format.ETC2_EAC_RGBA8: blockSizeMultiplier = 2; break; |
| case tcuCompressedTexture.Format.ETC2_EAC_SRGB8_ALPHA8: blockSizeMultiplier = 2; break; |
| |
| default: |
| throw new Error('Unsupported format ' + format); |
| break; |
| } |
| |
| this.m_array = new ArrayBuffer(blockSizeMultiplier * 8 * tcuCompressedTexture.divRoundUp(this.m_width, 4) * tcuCompressedTexture.divRoundUp(this.m_height, 4)); |
| this.m_data = new Uint8Array(this.m_array); |
| } |
| // else if (isASTCFormat(this.m_format)) |
| // { |
| // if (this.m_depth > 1) |
| // throw tcu::InternalError("3D ASTC textures not currently supported"); |
| |
| // const IVec3 blockSize = getASTCBlockSize(this.m_format); |
| // this.m_data.resize(ASTC_BLOCK_SIZE_BYTES * tcuCompressedTexture.divRoundUp(this.m_width, blockSize[0]) * tcuCompressedTexture.divRoundUp(this.m_height, blockSize[1]) * tcuCompressedTexture.divRoundUp(this.m_depth, blockSize[2])); |
| // } |
| // else |
| // { |
| // DE_ASSERT(this.m_format == FORMAT_LAST); |
| // DE_ASSERT(this.m_width == 0 && this.m_height == 0 && this.m_depth == 0); |
| // this.m_data.resize(0); |
| // } |
| }; |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief Get uncompressed texture format |
| *//*--------------------------------------------------------------------*/ |
| tcuCompressedTexture.CompressedTexture.prototype.getUncompressedFormat = function() { |
| if (tcuCompressedTexture.isEtcFormat(this.m_format)) { |
| switch (this.m_format) { |
| case tcuCompressedTexture.Format.ETC1_RGB8: return new tcuTexture.TextureFormat(tcuTexture.ChannelOrder.RGB, tcuTexture.ChannelType.UNORM_INT8); |
| case tcuCompressedTexture.Format.EAC_R11: return new tcuTexture.TextureFormat(tcuTexture.ChannelOrder.R, tcuTexture.ChannelType.UNORM_INT16); |
| case tcuCompressedTexture.Format.EAC_SIGNED_R11: return new tcuTexture.TextureFormat(tcuTexture.ChannelOrder.R, tcuTexture.ChannelType.SNORM_INT16); |
| case tcuCompressedTexture.Format.EAC_RG11: return new tcuTexture.TextureFormat(tcuTexture.ChannelOrder.RG, tcuTexture.ChannelType.UNORM_INT16); |
| case tcuCompressedTexture.Format.EAC_SIGNED_RG11: return new tcuTexture.TextureFormat(tcuTexture.ChannelOrder.RG, tcuTexture.ChannelType.SNORM_INT16); |
| case tcuCompressedTexture.Format.ETC2_RGB8: return new tcuTexture.TextureFormat(tcuTexture.ChannelOrder.RGB, tcuTexture.ChannelType.UNORM_INT8); |
| case tcuCompressedTexture.Format.ETC2_SRGB8: return new tcuTexture.TextureFormat(tcuTexture.ChannelOrder.sRGB, tcuTexture.ChannelType.UNORM_INT8); |
| case tcuCompressedTexture.Format.ETC2_RGB8_PUNCHTHROUGH_ALPHA1: return new tcuTexture.TextureFormat(tcuTexture.ChannelOrder.RGBA, tcuTexture.ChannelType.UNORM_INT8); |
| case tcuCompressedTexture.Format.ETC2_SRGB8_PUNCHTHROUGH_ALPHA1: return new tcuTexture.TextureFormat(tcuTexture.ChannelOrder.sRGBA, tcuTexture.ChannelType.UNORM_INT8); |
| case tcuCompressedTexture.Format.ETC2_EAC_RGBA8: return new tcuTexture.TextureFormat(tcuTexture.ChannelOrder.RGBA, tcuTexture.ChannelType.UNORM_INT8); |
| case tcuCompressedTexture.Format.ETC2_EAC_SRGB8_ALPHA8: return new tcuTexture.TextureFormat(tcuTexture.ChannelOrder.sRGBA, tcuTexture.ChannelType.UNORM_INT8); |
| default: |
| throw new Error('Unsupported format ' + this.m_format); |
| } |
| } |
| // else if (isASTCFormat(m_format)) |
| // { |
| // if (isASTCSRGBFormat(m_format)) |
| // return TextureFormat(tcuTexture.ChannelType.sRGBA, tcuTexture.ChannelType.UNORM_INT8); |
| // else |
| // return TextureFormat(tcuTexture.ChannelType.RGBA, tcuTexture.ChannelType.HALF_FLOAT); |
| // } |
| // else |
| // { |
| // DE_ASSERT(false); |
| // return TextureFormat(); |
| // } |
| }; |
| |
| /** |
| * Decode to uncompressed pixel data |
| * @param {tcuTexture.PixelBufferAccess} dst Destination buffer |
| */ |
| tcuCompressedTexture.CompressedTexture.prototype.decompress = function(dst) { |
| DE_ASSERT(dst.getWidth() == this.m_width && dst.getHeight() == this.m_height && dst.getDepth() == 1); |
| var format = this.getUncompressedFormat(); |
| if (dst.getFormat().order != format.order || dst.getFormat().type != format.type) |
| throw new Error('Formats do not match.'); |
| |
| if (tcuCompressedTexture.isEtcFormat(this.m_format)) { |
| switch (this.m_format) { |
| // case tcuCompressedTexture.Format.ETC1_RGB8: decompressETC1 (dst, this.m_width, this.m_height, this.m_data); break; |
| case tcuCompressedTexture.Format.EAC_R11: tcuCompressedTexture.etcDecompressInternal.decompressEAC_R11(dst, this.m_width, this.m_height, this.m_array, false); break; |
| case tcuCompressedTexture.Format.EAC_SIGNED_R11: tcuCompressedTexture.etcDecompressInternal.decompressEAC_R11(dst, this.m_width, this.m_height, this.m_array, true); break; |
| case tcuCompressedTexture.Format.EAC_RG11: tcuCompressedTexture.etcDecompressInternal.decompressEAC_RG11(dst, this.m_width, this.m_height, this.m_array, false); break; |
| case tcuCompressedTexture.Format.EAC_SIGNED_RG11: tcuCompressedTexture.etcDecompressInternal.decompressEAC_RG11(dst, this.m_width, this.m_height, this.m_array, true); break; |
| case tcuCompressedTexture.Format.ETC2_RGB8: tcuCompressedTexture.etcDecompressInternal.decompressETC2(dst, this.m_width, this.m_height, this.m_array); break; |
| case tcuCompressedTexture.Format.ETC2_SRGB8: tcuCompressedTexture.etcDecompressInternal.decompressETC2(dst, this.m_width, this.m_height, this.m_array); break; |
| case tcuCompressedTexture.Format.ETC2_RGB8_PUNCHTHROUGH_ALPHA1: tcuCompressedTexture.etcDecompressInternal.decompressETC2_RGB8_PUNCHTHROUGH_ALPHA1(dst, this.m_width, this.m_height, this.m_array); break; |
| case tcuCompressedTexture.Format.ETC2_SRGB8_PUNCHTHROUGH_ALPHA1: tcuCompressedTexture.etcDecompressInternal.decompressETC2_RGB8_PUNCHTHROUGH_ALPHA1(dst, this.m_width, this.m_height, this.m_array); break; |
| case tcuCompressedTexture.Format.ETC2_EAC_RGBA8: tcuCompressedTexture.etcDecompressInternal.decompressETC2_EAC_RGBA8(dst, this.m_width, this.m_height, this.m_array); break; |
| case tcuCompressedTexture.Format.ETC2_EAC_SRGB8_ALPHA8: tcuCompressedTexture.etcDecompressInternal.decompressETC2_EAC_RGBA8(dst, this.m_width, this.m_height, this.m_array); break; |
| |
| default: |
| throw new Error('Unsupported format ' + this.m_format); |
| break; |
| } |
| } |
| // else if (isASTCFormat(m_format)) |
| // { |
| // const tcu::IVec3 blockSize = getASTCBlockSize(m_format); |
| // const bool isSRGBFormat = isASTCSRGBFormat(m_format); |
| |
| // if (blockSize[2] > 1) |
| // throw tcu::InternalError("3D ASTC textures not currently supported"); |
| |
| // decompressASTC(dst, m_width, m_height, &m_data[0], blockSize[0], blockSize[1], isSRGBFormat, isSRGBFormat || params.isASTCModeLDR); |
| // } /**/ |
| else |
| throw new Error('Unsupported format ' + this.m_format); |
| }; |
| |
| }); |
