306 lines
11 KiB
C++
306 lines
11 KiB
C++
//===============================================================================
|
|
// Copyright (c) 2007-2016 Advanced Micro Devices, Inc. All rights reserved.
|
|
// Copyright (c) 2004-2006 ATI Technologies Inc.
|
|
//===============================================================================
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files(the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions :
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
// THE SOFTWARE.
|
|
//
|
|
// ASTC_Decode.cpp : A reference decoder for ASTC
|
|
//
|
|
|
|
#include "common.h"
|
|
#include "astc/astc_decode.h"
|
|
#include "astc_host.h"
|
|
|
|
// //using namespace ASTC_Encoder;
|
|
// void decompress_symbolic_block2(
|
|
// astc_decode_mode decode_mode,
|
|
// int xdim, int ydim, int zdim, // dimensions of block
|
|
// int xpos, int ypos, int zpos, // position of block
|
|
// const symbolic_compressed_block * scb, imageblock_cpu * blk)
|
|
// {
|
|
// blk->xpos = xpos;
|
|
// blk->ypos = ypos;
|
|
// blk->zpos = zpos;
|
|
//
|
|
// int i;
|
|
//
|
|
// // if we detected an error-block, blow up immediately.
|
|
// if (scb->error_block)
|
|
// {
|
|
// if (decode_mode == DECODE_LDR_SRGB)
|
|
// {
|
|
// for (i = 0; i < xdim * ydim * zdim; i++)
|
|
// {
|
|
// blk->orig_data[4 * i] = 1.0f;
|
|
// blk->orig_data[4 * i + 1] = 0.0f;
|
|
// blk->orig_data[4 * i + 2] = 1.0f;
|
|
// blk->orig_data[4 * i + 3] = 1.0f;
|
|
// blk->rgb_lns[i] = 0;
|
|
// blk->alpha_lns[i] = 0;
|
|
// blk->nan_texel[i] = 0;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// for (i = 0; i < xdim * ydim * zdim; i++)
|
|
// {
|
|
// blk->orig_data[4 * i] = 0.0f;
|
|
// blk->orig_data[4 * i + 1] = 0.0f;
|
|
// blk->orig_data[4 * i + 2] = 0.0f;
|
|
// blk->orig_data[4 * i + 3] = 0.0f;
|
|
// blk->rgb_lns[i] = 0;
|
|
// blk->alpha_lns[i] = 0;
|
|
// blk->nan_texel[i] = 1;
|
|
// }
|
|
// }
|
|
//
|
|
// imageblock_initialize_work_from_orig_cpu(blk, xdim * ydim * zdim);
|
|
// update_imageblock_flags_cpu(blk, xdim, ydim, zdim);
|
|
// return;
|
|
// }
|
|
//
|
|
//
|
|
//
|
|
//
|
|
// if (scb->block_mode < 0)
|
|
// {
|
|
// float red = 0, green = 0, blue = 0, alpha = 0;
|
|
// int use_lns = 0;
|
|
// int use_nan = 0;
|
|
//
|
|
// if (scb->block_mode == -2)
|
|
// {
|
|
// // For sRGB decoding, we should return only the top 8 bits.
|
|
// int mask = (decode_mode == DECODE_LDR_SRGB) ? 0xFF00 : 0xFFFF;
|
|
//
|
|
// red = sf16_to_float(unorm16_to_sf16((uint16_t)scb->constant_color[0] & mask));
|
|
// green = sf16_to_float(unorm16_to_sf16((uint16_t)scb->constant_color[1] & mask));
|
|
// blue = sf16_to_float(unorm16_to_sf16((uint16_t)scb->constant_color[2] & mask));
|
|
// alpha = sf16_to_float(unorm16_to_sf16((uint16_t)scb->constant_color[3] & mask));
|
|
// use_lns = 0;
|
|
// use_nan = 0;
|
|
// }
|
|
// else
|
|
// {
|
|
// switch (decode_mode)
|
|
// {
|
|
// case DECODE_LDR_SRGB:
|
|
// red = 1.0f;
|
|
// green = 0.0f;
|
|
// blue = 1.0f;
|
|
// alpha = 1.0f;
|
|
// use_lns = 0;
|
|
// use_nan = 0;
|
|
// break;
|
|
// case DECODE_LDR:
|
|
// red = 0.0f;
|
|
// green = 0.0f;
|
|
// blue = 0.0f;
|
|
// alpha = 0.0f;
|
|
// use_lns = 0;
|
|
// use_nan = 1;
|
|
// break;
|
|
// case DECODE_HDR:
|
|
// // constant-color block; unpack from FP16 to FP32.
|
|
// red = sf16_to_float((sf16)scb->constant_color[0]);
|
|
// green = sf16_to_float((sf16)scb->constant_color[1]);
|
|
// blue = sf16_to_float((sf16)scb->constant_color[2]);
|
|
// alpha = sf16_to_float((sf16)scb->constant_color[3]);
|
|
// use_lns = 1;
|
|
// use_nan = 0;
|
|
// break;
|
|
// }
|
|
// }
|
|
//
|
|
// for (i = 0; i < xdim * ydim * zdim; i++)
|
|
// {
|
|
// blk->orig_data[4 * i] = red;
|
|
// blk->orig_data[4 * i + 1] = green;
|
|
// blk->orig_data[4 * i + 2] = blue;
|
|
// blk->orig_data[4 * i + 3] = alpha;
|
|
// blk->rgb_lns[i] = (uint8_t)use_lns;
|
|
// blk->alpha_lns[i] = (uint8_t)use_lns;
|
|
// blk->nan_texel[i] = (uint8_t)use_nan;
|
|
// }
|
|
//
|
|
//
|
|
// imageblock_initialize_work_from_orig_cpu(blk, xdim * ydim * zdim);
|
|
// update_imageblock_flags_cpu(blk, xdim, ydim, zdim);
|
|
// return;
|
|
// }
|
|
//
|
|
//
|
|
// // get the appropriate partition-table entry
|
|
// int partition_count = scb->partition_count;
|
|
// const partition_info_cpu *pt = get_partition_table(xdim, ydim, zdim, partition_count);
|
|
// pt += scb->partition_index;
|
|
//
|
|
// // get the appropriate block descriptor
|
|
// const block_size_descriptor *bsd = get_block_size_descriptor(xdim, ydim, zdim);
|
|
// const decimation_table *const *ixtab2 = bsd->decimation_tables;
|
|
//
|
|
//
|
|
// const decimation_table *it = ixtab2[bsd->block_modes[scb->block_mode].decimation_mode];
|
|
//
|
|
// int is_dual_plane = bsd->block_modes[scb->block_mode].is_dual_plane;
|
|
//
|
|
// int weight_quantization_level = bsd->block_modes[scb->block_mode].quantization_mode;
|
|
//
|
|
//
|
|
// // decode the color endpoints
|
|
// ushort4 color_endpoint0[4];
|
|
// ushort4 color_endpoint1[4];
|
|
//
|
|
// int rgb_hdr_endpoint[4];
|
|
// int alpha_hdr_endpoint[4];
|
|
// int nan_endpoint[4];
|
|
//
|
|
// for (i = 0; i < partition_count; i++)
|
|
// unpack_color_endpoints(decode_mode,
|
|
// scb->color_formats[i],
|
|
// scb->color_quantization_level, scb->color_values[i], &(rgb_hdr_endpoint[i]), &(alpha_hdr_endpoint[i]), &(nan_endpoint[i]), &(color_endpoint0[i]), &(color_endpoint1[i]));
|
|
//
|
|
// // first unquantize the weights
|
|
// int uq_plane1_weights[MAX_WEIGHTS_PER_BLOCK];
|
|
// int uq_plane2_weights[MAX_WEIGHTS_PER_BLOCK];
|
|
// int weight_count = it->num_weights;
|
|
//
|
|
//
|
|
// const quantization_and_transfer_table *qat = &(quant_and_xfer_tables[weight_quantization_level]);
|
|
//
|
|
// for (i = 0; i < weight_count; i++)
|
|
// {
|
|
// uq_plane1_weights[i] = qat->unquantized_value[scb->plane1_weights[i]];
|
|
// }
|
|
// if (is_dual_plane)
|
|
// {
|
|
// for (i = 0; i < weight_count; i++)
|
|
// uq_plane2_weights[i] = qat->unquantized_value[scb->plane2_weights[i]];
|
|
// }
|
|
//
|
|
//
|
|
// // then un-decimate them.
|
|
// int weights[MAX_TEXELS_PER_BLOCK];
|
|
// int plane2_weights[MAX_TEXELS_PER_BLOCK];
|
|
//
|
|
//
|
|
// int texels_per_block = xdim * ydim * zdim;
|
|
// for (i = 0; i < texels_per_block; i++)
|
|
// weights[i] = compute_value_of_texel_int(i, it, uq_plane1_weights);
|
|
//
|
|
// if (is_dual_plane)
|
|
// for (i = 0; i < texels_per_block; i++)
|
|
// plane2_weights[i] = compute_value_of_texel_int(i, it, uq_plane2_weights);
|
|
//
|
|
//
|
|
// int plane2_color_component = scb->plane2_color_component;
|
|
//
|
|
//
|
|
// // now that we have endpoint colors and weights, we can unpack actual colors for
|
|
// // each texel.
|
|
// for (i = 0; i < texels_per_block; i++)
|
|
// {
|
|
// int partition = pt->partition_of_texel[i];
|
|
//
|
|
// ushort4 color = lerp_color_int(decode_mode,
|
|
// color_endpoint0[partition],
|
|
// color_endpoint1[partition],
|
|
// weights[i],
|
|
// plane2_weights[i],
|
|
// is_dual_plane ? plane2_color_component : -1);
|
|
//
|
|
// blk->rgb_lns[i] = (uint8_t)rgb_hdr_endpoint[partition];
|
|
// blk->alpha_lns[i] = (uint8_t)alpha_hdr_endpoint[partition];
|
|
// blk->nan_texel[i] = (uint8_t)nan_endpoint[partition];
|
|
//
|
|
// blk->work_data[4 * i] = color.x;
|
|
// blk->work_data[4 * i + 1] = color.y;
|
|
// blk->work_data[4 * i + 2] = color.z;
|
|
// blk->work_data[4 * i + 3] = color.w;
|
|
// }
|
|
//
|
|
// imageblock_initialize_orig_from_work_cpu(blk, xdim * ydim * zdim);
|
|
//
|
|
// update_imageblock_flags_cpu(blk, xdim, ydim, zdim);
|
|
// }
|
|
|
|
|
|
void ASTCBlockDecoder::DecompressBlock( BYTE BlockWidth,
|
|
BYTE BlockHeight,
|
|
BYTE bitness,
|
|
float out[][4],
|
|
BYTE in[ASTC_COMPRESSED_BLOCK_SIZE]) {
|
|
// Results Buffer
|
|
astc_codec_image_cpu *img = allocate_image_cpu(bitness, BlockWidth, BlockHeight, 1, 0);
|
|
initialize_image_cpu(img);
|
|
|
|
ASTC_Encoder::uint8_t *bp = in;
|
|
physical_compressed_block_cpu pcb = *(physical_compressed_block_cpu *) bp;
|
|
symbolic_compressed_block_cpu scb;
|
|
|
|
physical_to_symbolic_cpu(BlockWidth, BlockHeight, 1, pcb, &scb);
|
|
|
|
|
|
swizzlepattern_cpu swz_decode = { 0, 1, 2, 3 };
|
|
imageblock_cpu pb;
|
|
|
|
// astc_decode_mode decode_mode1 = DECODE_HDR;
|
|
// decompress_symbolic_block((astc_decode_mode)decode_mode1, BlockWidth, BlockHeight, 1, 0, 0, 0, (symbolic_compressed_block*)&scb, (imageblock_cpu *)&pb);
|
|
|
|
ASTC_Encoder::astc_decode_mode decode_mode = ASTC_Encoder::DECODE_HDR;
|
|
decompress_symbolic_block_cpu(decode_mode, BlockWidth, BlockHeight, 1, 0, 0, 0, &scb, &pb);
|
|
|
|
|
|
|
|
write_imageblock_cpu(img, &pb, BlockWidth, BlockHeight, 1, 0, 0, 0, swz_decode);
|
|
|
|
// copy results to our output buffer
|
|
int x, y, z;
|
|
int index=0;
|
|
|
|
int exsize = img->xsize + 2 * img->padding;
|
|
int eysize = img->ysize + 2 * img->padding;
|
|
int ezsize = (img->zsize == 1) ? 1 : img->zsize + 2 * img->padding;
|
|
|
|
if (img->imagedata8) {
|
|
for (z = 0; z < ezsize; z++)
|
|
for (y = 0; y < eysize; y++) {
|
|
for (x = 0; x < exsize; x++) {
|
|
out[index][0] = img->imagedata8[z][y][4 * x];
|
|
out[index][1] = img->imagedata8[z][y][4 * x + 1];
|
|
out[index][2] = img->imagedata8[z][y][4 * x + 2];
|
|
out[index][3] = img->imagedata8[z][y][4 * x + 3];
|
|
index++;
|
|
}
|
|
}
|
|
} else if (img->imagedata16) {
|
|
for (z = 0; z < ezsize; z++)
|
|
for (y = 0; y < eysize; y++)
|
|
for (x = 0; x < exsize; x++) {
|
|
out[index][0] = img->imagedata16[z][y][4 * x];
|
|
out[index][1] = img->imagedata16[z][y][4 * x + 1];
|
|
out[index][2] = img->imagedata16[z][y][4 * x + 2];
|
|
out[index][3] = img->imagedata16[z][y][4 * x + 3];
|
|
}
|
|
}
|
|
|
|
destroy_image_cpu(img);
|
|
}
|