ContainerMP4.h

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <cstring>
 
#include "AudioTools/AudioCodecs/AudioCodecsBase.h"
#include "AudioTools/AudioCodecs/CodecWAV.h"
#include "AudioTools/AudioCodecs/ContainerCommon.h"
#include "AudioTools/AudioCodecs/M4ACommonDemuxer.h"
#include "AudioTools/AudioCodecs/MP4Parser.h"
#include "AudioTools/CoreAudio/Buffers.h"
#include "AudioTools/Video/Video.h"
 
namespace audio_tools {
 
class DemuxerMP4 : public Demuxer {
 public:
  using Codec = M4ACommonDemuxer::Codec;
 
  DemuxerMP4() { setupParser(); }
 
  DemuxerMP4(Print& video_out, Print& audio_out) {
    setupParser();
    setOutputAudio(audio_out);
    setOutputVideo(video_out);
  }
 
  DemuxerMP4(VideoOutput& video_out, Print& audio_out) {
    setupParser();
    setOutputAudio(audio_out);
    setOutputVideo(video_out);
  }
 
  ~DemuxerMP4() { freeTracks(); }
 
  const char* mime() override { return "video/mp4"; }
 
  bool begin() override {
    freeTracks();
    schedule.clear();
    current_track = nullptr;
    p_video_track = nullptr;
    p_audio_track = nullptr;
    schedule_index = 0;
    samples_left_in_entry = 0;
    mdat_seen = false;
    box_accum_active = false;
    box_accum.clear();
    stsz_header_pending = true;
    sample_buffer.clear();
    sample_buffer_filled = 0;
    current_sample_size = 0;
    current_sample_track = nullptr;
    is_wav_header_sent = false;
    total_bytes_received = 0;
    playback_start_set = false;
    parser.begin();
    is_active = true;
    return true;
  }
 
  void end() override { is_active = false; }
 
  operator bool() override { return is_active; }
 
  void setOutputAudio(Print& out) override { p_output_audio = &out; }
 
  void setOutput(Print& out) override { setOutputAudio(out); }
 
  void setOutputVideo(Print& out) override { p_video_out = &out; }
  void setOutputVideo(VideoOutput& out) { p_video_out_video = &out; }
 
  VideoInfo getVideoInfo() override {
    VideoInfo result;
    result.total_file_size = total_bytes_received;
    // width==0 means 'avc1'/'hev1' hasn't been parsed yet (p_video_track can
    // already be set from 'hdlr' alone) - keep the all-UNKNOWN default then
    if (p_video_track == nullptr || p_video_track->width == 0) return result;
    result.width = p_video_track->width;
    result.height = p_video_track->height;
    result.format = p_video_track->is_hevc_unsupported ? VideoFormat::UNKNOWN
                                                       : VideoFormat::H264;
    result.frame_size = (uint32_t)videoFrameSizeBytes(
        result.format, result.width, result.height);
    return result;
  }
  AudioInfoFormat getAudioInfo() override {
    AudioInfoFormat result(info);
    result.format = audio_format;
    return result;
  }
  Vector<uint8_t>& audioALACMagicCookie() {
    static Vector<uint8_t> empty;
    return p_audio_track ? p_audio_track->alacMagicCookie : empty;
  }
 
  size_t write(const uint8_t* data, size_t len) override {
    if (!is_active) return 0;
    size_t written = parser.write(data, len);
    total_bytes_received += written;
    return written;
  }
 
 protected:
  struct StscEntry {
    uint32_t first_chunk;
    uint32_t samples_per_chunk;
  };
 
  struct SttsEntry {
    uint32_t sample_count;
    uint32_t sample_delta;
  };
 
  struct Track {
    enum class Kind { Unknown, Audio, Video } kind = Kind::Unknown;
 
    // audio
    Codec audio_codec = Codec::Unknown;
    int aacProfile = 2, sampleRateIdx = 4, channelCfg = 2;
    Vector<uint8_t> alacMagicCookie;
 
    // video (H.264 only in v1)
    uint16_t width = 0, height = 0;
    uint8_t nal_length_size = 4;
    Vector<uint8_t> sps_pps_annexb;
    bool avc_config_sent = false;
    bool is_hevc_unsupported = false;
 
    // sample tables, populated while parsing 'moov'
    Vector<uint32_t> sample_sizes;
    uint32_t fixed_sample_size = 0;
    uint32_t fixed_sample_count = 0;
    Vector<StscEntry> stsc;
    Vector<uint64_t> chunk_offsets;
 
    // playback timing: this track's own 'mdhd' timescale (ticks/second)
    // and its 'stts' time-to-sample table - both needed to turn a sample
    // index into a scheduled presentation time.
    uint32_t timescale = 0;
    Vector<SttsEntry> stts;
 
    // runtime cursor, used while walking the merge schedule
    uint32_t next_sample_index = 0;
 
    // runtime cursor for nextPtsTicks(), advanced once per dispatched
    // sample - kept separate from next_sample_index so it stays valid
    // even if next_sample_index is ever used for random access
    uint32_t stts_entry_idx = 0;
    uint32_t stts_entry_remaining = 0;
    uint64_t next_pts_ticks = 0;
 
    uint32_t sampleSize(uint32_t idx) {
      if (fixed_sample_size > 0) return fixed_sample_size;
      if (idx >= sample_sizes.size()) return 0;
      return sample_sizes[idx];
    }
 
    uint32_t sampleCount() {
      return fixed_sample_size > 0 ? fixed_sample_count
                                   : (uint32_t)sample_sizes.size();
    }
 
    uint64_t nextPtsTicks() {
      uint64_t pts = next_pts_ticks;
      if (stts_entry_idx < stts.size()) {
        if (stts_entry_remaining == 0)
          stts_entry_remaining = stts[stts_entry_idx].sample_count;
        next_pts_ticks += stts[stts_entry_idx].sample_delta;
        if (stts_entry_remaining > 0) {
          stts_entry_remaining--;
          if (stts_entry_remaining == 0) stts_entry_idx++;
        }
      }
      return pts;
    }
  };
 
  struct ScheduleEntry {
    Track* track;
    uint32_t sample_count;
  };
 
  MP4Parser parser;
  // heap-allocated (not Vector<Track>): current_track/p_video_track/
  // p_audio_track are captured *during* moov parsing, while more trak
  // boxes (and thus more push_back calls) may still arrive - Vector<T>
  // reallocates its backing array on growth, which would dangle any
  // pointer taken directly into it. Pointers to heap objects stay valid
  // regardless of how the Vector<Track*> itself grows.
  Vector<Track*> tracks;
  Track* current_track =
      nullptr;  
 
  void freeTracks() {
    for (size_t i = 0; i < tracks.size(); i++) delete tracks[i];
    tracks.clear();
  }
  Track* p_video_track = nullptr;  
  Track* p_audio_track = nullptr;  
 
  Vector<ScheduleEntry> schedule;
  size_t schedule_index = 0;  
  uint32_t samples_left_in_entry = 0;
  bool mdat_seen = false;
 
  Print* p_output_audio = nullptr;
  Print* p_video_out = nullptr;
  VideoOutput* p_video_out_video = nullptr;
  AudioFormat audio_format = AudioFormat::UNKNOWN;
  bool send_wav_header = false;
  bool send_wav_header_explicit = false;
  bool is_wav_header_sent = false;
  uint32_t total_bytes_received = 0;
  bool is_active = false;
 
  // video playback pacing: wall-clock reference captured at the first
  // dispatched video sample, against which each subsequent sample's
  // scheduled presentation time (from 'mdhd'+'stts') is compared - see
  // dispatchVideo().
  bool playback_start_set = false;
  uint32_t playback_start_ms = 0;
 
  // sample accumulation (mdat streaming)
  Vector<uint8_t> sample_buffer;
  size_t sample_buffer_filled = 0;
  uint32_t current_sample_size = 0;
  Track* current_sample_track = nullptr;
  bool current_sample_is_first_for_track = false;
 
  // scratch accumulation buffer, reused sequentially for stsz/stsc/stco/co64
  // (only one of these is ever "in progress" at a time in a linear parse)
  SingleBuffer<uint8_t> box_accum{0};
  // Explicit "are we mid-accumulation" state for box_accum, decoupled from
  // its fill level: box_accum.available()==0 is NOT a reliable "start of a
  // new box" signal, because some handlers (onStsz) legitimately drain it
  // to empty via clearArray() *while still mid-box* (e.g. right after
  // consuming a fixed-size sub-header, with more payload still to come) -
  // available()==0 in that case would be misread as a fresh box starting.
  bool box_accum_active = false;
  bool stsz_header_pending = true;
 
  bool beginBoxAccum(const MP4Parser::Box& box) {
    if (box_accum_active) return false;
    box_accum.resize(box.size);
    box_accum.clear();
    box_accum_active = true;
    return true;
  }
 
  void endBoxAccum() {
    box_accum.clear();
    box_accum_active = false;
  }
 
  Vector<uint8_t> nal_tmp;  
 
  static uint32_t readU32(const uint8_t* p) {
    return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
  }
  static uint64_t readU64(const uint8_t* p) {
    return ((uint64_t)readU32(p) << 32) | readU32(p + 4);
  }
  static uint16_t readU16(const uint8_t* p) { return (p[0] << 8) | p[1]; }
 
  void setupParser() {
    parser.setReference(this);
    // suppress MP4Parser's default behavior of printing every box we don't
    // otherwise handle (mvhd, tkhd, stts, ...) to Serial/stdout
    parser.setCallback([](MP4Parser::Box&, void*) {});
 
    parser.setCallback(
        "trak",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onTrak();
        },
        false);
 
    parser.setCallback(
        "hdlr",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onHdlr(box);
        },
        false);
 
    parser.setCallback(
        "stsd",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onStsd(box);
        },
        false);
 
    parser.setCallback(
        "mp4a",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onMp4a(box);
        },
        false);
    parser.setCallback(
        "alac",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onAlac(box);
        },
        false);
    parser.setCallback(
        "esds",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onEsds(box);
        },
        false);
 
    parser.setCallback(
        "avc1",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onAvc1(box);
        },
        false);
    parser.setCallback(
        "hev1",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onHevc(box);
        },
        false);
    parser.setCallback(
        "hvc1",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onHevc(box);
        },
        false);
    parser.setCallback(
        "avcC",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onAvcC(box);
        },
        false);
 
    parser.setCallback(
        "mdhd",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onMdhd(box);
        },
        false);
    parser.setCallback(
        "stts",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onStts(box);
        },
        false);
 
    parser.setCallback(
        "stsz",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onStsz(box);
        },
        false);
    parser.setCallback(
        "stsc",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onStsc(box);
        },
        false);
    parser.setCallback(
        "stco",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onStco(box, false);
        },
        false);
    parser.setCallback(
        "co64",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onStco(box, true);
        },
        false);
 
    parser.setCallback(
        "mdat",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onMdat(box);
        },
        false);
  }
 
  // ---- moov / track parsing ----
 
  void onTrak() {
    Track* t = new Track();
    tracks.push_back(t);
    current_track = t;
  }
 
  void onHdlr(MP4Parser::Box& box) {
    if (current_track == nullptr) return;
    beginBoxAccum(box);
    box_accum.writeArray(box.data, box.available);
    if (!box.is_complete || box_accum.available() < 12) return;
    const uint8_t* handler = box_accum.data() + 8;
    if (memcmp(handler, "vide", 4) == 0) {
      current_track->kind = Track::Kind::Video;
      if (p_video_track == nullptr) p_video_track = current_track;
    } else if (memcmp(handler, "soun", 4) == 0) {
      current_track->kind = Track::Kind::Audio;
      if (p_audio_track == nullptr) p_audio_track = current_track;
    }
    endBoxAccum();
  }
 
  void onStsd(MP4Parser::Box& box) {
    beginBoxAccum(box);
    box_accum.writeArray(box.data, box.available);
    if (box.is_complete && box_accum.available() >= 8) {
      // sample entries (mp4a/alac/avc1/hev1/...) parsed generically, same
      // mechanism as M4ACommonDemuxer::onStsd
      parser.parseString(box_accum.data() + 8, box_accum.available() - 8,
                         box.file_offset + 8 + 8, box.level + 1);
      endBoxAccum();
    }
  }
 
  void onMp4a(const MP4Parser::Box& box) {
    if (current_track == nullptr || !box.is_complete) return;
    current_track->aacProfile = 2;     // default AAC LC
    current_track->sampleRateIdx = 4;  // default 44100 Hz
    current_track->channelCfg = 2;     // default stereo
    current_track->audio_codec = Codec::AAC;
    setupAudioInfo(AudioFormat::AAC, box.data, box.data_size);
    // AudioSampleEntry fixed header is 28 bytes (incl. the 8 bytes already
    // stripped as the box header) - esds (child box) follows
    int pos = 36 - 8;
    if (box.data_size > (size_t)pos)
      parser.parseString(box.data + pos, box.data_size - pos,
                         box.file_offset + 8 + pos, box.level + 1);
  }
 
  void setupAudioInfo(AudioFormat format, const uint8_t* entryData,
                      size_t entrySize) {
    if (entrySize < 28) return;
    info.channels = readU16(entryData + 16);
    info.sample_rate = readU16(entryData + 24);
    info.bits_per_sample = 16;
    audio_format = format;
    info.logInfo();
    if (!send_wav_header_explicit) send_wav_header = isWavFormat(audio_format);
    if (send_wav_header) sendWavHeader();
    notifyAudioChange(info);
  }
 
  void setSendWavHeader(bool flag) override {
    send_wav_header = flag;
    send_wav_header_explicit = true;
  }
 
  void sendWavHeader() {
    if (is_wav_header_sent || p_output_audio == nullptr) return;
    WAVAudioInfo winfo(info);
    winfo.format = audio_format;
    winfo.is_streamed = true;
    winfo.block_align = info.channels * (info.bits_per_sample / 8);
    winfo.byte_rate = info.sample_rate * winfo.block_align;
    WAVHeader wav_header;
    wav_header.setAudioInfo(winfo);
    wav_header.writeHeader(p_output_audio);
    is_wav_header_sent = true;
  }
 
  void onEsds(const MP4Parser::Box& box) {
    if (current_track == nullptr) return;
    M4ACommonDemuxer::ESDSParser esdsParser;
    if (!esdsParser.parse(box.data, box.data_size)) {
      LOGE("Failed to parse esds box");
      return;
    }
    current_track->aacProfile = esdsParser.audioObjectType;
    current_track->sampleRateIdx = esdsParser.samplingRateIndex;
    current_track->channelCfg = esdsParser.channelConfiguration;
  }
 
  void onAlac(const MP4Parser::Box& box) {
    if (current_track == nullptr || !box.is_complete) return;
    current_track->audio_codec = Codec::ALAC;
    setupAudioInfo(AudioFormat::ALAC, box.data, box.data_size);
    MP4Parser::Box alac;
    if (parser.findBox("alac", box.data, box.data_size, alac)) {
      current_track->alacMagicCookie.resize(alac.data_size - 4);
      memcpy(current_track->alacMagicCookie.data(), alac.data + 4,
             alac.data_size - 4);
    }
  }
 
  void onAvc1(const MP4Parser::Box& box) {
    if (current_track == nullptr || !box.is_complete) return;
    current_track->kind = Track::Kind::Video;
    if (p_video_track == nullptr) p_video_track = current_track;
    if (box.data_size < 28) return;
    current_track->width = readU16(box.data + 24);
    current_track->height = readU16(box.data + 26);
    // VisualSampleEntry fixed header is 78 bytes (already excl. the 8 byte
    // box header) - avcC (child box) follows
    const int pos = 78;
    if (box.data_size > (size_t)pos)
      parser.parseString(box.data + pos, box.data_size - pos,
                         box.file_offset + 8 + pos, box.level + 1);
  }
 
  void onHevc(const MP4Parser::Box& box) {
    if (current_track == nullptr) return;
    current_track->kind = Track::Kind::Video;
    if (p_video_track == nullptr) p_video_track = current_track;
    if (!current_track->is_hevc_unsupported) {
      LOGE("HEVC (hev1/hvc1) video is not supported - only H.264 (avc1)");
      current_track->is_hevc_unsupported = true;
    }
  }
 
  void onAvcC(const MP4Parser::Box& box) {
    if (current_track == nullptr || !box.is_complete || box.data_size < 6)
      return;
    const uint8_t* d = box.data;
    current_track->nal_length_size = (d[4] & 0x03) + 1;
    int numSps = d[5] & 0x1F;
    size_t pos = 6;
    auto appendUnit = [&](const uint8_t* unit, size_t len) {
      static const uint8_t startCode[4] = {0, 0, 0, 1};
      auto& v = current_track->sps_pps_annexb;
      size_t off = v.size();
      v.resize(off + 4 + len);
      memcpy(v.data() + off, startCode, 4);
      memcpy(v.data() + off + 4, unit, len);
    };
    for (int i = 0; i < numSps && pos + 2 <= box.data_size; i++) {
      uint16_t len = readU16(d + pos);
      pos += 2;
      if (pos + len > box.data_size) break;
      appendUnit(d + pos, len);
      pos += len;
    }
    if (pos >= box.data_size) return;
    int numPps = d[pos++];
    for (int i = 0; i < numPps && pos + 2 <= box.data_size; i++) {
      uint16_t len = readU16(d + pos);
      pos += 2;
      if (pos + len > box.data_size) break;
      appendUnit(d + pos, len);
      pos += len;
    }
  }
 
  void onMdhd(MP4Parser::Box& box) {
    if (current_track == nullptr) return;
    beginBoxAccum(box);
    box_accum.writeArray(box.data, box.available);
    if (!box.is_complete) return;
    if (box_accum.available() < 4) {
      endBoxAccum();
      return;
    }
    uint8_t version = box_accum.data()[0];
    // v0: creation(4)+modification(4)+timescale(4)+duration(4)
    // v1: creation(8)+modification(8)+timescale(4)+duration(8)
    size_t timescaleOffset = version == 1 ? 20 : 12;
    if (box_accum.available() >= timescaleOffset + 4) {
      current_track->timescale = readU32(box_accum.data() + timescaleOffset);
    }
    endBoxAccum();
  }
 
  void onStts(MP4Parser::Box& box) {
    if (current_track == nullptr) return;
    beginBoxAccum(box);
    box_accum.writeArray(box.data, box.available);
    if (!box.is_complete) return;
    if (box_accum.available() < 8) {
      endBoxAccum();
      return;
    }
    uint32_t entryCount = readU32(box_accum.data() + 4);
    const uint8_t* p = box_accum.data() + 8;
    size_t avail = box_accum.available() - 8;
    for (uint32_t i = 0; i < entryCount && (i + 1) * 8 <= avail; i++) {
      SttsEntry e;
      e.sample_count = readU32(p + i * 8);
      e.sample_delta = readU32(p + i * 8 + 4);
      current_track->stts.push_back(e);
    }
    endBoxAccum();
  }
 
  void onStsz(MP4Parser::Box& box) {
    if (current_track == nullptr) return;
    if (beginBoxAccum(box))
      stsz_header_pending = true;  // starting a fresh stsz box
    box_accum.writeArray(box.data, box.available);
 
    // The 12-byte header (version+flags, sampleSize, sampleCount) must be
    // fully consumed *once* before any bytes are interpreted as per-sample
    // sizes. Using "no sizes pushed yet" as a stand-in for "header not
    // parsed yet" (as tried previously) is wrong: in the variable-size
    // case, both are simultaneously true right after the header IS parsed,
    // so under fine-grained incremental delivery the per-sample loop below
    // could start consuming still-unparsed header bytes as if they were
    // sample sizes. An explicit flag avoids that ambiguity.
    if (stsz_header_pending) {
      if (box_accum.available() < 12)
        return;  // wait for the rest of the header
      Track* t = current_track;
      uint32_t sampleSize = readU32(box_accum.data() + 4);
      uint32_t sampleCount = readU32(box_accum.data() + 8);
      box_accum.clearArray(12);
      stsz_header_pending = false;
      if (sampleSize != 0) {
        t->fixed_sample_size = sampleSize;
        t->fixed_sample_count = sampleCount;
      }
      // else: sample_sizes is filled below via push_back, one entry at a
      // time as bytes arrive - do NOT pre-resize it (Vector::push_back
      // always appends, unlike BaseBuffer::write() which fills pre-sized
      // capacity in place)
    }
    // incrementally consume per-sample sizes (fixed-size case has none left
    // to read; the table is only present in the box when sampleSize==0)
    if (current_track->fixed_sample_size == 0) {
      while (box_accum.available() >= 4) {
        current_track->sample_sizes.push_back(readU32(box_accum.data()));
        box_accum.clearArray(4);
      }
    }
    if (box.is_complete) endBoxAccum();
  }
 
  void onStsc(MP4Parser::Box& box) {
    if (current_track == nullptr) return;
    beginBoxAccum(box);
    box_accum.writeArray(box.data, box.available);
    if (!box.is_complete) return;
    if (box_accum.available() < 8) {
      endBoxAccum();
      return;
    }
    uint32_t entryCount = readU32(box_accum.data() + 4);
    const uint8_t* p = box_accum.data() + 8;
    size_t avail = box_accum.available() - 8;
    for (uint32_t i = 0; i < entryCount && (i + 1) * 12 <= avail; i++) {
      StscEntry e;
      e.first_chunk = readU32(p + i * 12);
      e.samples_per_chunk = readU32(p + i * 12 + 4);
      current_track->stsc.push_back(e);
    }
    endBoxAccum();
  }
 
  void onStco(MP4Parser::Box& box, bool is64) {
    if (current_track == nullptr) return;
    beginBoxAccum(box);
    box_accum.writeArray(box.data, box.available);
    if (!box.is_complete) return;
    if (box_accum.available() < 8) {
      endBoxAccum();
      return;
    }
    uint32_t entryCount = readU32(box_accum.data() + 4);
    const uint8_t* p = box_accum.data() + 8;
    size_t avail = box_accum.available() - 8;
    size_t entrySize = is64 ? 8 : 4;
    for (uint32_t i = 0; i < entryCount && (i + 1) * entrySize <= avail; i++) {
      uint64_t off = is64 ? readU64(p + i * 8) : readU32(p + i * 4);
      current_track->chunk_offsets.push_back(off);
    }
    endBoxAccum();
  }
 
  // ---- mdat / schedule / sample dispatch ----
 
  void onMdat(MP4Parser::Box& box) {
    if (!mdat_seen) {
      mdat_seen = true;
      buildSchedule();
    }
    feed(box.data, box.available);
  }
 
  void buildSchedule() {
    // (track*, chunk_index, offset) working list
    struct Item {
      Track* track;
      uint32_t chunk_index;
      uint64_t offset;
    };
    Vector<Item> items;
    for (size_t ti = 0; ti < tracks.size(); ti++) {
      Track* t = tracks[ti];
      if (t->kind == Track::Kind::Unknown) continue;
      if (t->kind == Track::Kind::Video && t != p_video_track) continue;
      if (t->kind == Track::Kind::Audio && t != p_audio_track) continue;
      for (size_t ci = 0; ci < t->chunk_offsets.size(); ci++) {
        items.push_back({t, (uint32_t)ci, t->chunk_offsets[ci]});
      }
    }
    // simple insertion sort by offset (small N: chunk count is typically
    // well under a few thousand for embedded-relevant clip lengths)
    for (size_t i = 1; i < items.size(); i++) {
      Item key = items[i];
      long j = (long)i - 1;
      while (j >= 0 && items[j].offset > key.offset) {
        items[j + 1] = items[j];
        j--;
      }
      items[j + 1] = key;
    }
    for (size_t i = 0; i < items.size(); i++) {
      Track* t = items[i].track;
      uint32_t samples = samplesInChunk(*t, items[i].chunk_index);
      if (samples > 0) schedule.push_back({t, samples});
    }
    schedule_index = 0;
    samples_left_in_entry = schedule.size() > 0 ? schedule[0].sample_count : 0;
  }
 
  uint32_t samplesInChunk(Track& t, uint32_t chunkIndex0) {
    uint32_t chunk1 = chunkIndex0 + 1;  // stsc uses 1-based chunk numbers
    uint32_t result = 0;
    for (size_t i = 0; i < t.stsc.size(); i++) {
      if (t.stsc[i].first_chunk <= chunk1) {
        result = t.stsc[i].samples_per_chunk;
      } else {
        break;
      }
    }
    return result;
  }
 
  void advanceScheduleIfNeeded() {
    while (samples_left_in_entry == 0 && schedule_index < schedule.size()) {
      schedule_index++;
      samples_left_in_entry = schedule_index < schedule.size()
                                  ? schedule[schedule_index].sample_count
                                  : 0;
    }
  }
 
  void feed(const uint8_t* data, size_t len) {
    size_t pos = 0;
    while (pos < len) {
      if (current_sample_track == nullptr) {
        advanceScheduleIfNeeded();
        if (schedule_index >= schedule.size()) return;  // nothing more expected
        Track* t = schedule[schedule_index].track;
        uint32_t size = t->sampleSize(t->next_sample_index);
        if (size == 0) {
          // no more sizes for this track - stop
          samples_left_in_entry = 0;
          continue;
        }
        current_sample_track = t;
        current_sample_size = size;
        current_sample_is_first_for_track = (t->next_sample_index == 0);
        // Vector::resize() sets the logical size immediately (unlike a
        // capacity reserve), so track how much of it is actually filled
        // separately rather than relying on sample_buffer.size().
        sample_buffer.resize(size);
        sample_buffer_filled = 0;
      }
 
      size_t need = current_sample_size - sample_buffer_filled;
      size_t take = std::min(need, len - pos);
      memcpy(sample_buffer.data() + sample_buffer_filled, data + pos, take);
      sample_buffer_filled += take;
      pos += take;
 
      if (sample_buffer_filled >= current_sample_size) {
        dispatchSample(*current_sample_track, sample_buffer.data(),
                       sample_buffer_filled, current_sample_is_first_for_track);
        current_sample_track->next_sample_index++;
        samples_left_in_entry--;
        current_sample_track = nullptr;
      }
    }
  }
 
  void dispatchSample(Track& t, const uint8_t* data, size_t size,
                      bool isFirst) {
    if (&t == p_video_track) {
      dispatchVideo(t, data, size, isFirst);
    } else if (&t == p_audio_track) {
      dispatchAudio(t, data, size, isFirst);
    }
  }
 
  void dispatchVideo(Track& t, const uint8_t* data, size_t size, bool isFirst) {
    // nextPtsTicks() must run unconditionally, in sample order, to keep
    // the track's timing cursor correct regardless of what we do below -
    // call it before any early return.
    uint64_t ptsTicks = t.nextPtsTicks();
    if ((p_video_out == nullptr && p_video_out_video == nullptr) ||
        t.is_hevc_unsupported)
      return;
 
    if (t.timescale > 0 && !t.stts.empty()) {
      uint32_t scheduledMs = (uint32_t)((ptsTicks * 1000) / t.timescale);
      uint32_t nowMs = millis();
      if (!playback_start_set) {
        playback_start_ms = nowMs;
        playback_start_set = true;
      }
      uint32_t scheduledWallMs = playback_start_ms + scheduledMs;
      if (nowMs > scheduledWallMs) {
        LOGW("DemuxerMP4: video frame %u ms late - skipping",
             (unsigned)(nowMs - scheduledWallMs));
        return;
      } else if (nowMs < scheduledWallMs) {
        LOGI("DemuxerMP4: video frame %u ms early",
             (unsigned)(scheduledWallMs - nowMs));
      }
    }
 
    // convert AVCC length-prefixed NAL units to Annex-B start codes
    nal_tmp.clear();
    size_t pos = 0;
    size_t lenSize = t.nal_length_size;
    while (pos + lenSize <= size) {
      uint32_t nalLen = 0;
      for (size_t i = 0; i < lenSize; i++)
        nalLen = (nalLen << 8) | data[pos + i];
      pos += lenSize;
      if (pos + nalLen > size) break;
      size_t off = nal_tmp.size();
      static const uint8_t startCode[4] = {0, 0, 0, 1};
      nal_tmp.resize(off + 4 + nalLen);
      memcpy(nal_tmp.data() + off, startCode, 4);
      memcpy(nal_tmp.data() + off + 4, data + pos, nalLen);
      pos += nalLen;
    }
 
    bool prependConfig =
        isFirst && !t.avc_config_sent && t.sps_pps_annexb.size() > 0;
    if (prependConfig) {
      writeVideo(t.sps_pps_annexb.data(), t.sps_pps_annexb.size());
      t.avc_config_sent = true;
    }
    if (nal_tmp.size() > 0) writeVideo(nal_tmp.data(), nal_tmp.size());
    flushVideo();
  }
 
  void writeVideo(uint8_t* data, size_t size) {
    if (p_video_out == nullptr && p_video_out_video == nullptr) return;
    if (size > 0) {
      if (p_video_out != nullptr) p_video_out->write(data, size);
      if (p_video_out_video != nullptr) p_video_out_video->write(data, size);
    }
  }
 
  void flushVideo() {
    if (p_video_out != nullptr) p_video_out->flush();
    if (p_video_out_video != nullptr) p_video_out_video->flush();
  }
 
  void dispatchAudio(Track& t, const uint8_t* data, size_t size, bool isFirst) {
    if (p_output_audio == nullptr) return;
    if (t.audio_codec == Codec::AAC) {
      uint8_t adts[7];
      writeAdtsHeader(adts, t.aacProfile, t.sampleRateIdx, t.channelCfg,
                      (int)size);
      p_output_audio->write(adts, sizeof(adts));
      p_output_audio->write(data, size);
    } else {
      // ALAC (magic cookie is exposed via audioALACMagicCookie() for the
      // caller to configure their own decoder with) and any other codec:
      // raw payload as-is.
      p_output_audio->write(data, size);
    }
  }
 
  static void writeAdtsHeader(uint8_t* adts, int aacProfile, int sampleRateIdx,
                              int channelCfg, int frameLen) {
    adts[0] = 0xFF;
    adts[1] = 0xF1;
    adts[2] = ((aacProfile - 1) << 6) | (sampleRateIdx << 2) |
              ((channelCfg >> 2) & 0x1);
    adts[3] = ((channelCfg & 0x3) << 6) | ((frameLen + 7) >> 11);
    adts[4] = ((frameLen + 7) >> 3) & 0xFF;
    adts[5] = (((frameLen + 7) & 0x7) << 5) | 0x1F;
    adts[6] = 0xFC;
  }
};
 
class MP4BoxWriter {
 public:
  Vector<uint8_t> buffer;
 
  void clear() { buffer.clear(); }
  size_t size() { return buffer.size(); }
  const uint8_t* data() { return buffer.data(); }
 
  void u8(uint8_t v) { buffer.push_back(v); }
  void u16(uint16_t v) {
    u8((uint8_t)(v >> 8));
    u8((uint8_t)v);
  }
  void u24(uint32_t v) {
    u8((uint8_t)(v >> 16));
    u8((uint8_t)(v >> 8));
    u8((uint8_t)v);
  }
  void u32(uint32_t v) {
    u8((uint8_t)(v >> 24));
    u8((uint8_t)(v >> 16));
    u8((uint8_t)(v >> 8));
    u8((uint8_t)v);
  }
  void fourcc(const char* type) { bytes((const uint8_t*)type, 4); }
  void bytes(const uint8_t* data, size_t len) {
    size_t off = buffer.size();
    buffer.resize(off + len);
    memcpy(buffer.data() + off, data, len);
  }
  void zeros(size_t len) {
    size_t off = buffer.size();
    buffer.resize(off + len);
    memset(buffer.data() + off, 0, len);
  }
  void cstr(const char* s) {
    while (*s) u8((uint8_t)*s++);
    u8(0);
  }
 
  size_t beginBox(const char* type) {
    size_t pos = buffer.size();
    u32(0);
    fourcc(type);
    return pos;
  }
  void endBox(size_t pos) {
    uint32_t sz = (uint32_t)(buffer.size() - pos);
    buffer[pos] = (uint8_t)(sz >> 24);
    buffer[pos + 1] = (uint8_t)(sz >> 16);
    buffer[pos + 2] = (uint8_t)(sz >> 8);
    buffer[pos + 3] = (uint8_t)sz;
  }
};
 
 
class MuxerMP4 : public Muxer {
 public:
  MuxerMP4() { audio_info.format = AudioFormat::AAC; }
  MuxerMP4(Print& out) : MuxerMP4() { setOutput(out); }
 
  const char* mime() override { return "video/mp4"; }
 
  void setOutput(Print& out) override { p_out = &out; }
 
  void setVideoInfo(MuxerVideoConfig config) override { video_cfg = config; }
 
  MuxerVideoConfig getVideoInfo() override { return video_cfg; }
 
  void setAudioInfo(AudioInfoFormat info) override {
    if (info.format == AudioFormat::UNKNOWN) info.format = audio_info.format;
    audio_info = info;
    has_audio = true;
  }
  AudioInfoFormat& audioInfo() override { return audio_info; }
  void setAudioProfile(int aacProfile) { audio_profile = aacProfile; }
 
  bool begin() override {
    if (p_out == nullptr) {
      LOGE("output not defined");
      return false;
    }
    if (video_cfg.width == 0 || video_cfg.height == 0) {
      LOGE("invalid video size: %d x %d", (int)video_cfg.width,
           (int)video_cfg.height);
      return false;
    }
    if (video_cfg.format != VideoFormat::H264 &&
        video_cfg.format != VideoFormat::MJPEG &&
        video_cfg.format != VideoFormat::YUV422 &&
        video_cfg.format != VideoFormat::RGB565 &&
        video_cfg.format != VideoFormat::I420) {
      LOGE(
          "unsupported video format: %d - MuxerMP4 writes H264, MJPEG, "
          "YUV422, RGB565 or I420",
          (int)video_cfg.format);
      return false;
    }
    video_timescale = 90000;
    video_sample_duration =
        video_cfg.fps > 0 ? (uint32_t)(video_timescale / video_cfg.fps) : 0;
    audio_timescale = has_audio ? audio_info.sample_rate : 0;
    // AAC: fixed 1024 samples/frame (LC). PCM: duration varies per call
    // (addAudioFrame() computes it from the actual byte length instead),
    // so this default is not used for PCM - trun always states it
    // explicitly per fragment regardless of codec.
    audio_sample_duration = (audio_info.format == AudioFormat::PCM) ? 0 : 1024;
 
    sps_data.clear();
    pps_data.clear();
    moov_written = false;
    video_seq = 0;
    video_base_time = 0;
    audio_seq = 0;
    audio_base_time = 0;
    fragment_seq = 0;
    video_frame_count = 0;
    audio_frame_count = 0;
    is_open = true;
    // MJPEG needs no stream-derived config (unlike H264's SPS/PPS), so
    // this writes 'moov' immediately; for H264 it's a no-op here and
    // happens lazily once SPS/PPS have been captured (see addVideoFrame()).
    tryWriteMoov();
    return true;
  }
 
  void end() override { is_open = false; }
 
  operator bool() override { return is_open; }
 
  void setStreamType(StreamContentType type) override {
    write_stream_type = type;
  }
  StreamContentType streamType() override { return write_stream_type; }
 
  size_t write(const uint8_t* data, size_t len) override {
    if (write_stream_type == StreamContentType::Audio) {
      return addAudioFrame(data, len);
    }
 
    switch (video_cfg.format) {
      case VideoFormat::MJPEG:
        return addJpegFrame(data, len);
      case VideoFormat::YUV422:
        return addYUV422Frame(data, len);
      case VideoFormat::RGB565:
        return addRGB565Frame(data, len);
      case VideoFormat::I420:
        return addI420Frame(data, len);
      default:
        return addVideoFrame(data, len);
    }
  }
 
  size_t addVideoFrame(const uint8_t* data, size_t len,
                       bool isKeyFrame = true) override {
    if (!is_open || video_cfg.format != VideoFormat::H264) return 0;
    setVideoConfigData(data, len);
    if (!tryWriteMoov()) {
      LOGW("dropping video frame: SPS/PPS not seen yet");
      return 0;
    }
    nal_tmp.clear();
    forEachAnnexBNal(data, len, [this](const uint8_t* nal, size_t nalLen) {
      if (nalLen == 0) return;
      uint8_t nalType = nal[0] & 0x1F;
      if (nalType == 7 || nalType == 8) return;  // SPS/PPS: already in avcC
      size_t off = nal_tmp.size();
      nal_tmp.resize(off + 4 + nalLen);
      uint8_t* p = nal_tmp.data() + off;
      p[0] = (uint8_t)(nalLen >> 24);
      p[1] = (uint8_t)(nalLen >> 16);
      p[2] = (uint8_t)(nalLen >> 8);
      p[3] = (uint8_t)nalLen;
      memcpy(p + 4, nal, nalLen);
    });
    if (nal_tmp.size() == 0) return 0;
    writeMoofMdat(kVideoTrackId, nal_tmp.data(), nal_tmp.size(),
                  video_sample_duration, isKeyFrame, video_base_time);
    video_base_time += video_sample_duration;
    video_frame_count++;
    return len;
  }
 
  size_t addJpegFrame(const uint8_t* data, size_t len) override {
    if (video_cfg.format != VideoFormat::MJPEG) return 0;
    return addRawFrame(data, len);
  }
 
  size_t addYUV422Frame(const uint8_t* data, size_t len) override {
    checkRawFrame(VideoFormat::YUV422, len);
    return addRawFrame(data, len);
  }
 
  size_t addRGB565Frame(const uint8_t* data, size_t len) override {
    checkRawFrame(VideoFormat::RGB565, len);
    return addRawFrame(data, len);
  }
 
  size_t addI420Frame(const uint8_t* data, size_t len) override {
    checkRawFrame(VideoFormat::I420, len);
    return addRawFrame(data, len);
  }
 
  size_t addAudioFrame(const uint8_t* data, size_t len) override {
    if (!is_open || !has_audio || len == 0) return 0;
    if (!moov_written) {
      LOGW(
          "dropping audio frame: moov not written yet (video SPS/PPS not "
          "seen)");
      return 0;
    }
    uint32_t duration = audio_sample_duration;  // AAC: fixed 1024
    if (audio_info.format == AudioFormat::PCM) {
      int bytesPerFrame =
          audio_info.channels * (audio_info.bits_per_sample / 8);
      duration = bytesPerFrame > 0 ? (uint32_t)(len / bytesPerFrame) : 0;
    }
    writeMoofMdat(kAudioTrackId, data, len, duration,
                  /*isKeyFrame*/ true, audio_base_time);
    audio_base_time += duration;
    audio_frame_count++;
    return len;
  }
 
  uint32_t videoFrameCount() { return video_frame_count; }
  uint32_t audioFrameCount() { return audio_frame_count; }
 
 protected:
  static const uint32_t kVideoTrackId = 1;
  static const uint32_t kAudioTrackId = 2;
 
  Print* p_out = nullptr;
  MuxerVideoConfig video_cfg;
  Vector<uint8_t> sps_data;
  Vector<uint8_t> pps_data;
 
  AudioInfoFormat audio_info;
  bool has_audio = false;
  int audio_profile = 2;  // AAC LC
 
  bool is_open = false;
  bool moov_written = false;
  StreamContentType write_stream_type = StreamContentType::Video;
  uint32_t video_timescale = 90000;
  uint32_t video_sample_duration = 0;
  uint32_t audio_timescale = 0;
  uint32_t audio_sample_duration = 1024;
 
  uint32_t video_seq = 0;
  uint32_t video_base_time = 0;
  uint32_t audio_seq = 0;
  uint32_t audio_base_time = 0;
  uint32_t fragment_seq = 0;
  uint32_t video_frame_count = 0;
  uint32_t audio_frame_count = 0;
 
  Vector<uint8_t> nal_tmp;  
  MP4BoxWriter box;  
 
  void setVideoConfigData(const uint8_t* spsPpsAnnexB, size_t len) {
    forEachAnnexBNal(spsPpsAnnexB, len,
                     [this](const uint8_t* nal, size_t nalLen) {
                       if (nalLen == 0) return;
                       uint8_t nalType = nal[0] & 0x1F;
                       if (nalType == 7) {
                         sps_data.resize(nalLen);
                         memcpy(sps_data.data(), nal, nalLen);
                       } else if (nalType == 8) {
                         pps_data.resize(nalLen);
                         memcpy(pps_data.data(), nal, nalLen);
                       }
                     });
  }
 
  bool tryWriteMoov() {
    if (moov_written) return true;
    if (video_cfg.format == VideoFormat::H264 &&
        (sps_data.size() == 0 || pps_data.size() == 0)) {
      return false;
    }
    writeFtypMoov();
    moov_written = true;
    return true;
  }
 
  void checkVideoFormat(VideoFormat expected) {
    if (video_cfg.format != expected) {
      LOGW("getVideoInfo().format does not match the addXxxFrame() called");
    }
  }
 
  void checkRawFrame(VideoFormat expected, size_t len) {
    checkVideoFormat(expected);
    size_t expectedSize =
        videoFrameSizeBytes(expected, video_cfg.width, video_cfg.height);
    if (expectedSize > 0 && len != expectedSize) {
      LOGW("frame size %d does not match the expected %d bytes for %d x %d",
           (int)len, (int)expectedSize, (int)video_cfg.width,
           (int)video_cfg.height);
    }
  }
 
  size_t addRawFrame(const uint8_t* data, size_t len) {
    if (!is_open || len == 0) return 0;
    if (!tryWriteMoov()) return 0;
    writeMoofMdat(kVideoTrackId, data, len, video_sample_duration,
                  /*isKeyFrame*/ true, video_base_time);
    video_base_time += video_sample_duration;
    video_frame_count++;
    return len;
  }
 
  template <typename F>
  static void forEachAnnexBNal(const uint8_t* data, size_t len, F callback) {
    size_t i = 0;
    while (i + 3 <= len) {
      size_t scLen = 0;
      if (i + 4 <= len && data[i] == 0 && data[i + 1] == 0 &&
          data[i + 2] == 0 && data[i + 3] == 1) {
        scLen = 4;
      } else if (data[i] == 0 && data[i + 1] == 0 && data[i + 2] == 1) {
        scLen = 3;
      }
      if (scLen == 0) {
        i++;
        continue;
      }
      size_t nalStart = i + scLen;
      size_t j = nalStart;
      size_t nextStart = len;
      while (j + 3 <= len) {
        if (data[j] == 0 && data[j + 1] == 0 &&
            (data[j + 2] == 1 ||
             (j + 3 < len && data[j + 2] == 0 && data[j + 3] == 1))) {
          nextStart = j;
          break;
        }
        j++;
      }
      if (nextStart > nalStart) callback(data + nalStart, nextStart - nalStart);
      i = nextStart;
    }
  }
 
  static int aacSampleRateIndex(uint32_t sampleRate) {
    static const uint32_t rates[13] = {96000, 88200, 64000, 48000, 44100,
                                       32000, 24000, 22050, 16000, 12000,
                                       11025, 8000,  7350};
    for (int i = 0; i < 13; i++)
      if (rates[i] == sampleRate) return i;
    return 4;  // default: 44100
  }
 
  void writeAvcC(MP4BoxWriter& b) {
    size_t pos = b.beginBox("avcC");
    b.u8(1);            // configurationVersion
    b.u8(sps_data[1]);  // AVCProfileIndication
    b.u8(sps_data[2]);  // profile_compatibility
    b.u8(sps_data[3]);  // AVCLevelIndication
    b.u8(0xFF);         // reserved(6) + lengthSizeMinusOne(2) = 4-byte lengths
    b.u8(0xE1);         // reserved(3) + numOfSPS(5) = 1
    b.u16((uint16_t)sps_data.size());
    b.bytes(sps_data.data(), sps_data.size());
    b.u8(1);  // numOfPPS
    b.u16((uint16_t)pps_data.size());
    b.bytes(pps_data.data(), pps_data.size());
    b.endBox(pos);
  }
 
  void writeEsdsMjpeg(MP4BoxWriter& b) {
    size_t pos = b.beginBox("esds");
    b.u32(0);  // version + flags
    b.u8(0x03);
    // size: ES_ID(2)+flags(1)+DecoderConfigDescr(15 incl. its own tag+size)
    // +SLConfigDescr(3 incl. its own tag+size) = 21
    b.u8(21);
    b.u16(kVideoTrackId);  // ES_ID
    b.u8(0);               // flags
    b.u8(0x04);
    b.u8(13);    // size: objType(1)+streamType(1)+bufSize(3)+maxBr(4)+avgBr(4)
    b.u8(0x6C);  // objectTypeIndication: JPEG (ISO/IEC 10918-1)
    b.u8((4 << 2) | 1);  // streamType: visual(4), reserved bit set
    b.u24(0);            // bufferSizeDB
    b.u32(0);            // maxBitrate (0 = unspecified)
    b.u32(0);            // avgBitrate
    b.u8(0x06);
    b.u8(1);
    b.u8(0x02);
    b.endBox(pos);
  }
 
  void writeEsds(MP4BoxWriter& b) {
    int sampleRateIdx = aacSampleRateIndex(audio_info.sample_rate);
    uint8_t asc[2];
    asc[0] = (uint8_t)((audio_profile << 3) | (sampleRateIdx >> 1));
    asc[1] = (uint8_t)(((sampleRateIdx & 1) << 7) | (audio_info.channels << 3));
 
    size_t pos = b.beginBox("esds");
    b.u32(0);  // version + flags
    // ES_Descriptor
    b.u8(0x03);
    // size: ES_ID(2)+flags(1)+DecoderConfigDescr(19 incl. its own tag+size)
    // +SLConfigDescr(3 incl. its own tag+size) = 25
    b.u8(25);
    b.u16(kAudioTrackId);  // ES_ID
    b.u8(0);               // flags
    // DecoderConfigDescr
    b.u8(0x04);
    b.u8(
        17);  // size:
              // objType(1)+streamType(1)+bufSize(3)+maxBr(4)+avgBr(4)+DecSpecificInfo(4)
    b.u8(0x40);          // objectTypeIndication: AAC
    b.u8((5 << 2) | 1);  // streamType: audio(5), upstream=0, reserved=1
    b.u24(0);            // bufferSizeDB
    b.u32(128000);       // maxBitrate
    b.u32(128000);       // avgBitrate
    // DecSpecificInfo (the 2-byte AudioSpecificConfig)
    b.u8(0x05);
    b.u8(2);
    b.bytes(asc, 2);
    // SLConfigDescr
    b.u8(0x06);
    b.u8(1);
    b.u8(0x02);
    b.endBox(pos);
  }
 
  void writeMvhd(MP4BoxWriter& b) {
    size_t pos = b.beginBox("mvhd");
    b.u32(0);           // version + flags
    b.u32(0);           // creation_time
    b.u32(0);           // modification_time
    b.u32(1000);        // timescale
    b.u32(0);           // duration (unknown - fragmented)
    b.u32(0x00010000);  // rate 1.0
    b.u16(0x0100);      // volume 1.0
    b.u16(0);           // reserved
    b.u32(0);
    b.u32(0);  // reserved[2]
    // unity matrix
    static const uint32_t identity[9] = {
        0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000};
    for (int i = 0; i < 9; i++) b.u32(identity[i]);
    b.zeros(24);                                               // pre_defined[6]
    b.u32(has_audio ? kAudioTrackId + 1 : kVideoTrackId + 1);  // next_track_ID
    b.endBox(pos);
  }
 
  void writeTkhd(MP4BoxWriter& b, uint32_t trackId, bool isVideo) {
    size_t pos = b.beginBox("tkhd");
    b.u32(0x000007);  // version 0 + flags: enabled|in_movie|in_preview
    b.u32(0);         // creation_time
    b.u32(0);         // modification_time
    b.u32(trackId);
    b.u32(0);  // reserved
    b.u32(0);  // duration (unknown)
    b.u32(0);
    b.u32(0);                     // reserved[2]
    b.u16(0);                     // layer
    b.u16(0);                     // alternate_group
    b.u16(isVideo ? 0 : 0x0100);  // volume
    b.u16(0);                     // reserved
    static const uint32_t identity[9] = {
        0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000};
    for (int i = 0; i < 9; i++) b.u32(identity[i]);
    b.u32(isVideo ? ((uint32_t)video_cfg.width << 16) : 0);
    b.u32(isVideo ? ((uint32_t)video_cfg.height << 16) : 0);
    b.endBox(pos);
  }
 
  void writeMdhd(MP4BoxWriter& b, uint32_t timescale) {
    size_t pos = b.beginBox("mdhd");
    b.u32(0);  // version + flags
    b.u32(0);  // creation_time
    b.u32(0);  // modification_time
    b.u32(timescale);
    b.u32(0);       // duration (unknown)
    b.u16(0x55C4);  // language: und
    b.u16(0);
    b.endBox(pos);
  }
 
  void writeHdlr(MP4BoxWriter& b, const char* handlerType, const char* name) {
    size_t pos = b.beginBox("hdlr");
    b.u32(0);  // version + flags
    b.u32(0);  // pre_defined
    b.fourcc(handlerType);
    b.zeros(12);  // reserved
    b.cstr(name);
    b.endBox(pos);
  }
 
  void writeDinf(MP4BoxWriter& b) {
    size_t pos = b.beginBox("dinf");
    size_t drefPos = b.beginBox("dref");
    b.u32(0);  // version + flags
    b.u32(1);  // entry_count
    size_t urlPos = b.beginBox("url ");
    b.u32(1);  // version + flags: self-contained (data in this file)
    b.endBox(urlPos);
    b.endBox(drefPos);
    b.endBox(pos);
  }
 
  void writeVideoStbl(MP4BoxWriter& b) {
    size_t pos = b.beginBox("stbl");
    size_t stsdPos = b.beginBox("stsd");
    b.u32(0);  // version + flags
    b.u32(1);  // entry_count
    // VisualSampleEntry: same fixed 78-byte header for every fourCC below
    const char* fourcc = "avc1";
    uint16_t depth = 0x0018;  // 24, nominal - not critical for playback
    switch (video_cfg.format) {
      case VideoFormat::MJPEG:
        fourcc = "mp4v";
        break;
      case VideoFormat::YUV422:
        fourcc = "yuvs";  // matches what ffmpeg itself writes for YUY2-in-MOV
        break;
      case VideoFormat::RGB565:
        fourcc = "L565";  // matches what ffmpeg itself writes for rgb565le
        depth = 16;       // actual bit depth, unlike the nominal 24 above
        break;
      case VideoFormat::I420:
        fourcc = "I420";  // see addI420Frame()'s note: unverified in MP4
        break;
      default:
        break;  // H264: 'avc1'
    }
    size_t entryPos = b.beginBox(fourcc);
    b.zeros(6);   // reserved
    b.u16(1);     // data_reference_index
    b.u16(0);     // pre_defined
    b.u16(0);     // reserved
    b.zeros(12);  // pre_defined[3]
    b.u16(video_cfg.width);
    b.u16(video_cfg.height);
    b.u32(0x00480000);  // horizresolution 72dpi
    b.u32(0x00480000);  // vertresolution 72dpi
    b.u32(0);           // reserved
    b.u16(1);           // frame_count
    b.zeros(32);        // compressorname
    b.u16(depth);
    b.u16(0xFFFF);  // pre_defined
    switch (video_cfg.format) {
      case VideoFormat::MJPEG:
        writeEsdsMjpeg(b);
        break;
      case VideoFormat::YUV422:
      case VideoFormat::RGB565:
      case VideoFormat::I420:
        break;  // raw formats: no child config box needed
      default:
        writeAvcC(b);  // H264
        break;
    }
    b.endBox(entryPos);
    b.endBox(stsdPos);
    // empty sample tables - samples are described per-fragment instead
    size_t sttsPos = b.beginBox("stts");
    b.u32(0);
    b.u32(0);
    b.endBox(sttsPos);
    size_t stscPos = b.beginBox("stsc");
    b.u32(0);
    b.u32(0);
    b.endBox(stscPos);
    size_t stszPos = b.beginBox("stsz");
    b.u32(0);
    b.u32(0);
    b.u32(0);
    b.endBox(stszPos);
    size_t stcoPos = b.beginBox("stco");
    b.u32(0);
    b.u32(0);
    b.endBox(stcoPos);
    b.endBox(pos);
  }
 
  void writeAudioSampleEntryHeader(MP4BoxWriter& b) {
    b.zeros(6);  // reserved
    b.u16(1);    // data_reference_index
    b.zeros(8);  // reserved[2]
    b.u16((uint16_t)audio_info.channels);
    b.u16((uint16_t)audio_info.bits_per_sample);
    b.u16(0);  // pre_defined
    b.u16(0);  // reserved
    b.u32((uint32_t)audio_info.sample_rate << 16);
  }
 
  void writeAudioStbl(MP4BoxWriter& b) {
    size_t pos = b.beginBox("stbl");
    size_t stsdPos = b.beginBox("stsd");
    b.u32(0);  // version + flags
    b.u32(1);  // entry_count
    if (audio_info.format == AudioFormat::PCM) {
      // 'sowt': little-endian signed PCM - the fixed AudioSampleEntry
      // header alone is a complete sample description, no child box
      // needed (unlike 'mp4a', which needs 'esds' for the AAC config).
      size_t sowtPos = b.beginBox("sowt");
      writeAudioSampleEntryHeader(b);
      b.endBox(sowtPos);
    } else {
      size_t mp4aPos = b.beginBox("mp4a");
      writeAudioSampleEntryHeader(b);
      writeEsds(b);
      b.endBox(mp4aPos);
    }
    b.endBox(stsdPos);
    size_t sttsPos = b.beginBox("stts");
    b.u32(0);
    b.u32(0);
    b.endBox(sttsPos);
    size_t stscPos = b.beginBox("stsc");
    b.u32(0);
    b.u32(0);
    b.endBox(stscPos);
    size_t stszPos = b.beginBox("stsz");
    b.u32(0);
    b.u32(0);
    b.u32(0);
    b.endBox(stszPos);
    size_t stcoPos = b.beginBox("stco");
    b.u32(0);
    b.u32(0);
    b.endBox(stcoPos);
    b.endBox(pos);
  }
 
  void writeTrak(MP4BoxWriter& b, uint32_t trackId, bool isVideo) {
    size_t pos = b.beginBox("trak");
    writeTkhd(b, trackId, isVideo);
    size_t mdiaPos = b.beginBox("mdia");
    writeMdhd(b, isVideo ? video_timescale : audio_timescale);
    writeHdlr(b, isVideo ? "vide" : "soun",
              isVideo ? "VideoHandler" : "SoundHandler");
    size_t minfPos = b.beginBox("minf");
    if (isVideo) {
      size_t vmhdPos = b.beginBox("vmhd");
      b.u32(1);    // version + flags
      b.zeros(8);  // graphicsmode + opcolor
      b.endBox(vmhdPos);
    } else {
      size_t smhdPos = b.beginBox("smhd");
      b.u32(0);  // version + flags
      b.u16(0);  // balance
      b.u16(0);  // reserved
      b.endBox(smhdPos);
    }
    writeDinf(b);
    if (isVideo) {
      writeVideoStbl(b);
    } else {
      writeAudioStbl(b);
    }
    b.endBox(minfPos);
    b.endBox(mdiaPos);
    b.endBox(pos);
  }
 
  void writeMvex(MP4BoxWriter& b) {
    size_t pos = b.beginBox("mvex");
    size_t trexVideoPos = b.beginBox("trex");
    b.u32(0);  // version + flags
    b.u32(kVideoTrackId);
    b.u32(1);  // default_sample_description_index
    b.u32(video_sample_duration);
    b.u32(0);  // default_sample_size
    b.u32(0);  // default_sample_flags
    b.endBox(trexVideoPos);
    if (has_audio) {
      size_t trexAudioPos = b.beginBox("trex");
      b.u32(0);
      b.u32(kAudioTrackId);
      b.u32(1);
      b.u32(audio_sample_duration);
      b.u32(0);
      b.u32(0);
      b.endBox(trexAudioPos);
    }
    b.endBox(pos);
  }
 
  void writeFtypMoov() {
    box.clear();
    size_t ftypPos = box.beginBox("ftyp");
    box.fourcc("isom");
    box.u32(0x200);
    box.fourcc("isom");
    box.fourcc("iso5");
    box.fourcc("iso6");
    box.fourcc("mp41");
    box.endBox(ftypPos);
 
    size_t moovPos = box.beginBox("moov");
    writeMvhd(box);
    writeTrak(box, kVideoTrackId, true);
    if (has_audio) writeTrak(box, kAudioTrackId, false);
    writeMvex(box);
    box.endBox(moovPos);
 
    p_out->write(box.data(), box.size());
  }
 
  void writeMoofMdat(uint32_t trackId, const uint8_t* data, size_t len,
                     uint32_t sampleDuration, bool isKeyFrame,
                     uint32_t baseTime) {
    if (p_out == nullptr) return;
    box.clear();
    size_t moofPos = box.beginBox("moof");
    size_t mfhdPos = box.beginBox("mfhd");
    box.u32(0);  // version + flags
    box.u32(fragment_seq);
    box.endBox(mfhdPos);
 
    size_t trafPos = box.beginBox("traf");
    size_t tfhdPos = box.beginBox("tfhd");
    box.u32(0x020000);  // version 0 + flags: default-base-is-moof
    box.u32(trackId);
    box.endBox(tfhdPos);
 
    size_t tfdtPos = box.beginBox("tfdt");
    box.u32(0);  // version 0 + flags
    box.u32(baseTime);
    box.endBox(tfdtPos);
 
    bool isVideo = (trackId == kVideoTrackId);
    // data-offset | sample-duration | sample-size (always explicit per
    // fragment - relying on trex's constant default doesn't hold once a
    // track's per-sample duration can vary, as with PCM audio)
    uint32_t trunFlags = 0x000001 | 0x000100 | 0x000200;
    if (isVideo) trunFlags |= 0x000400;  // + sample-flags
 
    size_t trunPos = box.beginBox("trun");
    box.u32(trunFlags);
    box.u32(1);  // sample_count
    size_t dataOffsetFieldPos = box.size();
    box.u32(0);  // data_offset placeholder
    // per-sample fields, in the fixed order the spec mandates: duration,
    // size, flags
    box.u32(sampleDuration);
    box.u32((uint32_t)len);
    if (isVideo) {
      // sample_depends_on / sample_is_non_sync_sample
      box.u32(isKeyFrame ? 0x02000000 : 0x01010000);
    }
    box.endBox(trunPos);
    box.endBox(trafPos);
    box.endBox(moofPos);
 
    uint32_t dataOffset = (uint32_t)(box.size() + 8);  // + mdat header
    box.buffer[dataOffsetFieldPos] = (uint8_t)(dataOffset >> 24);
    box.buffer[dataOffsetFieldPos + 1] = (uint8_t)(dataOffset >> 16);
    box.buffer[dataOffsetFieldPos + 2] = (uint8_t)(dataOffset >> 8);
    box.buffer[dataOffsetFieldPos + 3] = (uint8_t)dataOffset;
 
    p_out->write(box.data(), box.size());
 
    uint8_t mdatHeader[8];
    uint32_t mdatSize = (uint32_t)(len + 8);
    mdatHeader[0] = (uint8_t)(mdatSize >> 24);
    mdatHeader[1] = (uint8_t)(mdatSize >> 16);
    mdatHeader[2] = (uint8_t)(mdatSize >> 8);
    mdatHeader[3] = (uint8_t)mdatSize;
    mdatHeader[4] = 'm';
    mdatHeader[5] = 'd';
    mdatHeader[6] = 'a';
    mdatHeader[7] = 't';
    p_out->write(mdatHeader, 8);
    p_out->write(data, len);
 
    fragment_seq++;
  }
};
 
}  // namespace audio_tools