#include "export.hpp"

#include <SDL.h>
#include <SDL_image.h>

#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cmath>
#include <fstream>
#include <string>
#include <unordered_map>
#include <vector>

namespace sppm {
namespace {

using Bytes = std::vector<std::uint8_t>;

void be32(Bytes& out, std::uint32_t value) {
    out.push_back(static_cast<std::uint8_t>(value >> 24));
    out.push_back(static_cast<std::uint8_t>(value >> 16));
    out.push_back(static_cast<std::uint8_t>(value >> 8));
    out.push_back(static_cast<std::uint8_t>(value));
}
void be16(Bytes& out, std::uint16_t value) {
    out.push_back(static_cast<std::uint8_t>(value >> 8));
    out.push_back(static_cast<std::uint8_t>(value));
}
void type(Bytes& out, const char* value) {
    out.insert(out.end(), value, value + 4);
}
std::size_t boxBegin(Bytes& out, const char* name) {
    const std::size_t start = out.size();
    be32(out, 0); type(out, name);
    return start;
}
void boxEnd(Bytes& out, std::size_t start) {
    const std::size_t size = out.size() - start;
    out[start] = static_cast<std::uint8_t>(size >> 24);
    out[start + 1] = static_cast<std::uint8_t>(size >> 16);
    out[start + 2] = static_cast<std::uint8_t>(size >> 8);
    out[start + 3] = static_cast<std::uint8_t>(size);
}
std::size_t fullBoxBegin(Bytes& out, const char* name, std::uint8_t version = 0,
                         std::uint32_t flags = 0) {
    const auto start = boxBegin(out, name);
    out.push_back(version);
    out.push_back(static_cast<std::uint8_t>(flags >> 16));
    out.push_back(static_cast<std::uint8_t>(flags >> 8));
    out.push_back(static_cast<std::uint8_t>(flags));
    return start;
}

Bytes mp4MovieBox(const std::vector<std::uint32_t>& sizes,
                  const std::vector<std::uint32_t>& offsets,
                  double fps) {
    constexpr std::uint32_t timeScale = 1000000;
    const std::uint32_t frameDelta = static_cast<std::uint32_t>(std::lround(timeScale / fps));
    const std::uint32_t duration = static_cast<std::uint32_t>(std::llround(sizes.size() * static_cast<double>(timeScale) / fps));
    Bytes out;
    auto moov = boxBegin(out, "moov");
    auto mvhd = fullBoxBegin(out, "mvhd");
    be32(out, 0); be32(out, 0); be32(out, timeScale);
    be32(out, duration);
    be32(out, 0x00010000); be16(out, 0x0100); be16(out, 0);
    be32(out, 0); be32(out, 0);
    const std::uint32_t matrix[] = {0x00010000,0,0, 0,0x00010000,0, 0,0,0x40000000};
    for (auto value : matrix) be32(out, value);
    for (int i = 0; i < 6; ++i) be32(out, 0);
    be32(out, 2); boxEnd(out, mvhd);

    auto trak = boxBegin(out, "trak");
    auto tkhd = fullBoxBegin(out, "tkhd", 0, 7);
    be32(out, 0); be32(out, 0); be32(out, 1); be32(out, 0);
    be32(out, duration);
    be32(out, 0); be32(out, 0); be16(out, 0); be16(out, 0); be16(out, 0); be16(out, 0);
    for (auto value : matrix) be32(out, value);
    be32(out, static_cast<std::uint32_t>(kWidth) << 16);
    be32(out, static_cast<std::uint32_t>(kHeight) << 16); boxEnd(out, tkhd);

    auto mdia = boxBegin(out, "mdia");
    auto mdhd = fullBoxBegin(out, "mdhd");
    be32(out, 0); be32(out, 0); be32(out, timeScale);
    be32(out, duration); be16(out, 0x55c4); be16(out, 0);
    boxEnd(out, mdhd);
    auto hdlr = fullBoxBegin(out, "hdlr");
    be32(out, 0); type(out, "vide"); be32(out, 0); be32(out, 0); be32(out, 0);
    out.insert(out.end(), {'S','w','i','t','c','h','n','o','t','e',' ','V','i','d','e','o',0});
    boxEnd(out, hdlr);
    auto minf = boxBegin(out, "minf");
    auto vmhd = fullBoxBegin(out, "vmhd", 0, 1);
    be16(out, 0); be16(out, 0); be16(out, 0); be16(out, 0); boxEnd(out, vmhd);
    auto dinf = boxBegin(out, "dinf");
    auto dref = fullBoxBegin(out, "dref"); be32(out, 1);
    auto url = fullBoxBegin(out, "url ", 0, 1); boxEnd(out, url); boxEnd(out, dref); boxEnd(out, dinf);
    auto stbl = boxBegin(out, "stbl");
    auto stsd = fullBoxBegin(out, "stsd"); be32(out, 1);
    auto jpeg = boxBegin(out, "mjpg");
    be32(out, 0); be16(out, 0); be16(out, 1);
    be16(out, 0); be16(out, 0); be32(out, 0); be32(out, 0); be32(out, 0);
    be16(out, kWidth); be16(out, kHeight); be32(out, 0x00480000); be32(out, 0x00480000);
    be32(out, 0); be16(out, 1); out.insert(out.end(), 32, 0); be16(out, 0x0018); be16(out, 0xffff);
    boxEnd(out, jpeg); boxEnd(out, stsd);
    auto stts = fullBoxBegin(out, "stts"); be32(out, 1); be32(out, static_cast<std::uint32_t>(sizes.size())); be32(out, frameDelta); boxEnd(out, stts);
    auto stsc = fullBoxBegin(out, "stsc"); be32(out, 1); be32(out, 1); be32(out, 1); be32(out, 1); boxEnd(out, stsc);
    auto stsz = fullBoxBegin(out, "stsz"); be32(out, 0); be32(out, static_cast<std::uint32_t>(sizes.size()));
    for (auto size : sizes) be32(out, size);
    boxEnd(out, stsz);
    auto stco = fullBoxBegin(out, "stco"); be32(out, static_cast<std::uint32_t>(offsets.size()));
    for (auto offset : offsets) be32(out, offset);
    boxEnd(out, stco);
    auto stss = fullBoxBegin(out, "stss"); be32(out, static_cast<std::uint32_t>(sizes.size()));
    for (std::size_t i = 0; i < sizes.size(); ++i) be32(out, static_cast<std::uint32_t>(i + 1));
    boxEnd(out, stss);
    boxEnd(out, stbl); boxEnd(out, minf); boxEnd(out, mdia); boxEnd(out, trak); boxEnd(out, moov);
    return out;
}

Color opaqueFramePixel(const Frame& frame, const Palette& palette, std::size_t pixel) {
    Color result{255, 255, 255, 255};
    for (std::size_t layerIndex = frame.layers.size(); layerIndex-- > 0;) {
        const auto index = frame.layers[layerIndex][pixel];
        if (!index) continue;
        const auto& source = palette[index];
        if (!source.a) continue;
        const unsigned alpha = source.a;
        result.r = static_cast<std::uint8_t>((source.r * alpha + result.r * (255 - alpha) + 127) / 255);
        result.g = static_cast<std::uint8_t>((source.g * alpha + result.g * (255 - alpha) + 127) / 255);
        result.b = static_cast<std::uint8_t>((source.b * alpha + result.b * (255 - alpha) + 127) / 255);
    }
    return result;
}

bool checkDocument(const Document& document, bool cover, std::string& error) {
    if (document.frames.empty() || document.frames.size() > kMaxFrames) {
        error = "frame count must be between 1 and 9999";
        return false;
    }
    if (document.metadata.fps < 1 || document.metadata.fps > 30) {
        error = "frame rate must be between 1 and 30 fps";
        return false;
    }
    if (cover && document.metadata.coverFrame >= document.frames.size()) {
        error = "cover frame is out of range";
        return false;
    }
    for (const Frame& frame : document.frames) {
        for (const auto& layer : frame.layers) {
            if (layer.size() != kPixelsPerLayer) {
                error = "a layer has the wrong pixel count";
                return false;
            }
        }
    }
    error.clear();
    return true;
}

// Straight-alpha source-over compositing, with A foremost and D rearmost.
Color compositePixel(const Frame& frame, const Palette& palette,
                     std::size_t pixel) {
    Color result{0, 0, 0, 0};
    for (std::size_t layerIndex = frame.layers.size(); layerIndex-- > 0;) {
        const auto& layer = frame.layers[layerIndex];
        const std::uint8_t index = layer[pixel];
        if (index == 0) continue;
        const Color& source = palette[index];
        if (source.a == 0) continue;
        if (source.a == 255) {
            result = source;
            continue;
        }
        const std::uint32_t sourceWeight =
            static_cast<std::uint32_t>(source.a) * 255U;
        const std::uint32_t behindWeight =
            static_cast<std::uint32_t>(result.a) * (255U - source.a);
        const std::uint32_t total = sourceWeight + behindWeight;
        result.r = static_cast<std::uint8_t>(
            (source.r * sourceWeight + result.r * behindWeight + total / 2U) / total);
        result.g = static_cast<std::uint8_t>(
            (source.g * sourceWeight + result.g * behindWeight + total / 2U) / total);
        result.b = static_cast<std::uint8_t>(
            (source.b * sourceWeight + result.b * behindWeight + total / 2U) / total);
        result.a = static_cast<std::uint8_t>((total + 127U) / 255U);
    }
    return result;
}

std::uint8_t nearestPaletteIndex(const Color& color, const Palette& palette) {
    std::uint32_t bestDistance = 3U * 255U * 255U + 1U;
    std::uint8_t best = 0;
    for (std::size_t i = 1; i < palette.size(); ++i) {
        const Color& candidate = palette[i];
        if (candidate.a == 0) continue;
        const int dr = static_cast<int>(color.r) - candidate.r;
        const int dg = static_cast<int>(color.g) - candidate.g;
        const int db = static_cast<int>(color.b) - candidate.b;
        const std::uint32_t distance =
            static_cast<std::uint32_t>(dr * dr + dg * dg + db * db);
        if (distance < bestDistance) {
            bestDistance = distance;
            best = static_cast<std::uint8_t>(i);
            if (distance == 0) break;
        }
    }
    return best;
}

// GIF has a single transparent index, so partially transparent colors are
// composited first, then matched to the nearest RGB color in the palette.
std::vector<std::uint8_t> gifPixels(const Frame& frame,
                                    const Palette& palette) {
    std::vector<std::uint8_t> pixels(kPixelsPerLayer, 0);
    bool hasPartialAlpha = false;
    for (std::size_t i = 1; i < palette.size(); ++i) {
        if (palette[i].a != 0 && palette[i].a != 255) {
            hasPartialAlpha = true;
            break;
        }
    }
    if (!hasPartialAlpha) {
        for (std::size_t layerIndex = frame.layers.size(); layerIndex-- > 0;) {
            const auto& layer = frame.layers[layerIndex];
            for (std::size_t pixel = 0; pixel < pixels.size(); ++pixel) {
                const std::uint8_t index = layer[pixel];
                if (index != 0 && palette[index].a != 0) pixels[pixel] = index;
            }
        }
        return pixels;
    }

    std::unordered_map<std::uint32_t, std::uint8_t> matchCache;
    matchCache.reserve(512);
    for (std::size_t pixel = 0; pixel < pixels.size(); ++pixel) {
        const Color color = compositePixel(frame, palette, pixel);
        if (color.a < 128) continue;
        const std::uint32_t key =
            (static_cast<std::uint32_t>(color.r) << 16U) |
            (static_cast<std::uint32_t>(color.g) << 8U) | color.b;
        const auto found = matchCache.find(key);
        if (found != matchCache.end()) {
            pixels[pixel] = found->second;
        } else {
            const std::uint8_t index = nearestPaletteIndex(color, palette);
            matchCache.emplace(key, index);
            pixels[pixel] = index;
        }
    }
    return pixels;
}

struct BitPacker {
    std::vector<std::uint8_t> data;
    std::uint32_t pending = 0;
    unsigned pendingBits = 0;

    void code(std::uint16_t value, unsigned width) {
        pending |= static_cast<std::uint32_t>(value) << pendingBits;
        pendingBits += width;
        while (pendingBits >= 8) {
            data.push_back(static_cast<std::uint8_t>(pending & 0xFFU));
            pending >>= 8U;
            pendingBits -= 8U;
        }
    }

    void finish() {
        if (pendingBits != 0) data.push_back(static_cast<std::uint8_t>(pending));
    }
};

std::vector<std::uint8_t> gifLzw(const std::vector<std::uint8_t>& pixels) {
    constexpr std::uint16_t clearCode = 256;
    constexpr std::uint16_t endCode = 257;
    std::unordered_map<std::uint32_t, std::uint16_t> dictionary;
    dictionary.reserve(4096);
    std::uint16_t nextCode = 258;
    unsigned codeWidth = 9;
    BitPacker writer;
    writer.data.reserve(pixels.size() / 2);
    writer.code(clearCode, codeWidth);
    std::uint16_t prefix = pixels.front();

    for (std::size_t i = 1; i < pixels.size(); ++i) {
        const std::uint8_t suffix = pixels[i];
        const std::uint32_t key =
            (static_cast<std::uint32_t>(prefix) << 8U) | suffix;
        const auto found = dictionary.find(key);
        if (found != dictionary.end()) {
            prefix = found->second;
            continue;
        }

        writer.code(prefix, codeWidth);
        if (nextCode < 4096) {
            dictionary.emplace(key, nextCode++);
            // GIF's decoder learns each new phrase one code later.
            if (codeWidth < 12 && nextCode > (1U << codeWidth)) ++codeWidth;
        } else {
            writer.code(clearCode, codeWidth);
            dictionary.clear();
            nextCode = 258;
            codeWidth = 9;
        }
        prefix = suffix;
    }
    writer.code(prefix, codeWidth);
    writer.code(endCode, codeWidth);
    writer.finish();
    return writer.data;
}

void byte(std::ostream& out, std::uint8_t value) {
    out.put(static_cast<char>(value));
}

void le16(std::ostream& out, std::uint16_t value) {
    byte(out, static_cast<std::uint8_t>(value));
    byte(out, static_cast<std::uint8_t>(value >> 8U));
}

void be32(std::ostream& out, std::uint32_t value) {
    byte(out, static_cast<std::uint8_t>(value >> 24U));
    byte(out, static_cast<std::uint8_t>(value >> 16U));
    byte(out, static_cast<std::uint8_t>(value >> 8U));
    byte(out, static_cast<std::uint8_t>(value));
}

std::uint32_t crc32(const char* type, const std::vector<std::uint8_t>& data) {
    std::uint32_t crc = 0xFFFFFFFFU;
    auto update = [&crc](std::uint8_t value) {
        crc ^= value;
        for (unsigned bit = 0; bit < 8; ++bit) {
            crc = (crc >> 1U) ^ ((crc & 1U) ? 0xEDB88320U : 0U);
        }
    };
    for (int i = 0; i < 4; ++i) update(static_cast<std::uint8_t>(type[i]));
    for (std::uint8_t value : data) update(value);
    return crc ^ 0xFFFFFFFFU;
}

void pngChunk(std::ostream& out, const char* type,
              const std::vector<std::uint8_t>& data) {
    be32(out, static_cast<std::uint32_t>(data.size()));
    out.write(type, 4);
    if (!data.empty()) {
        out.write(reinterpret_cast<const char*>(data.data()),
                  static_cast<std::streamsize>(data.size()));
    }
    be32(out, crc32(type, data));
}

std::vector<std::uint8_t> zlibStored(const std::vector<std::uint8_t>& raw) {
    std::vector<std::uint8_t> encoded;
    encoded.reserve(raw.size() + 6 + (raw.size() / 65535 + 1) * 5);
    encoded.push_back(0x78); // zlib CMF: deflate, 32 KiB window
    encoded.push_back(0x01); // zlib FLG: no compression
    std::size_t offset = 0;
    while (offset < raw.size()) {
        const std::size_t length = std::min<std::size_t>(65535, raw.size() - offset);
        const bool final = offset + length == raw.size();
        const std::uint16_t len = static_cast<std::uint16_t>(length);
        const std::uint16_t inverse = static_cast<std::uint16_t>(~len);
        encoded.push_back(final ? 0x01 : 0x00);
        encoded.push_back(static_cast<std::uint8_t>(len));
        encoded.push_back(static_cast<std::uint8_t>(len >> 8U));
        encoded.push_back(static_cast<std::uint8_t>(inverse));
        encoded.push_back(static_cast<std::uint8_t>(inverse >> 8U));
        encoded.insert(encoded.end(), raw.begin() + static_cast<std::ptrdiff_t>(offset),
                       raw.begin() + static_cast<std::ptrdiff_t>(offset + length));
        offset += length;
    }
    std::uint32_t a = 1;
    std::uint32_t b = 0;
    for (std::uint8_t value : raw) {
        a = (a + value) % 65521U;
        b = (b + a) % 65521U;
    }
    const std::uint32_t adler = (b << 16U) | a;
    encoded.push_back(static_cast<std::uint8_t>(adler >> 24U));
    encoded.push_back(static_cast<std::uint8_t>(adler >> 16U));
    encoded.push_back(static_cast<std::uint8_t>(adler >> 8U));
    encoded.push_back(static_cast<std::uint8_t>(adler));
    return encoded;
}

} // namespace

bool exportGif(const Document& document, const std::string& path,
               std::string& error) {
    if (!checkDocument(document, false, error)) return false;
    if (path.empty()) {
        error = "GIF output path is empty";
        return false;
    }
    std::ofstream out(path, std::ios::binary | std::ios::trunc);
    if (!out) {
        error = "could not open GIF output";
        return false;
    }
    out.write("GIF89a", 6);
    le16(out, kWidth);
    le16(out, kHeight);
    byte(out, 0xF7); // global 256-color table, 8-bit color resolution
    byte(out, 1);    // white in the default palette as the canvas background
    byte(out, 0);
    for (const Color& color : document.palette) {
        byte(out, color.r);
        byte(out, color.g);
        byte(out, color.b);
    }

    // Netscape application extension: loop indefinitely.
    const std::array<std::uint8_t, 19> loop = {
        0x21, 0xFF, 0x0B, 'N', 'E', 'T', 'S', 'C', 'A', 'P', 'E', '2', '.', '0',
        0x03, 0x01, 0x00, 0x00, 0x00};
    out.write(reinterpret_cast<const char*>(loop.data()),
              static_cast<std::streamsize>(loop.size()));

    for (std::size_t i = 0; i < document.frames.size(); ++i) {
        const double fps = frameRate(document.metadata);
        const unsigned start = static_cast<unsigned>(std::llround(i * 100.0 / fps));
        const unsigned end = static_cast<unsigned>(std::llround((i + 1U) * 100.0 / fps));
        const std::uint16_t delay =
            static_cast<std::uint16_t>(std::max(1U, end - start));
        byte(out, 0x21); byte(out, 0xF9); byte(out, 0x04);
        byte(out, 0x09); // restore background before next frame, index 0 transparent
        le16(out, delay);
        byte(out, 0); byte(out, 0);

        byte(out, 0x2C); // full-canvas image descriptor
        le16(out, 0); le16(out, 0);
        le16(out, kWidth); le16(out, kHeight);
        byte(out, 0);    // use global palette
        byte(out, 8);    // LZW minimum code size
        const std::vector<std::uint8_t> pixels =
            gifPixels(document.frames[i], document.palette);
        const std::vector<std::uint8_t> compressed = gifLzw(pixels);
        for (std::size_t offset = 0; offset < compressed.size();) {
            const std::size_t length =
                std::min<std::size_t>(255, compressed.size() - offset);
            byte(out, static_cast<std::uint8_t>(length));
            out.write(reinterpret_cast<const char*>(compressed.data() + offset),
                      static_cast<std::streamsize>(length));
            offset += length;
        }
        byte(out, 0); // terminate LZW sub-blocks
        if (!out) {
            error = "could not write GIF frame";
            return false;
        }
    }
    byte(out, 0x3B);
    out.flush();
    if (!out) {
        error = "could not finish GIF output";
        return false;
    }
    error.clear();
    return true;
}

bool exportPngCover(const Document& document, const std::string& path,
                    std::string& error) {
    if (!checkDocument(document, true, error)) return false;
    if (path.empty()) {
        error = "PNG output path is empty";
        return false;
    }
    const Frame& frame = document.frames[document.metadata.coverFrame];
    std::vector<std::uint8_t> raw;
    raw.reserve(static_cast<std::size_t>(kHeight) * (1U + 4U * kWidth));
    for (std::size_t y = 0; y < kHeight; ++y) {
        raw.push_back(0); // PNG filter type 0
        for (std::size_t x = 0; x < kWidth; ++x) {
            const Color pixel = compositePixel(frame, document.palette,
                                                y * kWidth + x);
            raw.push_back(pixel.r);
            raw.push_back(pixel.g);
            raw.push_back(pixel.b);
            raw.push_back(pixel.a);
        }
    }
    std::ofstream out(path, std::ios::binary | std::ios::trunc);
    if (!out) {
        error = "could not open PNG output";
        return false;
    }
    constexpr std::array<std::uint8_t, 8> signature =
        {137, 80, 78, 71, 13, 10, 26, 10};
    out.write(reinterpret_cast<const char*>(signature.data()),
              static_cast<std::streamsize>(signature.size()));
    const std::vector<std::uint8_t> header = {
        static_cast<std::uint8_t>(kWidth >> 24U),
        static_cast<std::uint8_t>(kWidth >> 16U),
        static_cast<std::uint8_t>(kWidth >> 8U),
        static_cast<std::uint8_t>(kWidth),
        static_cast<std::uint8_t>(kHeight >> 24U),
        static_cast<std::uint8_t>(kHeight >> 16U),
        static_cast<std::uint8_t>(kHeight >> 8U),
        static_cast<std::uint8_t>(kHeight),
        8, 6, 0, 0, 0}; // RGBA, 8 bits/channel, no interlace
    pngChunk(out, "IHDR", header);
    pngChunk(out, "IDAT", zlibStored(raw));
    pngChunk(out, "IEND", {});
    out.flush();
    if (!out) {
        error = "could not finish PNG output";
        return false;
    }
    error.clear();
    return true;
}

bool exportMp4(const Document& document, const std::string& path,
               std::string& error) {
    if (!checkDocument(document, false, error)) return false;
    if (path.empty()) { error = "MP4 output path is empty"; return false; }
    const double fps = frameRate(document.metadata);
    if (!(fps > 0.0 && fps <= 30.0)) { error = "frame rate must be between 0 and 30 fps"; return false; }

    Bytes ftyp;
    auto ftypBox = boxBegin(ftyp, "ftyp");
    type(ftyp, "isom"); be32(ftyp, 0x00000200); type(ftyp, "isom"); type(ftyp, "iso2"); type(ftyp, "mp41"); type(ftyp, "mjpg");
    boxEnd(ftyp, ftypBox);

    std::ofstream out(path, std::ios::binary | std::ios::trunc);
    if (!out) { error = "could not create MP4 file"; return false; }
    out.write(reinterpret_cast<const char*>(ftyp.data()), static_cast<std::streamsize>(ftyp.size()));
    const std::uint32_t mdatStart = static_cast<std::uint32_t>(ftyp.size());
    const std::uint8_t mdatHeader[8] = {0,0,0,0,'m','d','a','t'};
    out.write(reinterpret_cast<const char*>(mdatHeader), sizeof(mdatHeader));
    std::vector<std::uint32_t> sampleSizes;
    std::vector<std::uint32_t> sampleOffsets;
    sampleSizes.reserve(document.frames.size());
    sampleOffsets.reserve(document.frames.size());

    constexpr int jpegCapacity = 2 * 1024 * 1024;
    std::vector<std::uint8_t> jpegBuffer(static_cast<std::size_t>(jpegCapacity));
    for (std::size_t frameIndex = 0; frameIndex < document.frames.size(); ++frameIndex) {
        SDL_Surface* surface = SDL_CreateRGBSurfaceWithFormat(0, kWidth, kHeight, 32, SDL_PIXELFORMAT_RGBA32);
        if (!surface) { error = "could not allocate frame image"; return false; }
        if (SDL_LockSurface(surface) != 0) {
            SDL_FreeSurface(surface); error = "could not prepare frame image"; return false;
        }
        auto* rows = static_cast<std::uint8_t*>(surface->pixels);
        for (std::size_t y = 0; y < kHeight; ++y) {
            auto* row = reinterpret_cast<std::uint32_t*>(rows + y * static_cast<std::size_t>(surface->pitch));
            for (std::size_t x = 0; x < kWidth; ++x) {
                const Color pixel = opaqueFramePixel(document.frames[frameIndex], document.palette, y * kWidth + x);
                row[x] = SDL_MapRGBA(surface->format, pixel.r, pixel.g, pixel.b, 255);
            }
        }
        SDL_UnlockSurface(surface);
        SDL_RWops* jpegStream = SDL_RWFromMem(jpegBuffer.data(), jpegCapacity);
        if (!jpegStream || IMG_SaveJPG_RW(surface, jpegStream, 0, 82) != 0) {
            if (jpegStream) SDL_RWclose(jpegStream);
            SDL_FreeSurface(surface); error = "could not encode an MP4 frame as JPEG"; return false;
        }
        const Sint64 jpegSize = SDL_RWtell(jpegStream);
        SDL_RWclose(jpegStream);
        SDL_FreeSurface(surface);
        if (jpegSize <= 0 || jpegSize > jpegCapacity) { error = "encoded frame is too large"; return false; }
        const auto position = out.tellp();
        if (position < 0 || static_cast<std::uint64_t>(position) > UINT32_MAX) {
            error = "MP4 exceeds the supported 4 GB file limit"; return false;
        }
        sampleOffsets.push_back(static_cast<std::uint32_t>(position));
        sampleSizes.push_back(static_cast<std::uint32_t>(jpegSize));
        out.write(reinterpret_cast<const char*>(jpegBuffer.data()), jpegSize);
        if (!out) { error = "could not write MP4 frame data"; return false; }
    }
    const auto endOfMedia = out.tellp();
    if (endOfMedia < 0 || static_cast<std::uint64_t>(endOfMedia) - mdatStart > UINT32_MAX) {
        error = "MP4 exceeds the supported 4 GB file limit"; return false;
    }
    const std::uint32_t mdatSize = static_cast<std::uint32_t>(static_cast<std::uint64_t>(endOfMedia) - mdatStart);
    out.seekp(mdatStart);
    const std::uint8_t encodedMdatSize[4] = {
        static_cast<std::uint8_t>(mdatSize >> 24), static_cast<std::uint8_t>(mdatSize >> 16),
        static_cast<std::uint8_t>(mdatSize >> 8), static_cast<std::uint8_t>(mdatSize)};
    out.write(reinterpret_cast<const char*>(encodedMdatSize), sizeof(encodedMdatSize));
    out.seekp(endOfMedia);
    const Bytes moov = mp4MovieBox(sampleSizes, sampleOffsets, fps);
    out.write(reinterpret_cast<const char*>(moov.data()), static_cast<std::streamsize>(moov.size()));
    out.flush();
    if (!out) { error = "could not finish MP4 index"; return false; }
    out.close();
    error.clear();
    return true;
}

} // namespace sppm