src/Device/BC_Decoder.cpp

// Copyright 2019 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 "BC_Decoder.hpp"

namespace
{
	static constexpr int BlockWidth = 4;
	static constexpr int BlockHeight = 4;

	struct BC_color
	{
		void decode(unsigned char* dst, int x, int y, int dstW, int dstH, int dstPitch, int dstBpp, bool hasAlphaChannel, bool hasSeparateAlpha) const
		{
			Color c[4];
			c[0].extract565(c0);
			c[1].extract565(c1);
			if(hasSeparateAlpha || (c0 > c1))
			{
				c[2] = ((c[0] * 2) + c[1]) / 3;
				c[3] = ((c[1] * 2) + c[0]) / 3;
			}
			else
			{
				c[2] = (c[0] + c[1]) >> 1;
				if(hasAlphaChannel)
				{
					c[3].clearAlpha();
				}
			}

			for(int j = 0; j < BlockHeight && (y + j) < dstH; j++)
			{
				int dstOffset = j * dstPitch;
				int idxOffset = j * BlockHeight;
				for(int i = 0; i < BlockWidth && (x + i) < dstW; i++, idxOffset++, dstOffset += dstBpp)
				{
					*reinterpret_cast<unsigned int*>(dst + dstOffset) = c[getIdx(idxOffset)].pack8888();
				}
			}
		}

	private:
		struct Color
		{
			Color()
			{
				c[0] = c[1] = c[2] = 0;
				c[3] = 0xFF000000;
			}

			void extract565(const unsigned int c565)
			{
				c[0] = ((c565 & 0x0000001F) << 3) | ((c565 & 0x0000001C) >> 2);
				c[1] = ((c565 & 0x000007E0) >> 3) | ((c565 & 0x00000600) >> 9);
				c[2] = ((c565 & 0x0000F800) >> 8) | ((c565 & 0x0000E000) >> 13);
			}

			unsigned int pack8888() const
			{
				return ((c[2] & 0xFF) << 16) | ((c[1] & 0xFF) << 8) | (c[0] & 0xFF) | c[3];
			}

			void clearAlpha()
			{
				c[3] = 0;
			}

			Color operator*(int factor) const
			{
				Color res;
				for(int i = 0; i < 4; ++i)
				{
					res.c[i] = c[i] * factor;
				}
				return res;
			}

			Color operator/(int factor) const
			{
				Color res;
				for(int i = 0; i < 4; ++i)
				{
					res.c[i] = c[i] / factor;
				}
				return res;
			}

			Color operator>>(int shift) const
			{
				Color res;
				for(int i = 0; i < 4; ++i)
				{
					res.c[i] = c[i] >> shift;
				}
				return res;
			}

			Color operator+(Color const& obj) const
			{
				Color res;
				for(int i = 0; i < 4; ++i)
				{
					res.c[i] = c[i] + obj.c[i];
				}
				return res;
			}

		private:
			int c[4];
		};

		unsigned int getIdx(int i) const
		{
			int offset = i << 1; // 2 bytes per index
			return (idx & (0x3 << offset)) >> offset;
		}

		unsigned short c0;
		unsigned short c1;
		unsigned int idx;
	};

	struct BC_channel
	{
		void decode(unsigned char* dst, int x, int y, int dstW, int dstH, int dstPitch, int dstBpp, int channel, bool isSigned) const
		{
			int c[8] = { 0 };

			if(isSigned)
			{
				c[0] = static_cast<signed char>(data & 0xFF);
				c[1] = static_cast<signed char>((data & 0xFF00) >> 8);
			}
			else
			{
				c[0] = static_cast<unsigned char>(data & 0xFF);
				c[1] = static_cast<unsigned char>((data & 0xFF00) >> 8);
			}

			if(c[0] > c[1])
			{
				for(int i = 2; i < 8; ++i)
				{
					c[i] = ((8 - i) * c[0] + (i - 1) * c[1]) / 7;
				}
			}
			else
			{
				for(int i = 2; i < 6; ++i)
				{
					c[i] = ((6 - i) * c[0] + (i - 1) * c[1]) / 5;
				}
				c[6] = isSigned ? -128 : 0;
				c[7] = isSigned ? 127 : 255;
			}

			for(int j = 0; j < BlockHeight && (y + j) < dstH; j++)
			{
				for(int i = 0; i < BlockWidth && (x + i) < dstW; i++)
				{
					dst[channel + (i * dstBpp) + (j * dstPitch)] = static_cast<unsigned char>(c[getIdx((j * BlockHeight) + i)]);
				}
			}
		}

	private:
		unsigned char getIdx(int i) const
		{
			int offset = i * 3 + 16;
			return static_cast<unsigned char>((data & (0x7ull << offset)) >> offset);
		}

		unsigned long long data;
	};

	struct BC_alpha
	{
		void decode(unsigned char* dst, int x, int y, int dstW, int dstH, int dstPitch, int dstBpp) const
		{
			dst += 3; // Write only to alpha (channel 3)
			for(int j = 0; j < BlockHeight && (y + j) < dstH; j++, dst += dstPitch)
			{
				unsigned char* dstRow = dst;
				for(int i = 0; i < BlockWidth && (x + i) < dstW; i++, dstRow += dstBpp)
				{
					*dstRow = getAlpha(j * BlockHeight + i);
				}
			}
		}

	private:
		unsigned char getAlpha(int i) const
		{
			int offset = i << 2;
			int alpha = (data & (0xFull << offset)) >> offset;
			return static_cast<unsigned char>(alpha | (alpha << 4));
		}

		unsigned long long data;
	};
} // end namespace

// Decodes 1 to 4 channel images to 8 bit output
bool BC_Decoder::Decode(const unsigned char* src, unsigned char* dst, int w, int h, int dstW, int dstH, int dstPitch, int dstBpp, int n, bool isNoAlphaU)
{
	static_assert(sizeof(BC_color) == 8, "BC_color must be 8 bytes");
	static_assert(sizeof(BC_channel) == 8, "BC_channel must be 8 bytes");
	static_assert(sizeof(BC_alpha) == 8, "BC_alpha must be 8 bytes");

	const int dx = BlockWidth * dstBpp;
	const int dy = BlockHeight * dstPitch;
	const bool isAlpha = (n == 1) && !isNoAlphaU;
	const bool isSigned = ((n == 4) || (n == 5) || (n == 6)) && !isNoAlphaU;

	switch(n)
	{
	case 1: // BC1
		{
			const BC_color* color = reinterpret_cast<const BC_color*>(src);
			for(int y = 0; y < h; y += BlockHeight, dst += dy)
			{
				unsigned char* dstRow = dst;
				for(int x = 0; x < w; x += BlockWidth, ++color, dstRow += dx)
				{
					color->decode(dstRow, x, y, dstW, dstH, dstPitch, dstBpp, isAlpha, false);
				}
			}
		}
		break;
	case 2: // BC2
		{
			const BC_alpha* alpha = reinterpret_cast<const BC_alpha*>(src);
			const BC_color* color = reinterpret_cast<const BC_color*>(src + 8);
			for(int y = 0; y < h; y += BlockHeight, dst += dy)
			{
				unsigned char* dstRow = dst;
				for(int x = 0; x < w; x += BlockWidth, alpha += 2, color += 2, dstRow += dx)
				{
					color->decode(dstRow, x, y, dstW, dstH, dstPitch, dstBpp, isAlpha, true);
					alpha->decode(dstRow, x, y, dstW, dstH, dstPitch, dstBpp);
				}
			}
		}
		break;
	case 3: // BC3
		{
			const BC_channel* alpha = reinterpret_cast<const BC_channel*>(src);
			const BC_color* color = reinterpret_cast<const BC_color*>(src + 8);
			for(int y = 0; y < h; y += BlockHeight, dst += dy)
			{
				unsigned char* dstRow = dst;
				for(int x = 0; x < w; x += BlockWidth, alpha += 2, color += 2, dstRow += dx)
				{
					color->decode(dstRow, x, y, dstW, dstH, dstPitch, dstBpp, isAlpha, true);
					alpha->decode(dstRow, x, y, dstW, dstH, dstPitch, dstBpp, 3, isSigned);
				}
			}
		}
		break;
	case 4: // BC4
		{
			const BC_channel* red = reinterpret_cast<const BC_channel*>(src);
			for(int y = 0; y < h; y += BlockHeight, dst += dy)
			{
				unsigned char* dstRow = dst;
				for(int x = 0; x < w; x += BlockWidth, ++red, dstRow += dx)
				{
					red->decode(dstRow, x, y, dstW, dstH, dstPitch, dstBpp, 0, isSigned);
				}
			}
		}
		break;
	case 5: // BC5
		{
			const BC_channel* red = reinterpret_cast<const BC_channel*>(src);
			const BC_channel* green = reinterpret_cast<const BC_channel*>(src + 8);
			for(int y = 0; y < h; y += BlockHeight, dst += dy)
			{
				unsigned char* dstRow = dst;
				for(int x = 0; x < w; x += BlockWidth, red += 2, green += 2, dstRow += dx)
				{
					red->decode(dstRow, x, y, dstW, dstH, dstPitch, dstBpp, 0, isSigned);
					green->decode(dstRow, x, y, dstW, dstH, dstPitch, dstBpp, 1, isSigned);
				}
			}
		}
		break;
	default:
		return false;
	}

	return true;
}