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/AudioCodecs/SampleTableStore.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(SeekableSource& seekSource) {
    setupParser();
    setSeekSource(seekSource);
  }

  DemuxerMP4(SpoolStorageFactory& spoolFactory) {
    setupParser();
    setSpoolStorageFactory(spoolFactory);
  }
 
  ~DemuxerMP4() { freeTracks(); }

  void setSeekSource(SeekableSource& seekSource) { p_seek_source = &seekSource; }

  void setSpoolStorageFactory(SpoolStorageFactory& spoolFactory) {
    p_spool_factory = &spoolFactory;
  }

  const char* mimeVideo() override { return "video/mp4"; }
  const char* mime() override { return toMime(audio_format); }

  bool isValid(const uint8_t* data, size_t len) override {
    return len >= 8 && memcmp(data + 4, "ftyp", 4) == 0;
  }
 
  bool begin() override {
    freeTracks();
    current_track = nullptr;
    p_video_track = nullptr;
    p_audio_track = nullptr;
    current_chunk_track = nullptr;
    samples_left_in_chunk = 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;
    dispatched_sample_count = 0;
    is_wav_header_sent = false;
    total_bytes_received = 0;
    quickstart_bytes_remaining = -1;
    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) override { 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);
    // Constant-frame-rate assumption: fps from the track's timescale and
    // its first 'stts' entry's sample_delta (ticks/sample) - true for the
    // overwhelming majority of real-world encoders; a genuinely variable
    // frame rate would need a per-sample duration, which nothing here
    // currently schedules against anyway (see PacedVideoOutput).
    if (p_video_track->timescale > 0 && p_video_track->stts->size() > 0) {
      SttsEntry first = p_video_track->stts->get(0);
      if (first.sample_delta > 0)
        result.fps = (float)p_video_track->timescale / first.sample_delta;
    }
    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;
    // After quickStart(), 'moov' still physically trails 'mdat' on disk
    // (only relocated logically) - cap feeding at 'mdat's declared size
    // and discard the trailing, already-parsed 'moov' bytes instead of
    // re-parsing them.
    size_t feed_len = len;
    bool truncated = false;
    if (quickstart_bytes_remaining >= 0 &&
        (int64_t)feed_len > quickstart_bytes_remaining) {
      feed_len = (size_t)quickstart_bytes_remaining;
      truncated = true;
    }
    size_t written = feed_len > 0 ? parser.write(data, feed_len) : 0;
    total_bytes_received += written;
    if (quickstart_bytes_remaining >= 0) quickstart_bytes_remaining -= written;
    // Only swallow the truncated remainder if 'feed_len' was fully
    // accepted - otherwise this is an ordinary partial write.
    return (truncated && written == feed_len) ? len : written;
  }

  bool quickStart() {
    if (p_seek_source == nullptr) return false;
 
    uint64_t pos = 0, moov_offset = 0, moov_size = 0, mdat_offset = 0,
             mdat_size = 0;
    bool moov_found = false, mdat_found = false;
    const int max_top_level_boxes = 64;  // safety bound against a corrupt file
 
    for (int i = 0; i < max_top_level_boxes; i++) {
      uint8_t hdr[8];
      if (!p_seek_source->seek((size_t)pos)) break;
      if (p_seek_source->readBytes(hdr, 8) < 8) break;
      uint64_t box_size = readU32(hdr);
      // 64-bit ('size'==1) and "extends to EOF" ('size'==0) boxes aren't
      // understood here or by MP4Parser's own walker - bail out and let
      // the caller fall back to normal sequential parsing.
      if (box_size < 8) break;
 
      if (memcmp(hdr + 4, "moov", 4) == 0) {
        moov_offset = pos;
        moov_size = box_size;
        moov_found = true;
      } else if (memcmp(hdr + 4, "mdat", 4) == 0) {
        mdat_offset = pos;
        mdat_size = box_size;
        mdat_found = true;
      }
      if (moov_found && mdat_found) break;
      pos += box_size;
    }
 
    if (!moov_found || !mdat_found || moov_offset < mdat_offset) {
      return false;  // nothing found, or already faststart
    }
 
    LOGI("DemuxerMP4::quickStart: moov at %u (size %u), mdat at %u - "
         "parsing moov directly",
         (unsigned)moov_offset, (unsigned)moov_size, (unsigned)mdat_offset);
 
    // Feed exactly 'moov's bytes through the same callback-driven parser
    // used for normal streaming - just sourced via seek()+readBytes().
    parser.begin(moov_offset);
    uint8_t buf[512];
    uint64_t remaining = moov_size;
    uint64_t off = moov_offset;
    while (remaining > 0) {
      size_t chunk = (size_t)std::min<uint64_t>(remaining, sizeof(buf));
      if (!p_seek_source->seek((size_t)off)) break;
      size_t got = p_seek_source->readBytes(buf, chunk);
      if (got == 0) break;
      parser.write(buf, got);
      off += got;
      remaining -= got;
    }
 
    // Hand off: reset the parser's box state machine to expect a fresh
    // box at 'mdat's offset, and reposition the seek source there so the
    // caller's normal write()-loop resumes from 'mdat', not offset 0.
    parser.begin(mdat_offset);
    p_seek_source->seek((size_t)mdat_offset);
    // caps write() at 'mdat's size so the trailing 'moov' isn't re-parsed
    quickstart_bytes_remaining = (int64_t)mdat_size;
    return true;
  }
 
 protected:
  struct StscEntry {
    uint32_t first_chunk;
    uint32_t samples_per_chunk;
  };

  struct SttsEntry {
    uint32_t sample_count;
    uint32_t sample_delta;
  };

  struct Track {
    // Kind alias kept for source compatibility with any existing
    // Track::Kind::X references - the real type is TrackKind
    // (SampleTableStore.h), shared with SpoolStorageFactory.
    using Kind = TrackKind;
    TrackKind kind = TrackKind::Unknown;
    bool spool_configured = false;
 
    // 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' - RAM-backed
    // (chunked allocation, see ChunkedSampleTableStore) by default; see
    // DemuxerMP4::setSeekSource()/onTrak() for the alternative that
    // re-reads entries from the original file on demand instead of
    // keeping them all resident
    SampleTableStore<uint32_t>* sample_sizes = new ChunkedSampleTableStore<uint32_t>();
    uint32_t fixed_sample_size = 0;
    uint32_t fixed_sample_count = 0;
    SampleTableStore<StscEntry>* stsc = new ChunkedSampleTableStore<StscEntry>();
    SampleTableStore<uint64_t>* chunk_offsets = new ChunkedSampleTableStore<uint64_t>();
 
    // 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;
    SampleTableStore<SttsEntry>* stts = new ChunkedSampleTableStore<SttsEntry>();
 
    ~Track() {
      delete sample_sizes;
      delete stsc;
      delete chunk_offsets;
      delete stts;
    }
 
    // runtime cursor, used while walking the merge schedule
    uint32_t next_sample_index = 0;
 
    // runtime cursor into chunk_offsets - which chunk of this track is
    // next up for the incremental cross-track merge (see
    // DemuxerMP4::advanceChunkIfNeeded())
    uint32_t next_chunk_index = 0;
    // runtime cursor into stsc for samplesInChunk() - valid only under
    // monotonically increasing chunkIndex0 calls (true for the sequential
    // per-chunk consumption above)
    uint32_t stsc_cursor = 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->get(idx);
    }
 
    uint32_t sampleCount() {
      return fixed_sample_size > 0 ? fixed_sample_count
                                   : (uint32_t)sample_sizes->size();
    }
  };
 
  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;  
  SeekableSource* p_seek_source = nullptr;
  SpoolStorageFactory* p_spool_factory = nullptr;

  int64_t quickstart_bytes_remaining = -1;
 
  // Incremental cross-track merge state (replaces a precomputed
  // whole-file schedule - see advanceChunkIfNeeded()): which track's
  // chunk is currently being consumed, and how many of its samples are
  // still left in that chunk.
  Track* current_chunk_track = nullptr;
  uint32_t samples_left_in_chunk = 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;
 
  // 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;
  uint32_t dispatched_sample_count = 0;
 
  // 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;
  uint64_t box_start_file_offset = 0;

  bool beginBoxAccum(const MP4Parser::Box& box) {
    if (box_accum_active) return false;
    box_accum.resize(box.size);
    box_accum.clear();
    box_accum_active = true;
    // box.file_offset is the absolute file offset of *this box's own*
    // 8-byte header (size+type) - captured only here, on the box's FIRST
    // delivery, because MP4Parser advances it per incremental delivery
    // (see startIncrementalBox()/continueIncrementalBox() in
    // MP4Parser.h): by the time a large box (e.g. a 147K-entry stco) is
    // fully accumulated and its entries are actually iterated, box.file_
    // offset reflects only the *last* delivery's start, not the box's -
    // capturing it here instead of computing it later from
    // total_bytes_received/box_accum.available() is what makes
    // SourceSeekSampleTableStore's offsets land correctly.
    box_start_file_offset = box.file_offset;
    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]; }
 
  // decoder callbacks for SourceSeekSampleTableStore - see its comment on
  // why get() can't just memcpy raw on-disk bytes into T
  static uint64_t readU32Widened(const uint8_t* p) { return (uint64_t)readU32(p); }
  static StscEntry readStscEntry(const uint8_t* p) {
    StscEntry e;
    e.first_chunk = readU32(p);
    e.samples_per_chunk = readU32(p + 4);
    return e;
  }
  static SttsEntry readSttsEntry(const uint8_t* p) {
    SttsEntry e;
    e.sample_count = readU32(p);
    e.sample_delta = readU32(p + 4);
    return e;
  }
 
  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(
        "ac-3",
        [](MP4Parser::Box& box, void* ref) {
          static_cast<DemuxerMP4*>(ref)->onAc3(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();
    if (p_seek_source != nullptr) {
      // RAM-backed defaults from Track's own member initializers aren't
      // needed when a seek source is configured - swap them for
      // SourceSeekSampleTableStore instead of paying for both.
      delete t->sample_sizes;
      t->sample_sizes = new SourceSeekSampleTableStore<uint32_t>(
          *p_seek_source, sizeof(uint32_t), readU32);
      delete t->chunk_offsets;
      // on-disk width (4 bytes for 'stco', 8 for 'co64') isn't known yet
      // here - defaults to 'stco' width and is corrected in onStco() via
      // setOnDiskEntrySize() once the actual box type is seen, always
      // before any get() call (which only happens much later, during
      // 'mdat' playback).
      t->chunk_offsets = new SourceSeekSampleTableStore<uint64_t>(
          *p_seek_source, sizeof(uint32_t), readU32Widened);
      delete t->stsc;
      // stsc's on-disk entries are 12 bytes (first_chunk, samples_per_chunk,
      // sample_description_index - all u32), matching onStsc()'s own i*12
      // parsing stride below, even though readStscEntry() only decodes the
      // first two fields into StscEntry. Passing 8 here previously
      // (2 fields' worth) misaligned every get() past index 0, since
      // get()'s offset math is entries*onDiskSize - reproducibly corrupted
      // chunk-to-sample mapping for any track whose stsc has more than one
      // entry (typically audio, not video, since a video track commonly
      // only ever needs one stsc entry for the whole file).
      t->stsc = new SourceSeekSampleTableStore<StscEntry>(
          *p_seek_source, sizeof(uint32_t) * 3, readStscEntry);
      delete t->stts;
      t->stts = new SourceSeekSampleTableStore<SttsEntry>(
          *p_seek_source, sizeof(uint32_t) * 2, readSttsEntry);
    }
    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;
    }
    // Spool-backed tables need to know the track's kind (to name/select
    // spool files) - unlike source-seek, which is set up eagerly in
    // onTrak() since it doesn't care about kind, this can only happen
    // here, once 'hdlr' has actually told us what this track is.
    if (p_spool_factory != nullptr && current_track->kind != Track::Kind::Unknown) {
      configureSpoolStores(*current_track);
    }
    endBoxAccum();
  }

  void configureSpoolStores(Track& t) {
    if (t.spool_configured) return;
    t.spool_configured = true;
    delete t.sample_sizes;
    t.sample_sizes = new SpoolFileSampleTableStore<uint32_t>(
        *p_spool_factory->createSpoolStorage(t.kind, SampleTableKind::SampleSizes));
    delete t.chunk_offsets;
    t.chunk_offsets = new SpoolFileSampleTableStore<uint64_t>(
        *p_spool_factory->createSpoolStorage(t.kind, SampleTableKind::ChunkOffsets));
    delete t.stsc;
    t.stsc = new SpoolFileSampleTableStore<StscEntry>(
        *p_spool_factory->createSpoolStorage(t.kind, SampleTableKind::Stsc));
    delete t.stts;
    t.stts = new SpoolFileSampleTableStore<SttsEntry>(
        *p_spool_factory->createSpoolStorage(t.kind, SampleTableKind::Stts));
  }
 
  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 onAc3(const MP4Parser::Box& box) {
    if (current_track == nullptr || !box.is_complete) return;
    current_track->audio_codec = Codec::AC3;
    setupAudioInfo(AudioFormat::AC3, box.data, box.data_size);
  }
 
  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();
  }

  uint64_t boxPayloadFileOffset() {
    return box_start_file_offset + 8;
  }

  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);
    LOGD("DemuxerMP4: stts entryCount=%u", (unsigned)entryCount);
    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);
      // +8: this table's own version/flags+entryCount sub-header
      current_track->stts->setNextEntryOffset(boxPayloadFileOffset() + 8);
      current_track->stts->append(e);
    }
    LOGD("DemuxerMP4: stts parsed %u entries", (unsigned)current_track->stts->size());
    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);
      LOGD("DemuxerMP4: stsz sampleSize=%u sampleCount=%u", (unsigned)sampleSize,
           (unsigned)sampleCount);
      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 append(), one entry at a
      // time as bytes arrive - do NOT pre-resize it (a RAM-backed store's
      // 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) {
        // +12: this table's own version/flags+sampleSize+sampleCount
        // sub-header (already drained from box_accum via clearArray(12)
        // above, but boxPayloadFileOffset() itself doesn't know that)
        current_track->sample_sizes->setNextEntryOffset(boxPayloadFileOffset() + 12);
        current_track->sample_sizes->append(readU32(box_accum.data()));
        box_accum.clearArray(4);
        size_t n = current_track->sample_sizes->size();
        if (n % 20000 == 0)
          LOGD("DemuxerMP4: stsz sample_sizes progress: %u", (unsigned)n);
      }
    }
    if (box.is_complete) {
      LOGD("DemuxerMP4: stsz complete, %u sample_sizes",
           (unsigned)current_track->sample_sizes->size());
      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);
    LOGD("DemuxerMP4: stsc entryCount=%u", (unsigned)entryCount);
    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);
      // +8: this table's own version/flags+entryCount sub-header
      current_track->stsc->setNextEntryOffset(boxPayloadFileOffset() + 8);
      current_track->stsc->append(e);
    }
    LOGD("DemuxerMP4: stsc parsed %u entries", (unsigned)current_track->stsc->size());
    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);
    LOGD("DemuxerMP4: %s entryCount=%u", is64 ? "co64" : "stco",
         (unsigned)entryCount);
    // no-op unless a SourceSeekSampleTableStore is active (see onTrak());
    // corrects its assumed on-disk stride if this turns out to be 'co64'
    // rather than the default 'stco' - always before any get() call.
    current_track->chunk_offsets->setOnDiskEntrySize(is64 ? 8 : 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);
      // +8: this table's own version/flags+entryCount sub-header
      current_track->chunk_offsets->setNextEntryOffset(boxPayloadFileOffset() + 8);
      current_track->chunk_offsets->append(off);
      size_t n = current_track->chunk_offsets->size();
      if (n % 20000 == 0)
        LOGD("DemuxerMP4: chunk_offsets progress: %u", (unsigned)n);
    }
    LOGD("DemuxerMP4: stco parsed %u chunk_offsets",
         (unsigned)current_track->chunk_offsets->size());
    endBoxAccum();
  }
 
  // ---- mdat / schedule / sample dispatch ----
 
  void onMdat(MP4Parser::Box& box) {
    if (!mdat_seen) {
      mdat_seen = true;
      LOGI("DemuxerMP4: mdat reached");
    }
    feed(box.data, box.available);
  }

  uint32_t samplesInChunk(Track& t, uint32_t chunkIndex0) {
    if (t.stsc->size() == 0) return 0;
    uint32_t chunk1 = chunkIndex0 + 1;  // stsc uses 1-based chunk numbers
    while (t.stsc_cursor + 1 < t.stsc->size() &&
           t.stsc->get(t.stsc_cursor + 1).first_chunk <= chunk1) {
      t.stsc_cursor++;
    }
    return t.stsc->get(t.stsc_cursor).samples_per_chunk;
  }

  void advanceChunkIfNeeded() {
    while (samples_left_in_chunk == 0) {
      Track* next = nullptr;
      uint64_t best_offset = 0;
      if (p_video_track != nullptr &&
          p_video_track->next_chunk_index < p_video_track->chunk_offsets->size()) {
        best_offset = p_video_track->chunk_offsets->get(p_video_track->next_chunk_index);
        next = p_video_track;
      }
      if (p_audio_track != nullptr &&
          p_audio_track->next_chunk_index < p_audio_track->chunk_offsets->size()) {
        uint64_t off = p_audio_track->chunk_offsets->get(p_audio_track->next_chunk_index);
        if (next == nullptr || off < best_offset) {
          best_offset = off;
          next = p_audio_track;
        }
      }
      if (next == nullptr) {
        current_chunk_track = nullptr;  // nothing more expected
        return;
      }
      uint32_t samples = samplesInChunk(*next, next->next_chunk_index);
      next->next_chunk_index++;
      if (samples == 0) continue;  // empty chunk entry - keep looking
      current_chunk_track = next;
      samples_left_in_chunk = samples;
    }
  }

  void feed(const uint8_t* data, size_t len) {
    size_t pos = 0;
    while (pos < len) {
      if (current_sample_track == nullptr) {
        advanceChunkIfNeeded();
        if (current_chunk_track == nullptr) return;  // nothing more expected
        Track* t = current_chunk_track;
        uint32_t size = t->sampleSize(t->next_sample_index);
        if (size == 0) {
          // no more sizes for this track - stop
          samples_left_in_chunk = 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_chunk--;
        current_sample_track = nullptr;
        dispatched_sample_count++;
        if (dispatched_sample_count % 5000 == 0) {
          LOGI("DemuxerMP4: dispatched %u samples so far",
               (unsigned)dispatched_sample_count);
        }
      }
    }
  }
 
  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) {
    // No wall-clock scheduling or skip decisions here anymore: every
    // sample is always converted and forwarded immediately, in full.
    // Pacing/scheduling is the caller's responsibility now - see
    // PacedVideoOutput (Video/PacedVideoOutput.h), which schedules
    // frames from its own background task instead of blocking this
    // dispatch loop (and, with it, audio delivery) the way an inline
    // wait here used to.
    if ((p_video_out == nullptr && p_video_out_video == nullptr) ||
        t.is_hevc_unsupported)
      return;
 
    // Prepend the SPS/PPS config (already Annex-B, same start-code
    // format the conversion below produces - see onAvcC()'s appendUnit())
    // into the *same* buffer as the frame's own NAL units, rather than a
    // separate writeVideo() call before them - so a downstream VideoOutput
    // always gets exactly one write() call per frame (matches DemuxerAVI/
    // DemuxerMPG; see PacedVideoOutput, the only current consumer that
    // cares about the distinction).
    nal_tmp.clear();
    bool prependConfig =
        isFirst && !t.avc_config_sent && t.sps_pps_annexb.size() > 0;
    if (prependConfig) {
      nal_tmp.resize(t.sps_pps_annexb.size());
      memcpy(nal_tmp.data(), t.sps_pps_annexb.data(), t.sps_pps_annexb.size());
      t.avc_config_sent = true;
    }
 
    // convert AVCC length-prefixed NAL units to Annex-B start codes
    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;
    }
 
    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* mimeVideo() 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) return 0;
    switch (video_cfg.format) {
      case VideoFormat::H264:
        break;
      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 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