Method decode

externals/bc_decoder/bc_decoder.cpp:800–918

            uint64_t high64;

            void decode(uint8_t *dst, size_t dstX, size_t dstY, size_t dstWidth, size_t dstHeight, size_t dstPitch, size_t dstBpp, bool isSigned) const {
                uint8_t mode = 0;
                Data data(low64, high64);
                assert(dstBpp == sizeof(Color));

                if ((data.low64 & 0x2) == 0) {
                    mode = data.consumeBits(1, 0);
                } else {
                    mode = data.consumeBits(4, 0);
                }

                int blockIndex = modeToIndex(mode);
                // Handle illegal or reserved mode
                if (blockIndex == -1) {
                    for (int y = 0; y < 4 && y + dstY < dstHeight; y++) {
                        for (int x = 0; x < 4 && x + dstX < dstWidth; x++) {
                            auto out = reinterpret_cast<Color *>(dst + sizeof(Color) * x + dstPitch * y);
                            out->rgba = {0, 0, 0};
                        }
                    }
                    return;
                }
                const BlockDesc *blockDesc = blockDescs[blockIndex];

                RGBf e[4];
                e[0].isSigned = e[1].isSigned = e[2].isSigned = e[3].isSigned = isSigned;

                int partition = 0;
                ModeDesc modeDesc;
                for (int index = 0; blockDesc[index].type != End; index++) {
                    const BlockDesc desc = blockDesc[index];

                    switch (desc.type) {
                        case Mode:
                            modeDesc = desc.modeDesc;
                            assert(modeDesc.number == mode);

                            e[0].size[0] = e[0].size[1] = e[0].size[2] = modeDesc.endpointBits;
                            for (int i = 0; i < RGBfChannels; i++) {
                                if (modeDesc.hasDelta) {
                                    e[1].size[i] = e[2].size[i] = e[3].size[i] = modeDesc.deltaBits.channel[i];
                                } else {
                                    e[1].size[i] = e[2].size[i] = e[3].size[i] = modeDesc.endpointBits;
                                }
                            }
                            break;
                        case Partition:
                            partition |= data.consumeBits(desc.MSB, desc.LSB);
                            break;
                        case EP0:
                        case EP1:
                        case EP2:
                        case EP3:
                            e[desc.type].channel[desc.channel] |= data.consumeBits(desc.MSB, desc.LSB);
                            break;
                        default:
                            assert(false);
                            return;