droboticflow/internal/api/annotation_source_movie_clock.go

86 lines
2.5 KiB
Go

package api
import (
"encoding/binary"
"fmt"
"io"
"math"
"os"
)
// MP4 edit-list durations use the movie clock, not the video's track clock.
// Read only atom headers and mvhd: a large mdat is skipped without loading it.
func sourceMovieClockTick(path string) (float64, error) {
f, err := os.Open(path)
if err != nil {
return 0, err
}
defer f.Close()
info, err := f.Stat()
if err != nil {
return 0, err
}
var scan func(int64, int64, bool) (float64, error)
scan = func(start, end int64, inMovie bool) (float64, error) {
for offset, boxes := start, 0; offset+8 <= end && boxes < 4096; boxes++ {
var header [16]byte
if _, err := f.ReadAt(header[:8], offset); err != nil {
return 0, err
}
size, headerSize := uint64(binary.BigEndian.Uint32(header[:4])), int64(8)
if size == 1 {
if _, err := f.ReadAt(header[8:], offset+8); err != nil {
return 0, err
}
size, headerSize = binary.BigEndian.Uint64(header[8:]), 16
} else if size == 0 {
size = uint64(end - offset)
}
if size < uint64(headerSize) || size > uint64(end-offset) {
return 0, fmt.Errorf("invalid MP4 atom size")
}
kind := string(header[4:8])
if kind == "moov" && !inMovie {
return scan(offset+headerSize, offset+int64(size), true)
}
if kind == "mvhd" && inMovie {
var version [1]byte
if _, err := f.ReadAt(version[:], offset+headerSize); err != nil {
return 0, err
}
clockOffset := int64(12)
if version[0] == 1 {
clockOffset = 20
} else if version[0] != 0 {
return 0, fmt.Errorf("unsupported MP4 movie clock")
}
if headerSize+clockOffset+4 > int64(size) {
return 0, io.ErrUnexpectedEOF
}
var clock [4]byte
if _, err := f.ReadAt(clock[:], offset+headerSize+clockOffset); err != nil {
return 0, err
}
timescale := binary.BigEndian.Uint32(clock[:])
if timescale == 0 {
return 0, fmt.Errorf("invalid MP4 movie timescale")
}
return 1 / float64(timescale), nil
}
offset += int64(size)
}
return 0, fmt.Errorf("MP4 movie clock unavailable")
}
return scan(0, info.Size(), false)
}
func sourceClockEndTolerance(path string, trackTick, period float64) float64 {
tolerance := math.Max(0.0001, trackTick+1e-9)
if movieTick, err := sourceMovieClockTick(path); err == nil {
// Both conversions can round. Never turn the container exception into
// permission to lose a whole final frame; decoded cadence stays strict.
tolerance = math.Max(tolerance, math.Min(movieTick+trackTick+1e-9, period/2))
}
return tolerance
}