forked from longtao.wu/droboticflow
86 lines
2.5 KiB
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
|
|
}
|