image_codecs.hpp

Go to the documentation of this file.

#pragma once
 
// Extended image codecs — GIF and TIFF readers/writers.
//
// Skia (the default Pulp decode path via SkImages::DeferredFromEncodedData)
// covers PNG / JPEG / WebP / BMP / ICO in the m144 prebuilt that Pulp pins,
// but does NOT compile in the GIF decoder by default and ships no TIFF
// codec at all. This header fills that gap with dedicated reader/writer
// entry points.
//
// This header provides a Skia-free public surface that:
//   • Decodes GIF87a / GIF89a (single frame + animation frames + LZW + LCT)
//     into RGBA8 pixel buffers using an in-tree decoder. The decoder is
//     MIT-clean (no LZW patent — patent expired in 2004), header-light,
//     and depends only on the C++ standard library.
//   • Decodes Baseline TIFF 6.0 (uncompressed and PackBits compression,
//     8-bit Grayscale / RGB / RGBA, BitsPerSample=8) into RGBA8. Wider
//     TIFF coverage (LZW, JPEG-in-TIFF, multi-strip stitching) would
//     require libtiff which is heavyweight and only ~MIT-compatible
//     under its custom permissive license; not pulled in here.
//   • Encodes uncompressed Baseline TIFF (RGB / RGBA) and a static
//     GIF89a (single global palette, 256-color quantisation via simple
//     median-cut). Writer paths are intended for editor / asset export
//     use; not optimized for runtime hot paths.
//
// The codec functions return std::optional<DecodedRaster> on success and
// std::nullopt on any malformed input — no exceptions thrown, callers
// can degrade gracefully (fall back to Skia, or report unsupported).
//
// Animation: GifReader::decode_first() decodes a single frame for
// callers that only want the cover image (matches existing
// SkImages::DeferredFromEncodedData behavior). GifReader::decode_all()
// returns every frame in order plus per-frame delays in milliseconds;
// the GIF89a wire format stores centi-seconds, which the codec converts.
 
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
 
namespace pulp::canvas {

struct DecodedRaster {
    uint32_t width = 0;
    uint32_t height = 0;
    std::vector<uint8_t> rgba;
};
 
struct GifFrame {
    DecodedRaster raster;
    uint32_t delay_ms = 0;
};

class GifReader {
public:
    static std::optional<DecodedRaster> decode_first(const uint8_t* data,
                                                     std::size_t size);

    static std::optional<std::vector<GifFrame>> decode_all(
        const uint8_t* data, std::size_t size);

    static bool is_gif(const uint8_t* data, std::size_t size);
};

class GifWriter {
public:
    static std::vector<uint8_t> encode_still(const DecodedRaster& raster);
};

class TiffReader {
public:
    static std::optional<DecodedRaster> decode(const uint8_t* data,
                                               std::size_t size);
 
    static bool is_tiff(const uint8_t* data, std::size_t size);
};

class TiffWriter {
public:
    static std::vector<uint8_t> encode(const DecodedRaster& raster);
};
 
}  // namespace pulp::canvas