aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--clip/clip.go490
-rw-r--r--clip/clip_test.go124
2 files changed, 614 insertions, 0 deletions
diff --git a/clip/clip.go b/clip/clip.go
new file mode 100644
index 0000000..288a3c8
--- /dev/null
+++ b/clip/clip.go
@@ -0,0 +1,490 @@
+// Package clip cuts a time range out of a progressive MP4 and writes it as a
+// new progressive MP4. Nothing is re-encoded: the coded samples inside the
+// range are copied byte for byte and a fresh moov describes them.
+package clip
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "math"
+
+ "github.com/tetsuo/mp4"
+ "github.com/tetsuo/mp4/track"
+)
+
+// Result describes the clip that was written. Start and Duration are what the
+// clip presents, which is what was asked for. MediaStart is where its media
+// really begins: the cut is moved back to a keyframe, and the frames between
+// that keyframe and the requested start are carried so the first presented
+// frame has something to decode from, but an edit list keeps them off the
+// timeline.
+type Result struct {
+ Start float64
+ End float64
+ Duration float64
+ MediaStart float64
+ Size int64
+}
+
+// maxClipSamples bounds the sample tables one clip may build. The tables are
+// held in memory while the file is written, and a request for a range that
+// large is a mistake rather than a clip.
+const maxClipSamples = 2 << 20
+
+// undeterminedLanguage is the ISO 639-2 code "und" packed as mdhd stores it,
+// five bits per letter.
+const undeterminedLanguage = 0x55C4
+
+var errNoTracks = errors.New("mp4: no playable track in the requested range")
+
+// Cut writes the part of src between start and end, in seconds, to dst. The
+// clip begins at the last keyframe at or before start, because a clip starting
+// between keyframes has no first frame to decode from. Metadata precedes the
+// media in the output, so a player can start it without reading to the end.
+func Cut(dst io.Writer, src io.ReaderAt, size int64, start, end float64) (Result, error) {
+ if start < 0 || !(end > start) {
+ return Result{}, errors.New("mp4: clip range must start at or after zero and end after it")
+ }
+ moovBuf, err := readMoov(src, size)
+ if err != nil {
+ return Result{}, err
+ }
+ tracks, movieTimescale, _, err := track.ParseTracks(moovBuf)
+ if err != nil {
+ return Result{}, err
+ }
+ if movieTimescale == 0 {
+ movieTimescale = 1000
+ }
+
+ // The video track decides where the clip can begin; every other track is
+ // then cut at the same instant so the result stays in sync.
+ video, syncIndex := keyframeAtOrBefore(tracks, start)
+ base := start
+ if video != nil {
+ base = float64(video.Samples[syncIndex].DTS) / float64(video.TimeScale)
+ }
+
+ var out []*clipTrack
+ samples := 0
+ for _, t := range tracks {
+ if len(t.Samples) == 0 || t.TimeScale == 0 {
+ continue
+ }
+ first, last := selectRange(t, base, end)
+ if t == video {
+ first = syncIndex
+ }
+ if first < 0 || last < first {
+ continue
+ }
+ ct := newClipTrack(t, t.Samples[first:last+1], start)
+ samples += len(ct.samples)
+ if samples > maxClipSamples {
+ return Result{}, fmt.Errorf("mp4: clip covers more than %d samples", maxClipSamples)
+ }
+ out = append(out, ct)
+ }
+ if len(out) == 0 {
+ return Result{}, errNoTracks
+ }
+
+ order := interleave(out)
+ payload := int64(0)
+ for _, ct := range out {
+ for i := range ct.samples {
+ payload += int64(ct.samples[i].Size())
+ }
+ }
+
+ movieDuration := uint64(0)
+ for _, ct := range out {
+ if d := ct.movieDuration(movieTimescale); d > movieDuration {
+ movieDuration = d
+ }
+ }
+
+ // The header is built twice. Chunk offsets are absolute file positions, so
+ // the first pass measures the header with placeholder offsets and the
+ // second fills in the real ones. Entry counts do not change between the
+ // two, so neither does the length.
+ ftyp := buildFtyp()
+ buf := make([]byte, moovBound(out))
+ assignOffsets(out, order, 0)
+ moov, err := buildMoov(buf, out, movieTimescale, movieDuration)
+ if err != nil {
+ return Result{}, err
+ }
+ mediaStart := int64(len(ftyp)) + int64(len(moov)) + 8
+ if mediaStart+payload > math.MaxUint32 {
+ return Result{}, errors.New("mp4: clip is too large for 32-bit chunk offsets")
+ }
+ assignOffsets(out, order, mediaStart)
+ moov, err = buildMoov(buf, out, movieTimescale, movieDuration)
+ if err != nil {
+ return Result{}, err
+ }
+ if int64(len(ftyp))+int64(len(moov))+8 != mediaStart {
+ return Result{}, errors.New("mp4: header length changed after chunk offsets were assigned")
+ }
+
+ if _, err := dst.Write(ftyp); err != nil {
+ return Result{}, err
+ }
+ if _, err := dst.Write(moov); err != nil {
+ return Result{}, err
+ }
+ var header [8]byte
+ be32(header[0:4], uint32(payload+8))
+ copy(header[4:8], mp4.TypeMdat[:])
+ if _, err := dst.Write(header[:]); err != nil {
+ return Result{}, err
+ }
+ copyBuf := make([]byte, 512<<10)
+ for _, ref := range order {
+ s := &out[ref.track].samples[ref.sample]
+ section := io.NewSectionReader(src, s.Offset, int64(s.Size()))
+ if _, err := io.CopyBuffer(dst, section, copyBuf); err != nil {
+ return Result{}, err
+ }
+ }
+
+ duration := float64(movieDuration) / float64(movieTimescale)
+ return Result{
+ Start: start,
+ End: start + duration,
+ Duration: duration,
+ MediaStart: base,
+ Size: mediaStart + payload,
+ }, nil
+}
+
+// clipTrack is one source track reduced to the samples inside the clip, with
+// the tables the new file needs.
+type clipTrack struct {
+ src *track.Track
+ samples []track.Sample
+ offsets []uint32 // new file position of each sample
+ sizes []uint32
+ stts []mp4.SttsEntry
+ ctts []mp4.CttsEntry
+ sync []uint32 // 1-based indices of the keyframes
+ duration uint64 // media timescale
+ presented uint64 // media timescale, the part the edit list shows
+ mediaAt int64 // media time the presentation starts at
+}
+
+// newClipTrack reduces one track to the samples of the clip. want is the time
+// the clip is meant to begin at; the samples before it are kept because the
+// first presented frame is decoded from them, and the edit list built from
+// mediaAt keeps them off the timeline.
+func newClipTrack(t *track.Track, samples []track.Sample, want float64) *clipTrack {
+ ct := &clipTrack{src: t, samples: samples}
+ ct.offsets = make([]uint32, len(samples))
+ ct.sizes = make([]uint32, len(samples))
+
+ // Composition offsets are written unsigned, so a track that carries
+ // negative ones is shifted until they are not. The shift moves every
+ // presentation time by the same amount and the edit list takes it back.
+ shift := int32(0)
+ for i := range samples {
+ if off := samples[i].PresentationOffset; off < 0 && -off > shift {
+ shift = -off
+ }
+ }
+
+ dts := int64(0)
+ firstPTS := int64(math.MaxInt64)
+ anyOffset := false
+ for i := range samples {
+ s := &samples[i]
+ ct.sizes[i] = s.Size()
+ if s.IsSync() {
+ ct.sync = append(ct.sync, uint32(i+1))
+ }
+ if n := len(ct.stts); n > 0 && ct.stts[n-1].Duration == s.Duration {
+ ct.stts[n-1].Count++
+ } else {
+ ct.stts = append(ct.stts, mp4.SttsEntry{Count: 1, Duration: s.Duration})
+ }
+ offset := s.PresentationOffset + shift
+ if offset != 0 {
+ anyOffset = true
+ }
+ if n := len(ct.ctts); n > 0 && ct.ctts[n-1].Offset == offset {
+ ct.ctts[n-1].Count++
+ } else {
+ ct.ctts = append(ct.ctts, mp4.CttsEntry{Count: 1, Offset: offset})
+ }
+ if pts := dts + int64(offset); pts < firstPTS {
+ firstPTS = pts
+ }
+ dts += int64(s.Duration)
+ ct.duration += uint64(s.Duration)
+ }
+ if !anyOffset {
+ ct.ctts = nil
+ }
+ if firstPTS == math.MaxInt64 {
+ firstPTS = 0
+ }
+ // The lead-in is whatever separates this track's first sample from the
+ // time the clip is meant to begin at, measured on this track's own clock
+ // rather than on the video's, so both tracks present from the same moment
+ // however their samples happen to be aligned. Rebasing the samples onto a
+ // timeline that starts at zero moves every presentation time by the same
+ // amount, so the lead-in is already the time to present from; it is only
+ // held back to the first frame, for a track whose earliest presentation
+ // comes after its earliest decode.
+ skip := int64(math.Round(want*float64(t.TimeScale))) - samples[0].DTS
+ ct.mediaAt = min(max(skip, firstPTS), int64(ct.duration))
+ ct.presented = ct.duration - uint64(max(ct.mediaAt, 0))
+ return ct
+}
+
+// movieDuration returns the length this track puts on the movie timeline,
+// which is the presented part rather than everything the file carries.
+func (ct *clipTrack) movieDuration(movieTimescale uint32) uint64 {
+ return uint64(float64(ct.presented) / float64(ct.src.TimeScale) * float64(movieTimescale))
+}
+
+// keyframeAtOrBefore returns the video track and the index of the last
+// keyframe presented at or before at. The first keyframe is used when the
+// requested time precedes all of them.
+func keyframeAtOrBefore(tracks []*track.Track, at float64) (*track.Track, int) {
+ for _, t := range tracks {
+ if t.Kind != track.TrackVideo || len(t.Samples) == 0 || t.TimeScale == 0 {
+ continue
+ }
+ scale := float64(t.TimeScale)
+ best, firstSync := -1, -1
+ for i := range t.Samples {
+ s := &t.Samples[i]
+ if !s.IsSync() {
+ continue
+ }
+ if firstSync < 0 {
+ firstSync = i
+ }
+ // Decode order is not presentation order once there are B
+ // frames, so every keyframe is considered rather than stopping
+ // at the first one past the requested time.
+ if float64(s.PTS())/scale <= at {
+ if best < 0 || s.PTS() > t.Samples[best].PTS() {
+ best = i
+ }
+ }
+ }
+ if best < 0 {
+ best = firstSync
+ }
+ if best < 0 {
+ best = 0
+ }
+ return t, best
+ }
+ return nil, 0
+}
+
+// selectRange returns the first and last sample of t that overlap the half
+// open interval, in decode order.
+func selectRange(t *track.Track, start, end float64) (int, int) {
+ scale := float64(t.TimeScale)
+ first, last := -1, -1
+ for i := range t.Samples {
+ s := &t.Samples[i]
+ from := float64(s.DTS) / scale
+ to := from + float64(s.Duration)/scale
+ if to <= start || from >= end {
+ continue
+ }
+ if first < 0 {
+ first = i
+ }
+ last = i
+ }
+ return first, last
+}
+
+// sampleRef points at one sample of one clip track.
+type sampleRef struct{ track, sample int }
+
+// interleave orders every sample of every track by decode time, so a player
+// reading the file forward always has the next sample of each track nearby.
+func interleave(tracks []*clipTrack) []sampleRef {
+ total := 0
+ for _, ct := range tracks {
+ total += len(ct.samples)
+ }
+ next := make([]int, len(tracks))
+ order := make([]sampleRef, 0, total)
+ for len(order) < total {
+ best, bestTime := -1, math.Inf(1)
+ for i, ct := range tracks {
+ if next[i] >= len(ct.samples) {
+ continue
+ }
+ at := float64(ct.samples[next[i]].DTS) / float64(ct.src.TimeScale)
+ if at < bestTime {
+ best, bestTime = i, at
+ }
+ }
+ if best < 0 {
+ break
+ }
+ order = append(order, sampleRef{best, next[best]})
+ next[best]++
+ }
+ return order
+}
+
+// assignOffsets lays the samples out in the media box in interleaved order,
+// starting at mediaStart bytes into the file.
+func assignOffsets(tracks []*clipTrack, order []sampleRef, mediaStart int64) {
+ at := mediaStart
+ for _, ref := range order {
+ ct := tracks[ref.track]
+ ct.offsets[ref.sample] = uint32(at)
+ at += int64(ct.samples[ref.sample].Size())
+ }
+}
+
+// moovBound is an upper bound on the header this clip needs. The sample tables
+// dominate it: at worst every sample contributes its own entry to the decode
+// time, composition offset, size, chunk offset and keyframe tables.
+func moovBound(tracks []*clipTrack) int {
+ size := 4096
+ for _, ct := range tracks {
+ size += 4096 + len(ct.src.StsdRaw()) + len(ct.src.HdlrRaw()) + len(ct.src.DinfRaw())
+ size += 28 * len(ct.samples)
+ }
+ return size
+}
+
+func buildFtyp() []byte {
+ buf := make([]byte, 64)
+ w := mp4.NewWriter(buf)
+ w.WriteFtyp([4]byte{'i', 's', 'o', 'm'}, 512, [][4]byte{
+ {'i', 's', 'o', 'm'}, {'i', 's', 'o', '2'}, {'a', 'v', 'c', '1'}, {'m', 'p', '4', '1'},
+ })
+ return w.Bytes()
+}
+
+func buildMoov(buf []byte, tracks []*clipTrack, movieTimescale uint32, movieDuration uint64) ([]byte, error) {
+ nextTrackID := uint32(1)
+ for _, ct := range tracks {
+ if ct.src.ID >= nextTrackID {
+ nextTrackID = ct.src.ID + 1
+ }
+ }
+ w := mp4.NewWriter(buf)
+ w.StartBox(mp4.TypeMoov)
+ w.WriteMvhd(movieTimescale, movieDuration, nextTrackID)
+ for _, ct := range tracks {
+ writeTrak(&w, ct, movieTimescale)
+ }
+ w.EndBox()
+ if err := w.Err(); err != nil {
+ return nil, err
+ }
+ return w.Bytes(), nil
+}
+
+func writeTrak(w *mp4.Writer, ct *clipTrack, movieTimescale uint32) {
+ t := ct.src
+ trackDuration := ct.movieDuration(movieTimescale)
+
+ w.StartBox(mp4.TypeTrak)
+ var width, height uint32
+ if t.Kind == track.TrackVideo {
+ width, height = uint32(t.Width)<<16, uint32(t.Height)<<16
+ }
+ // The enabled, in-movie and in-preview flags are carried over so a track
+ // the source had disabled stays that way.
+ w.WriteTkhd(t.TkhdFlags(), t.ID, trackDuration, width, height)
+ if ct.mediaAt > 0 {
+ // The clip begins at a keyframe, which is usually earlier than what
+ // was asked for, and composition offsets can delay the first frame
+ // past zero as well. This maps the movie's zero onto the frame the
+ // clip is meant to open on; the earlier frames stay in the file for
+ // the decoder and stay off the timeline.
+ w.StartBox(mp4.TypeEdts)
+ w.WriteElst([]mp4.ElstEntry{{
+ SegmentDuration: trackDuration, MediaTime: ct.mediaAt, MediaRateInt: 1,
+ }})
+ w.EndBox()
+ }
+
+ w.StartBox(mp4.TypeMdia)
+ w.WriteMdhd(t.TimeScale, ct.duration, undeterminedLanguage)
+ if raw := t.HdlrRaw(); len(raw) > 0 {
+ w.Write(raw)
+ } else if t.Kind == track.TrackVideo {
+ w.WriteHdlr([4]byte{'v', 'i', 'd', 'e'}, "VideoHandler")
+ } else {
+ w.WriteHdlr([4]byte{'s', 'o', 'u', 'n'}, "SoundHandler")
+ }
+
+ w.StartBox(mp4.TypeMinf)
+ if t.Kind == track.TrackVideo {
+ w.WriteVmhd()
+ } else {
+ w.WriteSmhd()
+ }
+ if raw := t.DinfRaw(); len(raw) > 0 {
+ w.Write(raw)
+ } else {
+ w.StartBox(mp4.TypeDinf)
+ w.WriteDref()
+ w.EndBox()
+ }
+
+ descIdx := t.SampleDescIdx
+ if descIdx == 0 {
+ descIdx = 1
+ }
+ w.StartBox(mp4.TypeStbl)
+ w.Write(t.StsdRaw())
+ w.WriteStts(ct.stts)
+ if len(ct.ctts) > 0 {
+ w.WriteCtts(ct.ctts)
+ }
+ // One sample per chunk keeps the mapping trivial and lets the samples be
+ // interleaved in whatever order playback wants to read them.
+ w.WriteStsc([]mp4.StscEntry{{FirstChunk: 1, SamplesPerChunk: 1, SampleDescriptionId: descIdx}})
+ w.WriteStsz(0, ct.sizes)
+ w.WriteStco(ct.offsets)
+ if t.Kind == track.TrackVideo && len(ct.sync) > 0 {
+ w.WriteStss(ct.sync)
+ }
+ w.EndBox() // stbl
+ w.EndBox() // minf
+ w.EndBox() // mdia
+ w.EndBox() // trak
+}
+
+// readMoov returns the complete moov box, which holds every sample table the
+// cut needs.
+func readMoov(src io.ReaderAt, size int64) ([]byte, error) {
+ sc := mp4.NewScanner(io.NewSectionReader(src, 0, size))
+ for sc.Next() {
+ entry := sc.Entry()
+ if entry.Type != mp4.TypeMoov {
+ continue
+ }
+ buf := make([]byte, entry.Size)
+ if err := sc.ReadBox(buf); err != nil {
+ return nil, err
+ }
+ return buf, nil
+ }
+ if err := sc.Err(); err != nil {
+ return nil, err
+ }
+ return nil, errors.New("mp4: file has no moov box")
+}
+
+func be32(dst []byte, v uint32) {
+ dst[0], dst[1], dst[2], dst[3] = byte(v>>24), byte(v>>16), byte(v>>8), byte(v)
+}
diff --git a/clip/clip_test.go b/clip/clip_test.go
new file mode 100644
index 0000000..a688f69
--- /dev/null
+++ b/clip/clip_test.go
@@ -0,0 +1,124 @@
+package clip_test
+
+import (
+ "bytes"
+ "os"
+ "testing"
+
+ "github.com/tetsuo/mp4"
+ "github.com/tetsuo/mp4/clip"
+ "github.com/tetsuo/mp4/track"
+)
+
+// sampleMP4 is a short progressive recording. It is not checked in; the test
+// is skipped when it is absent.
+const sampleMP4 = "../test-data/h264-aac-10s.mp4"
+
+func TestCut(t *testing.T) {
+ src, err := os.ReadFile(sampleMP4)
+ if err != nil {
+ t.Skipf("fixture unavailable: %v", err)
+ }
+ reader := bytes.NewReader(src)
+
+ const from, to = 3.0, 7.0
+ var out bytes.Buffer
+ result, err := clip.Cut(&out, reader, int64(len(src)), from, to)
+ if err != nil {
+ t.Fatalf("Cut: %v", err)
+ }
+ // What the clip presents is what was asked for, however far back the
+ // keyframe it decodes from happens to be.
+ if result.Start != from {
+ t.Errorf("clip presents from %.3fs, asked for %.3fs", result.Start, from)
+ }
+ if want := to - from; result.Duration < want-0.1 || result.Duration > want+0.1 {
+ t.Errorf("clip presents %.3fs, asked for %.3fs", result.Duration, want)
+ }
+ if result.MediaStart > from {
+ t.Errorf("clip's media starts at %.3fs, after the requested %.3fs", result.MediaStart, from)
+ }
+ if got := int64(out.Len()); got != result.Size {
+ t.Errorf("wrote %d bytes, reported %d", got, result.Size)
+ }
+
+ // The result must be readable by the same parser, which is what a player
+ // does with it.
+ clipped := out.Bytes()
+ moov := findBox(t, clipped, mp4.TypeMoov)
+ tracks, timescale, _, err := track.ParseTracks(moov)
+ if err != nil {
+ t.Fatalf("reparse: %v", err)
+ }
+ if timescale == 0 {
+ t.Fatal("clip declares no movie timescale")
+ }
+ if len(tracks) == 0 {
+ t.Fatal("clip has no tracks")
+ }
+
+ sawVideo := false
+ for _, tr := range tracks {
+ if len(tr.Samples) == 0 {
+ t.Errorf("track %d carries no samples", tr.ID)
+ continue
+ }
+ if tr.Kind == track.TrackVideo {
+ sawVideo = true
+ if !tr.Samples[0].IsSync() {
+ t.Error("the first video sample is not a keyframe, so the clip cannot be decoded from its start")
+ }
+ }
+ // Every sample must point inside the file it was written into.
+ for i := range tr.Samples {
+ s := &tr.Samples[i]
+ if s.Offset < 0 || s.Offset+int64(s.Size()) > int64(len(clipped)) {
+ t.Fatalf("track %d sample %d points outside the clip", tr.ID, i)
+ }
+ }
+ // The media carried runs from the keyframe, so it covers the lead-in
+ // as well as everything presented.
+ length := float64(0)
+ for i := range tr.Samples {
+ length += float64(tr.Samples[i].Duration) / float64(tr.TimeScale)
+ }
+ if want := result.End - result.MediaStart; length < want-0.5 || length > want+0.5 {
+ t.Errorf("track %d carries %.3fs, expected %.3fs of media", tr.ID, length, want)
+ }
+ // An edit list holds the lead-in off the timeline, so playback opens
+ // on the frame that was asked for rather than on the keyframe.
+ lead := result.Start - result.MediaStart
+ mediaTime, hasEdit := tr.EditMediaTime()
+ if lead > 0.05 && !hasEdit {
+ t.Errorf("track %d skips %.3fs of lead-in but carries no edit list", tr.ID, lead)
+ }
+ if hasEdit {
+ at := float64(mediaTime) / float64(tr.TimeScale)
+ if at < lead-0.05 || at > lead+0.05 {
+ t.Errorf("track %d presents from %.3fs into its media, expected %.3fs", tr.ID, at, lead)
+ }
+ }
+ }
+ if !sawVideo {
+ t.Error("clip has no video track")
+ }
+}
+
+func TestCutRejectsEmptyRange(t *testing.T) {
+ if _, err := clip.Cut(&bytes.Buffer{}, bytes.NewReader(nil), 0, 5, 5); err == nil {
+ t.Fatal("an end at the start was accepted")
+ }
+}
+
+func findBox(t *testing.T, data []byte, want mp4.BoxType) []byte {
+ t.Helper()
+ sc := mp4.NewScanner(bytes.NewReader(data))
+ for sc.Next() {
+ entry := sc.Entry()
+ if entry.Type == want {
+ return data[entry.Offset : entry.Offset+entry.Size]
+ }
+ }
+ t.Fatalf("clip has no %s box", want)
+ return nil
+}