diff options
| author | Onur Gündüz <ogunduz@gmail.com> | 2026-02-12 07:25:29 +0100 |
|---|---|---|
| committer | Onur Gündüz <ogunduz@gmail.com> | 2026-02-12 07:25:29 +0100 |
| commit | cc6b8652d01219632fca1f52a7e27a66964866b1 (patch) | |
| tree | 8feceb249115cea8da360e1fc13cc837b50f2f6a | |
| parent | ac66a7f3305a44721d84a4938e951fdaf1eb7c1f (diff) | |
| download | mp4-cc6b8652d01219632fca1f52a7e27a66964866b1.tar.gz mp4-cc6b8652d01219632fca1f52a7e27a66964866b1.zip | |
Add Remuxer
| -rw-r--r-- | remux/direct.go | 110 | ||||
| -rw-r--r-- | remux/remuxer.go | 693 | ||||
| -rw-r--r-- | remux/writer.go | 193 |
3 files changed, 996 insertions, 0 deletions
diff --git a/remux/direct.go b/remux/direct.go new file mode 100644 index 0000000..58eb6f9 --- /dev/null +++ b/remux/direct.go @@ -0,0 +1,110 @@ +package remux + +import ( + "encoding/binary" + "io" + + "github.com/tetsuo/mp4" +) + +// writeMoof writes a complete moof box directly as binary to w. +func writeMoof(w io.Writer, seqNum uint32, trackID uint32, baseMediaDecodeTime uint32, entries []mp4.TrunEntry, trunVersion uint8, buf []byte) ([]byte, error) { + be := binary.BigEndian + + // Fixed sizes (no version-1 tfdt for now, baseMediaDecodeTime is uint32) + // moof header: 8 + // mfhd: 16 (8 hdr + 4 ver/flags + 4 seqnum) + // traf header: 8 + // tfhd: 16 (8 hdr + 4 ver/flags + 4 trackid) + // tfdt: 16 (8 hdr + 4 ver/flags + 4 base_decode_time) + // trun header: 20 (8 hdr + 4 ver/flags + 4 sample_count + 4 data_offset) + // trun entries: 16 * len(entries) + n := len(entries) + trunSize := 20 + n*16 + trafSize := 8 + 16 + 16 + trunSize + moofSize := 8 + 16 + trafSize + dataOffset := moofSize + 8 // +8 for mdat header + + // Grow buffer when needed + if cap(buf) < moofSize { + buf = make([]byte, moofSize) + } else { + buf = buf[:moofSize] + } + + p := 0 + + // moof box header + be.PutUint32(buf[p:], uint32(moofSize)) + copy(buf[p+4:], "moof") + p += 8 + + // mfhd (full box: version=0, flags=0) + be.PutUint32(buf[p:], 16) + copy(buf[p+4:], "mfhd") + buf[p+8] = 0 + buf[p+9] = 0 + buf[p+10] = 0 + buf[p+11] = 0 + be.PutUint32(buf[p+12:], seqNum) + p += 16 + + // traf box header + be.PutUint32(buf[p:], uint32(trafSize)) + copy(buf[p+4:], "traf") + p += 8 + + // tfhd (full box: version=0, flags=0x020000 = default-base-is-moof) + be.PutUint32(buf[p:], 16) + copy(buf[p+4:], "tfhd") + buf[p+8] = 0 + buf[p+9] = 0x02 + buf[p+10] = 0 + buf[p+11] = 0 + be.PutUint32(buf[p+12:], trackID) + p += 16 + + // tfdt (full box: version=0, flags=0) + be.PutUint32(buf[p:], 16) + copy(buf[p+4:], "tfdt") + buf[p+8] = 0 + buf[p+9] = 0 + buf[p+10] = 0 + buf[p+11] = 0 + be.PutUint32(buf[p+12:], baseMediaDecodeTime) + p += 16 + + // trun (full box: version=trunVersion, flags=0x000f01) + // flags: 0x001 = data-offset-present + // 0x100 = sample-duration-present + // 0x200 = sample-size-present + // 0x400 = sample-flags-present + // 0x800 = sample-composition-time-offset-present + be.PutUint32(buf[p:], uint32(trunSize)) + copy(buf[p+4:], "trun") + buf[p+8] = trunVersion + buf[p+9] = 0x00 + buf[p+10] = 0x0f + buf[p+11] = 0x01 + be.PutUint32(buf[p+12:], uint32(n)) + be.PutUint32(buf[p+16:], uint32(dataOffset)) + p += 20 + + // trun entries: duration(4) + size(4) + flags(4) + compositionTimeOffset(4) + for i := range n { + e := &entries[i] + be.PutUint32(buf[p:], e.SampleDuration) + be.PutUint32(buf[p+4:], e.SampleSize) + be.PutUint32(buf[p+8:], e.SampleFlags) + if trunVersion == 1 { + // signed composition offset + be.PutUint32(buf[p+12:], uint32(e.SampleCompositionTimeOffset)) + } else { + be.PutUint32(buf[p+12:], uint32(e.SampleCompositionTimeOffset)) + } + p += 16 + } + + _, err := w.Write(buf[:moofSize]) + return buf, err +} diff --git a/remux/remuxer.go b/remux/remuxer.go new file mode 100644 index 0000000..6cf786b --- /dev/null +++ b/remux/remuxer.go @@ -0,0 +1,693 @@ +package remux + +import ( + "encoding/binary" + "fmt" + "io" + "sort" + + "github.com/tetsuo/mp4" +) + +var be = binary.BigEndian + +// Sample represents a single decoded sample (frame) with all metadata needed for remuxing. +type Sample struct { + Offset int64 + Size uint32 + Duration uint32 + DTS int64 + PresentationOffset int32 + Sync bool +} + +// Track holds the parsed metadata for one track (audio or video). +type Track struct { + TrackID uint32 + TimeScale uint32 + Codec string + Mime string + + Samples []Sample + + // initBuf is the pre-encoded ftyp+moov for this track's init segment. + initBuf []byte + // defaultSampleDescriptionIndex from the last stsc entry. + defaultSampleDescriptionIndex uint32 +} + +// Remuxer holds parsed MP4 metadata and writes fragmented MP4 streams. +type Remuxer struct { + Tracks []*Track +} + +// minFragmentDuration is the minimum fragment duration in seconds. +const minFragmentDuration = 1 + +// NewRemuxer parses the moov box from an MP4 source and prepares track metadata. +func NewRemuxer(rs io.ReadSeeker) (*Remuxer, error) { + moov, err := findAndParseMoov(rs) + if err != nil { + return nil, err + } + return newRemuxer(moov) +} + +// NewRemuxerFromBytes parses the moov box from an in-memory MP4 file. +func NewRemuxerFromBytes(data []byte) (*Remuxer, error) { + moov, err := findAndParseMoovBytes(data) + if err != nil { + return nil, err + } + return newRemuxer(moov) +} + +// findAndParseMoov locates the moov box by scanning top-level boxes. +func findAndParseMoov(rs io.ReadSeeker) (*mp4.Box, error) { + var hdr [8]byte + var offset int64 + + for { + if _, err := io.ReadFull(rs, hdr[:]); err != nil { + if err == io.EOF || err == io.ErrUnexpectedEOF { + return nil, fmt.Errorf("moov box not found") + } + return nil, err + } + + size := int64(binary.BigEndian.Uint32(hdr[:4])) + boxType := string(hdr[4:8]) + + if size == 1 { + // 64-bit extended size + var ext [8]byte + if _, err := io.ReadFull(rs, ext[:]); err != nil { + return nil, err + } + size = int64(binary.BigEndian.Uint64(ext[:])) + } + + if boxType == "moov" { + contentSize := size - 8 + buf := make([]byte, size) + copy(buf[:8], hdr[:]) + if _, err := io.ReadFull(rs, buf[8:]); err != nil { + return nil, fmt.Errorf("reading moov: %w", err) + } + box, err := mp4.Decode(buf, 0, int(size)) + if err != nil { + return nil, fmt.Errorf("decoding moov: %w", err) + } + _ = contentSize + return box, nil + } + + // Skip this box + skip := size - 8 + if skip > 0 { + if _, err := rs.Seek(skip, io.SeekCurrent); err != nil { + return nil, err + } + } + offset += size + } +} + +func findAndParseMoovBytes(data []byte) (*mp4.Box, error) { + ptr := 0 + for ptr+8 <= len(data) { + size := int(binary.BigEndian.Uint32(data[ptr:])) + if size < 8 { + return nil, fmt.Errorf("invalid box size %d at offset %d", size, ptr) + } + boxType := string(data[ptr+4 : ptr+8]) + if size == 1 && ptr+16 <= len(data) { + size = int(binary.BigEndian.Uint64(data[ptr+8:])) + } + if boxType == "moov" { + return mp4.Decode(data, ptr, ptr+size) + } + ptr += size + } + return nil, fmt.Errorf("moov box not found") +} + +func newRemuxer(moov *mp4.Box) (*Remuxer, error) { + mvhd := moov.Child(mp4.TypeMvhd) + if mvhd == nil || mvhd.Mvhd == nil { + return nil, fmt.Errorf("missing mvhd") + } + + traks := moov.ChildList(mp4.TypeTrak) + if len(traks) == 0 { + return nil, fmt.Errorf("no tracks found") + } + + r := &Remuxer{} + hasVideo := false + hasAudio := false + + for _, trak := range traks { + tkhdBox := trak.Child(mp4.TypeTkhd) + if tkhdBox == nil || tkhdBox.Tkhd == nil { + continue + } + mdiaBox := trak.Child(mp4.TypeMdia) + if mdiaBox == nil { + continue + } + hdlrBox := mdiaBox.Child(mp4.TypeHdlr) + if hdlrBox == nil || hdlrBox.Hdlr == nil { + continue + } + minfBox := mdiaBox.Child(mp4.TypeMinf) + if minfBox == nil { + continue + } + stblBox := minfBox.Child(mp4.TypeStbl) + if stblBox == nil { + continue + } + mdhdBox := mdiaBox.Child(mp4.TypeMdhd) + if mdhdBox == nil || mdhdBox.Mdhd == nil { + continue + } + + handlerType := string(hdlrBox.Hdlr.HandlerType[:]) + + stsdBox := stblBox.Child(mp4.TypeStsd) + if stsdBox == nil || stsdBox.Stsd == nil || len(stsdBox.Stsd.Entries) == 0 { + continue + } + stsdEntry := stsdBox.Stsd.Entries[0] + + var codec, mime string + + if handlerType == "vide" && stsdEntry.Type == mp4.TypeAvc1 { + if hasVideo { + continue + } + hasVideo = true + codec = "avc1" + if stsdEntry.Visual != nil { + for _, child := range stsdEntry.Visual.Children { + if child.Type == mp4.TypeAvcC && child.AvcC != nil { + codec += "." + child.AvcC.MimeCodec + break + } + } + } + mime = fmt.Sprintf(`video/mp4; codecs="%s"`, codec) + } else if handlerType == "soun" && stsdEntry.Type == mp4.TypeMp4a { + if hasAudio { + continue + } + hasAudio = true + codec = "mp4a" + if stsdEntry.Audio != nil { + for _, child := range stsdEntry.Audio.Children { + if child.Type == mp4.TypeEsds && child.Esds != nil && child.Esds.MimeCodec != "" { + codec += "." + child.Esds.MimeCodec + break + } + } + } + mime = fmt.Sprintf(`audio/mp4; codecs="%s"`, codec) + } else { + continue + } + + samples, defaultSdi, err := buildSampleTable(stblBox) + if err != nil { + return nil, fmt.Errorf("track %d: %w", tkhdBox.Tkhd.TrackId, err) + } + + track := &Track{ + TrackID: tkhdBox.Tkhd.TrackId, + TimeScale: mdhdBox.Mdhd.TimeScale, + Codec: codec, + Mime: mime, + Samples: samples, + defaultSampleDescriptionIndex: defaultSdi, + } + + // Build init segment + initBuf, err := buildInitSegment(mvhd, trak, track) + if err != nil { + return nil, fmt.Errorf("track %d init: %w", track.TrackID, err) + } + track.initBuf = initBuf + + r.Tracks = append(r.Tracks, track) + } + + if len(r.Tracks) == 0 { + return nil, fmt.Errorf("no playable tracks") + } + + return r, nil +} + +func buildSampleTable(stbl *mp4.Box) ([]Sample, uint32, error) { + stszBox := stbl.Child(mp4.TypeStsz) + if stszBox == nil || stszBox.Stsz == nil { + return nil, 0, fmt.Errorf("missing stsz") + } + sttsBox := stbl.Child(mp4.TypeStts) + if sttsBox == nil || sttsBox.Stts == nil { + return nil, 0, fmt.Errorf("missing stts") + } + stscBox := stbl.Child(mp4.TypeStsc) + if stscBox == nil || stscBox.Stsc == nil { + return nil, 0, fmt.Errorf("missing stsc") + } + + // Chunk offset table (stco or co64) + var chunkOffsets []int64 + if co64Box := stbl.Child(mp4.TypeCo64); co64Box != nil && co64Box.Co64 != nil { + chunkOffsets = make([]int64, len(co64Box.Co64.Entries)) + for i, v := range co64Box.Co64.Entries { + chunkOffsets[i] = int64(v) + } + } else if stcoBox := stbl.Child(mp4.TypeStco); stcoBox != nil && stcoBox.Stco != nil { + chunkOffsets = make([]int64, len(stcoBox.Stco.Entries)) + for i, v := range stcoBox.Stco.Entries { + chunkOffsets[i] = int64(v) + } + } else { + return nil, 0, fmt.Errorf("missing stco/co64") + } + + numSamples := len(stszBox.Stsz.Entries) + samples := make([]Sample, numSamples) + + // Chunk/position iterators + sampleInChunk := 0 + chunk := 0 + var offsetInChunk int64 + sampleToChunkIndex := 0 + stscEntries := stscBox.Stsc.Entries + + // Time iterators + var dts int64 + sttsEntries := sttsBox.Stts.Entries + decodingIdx := 0 + decodingOff := 0 + + // Composition offsets (optional) + var cttsEntries []mp4.CTTSEntry + cttsIdx := 0 + cttsOff := 0 + if cttsBox := stbl.Child(mp4.TypeCtts); cttsBox != nil && cttsBox.Ctts != nil { + cttsEntries = cttsBox.Ctts.Entries + } + + // Sync sample table (optional) + var syncEntries []uint32 + syncIdx := 0 + if stssBox := stbl.Child(mp4.TypeStss); stssBox != nil && stssBox.Stco != nil { + syncEntries = stssBox.Stco.Entries + } + + var defaultSdi uint32 + + for i := range numSamples { + currChunkEntry := stscEntries[sampleToChunkIndex] + defaultSdi = currChunkEntry.SampleDescriptionId + + size := stszBox.Stsz.Entries[i] + duration := sttsEntries[decodingIdx].Duration + + var presentationOffset int32 + if cttsEntries != nil && cttsIdx < len(cttsEntries) { + presentationOffset = cttsEntries[cttsIdx].CompositionOffset + } + + sync := true + if syncEntries != nil { + sync = syncIdx < len(syncEntries) && syncEntries[syncIdx] == uint32(i+1) + } + + samples[i] = Sample{ + Offset: offsetInChunk + chunkOffsets[chunk], + Size: size, + Duration: duration, + DTS: dts, + PresentationOffset: presentationOffset, + Sync: sync, + } + + // Advance to next sample + if i+1 >= numSamples { + break + } + + // Advance chunk position + sampleInChunk++ + offsetInChunk += int64(size) + if sampleInChunk >= int(currChunkEntry.SamplesPerChunk) { + sampleInChunk = 0 + offsetInChunk = 0 + chunk++ + if sampleToChunkIndex+1 < len(stscEntries) { + nextEntry := stscEntries[sampleToChunkIndex+1] + if uint32(chunk+1) >= nextEntry.FirstChunk { + sampleToChunkIndex++ + } + } + } + + // Advance time + dts += int64(duration) + decodingOff++ + if decodingOff >= int(sttsEntries[decodingIdx].Count) { + decodingIdx++ + decodingOff = 0 + } + + // Advance composition offset + if cttsEntries != nil { + cttsOff++ + if cttsIdx < len(cttsEntries) && cttsOff >= int(cttsEntries[cttsIdx].Count) { + cttsIdx++ + cttsOff = 0 + } + } + + // Advance sync index + if sync { + syncIdx++ + } + } + + return samples, defaultSdi, nil +} + +func buildInitSegment(mvhd *mp4.Box, trak *mp4.Box, track *Track) ([]byte, error) { + tkhdBox := trak.Child(mp4.TypeTkhd) + mdiaBox := trak.Child(mp4.TypeMdia) + mdhdBox := mdiaBox.Child(mp4.TypeMdhd) + hdlrBox := mdiaBox.Child(mp4.TypeHdlr) + minfBox := mdiaBox.Child(mp4.TypeMinf) + stblBox := minfBox.Child(mp4.TypeStbl) + stsdBox := stblBox.Child(mp4.TypeStsd) + + // Clone tkhd with duration=0 + tkhdClone := *tkhdBox.Tkhd + be.PutUint32(tkhdClone.CTime[:], be.Uint32(tkhdBox.Tkhd.CTime[:])) + // zero out duration + tkhdClone.Duration = 0 + + // Clone mdhd with duration=0 + mdhdClone := *mdhdBox.Mdhd + mdhdClone.Duration = 0 + + emptyBox := func(t mp4.BoxType) *mp4.Box { + return &mp4.Box{ + Type: t, + Version: 0, + Flags: 0, + } + } + + emptyEntryBox := func(t mp4.BoxType) *mp4.Box { + b := emptyBox(t) + switch t { + case mp4.TypeStts: + b.Stts = &mp4.Stts{} + case mp4.TypeCtts: + b.Ctts = &mp4.Ctts{} + case mp4.TypeStsc: + b.Stsc = &mp4.Stsc{} + case mp4.TypeStsz: + b.Stsz = &mp4.Stsz{} + case mp4.TypeStco: + b.Stco = &mp4.Stco{} + case mp4.TypeStss: + b.Stco = &mp4.Stco{} // stss uses same codec as stco + } + return b + } + + // Build minf children + minfChildren := make(map[mp4.BoxType][]*mp4.Box) + // Copy vmhd or smhd + if vmhd := minfBox.Child(mp4.TypeVmhd); vmhd != nil { + minfChildren[mp4.TypeVmhd] = []*mp4.Box{vmhd} + } + if smhd := minfBox.Child(mp4.TypeSmhd); smhd != nil { + minfChildren[mp4.TypeSmhd] = []*mp4.Box{smhd} + } + if dinf := minfBox.Child(mp4.TypeDinf); dinf != nil { + minfChildren[mp4.TypeDinf] = []*mp4.Box{dinf} + } + + stblNew := &mp4.Box{ + Type: mp4.TypeStbl, + Children: map[mp4.BoxType][]*mp4.Box{ + mp4.TypeStsd: {stsdBox}, + mp4.TypeStts: {emptyEntryBox(mp4.TypeStts)}, + mp4.TypeCtts: {emptyEntryBox(mp4.TypeCtts)}, + mp4.TypeStsc: {emptyEntryBox(mp4.TypeStsc)}, + mp4.TypeStsz: {emptyEntryBox(mp4.TypeStsz)}, + mp4.TypeStco: {emptyEntryBox(mp4.TypeStco)}, + mp4.TypeStss: {emptyEntryBox(mp4.TypeStss)}, + }, + } + minfChildren[mp4.TypeStbl] = []*mp4.Box{stblNew} + + // Clone mvhd with duration=0 + mvhdClone := *mvhd.Mvhd + mvhdClone.Duration = 0 + mvhdBox := &mp4.Box{Type: mp4.TypeMvhd, Version: mvhd.Version, Flags: mvhd.Flags, Mvhd: &mvhdClone} + + moov := &mp4.Box{ + Type: mp4.TypeMoov, + Children: map[mp4.BoxType][]*mp4.Box{ + mp4.TypeMvhd: {mvhdBox}, + mp4.TypeTrak: {{ + Type: mp4.TypeTrak, + Children: map[mp4.BoxType][]*mp4.Box{ + mp4.TypeTkhd: {{Type: mp4.TypeTkhd, Version: tkhdBox.Version, Flags: tkhdBox.Flags, Tkhd: &tkhdClone}}, + mp4.TypeMdia: {{ + Type: mp4.TypeMdia, + Children: map[mp4.BoxType][]*mp4.Box{ + mp4.TypeMdhd: {{Type: mp4.TypeMdhd, Version: mdhdBox.Version, Flags: mdhdBox.Flags, Mdhd: &mdhdClone}}, + mp4.TypeHdlr: {hdlrBox}, + mp4.TypeMinf: {{ + Type: mp4.TypeMinf, + Children: minfChildren, + }}, + }, + }}, + }, + }}, + mp4.TypeMvex: {{ + Type: mp4.TypeMvex, + Children: map[mp4.BoxType][]*mp4.Box{ + mp4.TypeMehd: {{Type: mp4.TypeMehd, Mehd: &mp4.Mehd{FragmentDuration: mvhd.Mvhd.Duration}}}, + mp4.TypeTrex: {{Type: mp4.TypeTrex, Trex: &mp4.Trex{ + TrackId: track.TrackID, + DefaultSampleDescriptionIndex: track.defaultSampleDescriptionIndex, + }}}, + }, + }}, + }, + } + + ftyp := &mp4.Box{ + Type: mp4.TypeFtyp, + Ftyp: &mp4.Ftyp{ + Brand: [4]byte{'i', 's', 'o', '5'}, + BrandVersion: 0, + CompatibleBrands: [][4]byte{{'i', 's', 'o', '5'}}, + }, + } + + ftypBuf, err := mp4.EncodeToBytes(ftyp) + if err != nil { + return nil, err + } + moovBuf, err := mp4.EncodeToBytes(moov) + if err != nil { + return nil, err + } + + out := make([]byte, len(ftypBuf)+len(moovBuf)) + copy(out, ftypBuf) + copy(out[len(ftypBuf):], moovBuf) + return out, nil +} + +// InitSegment returns the pre-built init segment (ftyp+moov) for the given track. +func (t *Track) InitSegment() []byte { + return t.initBuf +} + +// Duration returns the total duration of the track in seconds. +func (t *Track) Duration() float64 { + if len(t.Samples) == 0 || t.TimeScale == 0 { + return 0 + } + last := t.Samples[len(t.Samples)-1] + return float64(last.DTS+int64(last.Duration)) / float64(t.TimeScale) +} + +// Fragment represents a moof+mdat fragment to be written. +type Fragment struct { + trackID uint32 + timeScale uint32 + firstSample int + lastSample int // exclusive + samples []Sample + sequenceNumber uint32 + version uint8 +} + +// FindSampleBefore finds the sync sample at or before the given time (in seconds). +// Useful for seeking backward to a safe playback position. +func (t *Track) FindSampleBefore(timeSeconds float64) int { + scaledTime := int64(timeSeconds * float64(t.TimeScale)) + + // Binary search: find last sample with pts <= scaledTime + idx := max(sort.Search(len(t.Samples), func(i int) bool { + pts := t.Samples[i].DTS + int64(t.Samples[i].PresentationOffset) + return pts > scaledTime + })-1, 0) + + // Walk backward to find the preceding sync sample + for idx > 0 && !t.Samples[idx].Sync { + idx-- + } + + return idx +} + +// FindSampleAfter finds the first sync sample at or after the given time (in seconds). +// Useful for finding a clean start point for time-based extraction. +func (t *Track) FindSampleAfter(timeSeconds float64) int { + scaledTime := int64(timeSeconds * float64(t.TimeScale)) + + // Binary search: find first sample with pts >= scaledTime + idx := sort.Search(len(t.Samples), func(i int) bool { + pts := t.Samples[i].DTS + int64(t.Samples[i].PresentationOffset) + return pts >= scaledTime + }) + + if idx >= len(t.Samples) { + return len(t.Samples) - 1 + } + + // Walk forward to find the next sync sample + for idx < len(t.Samples) && !t.Samples[idx].Sync { + idx++ + } + + // If went past the end, return the last sample + if idx >= len(t.Samples) { + return len(t.Samples) - 1 + } + + return idx +} + +// byteRange represents a contiguous range of bytes in the source file. +type byteRange struct { + Start int64 + End int64 // exclusive +} + +// generateFragment builds fragment metadata for samples starting at firstSample. +// trunEntries and ranges are caller-provided slices that will be reused (resliced). +// Returns the populated slices, total mdat payload size, next sample index, and trun version. +func generateFragment(track *Track, firstSample int, endTimeScaled int64, trunEntries []mp4.TrunEntry, ranges []byteRange) ([]mp4.TrunEntry, []byteRange, int64, int, uint8) { + samples := track.Samples + if firstSample >= len(samples) { + return trunEntries[:0], ranges[:0], 0, firstSample, 0 + } + + startDts := samples[firstSample].DTS + threshold := int64(track.TimeScale) * minFragmentDuration + + // Find the end of this fragment + lastSample := firstSample + + for lastSample < len(samples) { + s := samples[lastSample] + pts := s.DTS + int64(s.PresentationOffset) + + // Hard stop: don't include any sample at or past end time + if endTimeScaled > 0 && pts >= endTimeScaled { + break + } + + // Fragment boundary: when no end time, break at sync samples + // after minimum duration + if endTimeScaled == 0 && lastSample > firstSample && s.Sync { + elapsed := s.DTS - startDts + if elapsed >= threshold { + break + } + } + + lastSample++ + } + + n := lastSample - firstSample + if n == 0 { + return trunEntries[:0], ranges[:0], 0, lastSample, 0 + } + + // Grow trunEntries when needed + if cap(trunEntries) < n { + trunEntries = make([]mp4.TrunEntry, n) + } else { + trunEntries = trunEntries[:n] + } + + var totalLen int64 + var trunVersion uint8 + + for i := range n { + s := samples[firstSample+i] + if s.PresentationOffset < 0 { + trunVersion = 1 + } + flags := uint32(0x2000000) // sync + if !s.Sync { + flags = 0x1010000 // non-sync + } + trunEntries[i] = mp4.TrunEntry{ + SampleDuration: s.Duration, + SampleSize: s.Size, + SampleFlags: flags, + SampleCompositionTimeOffset: s.PresentationOffset, + } + totalLen += int64(s.Size) + } + + // Build contiguous byte ranges, reuse slice + ranges = ranges[:0] + for i := range n { + s := samples[firstSample+i] + sStart := s.Offset + sEnd := s.Offset + int64(s.Size) + if len(ranges) > 0 && ranges[len(ranges)-1].End == sStart { + ranges[len(ranges)-1].End = sEnd + } else { + ranges = append(ranges, byteRange{Start: sStart, End: sEnd}) + } + } + + return trunEntries, ranges, totalLen, lastSample, trunVersion +} + +// WriteTo writes a complete fragmented MP4 stream for a single track, +// starting from the given time (seconds), to w. +// If endTime > 0, stops writing fragments at or before the given end time. +// +// Each call creates a new [Writer]. For repeated calls, create a [Writer] +// once and call its [Writer.WriteTo] method instead of this helper. +func WriteTo(w io.Writer, rs io.ReadSeeker, track *Track, startTime float64, endTime float64) error { + return NewWriter().WriteTo(w, rs, track, startTime, endTime) +} diff --git a/remux/writer.go b/remux/writer.go new file mode 100644 index 0000000..89c06ba --- /dev/null +++ b/remux/writer.go @@ -0,0 +1,193 @@ +package remux + +import ( + "encoding/binary" + "io" + + "github.com/tetsuo/mp4" +) + +// Writer holds reusable buffers for writing fragmented MP4 streams. +// +// A Writer is NOT safe for concurrent use. Use one Writer per goroutine, +// or protect with a mutex. +type Writer struct { + trunEntries []mp4.TrunEntry + ranges []byteRange + copyBuf []byte + moofBuf []byte + mdatHdr [8]byte +} + +// NewWriter creates a Writer with pre-allocated buffers. +func NewWriter() *Writer { + return &Writer{ + trunEntries: make([]mp4.TrunEntry, 0, 512), + ranges: make([]byteRange, 0, 64), + copyBuf: make([]byte, 32768), + moofBuf: make([]byte, 0, 8192), + } +} + +// WriteTo writes a complete fragmented MP4 stream for a single track to w. +// rs must support Seek+Read (e.g. *[os.File]). +// For concurrent use with a shared file, use [Writer.WriteToFrom] with [io.ReaderAt] instead. +func (wr *Writer) WriteTo(w io.Writer, rs io.ReadSeeker, track *Track, startTime float64, endTime float64) error { + firstSample, dtsOffset, endTimeScaled := wr.resolveRange(track, startTime, endTime) + + if _, err := w.Write(track.InitSegment()); err != nil { + return err + } + + var seqNum uint32 = 1 + sample := firstSample + + for sample < len(track.Samples) { + if endTimeScaled > 0 { + pts := track.Samples[sample].DTS + int64(track.Samples[sample].PresentationOffset) + if pts >= endTimeScaled { + break + } + } + + var mdatSize int64 + var nextSample int + var trunVersion uint8 + wr.trunEntries, wr.ranges, mdatSize, nextSample, trunVersion = generateFragment(track, sample, endTimeScaled, wr.trunEntries, wr.ranges) + if len(wr.trunEntries) == 0 { + break + } + + baseMediaDecodeTime := uint32(track.Samples[sample].DTS - dtsOffset) + var err error + wr.moofBuf, err = writeMoof(w, seqNum, track.TrackID, baseMediaDecodeTime, wr.trunEntries, trunVersion, wr.moofBuf) + if err != nil { + return err + } + + binary.BigEndian.PutUint32(wr.mdatHdr[:4], uint32(8+mdatSize)) + copy(wr.mdatHdr[4:8], "mdat") + if _, err := w.Write(wr.mdatHdr[:]); err != nil { + return err + } + + for _, r := range wr.ranges { + if _, err := rs.Seek(r.Start, io.SeekStart); err != nil { + return err + } + remaining := r.End - r.Start + for remaining > 0 { + n := min(int64(len(wr.copyBuf)), remaining) + nr, err := rs.Read(wr.copyBuf[:n]) + if nr > 0 { + if _, werr := w.Write(wr.copyBuf[:nr]); werr != nil { + return werr + } + remaining -= int64(nr) + } + if err != nil { + if err == io.EOF && remaining == 0 { + break + } + return err + } + } + } + + seqNum++ + sample = nextSample + } + + return nil +} + +// WriteToFrom writes a complete fragmented MP4 stream using an [io.ReaderAt]. +// Unlike [Writer.WriteTo], this is safe to use with a single shared *[os.File] from multiple +// goroutines (each with their own Writer), because [io.ReaderAt.ReadAt] does not mutate file position. +func (wr *Writer) WriteToFrom(w io.Writer, ra io.ReaderAt, track *Track, startTime float64, endTime float64) error { + firstSample, dtsOffset, endTimeScaled := wr.resolveRange(track, startTime, endTime) + + if _, err := w.Write(track.InitSegment()); err != nil { + return err + } + + var seqNum uint32 = 1 + sample := firstSample + + for sample < len(track.Samples) { + if endTimeScaled > 0 { + pts := track.Samples[sample].DTS + int64(track.Samples[sample].PresentationOffset) + if pts >= endTimeScaled { + break + } + } + + var mdatSize int64 + var nextSample int + var trunVersion uint8 + wr.trunEntries, wr.ranges, mdatSize, nextSample, trunVersion = generateFragment(track, sample, endTimeScaled, wr.trunEntries, wr.ranges) + if len(wr.trunEntries) == 0 { + break + } + + baseMediaDecodeTime := uint32(track.Samples[sample].DTS - dtsOffset) + var err error + wr.moofBuf, err = writeMoof(w, seqNum, track.TrackID, baseMediaDecodeTime, wr.trunEntries, trunVersion, wr.moofBuf) + if err != nil { + return err + } + + binary.BigEndian.PutUint32(wr.mdatHdr[:4], uint32(8+mdatSize)) + copy(wr.mdatHdr[4:8], "mdat") + if _, err := w.Write(wr.mdatHdr[:]); err != nil { + return err + } + + for _, r := range wr.ranges { + off := r.Start + remaining := r.End - r.Start + for remaining > 0 { + n := min(int64(len(wr.copyBuf)), remaining) + nr, err := ra.ReadAt(wr.copyBuf[:n], off) + if nr > 0 { + if _, werr := w.Write(wr.copyBuf[:nr]); werr != nil { + return werr + } + off += int64(nr) + remaining -= int64(nr) + } + if err != nil { + if err == io.EOF && remaining == 0 { + break + } + return err + } + } + } + + seqNum++ + sample = nextSample + } + + return nil +} + +func (wr *Writer) resolveRange(track *Track, startTime float64, endTime float64) (firstSample int, dtsOffset int64, endTimeScaled int64) { + firstSample = track.FindSampleAfter(startTime) + + if endTime > 0 && firstSample < len(track.Samples) { + pts := track.Samples[firstSample].DTS + int64(track.Samples[firstSample].PresentationOffset) + endScaled := int64(endTime * float64(track.TimeScale)) + if pts >= endScaled { + firstSample = track.FindSampleBefore(startTime) + } + } + + dtsOffset = track.Samples[firstSample].DTS + + if endTime > 0 { + endTimeScaled = int64(endTime * float64(track.TimeScale)) + } + + return +} |
