decoders/src/decode_etc_texture.cpp

/*
 * Copyright 2026 Rive
 */

#include "rive/decoders/bitmap_decoder.hpp"
#include "rive/gpu_texture_format.hpp"

#include <cstdio>
#include <cstring>
#include <memory>

// Forward declarations for Ericsson ETCPACK's etcdec.cxx (built as part of
// rive_decoders when RIVE_ETC_DECODER is set). Each entrypoint writes one 4x4
// block into a planar RGBA buffer at byte offsets +0/+1/+2 (RGB) and +3 (A).
extern void decompressBlockETC2c(unsigned int block_part1,
                                 unsigned int block_part2,
                                 unsigned char* img,
                                 int width,
                                 int height,
                                 int startx,
                                 int starty,
                                 int channels);
extern void decompressBlockAlphaC(unsigned char* data,
                                  unsigned char* img,
                                  int width,
                                  int height,
                                  int ix,
                                  int iy,
                                  int channels);

namespace
{
unsigned int readBE32(const uint8_t* p)
{
    return (static_cast<unsigned int>(p[0]) << 24) |
           (static_cast<unsigned int>(p[1]) << 16) |
           (static_cast<unsigned int>(p[2]) << 8) |
           static_cast<unsigned int>(p[3]);
}
} // namespace

// Decodes ETC2 RGBA8 (16 bytes/block: 8 bytes EAC alpha + 8 bytes ETC2 RGB).
std::unique_ptr<Bitmap> decode_etc_texture(const uint8_t* blocks,
                                           size_t byteCount,
                                           uint32_t width,
                                           uint32_t height,
                                           rive::GPUTextureFormat format)
{
    if (format != rive::GPUTextureFormat::etc2 || width == 0 || height == 0)
    {
        return nullptr;
    }

    const uint32_t paddedW = (width + 3u) & ~3u;
    const uint32_t paddedH = (height + 3u) & ~3u;
    const uint32_t blocksX = paddedW / 4u;
    const uint32_t blocksY = paddedH / 4u;
    const size_t expectedBytes = static_cast<size_t>(blocksX) * blocksY * 16u;
    if (byteCount != expectedBytes)
    {
        fprintf(stderr,
                "DecodeEtcTexture - byteCount %zu != expected %zu for %ux%u\n",
                byteCount,
                expectedBytes,
                width,
                height);
        return nullptr;
    }

    const size_t paddedPixels =
        static_cast<size_t>(paddedW) * static_cast<size_t>(paddedH);
    auto padded = std::make_unique<uint8_t[]>(paddedPixels * 4);

    const uint8_t* src = blocks;
    for (uint32_t by = 0; by < blocksY; ++by)
    {
        for (uint32_t bx = 0; bx < blocksX; ++bx)
        {
            const int startX = static_cast<int>(bx * 4u);
            const int startY = static_cast<int>(by * 4u);
            decompressBlockAlphaC(const_cast<uint8_t*>(src),
                                  padded.get() + 3,
                                  static_cast<int>(paddedW),
                                  static_cast<int>(paddedH),
                                  startX,
                                  startY,
                                  4);
            const unsigned int p1 = readBE32(src + 8);
            const unsigned int p2 = readBE32(src + 12);
            decompressBlockETC2c(p1,
                                 p2,
                                 padded.get(),
                                 static_cast<int>(paddedW),
                                 static_cast<int>(paddedH),
                                 startX,
                                 startY,
                                 4);
            src += 16;
        }
    }

    // Crop padded RGBA grid down to (width, height).
    const size_t outPixels =
        static_cast<size_t>(width) * static_cast<size_t>(height);
    auto pixels = std::make_unique<uint8_t[]>(outPixels * 4);
    for (uint32_t y = 0; y < height; ++y)
    {
        std::memcpy(pixels.get() + static_cast<size_t>(y) * width * 4,
                    padded.get() + static_cast<size_t>(y) * paddedW * 4,
                    static_cast<size_t>(width) * 4);
    }

    return std::make_unique<Bitmap>(width,
                                    height,
                                    outPixels * 4,
                                    Bitmap::PixelFormat::RGBA,
                                    std::move(pixels));
}