codec.hpp

Go to the documentation of this file.

#pragma once

 
#include <array>
#include <cstddef>
#include <cstdint>
#include <span>
#include <vector>
 
#include <wowlib/core/buffer.hpp>
#include <wowlib/core/error.hpp>
#include <wowlib/formats/blp/blp.hpp>
#include <wowlib/formats/common/types.hpp>
 
namespace wowlib::formats::blp::detail {
  using BlockPixels = std::array<std::uint8_t, 16 * 4>;

  class DxtCodec {
  public:
    explicit DxtCodec(PixelFormat format) noexcept : _format{format} {}

    [[nodiscard]]
    std::size_t blockBytes() const noexcept {
      return _format == PixelFormat::Dxt1 ? 8 : 16;
    }

    [[nodiscard]]
    std::size_t encodedSize(std::uint32_t width, std::uint32_t height) const noexcept {
      return ((width + 3) / 4) * std::size_t{(height + 3) / 4} * blockBytes();
    }

    [[nodiscard]]
    Result<std::vector<std::uint8_t>> decode(std::span<const std::byte> src,
                                             std::uint32_t width,
                                             std::uint32_t height) const;

    [[nodiscard]]
    Result<FileBuffer> encode(std::span<const std::uint8_t> rgba, std::uint32_t width, std::uint32_t height) const;
 
  protected:
    static void _decodeColorBlock(const std::uint8_t* block, BlockPixels& out, bool punchThrough) noexcept;

    static void _decodeExplicitAlpha(const std::uint8_t* block, BlockPixels& out) noexcept;

    static void _decodeInterpolatedAlpha(const std::uint8_t* block, std::span<std::uint8_t, 16> out) noexcept;

    static void _encodePunchThroughBlock(const BlockPixels& pixels, std::uint8_t* dest) noexcept;

    static BlockPixels _extractBlock(std::span<const std::uint8_t> rgba,
                                     std::uint32_t width,
                                     std::uint32_t height,
                                     std::uint32_t bx,
                                     std::uint32_t by) noexcept;
 
  private:
    PixelFormat _format;
  };

  class PaletteCodec {
  public:
    explicit PaletteCodec(std::uint8_t alphaDepth) noexcept : _alphaDepth{alphaDepth} {}

    [[nodiscard]]
    std::size_t encodedSize(std::uint32_t width, std::uint32_t height) const noexcept {
      const std::size_t texels = std::size_t{width} * height;
      return texels + (texels * _alphaDepth + 7) / 8;
    }

    [[nodiscard]]
    Result<std::vector<std::uint8_t>> decode(std::span<const std::byte> src,
                                             std::span<const CImVector, BlpPaletteSize> palette,
                                             std::uint32_t width,
                                             std::uint32_t height) const;

    [[nodiscard]]
    Result<FileBuffer> encode(std::span<const std::uint8_t> rgba,
                              std::span<const CImVector, BlpPaletteSize> palette,
                              std::uint32_t width,
                              std::uint32_t height) const;

    [[nodiscard]]
    std::array<CImVector, BlpPaletteSize> buildPalette(std::span<const std::uint8_t> rgba) const;
 
  protected:
    std::uint8_t _unpackAlpha(std::span<const std::byte> plane, std::size_t index) const noexcept;

    void _packAlpha(std::uint8_t alpha, std::span<std::byte> plane, std::size_t index) const noexcept;

    static std::uint8_t _nearestIndex(std::span<const CImVector, BlpPaletteSize> palette,
                                      std::uint8_t r,
                                      std::uint8_t g,
                                      std::uint8_t b) noexcept;
 
  private:
    std::uint8_t _alphaDepth;
  };

  class RawCodec {
  public:
    [[nodiscard]]
    Result<std::vector<std::uint8_t>> decode(std::span<const std::byte> src,
                                             std::uint32_t width,
                                             std::uint32_t height) const;

    [[nodiscard]]
    Result<FileBuffer> encode(std::span<const std::uint8_t> rgba, std::uint32_t width, std::uint32_t height) const;
  };

  class MipmapScaler {
  public:
    [[nodiscard]]
    std::vector<std::uint8_t> downscale(std::span<const std::uint8_t> rgba,
                                        std::uint32_t width,
                                        std::uint32_t height) const;
  };
}