| // Copyright 2020 The SwiftShader Authors. All Rights Reserved. |
| // |
| // 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. |
| |
| #include "ASTC_Decoder.hpp" |
| |
| #include "System/Math.hpp" |
| |
| #ifdef SWIFTSHADER_ENABLE_ASTC |
| # include "astc_codec_internals.h" |
| #endif |
| |
| #include <memory> |
| #include <unordered_map> |
| |
| namespace { |
| |
| #ifdef SWIFTSHADER_ENABLE_ASTC |
| void write_imageblock(unsigned char *img, |
| // picture-block to initialize with image data. We assume that orig_data is valid |
| const imageblock *pb, |
| // output dimensions |
| int xsize, int ysize, int zsize, |
| // output format |
| int bytes, int destPitchB, int destSliceB, bool isUnsignedByte, |
| // block dimensions |
| int xdim, int ydim, int zdim, |
| // position to write the block to |
| int xpos, int ypos, int zpos) |
| { |
| const float *fptr = pb->orig_data; |
| const uint8_t *nptr = pb->nan_texel; |
| |
| for(int z = 0; z < zdim; z++) |
| { |
| for(int y = 0; y < ydim; y++) |
| { |
| for(int x = 0; x < xdim; x++) |
| { |
| int xi = xpos + x; |
| int yi = ypos + y; |
| int zi = zpos + z; |
| |
| if(xi >= 0 && yi >= 0 && zi >= 0 && xi < xsize && yi < ysize && zi < zsize) |
| { |
| unsigned char *pix = &img[zi * destSliceB + yi * destPitchB + xi * bytes]; |
| |
| if(isUnsignedByte) |
| { |
| if(*nptr) |
| { |
| // NaN-pixel, but we can't display it. Display purple instead. |
| pix[0] = 0xFF; |
| pix[1] = 0x00; |
| pix[2] = 0xFF; |
| pix[3] = 0xFF; |
| } |
| else |
| { |
| pix[0] = static_cast<unsigned char>(sw::clamp(fptr[0], 0.0f, 1.0f) * 255.0f + 0.5f); |
| pix[1] = static_cast<unsigned char>(sw::clamp(fptr[1], 0.0f, 1.0f) * 255.0f + 0.5f); |
| pix[2] = static_cast<unsigned char>(sw::clamp(fptr[2], 0.0f, 1.0f) * 255.0f + 0.5f); |
| pix[3] = static_cast<unsigned char>(sw::clamp(fptr[3], 0.0f, 1.0f) * 255.0f + 0.5f); |
| } |
| } |
| else |
| { |
| if(*nptr) |
| { |
| unsigned int *pixu = reinterpret_cast<unsigned int *>(pix); |
| pixu[0] = pixu[1] = pixu[2] = pixu[3] = 0x7FFFFFFF; // QNaN |
| } |
| else |
| { |
| float *pixf = reinterpret_cast<float *>(pix); |
| pixf[0] = fptr[0]; |
| pixf[1] = fptr[1]; |
| pixf[2] = fptr[2]; |
| pixf[3] = fptr[3]; |
| } |
| } |
| } |
| fptr += 4; |
| nptr++; |
| } |
| } |
| } |
| } |
| #endif |
| |
| } // namespace |
| |
| void ASTC_Decoder::Decode(const unsigned char *source, unsigned char *dest, |
| int destWidth, int destHeight, int destDepth, |
| int bytes, int destPitchB, int destSliceB, |
| int xBlockSize, int yBlockSize, int zBlockSize, |
| int xblocks, int yblocks, int zblocks, bool isUnsignedByte) |
| { |
| #ifdef SWIFTSHADER_ENABLE_ASTC |
| build_quantization_mode_table(); |
| |
| astc_decode_mode decode_mode = isUnsignedByte ? DECODE_LDR : DECODE_HDR; |
| |
| std::unique_ptr<block_size_descriptor> bsd(new block_size_descriptor); |
| init_block_size_descriptor(xBlockSize, yBlockSize, zBlockSize, bsd.get()); |
| |
| std::unique_ptr<imageblock> ib(new imageblock); |
| std::unique_ptr<symbolic_compressed_block> scb(new symbolic_compressed_block); |
| for(int z = 0; z < zblocks; z++) |
| { |
| for(int y = 0; y < yblocks; y++) |
| { |
| for(int x = 0; x < xblocks; x++, source += 16) |
| { |
| physical_to_symbolic(bsd.get(), *(physical_compressed_block *)source, scb.get()); |
| decompress_symbolic_block(decode_mode, bsd.get(), x * xBlockSize, y * yBlockSize, z * zBlockSize, scb.get(), ib.get()); |
| write_imageblock(dest, ib.get(), destWidth, destHeight, destDepth, bytes, destPitchB, destSliceB, isUnsignedByte, |
| xBlockSize, yBlockSize, zBlockSize, x * xBlockSize, y * yBlockSize, z * zBlockSize); |
| } |
| } |
| } |
| |
| term_block_size_descriptor(bsd.get()); |
| #endif |
| } |