Add 'mp4/' from commit 'bd71ca9823ec91410ccdf4d2ed783ba44b8a14d7'
git-subtree-dir: mp4 git-subtree-mainline: 8bb2ec1a5cdf4acae1ca4dfa09dd876b850bea24 git-subtree-split: bd71ca9823ec91410ccdf4d2ed783ba44b8a14d7
This commit is contained in:
nareix
commit
92528599ba
44
mp4/atom/atom.go
Normal file
44
mp4/atom/atom.go
Normal file
@ -0,0 +1,44 @@
|
||||
package atom
|
||||
|
||||
import (
|
||||
"io"
|
||||
)
|
||||
|
||||
func WalkFile(w Walker, r io.Reader) (err error) {
|
||||
var moov *Movie
|
||||
var moof *MovieFrag
|
||||
|
||||
for {
|
||||
var lr *io.LimitedReader
|
||||
var cc4 string
|
||||
if lr, cc4, err = ReadAtomHeader(lr, ""); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
switch cc4 {
|
||||
case "moov":
|
||||
if moov, err = ReadMovie(lr); err != nil {
|
||||
return
|
||||
}
|
||||
WalkMovie(w, moov)
|
||||
|
||||
case "moof":
|
||||
if moof, err = ReadMovieFrag(lr); err != nil {
|
||||
return
|
||||
}
|
||||
WalkMovieFrag(w, moof)
|
||||
|
||||
case "mdat":
|
||||
w.StartStruct("MovieData")
|
||||
w.Name("Length")
|
||||
w.Int64(lr.N)
|
||||
w.EndStruct()
|
||||
}
|
||||
|
||||
if _, err = ReadDummy(r, int(lr.N)); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
95
mp4/atom/dumper.go
Normal file
95
mp4/atom/dumper.go
Normal file
@ -0,0 +1,95 @@
|
||||
package atom
|
||||
|
||||
import (
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"io"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type Walker interface {
|
||||
FilterArrayItem(string, string, int, int) bool
|
||||
ArrayLeft(int, int)
|
||||
StartStruct(string)
|
||||
EndStruct()
|
||||
Name(string)
|
||||
Int(int)
|
||||
Int64(int64)
|
||||
HexInt(int)
|
||||
Fixed(Fixed)
|
||||
String(string)
|
||||
Bytes([]byte)
|
||||
TimeStamp(TimeStamp)
|
||||
Println(msg ...interface{})
|
||||
}
|
||||
|
||||
type Dumper struct {
|
||||
W io.Writer
|
||||
depth int
|
||||
name string
|
||||
arrlen int
|
||||
arridx int
|
||||
}
|
||||
|
||||
func (self Dumper) tab() string {
|
||||
return strings.Repeat(" ", self.depth*2)
|
||||
}
|
||||
|
||||
func (self Dumper) Println(msg ...interface{}) {
|
||||
fmt.Fprintln(self.W, self.tab()+fmt.Sprint(msg...))
|
||||
}
|
||||
|
||||
func (self *Dumper) ArrayLeft(i int, n int) {
|
||||
self.Println(fmt.Sprintf("... total %d elements", n))
|
||||
}
|
||||
|
||||
func (self *Dumper) FilterArrayItem(name string, field string, i int, n int) bool {
|
||||
if n > 20 && i > 20 {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func (self *Dumper) EndArray() {
|
||||
}
|
||||
|
||||
func (self *Dumper) StartStruct(name string) {
|
||||
self.depth++
|
||||
self.Println(fmt.Sprintf("[%s]", name))
|
||||
}
|
||||
|
||||
func (self *Dumper) EndStruct() {
|
||||
self.depth--
|
||||
}
|
||||
|
||||
func (self *Dumper) Name(name string) {
|
||||
self.name = name
|
||||
}
|
||||
|
||||
func (self Dumper) Int(val int) {
|
||||
self.Int64(int64(val))
|
||||
}
|
||||
|
||||
func (self Dumper) Int64(val int64) {
|
||||
self.Println(fmt.Sprintf("%s: %d", self.name, val))
|
||||
}
|
||||
|
||||
func (self Dumper) HexInt(val int) {
|
||||
self.Println(fmt.Sprintf("%s: %x", self.name, val))
|
||||
}
|
||||
|
||||
func (self Dumper) String(val string) {
|
||||
self.Println(fmt.Sprintf("%s: %s", self.name, val))
|
||||
}
|
||||
|
||||
func (self Dumper) Fixed(val Fixed) {
|
||||
self.Println(fmt.Sprintf("%s: %d", self.name, FixedToInt(val)))
|
||||
}
|
||||
|
||||
func (self Dumper) Bytes(val []byte) {
|
||||
self.Println(fmt.Sprintf("%s: %s", self.name, hex.EncodeToString(val)))
|
||||
}
|
||||
|
||||
func (self Dumper) TimeStamp(val TimeStamp) {
|
||||
self.Println(fmt.Sprintf("%s: %d", self.name, int(val)))
|
||||
}
|
||||
274
mp4/atom/frag.go
Normal file
274
mp4/atom/frag.go
Normal file
@ -0,0 +1,274 @@
|
||||
package atom
|
||||
|
||||
import (
|
||||
_ "bytes"
|
||||
"fmt"
|
||||
"github.com/nareix/bits"
|
||||
"io"
|
||||
)
|
||||
|
||||
const (
|
||||
TFHD_BASE_DATA_OFFSET = 0x01
|
||||
TFHD_STSD_ID = 0x02
|
||||
TFHD_DEFAULT_DURATION = 0x08
|
||||
TFHD_DEFAULT_SIZE = 0x10
|
||||
TFHD_DEFAULT_FLAGS = 0x20
|
||||
TFHD_DURATION_IS_EMPTY = 0x010000
|
||||
TFHD_DEFAULT_BASE_IS_MOOF = 0x020000
|
||||
)
|
||||
|
||||
type TrackFragHeader struct {
|
||||
Version int
|
||||
Flags int
|
||||
Id int
|
||||
DefaultSize int
|
||||
DefaultDuration int
|
||||
DefaultFlags int
|
||||
BaseDataOffset int64
|
||||
StsdId int
|
||||
}
|
||||
|
||||
func WalkTrackFragHeader(w Walker, self *TrackFragHeader) {
|
||||
w.StartStruct("TrackFragHeader")
|
||||
w.Name("Flags")
|
||||
w.HexInt(self.Flags)
|
||||
w.Name("Id")
|
||||
w.Int(self.Id)
|
||||
w.Name("DefaultDuration")
|
||||
w.Int(self.DefaultDuration)
|
||||
w.Name("DefaultSize")
|
||||
w.Int(self.DefaultSize)
|
||||
w.Name("DefaultFlags")
|
||||
w.HexInt(self.DefaultFlags)
|
||||
w.EndStruct()
|
||||
}
|
||||
|
||||
func WriteTrackFragHeader(w io.WriteSeeker, self *TrackFragHeader) (err error) {
|
||||
panic("unimplmented")
|
||||
return
|
||||
}
|
||||
|
||||
func ReadTrackFragHeader(r *io.LimitedReader) (res *TrackFragHeader, err error) {
|
||||
self := &TrackFragHeader{}
|
||||
|
||||
if self.Version, err = ReadInt(r, 1); err != nil {
|
||||
return
|
||||
}
|
||||
if self.Flags, err = ReadInt(r, 3); err != nil {
|
||||
return
|
||||
}
|
||||
if self.Id, err = ReadInt(r, 4); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
if self.Flags&TFHD_BASE_DATA_OFFSET != 0 {
|
||||
if self.BaseDataOffset, err = bits.ReadInt64BE(r, 64); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if self.Flags&TFHD_STSD_ID != 0 {
|
||||
if self.StsdId, err = ReadInt(r, 4); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if self.Flags&TFHD_DEFAULT_DURATION != 0 {
|
||||
if self.DefaultDuration, err = ReadInt(r, 4); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if self.Flags&TFHD_DEFAULT_SIZE != 0 {
|
||||
if self.DefaultSize, err = ReadInt(r, 4); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if self.Flags&TFHD_DEFAULT_FLAGS != 0 {
|
||||
if self.DefaultFlags, err = ReadInt(r, 4); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
res = self
|
||||
return
|
||||
}
|
||||
|
||||
const (
|
||||
TRUN_DATA_OFFSET = 0x01
|
||||
TRUN_FIRST_SAMPLE_FLAGS = 0x04
|
||||
TRUN_SAMPLE_DURATION = 0x100
|
||||
TRUN_SAMPLE_SIZE = 0x200
|
||||
TRUN_SAMPLE_FLAGS = 0x400
|
||||
TRUN_SAMPLE_CTS = 0x800
|
||||
)
|
||||
|
||||
type TrackFragRunEntry struct {
|
||||
Duration int
|
||||
Size int
|
||||
Flags int
|
||||
Cts int
|
||||
}
|
||||
|
||||
type TrackFragRun struct {
|
||||
Version int
|
||||
Flags int
|
||||
FirstSampleFlags int
|
||||
DataOffset int
|
||||
Entries []TrackFragRunEntry
|
||||
}
|
||||
|
||||
func WalkTrackFragRun(w Walker, self *TrackFragRun) {
|
||||
w.StartStruct("TrackFragRun")
|
||||
w.Name("Flags")
|
||||
w.HexInt(self.Flags)
|
||||
w.Name("FirstSampleFlags")
|
||||
w.HexInt(self.FirstSampleFlags)
|
||||
w.Name("DataOffset")
|
||||
w.Int(self.DataOffset)
|
||||
w.Name("EntriesCount")
|
||||
w.Int(len(self.Entries))
|
||||
for i := 0; i < 10 && i < len(self.Entries); i++ {
|
||||
entry := self.Entries[i]
|
||||
w.Println(fmt.Sprintf("Entry[%d] Flags=%x Duration=%d Size=%d Cts=%d",
|
||||
i, entry.Flags, entry.Duration, entry.Size, entry.Cts))
|
||||
}
|
||||
w.EndStruct()
|
||||
}
|
||||
|
||||
func WriteTrackFragRun(w io.WriteSeeker, self *TrackFragRun) (err error) {
|
||||
panic("unimplmented")
|
||||
return
|
||||
}
|
||||
|
||||
func ReadTrackFragRun(r *io.LimitedReader) (res *TrackFragRun, err error) {
|
||||
self := &TrackFragRun{}
|
||||
|
||||
if self.Version, err = ReadInt(r, 1); err != nil {
|
||||
return
|
||||
}
|
||||
if self.Flags, err = ReadInt(r, 3); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
var count int
|
||||
if count, err = ReadInt(r, 4); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
if self.Flags&TRUN_DATA_OFFSET != 0 {
|
||||
if self.DataOffset, err = ReadInt(r, 4); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
if self.Flags&TRUN_FIRST_SAMPLE_FLAGS != 0 {
|
||||
if self.FirstSampleFlags, err = ReadInt(r, 4); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
for i := 0; i < count; i++ {
|
||||
var flags int
|
||||
|
||||
if i > 0 {
|
||||
flags = self.Flags
|
||||
} else {
|
||||
flags = self.FirstSampleFlags
|
||||
}
|
||||
|
||||
entry := TrackFragRunEntry{}
|
||||
if flags&TRUN_SAMPLE_DURATION != 0 {
|
||||
if entry.Duration, err = ReadInt(r, 4); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
if flags&TRUN_SAMPLE_SIZE != 0 {
|
||||
if entry.Size, err = ReadInt(r, 4); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
if flags&TRUN_SAMPLE_FLAGS != 0 {
|
||||
if entry.Flags, err = ReadInt(r, 4); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
if flags&TRUN_SAMPLE_CTS != 0 {
|
||||
if entry.Cts, err = ReadInt(r, 4); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
self.Entries = append(self.Entries, entry)
|
||||
}
|
||||
|
||||
res = self
|
||||
return
|
||||
}
|
||||
|
||||
type TrackFragDecodeTime struct {
|
||||
Version int
|
||||
Flags int
|
||||
Time int64
|
||||
}
|
||||
|
||||
func ReadTrackFragDecodeTime(r *io.LimitedReader) (res *TrackFragDecodeTime, err error) {
|
||||
|
||||
self := &TrackFragDecodeTime{}
|
||||
if self.Version, err = ReadInt(r, 1); err != nil {
|
||||
return
|
||||
}
|
||||
if self.Flags, err = ReadInt(r, 3); err != nil {
|
||||
return
|
||||
}
|
||||
if self.Version != 0 {
|
||||
if self.Time, err = bits.ReadInt64BE(r, 64); err != nil {
|
||||
return
|
||||
}
|
||||
} else {
|
||||
if self.Time, err = bits.ReadInt64BE(r, 32); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
res = self
|
||||
return
|
||||
}
|
||||
|
||||
func WriteTrackFragDecodeTime(w io.WriteSeeker, self *TrackFragDecodeTime) (err error) {
|
||||
var aw *Writer
|
||||
if aw, err = WriteAtomHeader(w, "tfdt"); err != nil {
|
||||
return
|
||||
}
|
||||
w = aw
|
||||
if err = WriteInt(w, self.Version, 1); err != nil {
|
||||
return
|
||||
}
|
||||
if err = WriteInt(w, self.Flags, 3); err != nil {
|
||||
return
|
||||
}
|
||||
if self.Version != 0 {
|
||||
if err = bits.WriteInt64BE(w, self.Time, 64); err != nil {
|
||||
return
|
||||
}
|
||||
} else {
|
||||
if err = bits.WriteInt64BE(w, self.Time, 32); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
if err = aw.Close(); err != nil {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func WalkTrackFragDecodeTime(w Walker, self *TrackFragDecodeTime) {
|
||||
w.StartStruct("TrackFragDecodeTime")
|
||||
w.Name("Version")
|
||||
w.Int(self.Version)
|
||||
w.Name("Flags")
|
||||
w.Int(self.Flags)
|
||||
w.Name("Time")
|
||||
w.Int64(self.Time)
|
||||
w.EndStruct()
|
||||
return
|
||||
}
|
||||
875
mp4/atom/genStruct.js
Normal file
875
mp4/atom/genStruct.js
Normal file
@ -0,0 +1,875 @@
|
||||
|
||||
var uc = x => x && x.substr(0,1).toUpperCase()+x.slice(1);
|
||||
Array.prototype.nonull = function () {
|
||||
return this.filter(x => x);
|
||||
};
|
||||
|
||||
var atoms = {
|
||||
movie: {
|
||||
cc4: 'moov',
|
||||
fields: [
|
||||
['$atoms', [
|
||||
['header', '*movieHeader'],
|
||||
['iods', '*iods'],
|
||||
['tracks', '[]*track'],
|
||||
['movieExtend', '*movieExtend'],
|
||||
]],
|
||||
],
|
||||
},
|
||||
|
||||
iods: {
|
||||
cc4: 'iods',
|
||||
fields: [
|
||||
['data', '[]byte'],
|
||||
],
|
||||
},
|
||||
|
||||
movieHeader: {
|
||||
cc4: 'mvhd',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
['createTime', 'TimeStamp32'],
|
||||
['modifyTime', 'TimeStamp32'],
|
||||
['timeScale', 'int32'],
|
||||
['duration', 'int32'],
|
||||
['preferredRate', 'Fixed32'],
|
||||
['preferredVolume', 'Fixed16'],
|
||||
['_', '[10]byte'],
|
||||
['matrix', '[9]int32'],
|
||||
['previewTime', 'TimeStamp32'],
|
||||
['previewDuration', 'TimeStamp32'],
|
||||
['posterTime', 'TimeStamp32'],
|
||||
['selectionTime', 'TimeStamp32'],
|
||||
['selectionDuration', 'TimeStamp32'],
|
||||
['currentTime', 'TimeStamp32'],
|
||||
['nextTrackId', 'int32'],
|
||||
],
|
||||
},
|
||||
|
||||
track: {
|
||||
cc4: 'trak',
|
||||
fields: [
|
||||
['$atoms', [
|
||||
['header', '*trackHeader'],
|
||||
['media', '*media'],
|
||||
]],
|
||||
],
|
||||
},
|
||||
|
||||
trackHeader: {
|
||||
cc4: 'tkhd',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
['createTime', 'TimeStamp32'],
|
||||
['modifyTime', 'TimeStamp32'],
|
||||
['trackId', 'int32'],
|
||||
['_', '[4]byte'],
|
||||
['duration', 'int32'],
|
||||
['_', '[8]byte'],
|
||||
['layer', 'int16'],
|
||||
['alternateGroup', 'int16'],
|
||||
['volume', 'Fixed16'],
|
||||
['_', '[2]byte'],
|
||||
['matrix', '[9]int32'],
|
||||
['trackWidth', 'Fixed32'],
|
||||
['trackHeight', 'Fixed32'],
|
||||
],
|
||||
},
|
||||
|
||||
handlerRefer: {
|
||||
cc4: 'hdlr',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
['type', '[4]char'],
|
||||
['subType', '[4]char'],
|
||||
['name', '[]char'],
|
||||
],
|
||||
},
|
||||
|
||||
media: {
|
||||
cc4: 'mdia',
|
||||
fields: [
|
||||
['$atoms', [
|
||||
['header', '*mediaHeader'],
|
||||
['handler', '*handlerRefer'],
|
||||
['info', '*mediaInfo'],
|
||||
]],
|
||||
],
|
||||
},
|
||||
|
||||
mediaHeader: {
|
||||
cc4: 'mdhd',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
['createTime', 'TimeStamp32'],
|
||||
['modifyTime', 'TimeStamp32'],
|
||||
['timeScale', 'int32'],
|
||||
['duration', 'int32'],
|
||||
['language', 'int16'],
|
||||
['quality', 'int16'],
|
||||
],
|
||||
},
|
||||
|
||||
mediaInfo: {
|
||||
cc4: 'minf',
|
||||
fields: [
|
||||
['$atoms', [
|
||||
['sound', '*soundMediaInfo'],
|
||||
['video', '*videoMediaInfo'],
|
||||
['data', '*dataInfo'],
|
||||
['sample', '*sampleTable'],
|
||||
]],
|
||||
],
|
||||
},
|
||||
|
||||
dataInfo: {
|
||||
cc4: 'dinf',
|
||||
fields: [
|
||||
['$atoms', [
|
||||
['refer', '*dataRefer'],
|
||||
]],
|
||||
],
|
||||
},
|
||||
|
||||
dataRefer: {
|
||||
cc4: 'dref',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
|
||||
['$atomsCount', 'int32'],
|
||||
['$atoms', [
|
||||
['url', '*dataReferUrl'],
|
||||
]],
|
||||
],
|
||||
},
|
||||
|
||||
dataReferUrl: {
|
||||
cc4: 'url ',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
],
|
||||
},
|
||||
|
||||
soundMediaInfo: {
|
||||
cc4: 'smhd',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
['balance', 'int16'],
|
||||
['_', 'int16'],
|
||||
],
|
||||
},
|
||||
|
||||
videoMediaInfo: {
|
||||
cc4: 'vmhd',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
['graphicsMode', 'int16'],
|
||||
['opcolor', '[3]int16'],
|
||||
],
|
||||
},
|
||||
|
||||
sampleTable: {
|
||||
cc4: 'stbl',
|
||||
fields: [
|
||||
['$atoms', [
|
||||
['sampleDesc', '*sampleDesc'],
|
||||
['timeToSample', '*timeToSample'],
|
||||
['compositionOffset', '*compositionOffset'],
|
||||
['sampleToChunk', '*sampleToChunk'],
|
||||
['syncSample', '*syncSample'],
|
||||
['chunkOffset', '*chunkOffset'],
|
||||
['sampleSize', '*sampleSize'],
|
||||
]],
|
||||
],
|
||||
},
|
||||
|
||||
sampleDesc: {
|
||||
cc4: 'stsd',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['_', '[3]byte'],
|
||||
['$atomsCount', 'int32'],
|
||||
['$atoms', [
|
||||
['avc1Desc', '*avc1Desc'],
|
||||
['mp4aDesc', '*mp4aDesc'],
|
||||
]],
|
||||
],
|
||||
},
|
||||
|
||||
mp4aDesc: {
|
||||
cc4: 'mp4a',
|
||||
fields: [
|
||||
['_', '[6]byte'],
|
||||
['dataRefIdx', 'int16'],
|
||||
['version', 'int16'],
|
||||
['revisionLevel', 'int16'],
|
||||
['vendor', 'int32'],
|
||||
['numberOfChannels', 'int16'],
|
||||
['sampleSize', 'int16'],
|
||||
['compressionId', 'int16'],
|
||||
['_', 'int16'],
|
||||
['sampleRate', 'Fixed32'],
|
||||
['$atoms', [
|
||||
['conf', '*elemStreamDesc'],
|
||||
]],
|
||||
],
|
||||
},
|
||||
|
||||
elemStreamDesc: {
|
||||
cc4: 'esds',
|
||||
fields: [
|
||||
['version', 'int32'],
|
||||
['data', '[]byte'],
|
||||
],
|
||||
},
|
||||
|
||||
avc1Desc: {
|
||||
cc4: 'avc1',
|
||||
fields: [
|
||||
['_', '[6]byte'],
|
||||
['dataRefIdx', 'int16'],
|
||||
['version', 'int16'],
|
||||
['revision', 'int16'],
|
||||
['vendor', 'int32'],
|
||||
['temporalQuality', 'int32'],
|
||||
['spatialQuality', 'int32'],
|
||||
['width', 'int16'],
|
||||
['height', 'int16'],
|
||||
['horizontalResolution', 'Fixed32'],
|
||||
['vorizontalResolution', 'Fixed32'],
|
||||
['_', 'int32'],
|
||||
['frameCount', 'int16'],
|
||||
['compressorName', '[32]char'],
|
||||
['depth', 'int16'],
|
||||
['colorTableId', 'int16'],
|
||||
|
||||
['$atoms', [
|
||||
['conf', '*avc1Conf'],
|
||||
]],
|
||||
],
|
||||
},
|
||||
|
||||
avc1Conf: {
|
||||
cc4: 'avcC',
|
||||
fields: [
|
||||
['data', '[]byte'],
|
||||
],
|
||||
},
|
||||
|
||||
timeToSample: {
|
||||
cc4: 'stts',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
['entries', '[int32]timeToSampleEntry'],
|
||||
],
|
||||
},
|
||||
|
||||
timeToSampleEntry: {
|
||||
fields: [
|
||||
['count', 'int32'],
|
||||
['duration', 'int32'],
|
||||
],
|
||||
},
|
||||
|
||||
sampleToChunk: {
|
||||
cc4: 'stsc',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
['entries', '[int32]sampleToChunkEntry'],
|
||||
],
|
||||
},
|
||||
|
||||
sampleToChunkEntry: {
|
||||
fields: [
|
||||
['firstChunk', 'int32'],
|
||||
['samplesPerChunk', 'int32'],
|
||||
['sampleDescId', 'int32'],
|
||||
],
|
||||
},
|
||||
|
||||
compositionOffset: {
|
||||
cc4: 'ctts',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
['entries', '[int32]compositionOffsetEntry'],
|
||||
],
|
||||
},
|
||||
|
||||
compositionOffsetEntry: {
|
||||
fields: [
|
||||
['count', 'int32'],
|
||||
['offset', 'int32'],
|
||||
],
|
||||
},
|
||||
|
||||
syncSample: {
|
||||
cc4: 'stss',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
['entries', '[int32]int32'],
|
||||
],
|
||||
},
|
||||
|
||||
sampleSize: {
|
||||
cc4: 'stsz',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
['sampleSize', 'int32'],
|
||||
['entries', '[int32]int32'],
|
||||
],
|
||||
},
|
||||
|
||||
chunkOffset: {
|
||||
cc4: 'stco',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
['entries', '[int32]int32'],
|
||||
],
|
||||
},
|
||||
|
||||
movieFrag: {
|
||||
cc4: 'moof',
|
||||
fields: [
|
||||
['$atoms', [
|
||||
['header', '*movieFragHeader'],
|
||||
['tracks', '[]*trackFrag'],
|
||||
]],
|
||||
],
|
||||
},
|
||||
|
||||
trackFragDecodeTime: {
|
||||
cc4: 'tfdt',
|
||||
},
|
||||
|
||||
movieFragHeader: {
|
||||
cc4: 'mfhd',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
['seqNum', 'int32'],
|
||||
],
|
||||
},
|
||||
|
||||
trackFrag: {
|
||||
cc4: 'traf',
|
||||
fields: [
|
||||
['$atoms', [
|
||||
['header', '*trackFragHeader'],
|
||||
['decodeTime', '*trackFragDecodeTime'],
|
||||
['run', '*trackFragRun'],
|
||||
]],
|
||||
],
|
||||
},
|
||||
|
||||
trackFragRun: {
|
||||
cc4: 'trun',
|
||||
},
|
||||
|
||||
trackFragHeader: {
|
||||
cc4: 'tfhd',
|
||||
},
|
||||
|
||||
movieExtend: {
|
||||
cc4: 'mvex',
|
||||
fields: [
|
||||
['$atoms', [
|
||||
['tracks', '[]*trackExtend'],
|
||||
]],
|
||||
],
|
||||
},
|
||||
|
||||
trackExtend: {
|
||||
cc4: 'trex',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
['trackId', 'int32'],
|
||||
['defaultSampleDescIdx', 'int32'],
|
||||
['defaultSampleDuration', 'int32'],
|
||||
['defaultSampleSize', 'int32'],
|
||||
['defaultSampleFlags', 'int32'],
|
||||
],
|
||||
},
|
||||
|
||||
/*
|
||||
// need hand write
|
||||
trackFragRun: {
|
||||
cc4: 'trun',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
['sampleCount', 'int32'],
|
||||
['dataOffset', 'int32'],
|
||||
['entries', '[]int32'],
|
||||
],
|
||||
},
|
||||
|
||||
trackFragHeader: {
|
||||
cc4: 'tfhd',
|
||||
fields: [
|
||||
['version', 'int8'],
|
||||
['flags', 'int24'],
|
||||
['id', 'int32'],
|
||||
['sampleDescriptionIndex', 'int32'],
|
||||
['_', '[12]byte'],
|
||||
],
|
||||
},
|
||||
*/
|
||||
};
|
||||
|
||||
var DeclReadFunc = (opts) => {
|
||||
var stmts = [];
|
||||
|
||||
var DebugStmt = type => `// ${JSON.stringify(type)}`;
|
||||
|
||||
var ReadArr = (name, type) => {
|
||||
return [
|
||||
//StrStmt('// ReadArr'),
|
||||
//DebugStmt(type),
|
||||
type.varcount && [
|
||||
DeclVar('count', 'int'),
|
||||
CallCheckAssign('ReadInt', ['r', type.varcount], ['count']),
|
||||
`${name} = make(${typeStr(type)}, count)`,
|
||||
],
|
||||
For(RangeN('i', type.varcount ? 'count' : type.count), [
|
||||
ReadCommnType(name+'[i]', type),
|
||||
]),
|
||||
];
|
||||
};
|
||||
|
||||
var elemTypeStr = type => typeStr(Object.assign({}, type, {arr: false}));
|
||||
var ReadAtoms = fields => [
|
||||
For(`r.N > 0`, [
|
||||
DeclVar('cc4', 'string'),
|
||||
DeclVar('ar', '*io.LimitedReader'),
|
||||
CallCheckAssign('ReadAtomHeader', ['r', '""'], ['ar', 'cc4']),
|
||||
Switch('cc4', fields.map(field => [
|
||||
`"${atoms[field.type.struct].cc4}"`, [
|
||||
field.type.arr ? [
|
||||
DeclVar('item', elemTypeStr(field.type)),
|
||||
CallCheckAssign('Read'+field.type.Struct, ['ar'], ['item']),
|
||||
`self.${field.name} = append(self.${field.name}, item)`,
|
||||
] : [
|
||||
CallCheckAssign('Read'+field.type.Struct, ['ar'], [`self.${field.name}`]),
|
||||
],
|
||||
]
|
||||
]), showlog && [`log.Println("skip", cc4)`]),
|
||||
CallCheckAssign('ReadDummy', ['ar', 'int(ar.N)'], ['_']),
|
||||
])
|
||||
];
|
||||
|
||||
var ReadCommnType = (name, type) => {
|
||||
if (type.struct)
|
||||
return CallCheckAssign(
|
||||
'Read'+type.Struct, ['r'], [name]);
|
||||
return [
|
||||
//DebugStmt(type),
|
||||
CallCheckAssign(
|
||||
'Read'+type.fn, ['r', type.len||'int(r.N)'], [name]),
|
||||
]
|
||||
};
|
||||
|
||||
var ReadField = (name, type) => {
|
||||
if (name == '_')
|
||||
return CallCheckAssign('ReadDummy', ['r', type.len], ['_']);
|
||||
if (name == '$atoms')
|
||||
return ReadAtoms(type.list);
|
||||
if (name == '$atomsCount')
|
||||
return CallCheckAssign('ReadDummy', ['r', type.len], ['_']);
|
||||
if (type.arr && type.fn != 'Bytes')
|
||||
return ReadArr('self.'+name, type);
|
||||
return ReadCommnType('self.'+name, type);
|
||||
};
|
||||
|
||||
var ReadFields = () => opts.fields.map(field => {
|
||||
var name = field.name;
|
||||
var type = field.type;
|
||||
return ReadField(name, type);
|
||||
}).nonull();
|
||||
|
||||
var ptr = opts.cc4;
|
||||
|
||||
return Func(
|
||||
'Read'+opts.type,
|
||||
[['r', '*io.LimitedReader']],
|
||||
[[ptr?'res':'self', (ptr?'*':'')+opts.type], ['err', 'error']],
|
||||
[
|
||||
ptr && `self := &${opts.type}{}`,
|
||||
ReadFields(),
|
||||
ptr && `res = self`,
|
||||
]
|
||||
);
|
||||
};
|
||||
|
||||
var DeclWriteFunc = (opts) => {
|
||||
var SavePos = [
|
||||
DeclVar('aw', '*Writer'),
|
||||
CallCheckAssign('WriteAtomHeader', ['w', `"${opts.cc4}"`], ['aw']),
|
||||
`w = aw`,
|
||||
];
|
||||
|
||||
var RestorePosSetSize = [
|
||||
CallCheckAssign('aw.Close', [], []),
|
||||
];
|
||||
|
||||
var WriteAtoms = fields => fields.map(field => {
|
||||
var name = 'self.'+field.name;
|
||||
return [
|
||||
`if ${name} != nil {`,
|
||||
field.type.arr ? WriteArr(name, field.type) : WriteCommnType(name, field.type),
|
||||
atomsCount && `${atomsCount.name}++`,
|
||||
`}`,
|
||||
];
|
||||
});
|
||||
|
||||
var WriteArr = (name, type) => {
|
||||
return [
|
||||
type.varcount && CallCheckAssign('WriteInt', ['w', `len(${name})`, type.varcount], []),
|
||||
For(`_, elem := range ${name}`, [
|
||||
WriteCommnType('elem', type),
|
||||
]),
|
||||
];
|
||||
};
|
||||
|
||||
var WriteCommnType = (name, type) => {
|
||||
if (type.struct)
|
||||
return CallCheckAssign(
|
||||
'Write'+type.Struct, ['w', name], []);
|
||||
return [
|
||||
CallCheckAssign(
|
||||
'Write'+type.fn, ['w', name, type.len||`len(${name})`], []),
|
||||
]
|
||||
};
|
||||
|
||||
var atomsCount;
|
||||
|
||||
var WriteAtomsCountStart = (type) => {
|
||||
atomsCount = {
|
||||
name: 'atomsCount',
|
||||
namePos: 'atomsCountPos',
|
||||
type: type,
|
||||
}
|
||||
return [
|
||||
DeclVar(atomsCount.name, 'int'),
|
||||
DeclVar(atomsCount.namePos, 'int64'),
|
||||
CallCheckAssign('WriteEmptyInt', ['w', type.len], [atomsCount.namePos]),
|
||||
];
|
||||
};
|
||||
|
||||
var WriteAtomsCountEnd = (type) => {
|
||||
return [
|
||||
CallCheckAssign('RefillInt',
|
||||
['w', atomsCount.namePos, atomsCount.name, atomsCount.type.len],
|
||||
[]
|
||||
),
|
||||
];
|
||||
};
|
||||
|
||||
var WriteField = (name, type) => {
|
||||
if (name == '_')
|
||||
return CallCheckAssign('WriteDummy', ['w', type.len], []);
|
||||
if (name == '$atoms')
|
||||
return WriteAtoms(type.list);
|
||||
if (name == '$atomsCount')
|
||||
return WriteAtomsCountStart(type);
|
||||
if (type.arr && type.fn != 'Bytes')
|
||||
return WriteArr('self.'+name, type);
|
||||
return WriteCommnType('self.'+name, type);
|
||||
};
|
||||
|
||||
var WriteFields = () => opts.fields
|
||||
.map(field => WriteField(field.name, field.type))
|
||||
.concat(atomsCount && WriteAtomsCountEnd())
|
||||
|
||||
return Func(
|
||||
'Write'+opts.type,
|
||||
[['w', 'io.WriteSeeker'], ['self', (opts.cc4?'*':'')+opts.type]],
|
||||
[['err', 'error']],
|
||||
[
|
||||
opts.cc4 && SavePos,
|
||||
WriteFields(),
|
||||
opts.cc4 && RestorePosSetSize,
|
||||
]
|
||||
);
|
||||
};
|
||||
|
||||
var DeclDumpFunc = (opts) => {
|
||||
var dumpStruct = (name, type) => {
|
||||
if (type.ptr)
|
||||
return If(`${name} != nil`, Call('Walk'+type.Struct, ['w', name]));
|
||||
return Call('Walk'+type.Struct, ['w', name]);
|
||||
};
|
||||
|
||||
var dumpArr = (name, type, id) => {
|
||||
return [
|
||||
//Call('w.StartArray', [`"${id}"`, `len(${name})`]),
|
||||
For(`i, item := range(${name})`, If(
|
||||
`w.FilterArrayItem("${opts.type}", "${id}", i, len(${name}))`,
|
||||
dumpCommonType('item', type, id),
|
||||
[`w.ArrayLeft(i, len(${name}))`, 'break']
|
||||
)),
|
||||
//Call('w.EndArray', []),
|
||||
];
|
||||
};
|
||||
|
||||
var dumpCommonType = (name, type, id) => {
|
||||
if (type.struct)
|
||||
return dumpStruct(name, type);
|
||||
return [
|
||||
Call('w.Name', [`"${id}"`]),
|
||||
Call('w.'+type.fn, [name]),
|
||||
];
|
||||
};
|
||||
|
||||
var dumpField = (name, type, noarr) => {
|
||||
if (name == '_')
|
||||
return;
|
||||
if (name == '$atomsCount')
|
||||
return;
|
||||
if (name == '$atoms') {
|
||||
return type.list.map(field => dumpField(field.name, field.type));
|
||||
}
|
||||
if (!noarr && type.arr && type.fn != 'Bytes')
|
||||
return dumpArr('self.'+name, type, name);
|
||||
return dumpCommonType('self.'+name, type, name);
|
||||
};
|
||||
|
||||
var dumpFields = fields =>
|
||||
[ Call('w.StartStruct', [`"${opts.type}"`]) ]
|
||||
.concat(fields.map(field => dumpField(field.name, field.type)))
|
||||
.concat([Call('w.EndStruct', [])]);
|
||||
|
||||
return Func(
|
||||
'Walk'+opts.type,
|
||||
[['w', 'Walker'], ['self', (opts.cc4?'*':'')+opts.type]],
|
||||
[],
|
||||
dumpFields(opts.fields)
|
||||
)
|
||||
};
|
||||
|
||||
var D = (cls, ...fields) => {
|
||||
global[cls] = (...args) => {
|
||||
var obj = {cls: cls};
|
||||
fields.forEach((k, i) => obj[k] = args[i]);
|
||||
return obj;
|
||||
};
|
||||
};
|
||||
|
||||
D('Func', 'name', 'args', 'rets', 'body');
|
||||
D('If', 'cond', 'action', 'else');
|
||||
D('Call', 'fn', 'args');
|
||||
D('CallCheckAssign', 'fn', 'args', 'rets', 'action');
|
||||
D('DeclVar', 'name', 'type');
|
||||
D('For', 'cond', 'body');
|
||||
D('RangeN', 'i', 'n');
|
||||
D('DeclStruct', 'name', 'body');
|
||||
D('StrStmt', 'content');
|
||||
D('Switch', 'cond', 'cases', 'default');
|
||||
|
||||
var showlog = false;
|
||||
var S = s => s && s || '';
|
||||
|
||||
var dumpFn = f => {
|
||||
var dumpArgs = x => x.map(x => x.join(' ')).join(',');
|
||||
return `func ${f.name}(${dumpArgs(f.args)}) (${dumpArgs(f.rets)}) {
|
||||
${S(showlog && 'log.Println("'+f.name+'")')}
|
||||
${dumpStmts(f.body)}
|
||||
return
|
||||
}`;
|
||||
};
|
||||
|
||||
var dumpStmts = stmt => {
|
||||
if (typeof(stmt) == 'string') {
|
||||
return stmt;
|
||||
} else if (stmt instanceof Array) {
|
||||
return stmt.nonull().map(dumpStmts).join('\n');
|
||||
} else if (stmt.cls == 'If') {
|
||||
var s = `if ${stmt.cond} {
|
||||
${dumpStmts(stmt.action)}
|
||||
}`;
|
||||
if (stmt.else) {
|
||||
s += ` else {
|
||||
${dumpStmts(stmt.else)}
|
||||
}`;
|
||||
}
|
||||
return s;
|
||||
} else if (stmt.cls == 'Call') {
|
||||
return `${stmt.fn}(${stmt.args.join(',')})`;
|
||||
} else if (stmt.cls == 'CallCheckAssign') {
|
||||
return `if ${stmt.rets.concat(['err']).join(',')} = ${stmt.fn}(${stmt.args.join(',')}); err != nil {
|
||||
${stmt.action ? stmt.action : 'return'}
|
||||
}`;
|
||||
} else if (stmt.cls == 'DeclVar') {
|
||||
return `var ${stmt.name} ${stmt.type}`;
|
||||
} else if (stmt.cls == 'For') {
|
||||
return `for ${dumpStmts(stmt.cond)} {
|
||||
${dumpStmts(stmt.body)}
|
||||
}`;
|
||||
} else if (stmt.cls == 'RangeN') {
|
||||
return `${stmt.i} := 0; ${stmt.i} < ${stmt.n}; ${stmt.i}++`;
|
||||
} else if (stmt.cls == 'DeclStruct') {
|
||||
return `type ${stmt.name} struct {
|
||||
${stmt.body.map(line => line.join(' ')).join('\n')}
|
||||
}`;
|
||||
} else if (stmt.cls == 'Func') {
|
||||
return dumpFn(stmt);
|
||||
} else if (stmt.cls == 'StrStmt') {
|
||||
return stmt.content;
|
||||
} else if (stmt.cls == 'Switch') {
|
||||
var dumpCase = c => `case ${c[0]}: { ${dumpStmts(c[1])} }`;
|
||||
var dumpDefault = c => `default: { ${dumpStmts(c)} }`;
|
||||
return `switch ${stmt.cond} {
|
||||
${stmt.cases.map(dumpCase).join('\n')}
|
||||
${stmt.default && dumpDefault(stmt.default) || ''}
|
||||
}`;
|
||||
}
|
||||
};
|
||||
|
||||
var parseType = s => {
|
||||
var r = {};
|
||||
var bracket = /^\[(.*)\]/;
|
||||
var lenDiv = 8;
|
||||
var types = /^(int|TimeStamp|byte|Fixed|char)/;
|
||||
var number = /^[0-9]+/;
|
||||
|
||||
if (s.match(bracket)) {
|
||||
var count = s.match(bracket)[1];
|
||||
if (count.substr(0,3) == 'int') {
|
||||
r.varcount = +count.substr(3)/8;
|
||||
} else {
|
||||
r.count = +count;
|
||||
}
|
||||
r.arr = true;
|
||||
s = s.replace(bracket, '');
|
||||
}
|
||||
|
||||
if (s.substr(0,1) == '*') {
|
||||
r.ptr = true;
|
||||
s = s.slice(1);
|
||||
}
|
||||
|
||||
if (s.match(types)) {
|
||||
r.type = s.match(types)[0];
|
||||
r.fn = uc(r.type);
|
||||
s = s.replace(types, '');
|
||||
}
|
||||
|
||||
if (r.type == 'byte' && r.arr) {
|
||||
r.len = r.count;
|
||||
r.fn = 'Bytes';
|
||||
}
|
||||
|
||||
if (r.type == 'char' && r.arr) {
|
||||
r.len = r.count;
|
||||
r.fn = 'String';
|
||||
r.type = 'string';
|
||||
r.arr = false;
|
||||
lenDiv = 1;
|
||||
}
|
||||
|
||||
if (s.match(number)) {
|
||||
r.len = +s.match(number)[0]/lenDiv;
|
||||
s = s.replace(number, '');
|
||||
}
|
||||
|
||||
if (s != '') {
|
||||
r.struct = s;
|
||||
r.Struct = uc(s);
|
||||
}
|
||||
return r;
|
||||
};
|
||||
|
||||
var typeStr = (t) => {
|
||||
var s = '';
|
||||
if (t.arr)
|
||||
s += '['+(t.count||'')+']';
|
||||
if (t.ptr)
|
||||
s += '*';
|
||||
if (t.struct)
|
||||
s += t.Struct;
|
||||
if (t.type)
|
||||
s += t.type;
|
||||
return s;
|
||||
};
|
||||
|
||||
var nameShouldHide = (name) => name == '_'
|
||||
|
||||
var allStmts = () => {
|
||||
var stmts = [];
|
||||
|
||||
var parseFields = fields => fields.map(field => {
|
||||
return {
|
||||
name: uc(field[0]),
|
||||
type: field[0] == '$atoms' ? {list: parseFields(field[1])} : parseType(field[1]),
|
||||
};
|
||||
});
|
||||
|
||||
var genStructFields = fields => fields.map(field => {
|
||||
if (field.name == '_')
|
||||
return;
|
||||
if (field.name == '$atomsCount')
|
||||
return;
|
||||
if (field.name == '$atoms')
|
||||
return field.type.list;
|
||||
return [field];
|
||||
}).nonull().reduce((prev, cur) => prev.concat(cur)).map(field => [
|
||||
field.name, typeStr(field.type)]);
|
||||
|
||||
for (var k in atoms) {
|
||||
var atom = atoms[k];
|
||||
var name = uc(k);
|
||||
|
||||
if (atom.fields == null)
|
||||
continue;
|
||||
|
||||
var fields = parseFields(atom.fields);
|
||||
|
||||
stmts = stmts.concat([
|
||||
DeclStruct(name, genStructFields(fields)),
|
||||
|
||||
DeclReadFunc({
|
||||
type: name,
|
||||
fields: fields,
|
||||
cc4: atom.cc4,
|
||||
}),
|
||||
|
||||
DeclWriteFunc({
|
||||
type: name,
|
||||
fields: fields,
|
||||
cc4: atom.cc4,
|
||||
}),
|
||||
|
||||
DeclDumpFunc({
|
||||
type: name,
|
||||
fields: fields,
|
||||
cc4: atom.cc4,
|
||||
}),
|
||||
]);
|
||||
}
|
||||
|
||||
return stmts;
|
||||
};
|
||||
|
||||
console.log(`
|
||||
// THIS FILE IS AUTO GENERATED
|
||||
package atom
|
||||
import (
|
||||
"io"
|
||||
${showlog && '"log"' || ''}
|
||||
)
|
||||
`, dumpStmts(allStmts()));
|
||||
|
||||
7
mp4/atom/genStruct.sh
Executable file
7
mp4/atom/genStruct.sh
Executable file
@ -0,0 +1,7 @@
|
||||
#!/bin/bash
|
||||
|
||||
node genStruct.js > struct.go && gofmt -w struct.go && go build . || {
|
||||
echo
|
||||
echo "Please use node version > 6.0.0"
|
||||
}
|
||||
|
||||
115
mp4/atom/reader.go
Normal file
115
mp4/atom/reader.go
Normal file
@ -0,0 +1,115 @@
|
||||
package atom
|
||||
|
||||
import (
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"log"
|
||||
)
|
||||
|
||||
func ReadBytes(r io.Reader, n int) (res []byte, err error) {
|
||||
res = make([]byte, n)
|
||||
if n, err = r.Read(res); err != nil {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func ReadUInt(r io.Reader, n int) (res uint, err error) {
|
||||
var b []byte
|
||||
if b, err = ReadBytes(r, n); err != nil {
|
||||
return
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
res <<= 8
|
||||
res += uint(b[i])
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func ReadInt(r io.Reader, n int) (res int, err error) {
|
||||
var uval uint
|
||||
if uval, err = ReadUInt(r, n); err != nil {
|
||||
return
|
||||
}
|
||||
if uval&(1<<uint(n*8-1)) != 0 {
|
||||
res = -int((1 << uint(n*8)) - uval)
|
||||
} else {
|
||||
res = int(uval)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func ReadFixed(r io.Reader, n int) (res Fixed, err error) {
|
||||
var ui uint
|
||||
if ui, err = ReadUInt(r, n); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
if n == 2 {
|
||||
res = Fixed(ui << 8)
|
||||
} else if n == 4 {
|
||||
res = Fixed(ui)
|
||||
} else {
|
||||
panic("only fixed32 and fixed16 is supported")
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func ReadTimeStamp(r io.Reader, n int) (res TimeStamp, err error) {
|
||||
var ui uint
|
||||
if ui, err = ReadUInt(r, n); err != nil {
|
||||
return
|
||||
}
|
||||
res = TimeStamp(ui)
|
||||
return
|
||||
}
|
||||
|
||||
func ReadString(r io.Reader, n int) (res string, err error) {
|
||||
var b []byte
|
||||
if b, err = ReadBytes(r, n); err != nil {
|
||||
return
|
||||
}
|
||||
res = string(b)
|
||||
return
|
||||
}
|
||||
|
||||
func ReadDummy(r io.Reader, n int) (res int, err error) {
|
||||
_, err = io.CopyN(ioutil.Discard, r, int64(n))
|
||||
return
|
||||
}
|
||||
|
||||
func ReadAtomHeader(r io.Reader, targetCC4 string) (res *io.LimitedReader, cc4 string, err error) {
|
||||
for {
|
||||
var size int
|
||||
if size, err = ReadInt(r, 4); err != nil {
|
||||
return
|
||||
}
|
||||
if size == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
if cc4, err = ReadString(r, 4); err != nil {
|
||||
return
|
||||
}
|
||||
size = size - 8
|
||||
|
||||
if false {
|
||||
log.Println(cc4, targetCC4, size, cc4 == targetCC4)
|
||||
}
|
||||
|
||||
if targetCC4 != "" && cc4 != targetCC4 {
|
||||
log.Println("ReadAtomHeader skip:", cc4)
|
||||
if _, err = ReadDummy(r, size); err != nil {
|
||||
return
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
res = &io.LimitedReader{
|
||||
R: r,
|
||||
N: int64(size),
|
||||
}
|
||||
return
|
||||
}
|
||||
}
|
||||
2874
mp4/atom/struct.go
Normal file
2874
mp4/atom/struct.go
Normal file
File diff suppressed because it is too large
Load Diff
12
mp4/atom/types.go
Normal file
12
mp4/atom/types.go
Normal file
@ -0,0 +1,12 @@
|
||||
package atom
|
||||
|
||||
type Fixed uint32
|
||||
type TimeStamp uint32
|
||||
|
||||
func IntToFixed(val int) Fixed {
|
||||
return Fixed(val << 16)
|
||||
}
|
||||
|
||||
func FixedToInt(val Fixed) int {
|
||||
return int(val >> 16)
|
||||
}
|
||||
29
mp4/atom/utils.go
Normal file
29
mp4/atom/utils.go
Normal file
@ -0,0 +1,29 @@
|
||||
package atom
|
||||
|
||||
func GetAvc1ConfByTrack(stream *Track) (avc1 *Avc1Conf) {
|
||||
if media := stream.Media; media != nil {
|
||||
if info := media.Info; info != nil {
|
||||
if sample := info.Sample; sample != nil {
|
||||
if desc := sample.SampleDesc; desc != nil {
|
||||
if avc1 := desc.Avc1Desc; avc1 != nil {
|
||||
return avc1.Conf
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func GetMp4aDescByTrack(stream *Track) (mp4a *Mp4aDesc) {
|
||||
if media := stream.Media; media != nil {
|
||||
if info := media.Info; info != nil {
|
||||
if sample := info.Sample; sample != nil {
|
||||
if desc := sample.SampleDesc; desc != nil {
|
||||
return desc.Mp4aDesc
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
119
mp4/atom/writer.go
Normal file
119
mp4/atom/writer.go
Normal file
@ -0,0 +1,119 @@
|
||||
package atom
|
||||
|
||||
import (
|
||||
"io"
|
||||
"log"
|
||||
)
|
||||
|
||||
func WriteBytes(w io.Writer, b []byte, n int) (err error) {
|
||||
if len(b) < n {
|
||||
b = append(b, make([]byte, n-len(b))...)
|
||||
}
|
||||
_, err = w.Write(b[:n])
|
||||
return
|
||||
}
|
||||
|
||||
func WriteUInt(w io.Writer, val uint, n int) (err error) {
|
||||
var b [8]byte
|
||||
for i := n - 1; i >= 0; i-- {
|
||||
b[i] = byte(val)
|
||||
val >>= 8
|
||||
}
|
||||
return WriteBytes(w, b[:], n)
|
||||
}
|
||||
|
||||
func WriteInt(w io.Writer, val int, n int) (err error) {
|
||||
var uval uint
|
||||
if val < 0 {
|
||||
uval = uint((1 << uint(n*8)) + val)
|
||||
} else {
|
||||
uval = uint(val)
|
||||
}
|
||||
return WriteUInt(w, uval, n)
|
||||
}
|
||||
|
||||
func WriteFixed(w io.Writer, val Fixed, n int) (err error) {
|
||||
var uval uint
|
||||
|
||||
if n == 2 {
|
||||
uval = uint(val) >> 8
|
||||
} else if n == 4 {
|
||||
uval = uint(val)
|
||||
} else {
|
||||
panic("only fixed32 and fixed16 is supported")
|
||||
}
|
||||
|
||||
return WriteUInt(w, uval, n)
|
||||
}
|
||||
|
||||
func WriteTimeStamp(w io.Writer, ts TimeStamp, n int) (err error) {
|
||||
return WriteUInt(w, uint(ts), n)
|
||||
}
|
||||
|
||||
func WriteString(w io.Writer, val string, n int) (err error) {
|
||||
return WriteBytes(w, []byte(val), n)
|
||||
}
|
||||
|
||||
func WriteDummy(w io.Writer, n int) (err error) {
|
||||
return WriteBytes(w, []byte{}, n)
|
||||
}
|
||||
|
||||
type Writer struct {
|
||||
io.WriteSeeker
|
||||
sizePos int64
|
||||
}
|
||||
|
||||
func WriteEmptyInt(w io.WriteSeeker, n int) (pos int64, err error) {
|
||||
if pos, err = w.Seek(0, 1); err != nil {
|
||||
return
|
||||
}
|
||||
if err = WriteInt(w, 0, n); err != nil {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func RefillInt(w io.WriteSeeker, pos int64, val int, n int) (err error) {
|
||||
var curPos int64
|
||||
if curPos, err = w.Seek(0, 1); err != nil {
|
||||
return
|
||||
}
|
||||
if _, err = w.Seek(pos, 0); err != nil {
|
||||
return
|
||||
}
|
||||
if err = WriteInt(w, val, n); err != nil {
|
||||
return
|
||||
}
|
||||
if _, err = w.Seek(curPos, 0); err != nil {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (self *Writer) Close() (err error) {
|
||||
var curPos int64
|
||||
if curPos, err = self.Seek(0, 1); err != nil {
|
||||
return
|
||||
}
|
||||
if err = RefillInt(self, self.sizePos, int(curPos-self.sizePos), 4); err != nil {
|
||||
return
|
||||
}
|
||||
if false {
|
||||
log.Println("writeback", self.sizePos, curPos, curPos-self.sizePos)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func WriteAtomHeader(w io.WriteSeeker, cc4 string) (res *Writer, err error) {
|
||||
self := &Writer{WriteSeeker: w}
|
||||
|
||||
if self.sizePos, err = WriteEmptyInt(w, 4); err != nil {
|
||||
return
|
||||
}
|
||||
if err = WriteString(self, cc4, 4); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
res = self
|
||||
return
|
||||
}
|
||||
460
mp4/demuxer.go
Normal file
460
mp4/demuxer.go
Normal file
@ -0,0 +1,460 @@
|
||||
package mp4
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"time"
|
||||
"fmt"
|
||||
"github.com/nareix/av"
|
||||
"github.com/nareix/codec/aacparser"
|
||||
"github.com/nareix/codec/h264parser"
|
||||
"github.com/nareix/mp4/atom"
|
||||
"github.com/nareix/mp4/isom"
|
||||
"io"
|
||||
)
|
||||
|
||||
type Demuxer struct {
|
||||
R io.ReadSeeker
|
||||
|
||||
streams []*Stream
|
||||
movieAtom *atom.Movie
|
||||
}
|
||||
|
||||
func (self *Demuxer) Streams() (streams []av.CodecData, err error) {
|
||||
if err = self.probe(); err != nil {
|
||||
return
|
||||
}
|
||||
for _, stream := range self.streams {
|
||||
streams = append(streams, stream.CodecData)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (self *Demuxer) probe() (err error) {
|
||||
if self.movieAtom != nil {
|
||||
return
|
||||
}
|
||||
|
||||
var N int64
|
||||
var moov *atom.Movie
|
||||
|
||||
if N, err = self.R.Seek(0, 2); err != nil {
|
||||
return
|
||||
}
|
||||
if _, err = self.R.Seek(0, 0); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
lr := &io.LimitedReader{R: self.R, N: N}
|
||||
for lr.N > 0 {
|
||||
var ar *io.LimitedReader
|
||||
|
||||
var cc4 string
|
||||
if ar, cc4, err = atom.ReadAtomHeader(lr, ""); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
if cc4 == "moov" {
|
||||
if moov, err = atom.ReadMovie(ar); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if _, err = atom.ReadDummy(lr, int(ar.N)); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if moov == nil {
|
||||
err = fmt.Errorf("mp4: 'moov' atom not found")
|
||||
return
|
||||
}
|
||||
|
||||
self.streams = []*Stream{}
|
||||
for i, atrack := range moov.Tracks {
|
||||
stream := &Stream{
|
||||
trackAtom: atrack,
|
||||
r: self.R,
|
||||
idx: i,
|
||||
}
|
||||
if atrack.Media != nil && atrack.Media.Info != nil && atrack.Media.Info.Sample != nil {
|
||||
stream.sample = atrack.Media.Info.Sample
|
||||
stream.timeScale = int64(atrack.Media.Header.TimeScale)
|
||||
} else {
|
||||
err = fmt.Errorf("mp4: sample table not found")
|
||||
return
|
||||
}
|
||||
|
||||
if avc1 := atom.GetAvc1ConfByTrack(atrack); avc1 != nil {
|
||||
if stream.CodecData, err = h264parser.NewCodecDataFromAVCDecoderConfRecord(avc1.Data); err != nil {
|
||||
return
|
||||
}
|
||||
self.streams = append(self.streams, stream)
|
||||
|
||||
} else if mp4a := atom.GetMp4aDescByTrack(atrack); mp4a != nil && mp4a.Conf != nil {
|
||||
var config []byte
|
||||
if config, err = isom.ReadElemStreamDesc(bytes.NewReader(mp4a.Conf.Data)); err != nil {
|
||||
return
|
||||
}
|
||||
if stream.CodecData, err = aacparser.NewCodecDataFromMPEG4AudioConfigBytes(config); err != nil {
|
||||
return
|
||||
}
|
||||
self.streams = append(self.streams, stream)
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
self.movieAtom = moov
|
||||
return
|
||||
}
|
||||
|
||||
func (self *Stream) setSampleIndex(index int) (err error) {
|
||||
found := false
|
||||
start := 0
|
||||
self.chunkGroupIndex = 0
|
||||
|
||||
for self.chunkIndex = range self.sample.ChunkOffset.Entries {
|
||||
if self.chunkGroupIndex+1 < len(self.sample.SampleToChunk.Entries) &&
|
||||
self.chunkIndex+1 == self.sample.SampleToChunk.Entries[self.chunkGroupIndex+1].FirstChunk {
|
||||
self.chunkGroupIndex++
|
||||
}
|
||||
n := self.sample.SampleToChunk.Entries[self.chunkGroupIndex].SamplesPerChunk
|
||||
if index >= start && index < start+n {
|
||||
found = true
|
||||
self.sampleIndexInChunk = index - start
|
||||
break
|
||||
}
|
||||
start += n
|
||||
}
|
||||
if !found {
|
||||
err = fmt.Errorf("mp4: stream[%d]: cannot locate sample index in chunk", self.idx)
|
||||
return
|
||||
}
|
||||
|
||||
if self.sample.SampleSize.SampleSize != 0 {
|
||||
self.sampleOffsetInChunk = int64(self.sampleIndexInChunk * self.sample.SampleSize.SampleSize)
|
||||
} else {
|
||||
if index >= len(self.sample.SampleSize.Entries) {
|
||||
err = fmt.Errorf("mp4: stream[%d]: sample index out of range", self.idx)
|
||||
return
|
||||
}
|
||||
self.sampleOffsetInChunk = int64(0)
|
||||
for i := index - self.sampleIndexInChunk; i < index; i++ {
|
||||
self.sampleOffsetInChunk += int64(self.sample.SampleSize.Entries[i])
|
||||
}
|
||||
}
|
||||
|
||||
self.dts = int64(0)
|
||||
start = 0
|
||||
found = false
|
||||
self.sttsEntryIndex = 0
|
||||
for self.sttsEntryIndex < len(self.sample.TimeToSample.Entries) {
|
||||
entry := self.sample.TimeToSample.Entries[self.sttsEntryIndex]
|
||||
n := entry.Count
|
||||
if index >= start && index < start+n {
|
||||
self.sampleIndexInSttsEntry = index - start
|
||||
self.dts += int64((index - start) * entry.Duration)
|
||||
found = true
|
||||
break
|
||||
}
|
||||
start += n
|
||||
self.dts += int64(n * entry.Duration)
|
||||
self.sttsEntryIndex++
|
||||
}
|
||||
if !found {
|
||||
err = fmt.Errorf("mp4: stream[%d]: cannot locate sample index in stts entry", self.idx)
|
||||
return
|
||||
}
|
||||
|
||||
if self.sample.CompositionOffset != nil && len(self.sample.CompositionOffset.Entries) > 0 {
|
||||
start = 0
|
||||
found = false
|
||||
self.cttsEntryIndex = 0
|
||||
for self.cttsEntryIndex < len(self.sample.CompositionOffset.Entries) {
|
||||
n := self.sample.CompositionOffset.Entries[self.cttsEntryIndex].Count
|
||||
if index >= start && index < start+n {
|
||||
self.sampleIndexInCttsEntry = index - start
|
||||
found = true
|
||||
break
|
||||
}
|
||||
start += n
|
||||
self.cttsEntryIndex++
|
||||
}
|
||||
if !found {
|
||||
err = fmt.Errorf("mp4: stream[%d]: cannot locate sample index in ctts entry", self.idx)
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if self.sample.SyncSample != nil {
|
||||
self.syncSampleIndex = 0
|
||||
for self.syncSampleIndex < len(self.sample.SyncSample.Entries)-1 {
|
||||
if self.sample.SyncSample.Entries[self.syncSampleIndex+1]-1 > index {
|
||||
break
|
||||
}
|
||||
self.syncSampleIndex++
|
||||
}
|
||||
}
|
||||
|
||||
if false {
|
||||
fmt.Printf("mp4: stream[%d]: setSampleIndex chunkGroupIndex=%d chunkIndex=%d sampleOffsetInChunk=%d\n",
|
||||
self.idx, self.chunkGroupIndex, self.chunkIndex, self.sampleOffsetInChunk)
|
||||
}
|
||||
|
||||
self.sampleIndex = index
|
||||
return
|
||||
}
|
||||
|
||||
func (self *Stream) isSampleValid() bool {
|
||||
if self.chunkIndex >= len(self.sample.ChunkOffset.Entries) {
|
||||
return false
|
||||
}
|
||||
if self.chunkGroupIndex >= len(self.sample.SampleToChunk.Entries) {
|
||||
return false
|
||||
}
|
||||
if self.sttsEntryIndex >= len(self.sample.TimeToSample.Entries) {
|
||||
return false
|
||||
}
|
||||
if self.sample.CompositionOffset != nil && len(self.sample.CompositionOffset.Entries) > 0 {
|
||||
if self.cttsEntryIndex >= len(self.sample.CompositionOffset.Entries) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
if self.sample.SyncSample != nil {
|
||||
if self.syncSampleIndex >= len(self.sample.SyncSample.Entries) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
if self.sample.SampleSize.SampleSize != 0 {
|
||||
if self.sampleIndex >= len(self.sample.SampleSize.Entries) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func (self *Stream) incSampleIndex() (duration int64) {
|
||||
if false {
|
||||
fmt.Printf("incSampleIndex sampleIndex=%d sampleOffsetInChunk=%d sampleIndexInChunk=%d chunkGroupIndex=%d chunkIndex=%d\n",
|
||||
self.sampleIndex, self.sampleOffsetInChunk, self.sampleIndexInChunk, self.chunkGroupIndex, self.chunkIndex)
|
||||
}
|
||||
|
||||
self.sampleIndexInChunk++
|
||||
if self.sampleIndexInChunk == self.sample.SampleToChunk.Entries[self.chunkGroupIndex].SamplesPerChunk {
|
||||
self.chunkIndex++
|
||||
self.sampleIndexInChunk = 0
|
||||
self.sampleOffsetInChunk = int64(0)
|
||||
} else {
|
||||
if self.sample.SampleSize.SampleSize != 0 {
|
||||
self.sampleOffsetInChunk += int64(self.sample.SampleSize.SampleSize)
|
||||
} else {
|
||||
self.sampleOffsetInChunk += int64(self.sample.SampleSize.Entries[self.sampleIndex])
|
||||
}
|
||||
}
|
||||
|
||||
if self.chunkGroupIndex+1 < len(self.sample.SampleToChunk.Entries) &&
|
||||
self.chunkIndex+1 == self.sample.SampleToChunk.Entries[self.chunkGroupIndex+1].FirstChunk {
|
||||
self.chunkGroupIndex++
|
||||
}
|
||||
|
||||
sttsEntry := self.sample.TimeToSample.Entries[self.sttsEntryIndex]
|
||||
duration = int64(sttsEntry.Duration)
|
||||
self.sampleIndexInSttsEntry++
|
||||
self.dts += duration
|
||||
if self.sampleIndexInSttsEntry == sttsEntry.Count {
|
||||
self.sampleIndexInSttsEntry = 0
|
||||
self.sttsEntryIndex++
|
||||
}
|
||||
|
||||
if self.sample.CompositionOffset != nil && len(self.sample.CompositionOffset.Entries) > 0 {
|
||||
self.sampleIndexInCttsEntry++
|
||||
if self.sampleIndexInCttsEntry == self.sample.CompositionOffset.Entries[self.cttsEntryIndex].Count {
|
||||
self.sampleIndexInCttsEntry = 0
|
||||
self.cttsEntryIndex++
|
||||
}
|
||||
}
|
||||
|
||||
if self.sample.SyncSample != nil {
|
||||
entries := self.sample.SyncSample.Entries
|
||||
if self.syncSampleIndex+1 < len(entries) && entries[self.syncSampleIndex+1]-1 == self.sampleIndex+1 {
|
||||
self.syncSampleIndex++
|
||||
}
|
||||
}
|
||||
|
||||
self.sampleIndex++
|
||||
return
|
||||
}
|
||||
|
||||
func (self *Stream) sampleCount() int {
|
||||
if self.sample.SampleSize.SampleSize == 0 {
|
||||
chunkGroupIndex := 0
|
||||
count := 0
|
||||
for chunkIndex := range self.sample.ChunkOffset.Entries {
|
||||
n := self.sample.SampleToChunk.Entries[chunkGroupIndex].SamplesPerChunk
|
||||
count += n
|
||||
if chunkGroupIndex+1 < len(self.sample.SampleToChunk.Entries) &&
|
||||
chunkIndex+1 == self.sample.SampleToChunk.Entries[chunkGroupIndex+1].FirstChunk {
|
||||
chunkGroupIndex++
|
||||
}
|
||||
}
|
||||
return count
|
||||
} else {
|
||||
return len(self.sample.SampleSize.Entries)
|
||||
}
|
||||
}
|
||||
|
||||
func (self *Demuxer) ReadPacket() (pkt av.Packet, err error) {
|
||||
if err = self.probe(); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
var chosen *Stream
|
||||
var chosenidx int
|
||||
for i, stream := range self.streams {
|
||||
if chosen == nil || stream.tsToTime(stream.dts) < chosen.tsToTime(chosen.dts) {
|
||||
chosen = stream
|
||||
chosenidx = i
|
||||
}
|
||||
}
|
||||
if false {
|
||||
fmt.Printf("ReadPacket: chosen index=%v time=%v\n", chosen.idx, chosen.tsToTime(chosen.dts))
|
||||
}
|
||||
tm := chosen.tsToTime(chosen.dts)
|
||||
if pkt, err = chosen.readPacket(); err != nil {
|
||||
return
|
||||
}
|
||||
pkt.Time = tm
|
||||
pkt.Idx = int8(chosenidx)
|
||||
return
|
||||
}
|
||||
|
||||
func (self *Demuxer) CurrentTime() (tm time.Duration) {
|
||||
if len(self.streams) > 0 {
|
||||
stream := self.streams[0]
|
||||
tm = stream.tsToTime(stream.dts)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (self *Demuxer) SeekToTime(tm time.Duration) (err error) {
|
||||
for _, stream := range self.streams {
|
||||
if stream.Type().IsVideo() {
|
||||
if err = stream.seekToTime(tm); err != nil {
|
||||
return
|
||||
}
|
||||
tm = stream.tsToTime(stream.dts)
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
for _, stream := range self.streams {
|
||||
if !stream.Type().IsVideo() {
|
||||
if err = stream.seekToTime(tm); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (self *Stream) readPacket() (pkt av.Packet, err error) {
|
||||
if !self.isSampleValid() {
|
||||
err = io.EOF
|
||||
return
|
||||
}
|
||||
//fmt.Println("readPacket", self.sampleIndex)
|
||||
|
||||
chunkOffset := self.sample.ChunkOffset.Entries[self.chunkIndex]
|
||||
sampleSize := 0
|
||||
if self.sample.SampleSize.SampleSize != 0 {
|
||||
sampleSize = self.sample.SampleSize.SampleSize
|
||||
} else {
|
||||
sampleSize = self.sample.SampleSize.Entries[self.sampleIndex]
|
||||
}
|
||||
|
||||
sampleOffset := int64(chunkOffset) + self.sampleOffsetInChunk
|
||||
if _, err = self.r.Seek(sampleOffset, 0); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
pkt.Data = make([]byte, sampleSize)
|
||||
if _, err = self.r.Read(pkt.Data); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
switch self.Type() {
|
||||
case av.H264:
|
||||
var ok bool
|
||||
if pkt.Data, ok = h264parser.FindDataNALUInAVCCNALUs(pkt.Data); !ok {
|
||||
err = fmt.Errorf("mp4: input h264 format invalid")
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if self.sample.SyncSample != nil {
|
||||
if self.sample.SyncSample.Entries[self.syncSampleIndex]-1 == self.sampleIndex {
|
||||
pkt.IsKeyFrame = true
|
||||
}
|
||||
}
|
||||
|
||||
//println("pts/dts", self.ptsEntryIndex, self.dtsEntryIndex)
|
||||
if self.sample.CompositionOffset != nil && len(self.sample.CompositionOffset.Entries) > 0 {
|
||||
cts := int64(self.sample.CompositionOffset.Entries[self.cttsEntryIndex].Offset)
|
||||
pkt.CompositionTime = self.tsToTime(cts)
|
||||
}
|
||||
|
||||
self.incSampleIndex()
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (self *Stream) seekToTime(tm time.Duration) (err error) {
|
||||
index := self.timeToSampleIndex(tm)
|
||||
if err = self.setSampleIndex(index); err != nil {
|
||||
return
|
||||
}
|
||||
if false {
|
||||
fmt.Printf("stream[%d]: seekToTime index=%v time=%v cur=%v\n", self.idx, index, tm, self.tsToTime(self.dts))
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (self *Stream) timeToSampleIndex(tm time.Duration) int {
|
||||
targetTs := self.timeToTs(tm)
|
||||
targetIndex := 0
|
||||
|
||||
startTs := int64(0)
|
||||
endTs := int64(0)
|
||||
startIndex := 0
|
||||
endIndex := 0
|
||||
found := false
|
||||
for _, entry := range self.sample.TimeToSample.Entries {
|
||||
endTs = startTs + int64(entry.Count*entry.Duration)
|
||||
endIndex = startIndex + entry.Count
|
||||
if targetTs >= startTs && targetTs < endTs {
|
||||
targetIndex = startIndex + int((targetTs-startTs)/int64(entry.Duration))
|
||||
found = true
|
||||
}
|
||||
startTs = endTs
|
||||
startIndex = endIndex
|
||||
}
|
||||
if !found {
|
||||
if targetTs < 0 {
|
||||
targetIndex = 0
|
||||
} else {
|
||||
targetIndex = endIndex - 1
|
||||
}
|
||||
}
|
||||
|
||||
if self.sample.SyncSample != nil {
|
||||
entries := self.sample.SyncSample.Entries
|
||||
for i := len(entries) - 1; i >= 0; i-- {
|
||||
if entries[i]-1 < targetIndex {
|
||||
targetIndex = entries[i] - 1
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return targetIndex
|
||||
}
|
||||
18
mp4/handler.go
Normal file
18
mp4/handler.go
Normal file
@ -0,0 +1,18 @@
|
||||
package mp4
|
||||
|
||||
import (
|
||||
"io"
|
||||
"github.com/nareix/av"
|
||||
"github.com/nareix/av/avutil"
|
||||
)
|
||||
|
||||
func Handler(h *avutil.RegisterHandler) {
|
||||
h.Ext = ".mp4"
|
||||
h.ReaderDemuxer = func(r io.Reader) av.Demuxer {
|
||||
return &Demuxer{R: r.(io.ReadSeeker)}
|
||||
}
|
||||
h.WriterMuxer = func(w io.Writer) av.Muxer {
|
||||
return &Muxer{W: w.(io.WriteSeeker)}
|
||||
}
|
||||
}
|
||||
|
||||
262
mp4/isom/isom.go
Normal file
262
mp4/isom/isom.go
Normal file
@ -0,0 +1,262 @@
|
||||
package isom
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"github.com/nareix/bits"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
)
|
||||
|
||||
// copied from libavformat/isom.h
|
||||
|
||||
const (
|
||||
MP4ESDescrTag = 3
|
||||
MP4DecConfigDescrTag = 4
|
||||
MP4DecSpecificDescrTag = 5
|
||||
)
|
||||
|
||||
var debugReader = false
|
||||
var debugWriter = false
|
||||
|
||||
func readDesc(r io.Reader) (tag uint, data []byte, err error) {
|
||||
if tag, err = bits.ReadUIntBE(r, 8); err != nil {
|
||||
return
|
||||
}
|
||||
var length uint
|
||||
for i := 0; i < 4; i++ {
|
||||
var c uint
|
||||
if c, err = bits.ReadUIntBE(r, 8); err != nil {
|
||||
return
|
||||
}
|
||||
length = (length << 7) | (c & 0x7f)
|
||||
if c&0x80 == 0 {
|
||||
break
|
||||
}
|
||||
}
|
||||
data = make([]byte, length)
|
||||
if _, err = r.Read(data); err != nil {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func writeDesc(w io.Writer, tag uint, data []byte) (err error) {
|
||||
if err = bits.WriteUIntBE(w, tag, 8); err != nil {
|
||||
return
|
||||
}
|
||||
length := uint(len(data))
|
||||
for i := 3; i > 0; i-- {
|
||||
if err = bits.WriteUIntBE(w, (length>>uint(7*i))&0x7f|0x80, 8); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
if err = bits.WriteUIntBE(w, length&0x7f, 8); err != nil {
|
||||
return
|
||||
}
|
||||
if _, err = w.Write(data); err != nil {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func readESDesc(r io.Reader) (err error) {
|
||||
var ES_ID uint
|
||||
// ES_ID
|
||||
if ES_ID, err = bits.ReadUIntBE(r, 16); err != nil {
|
||||
return
|
||||
}
|
||||
var flags uint
|
||||
if flags, err = bits.ReadUIntBE(r, 8); err != nil {
|
||||
return
|
||||
}
|
||||
//streamDependenceFlag
|
||||
if flags&0x80 != 0 {
|
||||
if _, err = bits.ReadUIntBE(r, 16); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
//URL_Flag
|
||||
if flags&0x40 != 0 {
|
||||
var length uint
|
||||
if length, err = bits.ReadUIntBE(r, 8); err != nil {
|
||||
return
|
||||
}
|
||||
if _, err = io.CopyN(ioutil.Discard, r, int64(length)); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
//OCRstreamFlag
|
||||
if flags&0x20 != 0 {
|
||||
if _, err = bits.ReadUIntBE(r, 16); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
if debugReader {
|
||||
println("readESDesc:", ES_ID, flags)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func writeESDesc(w io.Writer, ES_ID uint) (err error) {
|
||||
// ES_ID
|
||||
if err = bits.WriteUIntBE(w, ES_ID, 16); err != nil {
|
||||
return
|
||||
}
|
||||
// flags
|
||||
if err = bits.WriteUIntBE(w, 0, 8); err != nil {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func readDescByTag(r io.Reader, targetTag uint) (data []byte, err error) {
|
||||
var found bool
|
||||
for {
|
||||
if tag, _data, err := readDesc(r); err != nil {
|
||||
break
|
||||
} else {
|
||||
if tag == targetTag {
|
||||
data = _data
|
||||
found = true
|
||||
}
|
||||
if debugReader {
|
||||
println("readDescByTag:", tag, len(_data))
|
||||
}
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
err = fmt.Errorf("tag not found")
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// copied from libavformat/isom.c ff_mp4_read_dec_config_descr()
|
||||
func readDecConfDesc(r io.Reader) (decConfig []byte, err error) {
|
||||
var objectId uint
|
||||
var streamType uint
|
||||
var bufSize uint
|
||||
var maxBitrate uint
|
||||
var avgBitrate uint
|
||||
|
||||
// objectId
|
||||
if objectId, err = bits.ReadUIntBE(r, 8); err != nil {
|
||||
return
|
||||
}
|
||||
// streamType
|
||||
if streamType, err = bits.ReadUIntBE(r, 8); err != nil {
|
||||
return
|
||||
}
|
||||
// buffer size db
|
||||
if bufSize, err = bits.ReadUIntBE(r, 24); err != nil {
|
||||
return
|
||||
}
|
||||
// max bitrate
|
||||
if maxBitrate, err = bits.ReadUIntBE(r, 32); err != nil {
|
||||
return
|
||||
}
|
||||
// avg bitrate
|
||||
if avgBitrate, err = bits.ReadUIntBE(r, 32); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
if debugReader {
|
||||
println("readDecConfDesc:", objectId, streamType, bufSize, maxBitrate, avgBitrate)
|
||||
}
|
||||
|
||||
if decConfig, err = readDescByTag(r, MP4DecSpecificDescrTag); err != nil {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// copied from libavformat/movenc.c mov_write_esds_tag()
|
||||
func writeDecConfDesc(w io.Writer, objectId uint, streamType uint, decConfig []byte) (err error) {
|
||||
// objectId
|
||||
if err = bits.WriteUIntBE(w, objectId, 8); err != nil {
|
||||
return
|
||||
}
|
||||
// streamType
|
||||
if err = bits.WriteUIntBE(w, streamType, 8); err != nil {
|
||||
return
|
||||
}
|
||||
// buffer size db
|
||||
if err = bits.WriteUIntBE(w, 0, 24); err != nil {
|
||||
return
|
||||
}
|
||||
// max bitrate
|
||||
if err = bits.WriteUIntBE(w, 200000, 32); err != nil {
|
||||
return
|
||||
}
|
||||
// avg bitrate
|
||||
if err = bits.WriteUIntBE(w, 0, 32); err != nil {
|
||||
return
|
||||
}
|
||||
if err = writeDesc(w, MP4DecSpecificDescrTag, decConfig); err != nil {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// copied from libavformat/mov.c ff_mov_read_esds()
|
||||
func ReadElemStreamDesc(r io.Reader) (decConfig []byte, err error) {
|
||||
if debugReader {
|
||||
println("ReadElemStreamDesc: start")
|
||||
}
|
||||
|
||||
var data []byte
|
||||
if data, err = readDescByTag(r, MP4ESDescrTag); err != nil {
|
||||
return
|
||||
}
|
||||
r = bytes.NewReader(data)
|
||||
|
||||
if err = readESDesc(r); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
if data, err = readDescByTag(r, MP4DecConfigDescrTag); err != nil {
|
||||
return
|
||||
}
|
||||
r = bytes.NewReader(data)
|
||||
|
||||
if decConfig, err = readDecConfDesc(r); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
if debugReader {
|
||||
println("ReadElemStreamDesc: end")
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func WriteElemStreamDesc(w io.Writer, decConfig []byte, trackId uint) (err error) {
|
||||
// MP4ESDescrTag(ESDesc MP4DecConfigDescrTag(objectId streamType bufSize avgBitrate MP4DecSpecificDescrTag(decConfig)))
|
||||
|
||||
data := decConfig
|
||||
|
||||
buf := &bytes.Buffer{}
|
||||
// 0x40 = ObjectType AAC
|
||||
// 0x15 = Audiostream
|
||||
writeDecConfDesc(buf, 0x40, 0x15, data)
|
||||
data = buf.Bytes()
|
||||
|
||||
buf = &bytes.Buffer{}
|
||||
writeDesc(buf, MP4DecConfigDescrTag, data) // 4
|
||||
data = buf.Bytes()
|
||||
|
||||
buf = &bytes.Buffer{}
|
||||
writeESDesc(buf, trackId)
|
||||
buf.Write(data)
|
||||
writeDesc(buf, 0x06, []byte{0x02})
|
||||
data = buf.Bytes()
|
||||
|
||||
buf = &bytes.Buffer{}
|
||||
writeDesc(buf, MP4ESDescrTag, data) // 3
|
||||
data = buf.Bytes()
|
||||
|
||||
if _, err = w.Write(data); err != nil {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
53
mp4/isom/isom_test.go
Normal file
53
mp4/isom/isom_test.go
Normal file
@ -0,0 +1,53 @@
|
||||
package isom
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestReadElemStreamDesc(t *testing.T) {
|
||||
debugReader = true
|
||||
debugWriter = true
|
||||
|
||||
var err error
|
||||
|
||||
data, _ := hex.DecodeString("03808080220002000480808014401500000000030d400000000005808080021210068080800102")
|
||||
t.Logf("elemDesc=%x", data)
|
||||
t.Logf("length=%d", len(data))
|
||||
|
||||
var aconfig MPEG4AudioConfig
|
||||
if aconfig, err = ReadElemStreamDescAAC(bytes.NewReader(data)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
aconfig = aconfig.Complete()
|
||||
t.Logf("aconfig=%v", aconfig)
|
||||
|
||||
bw := &bytes.Buffer{}
|
||||
WriteMPEG4AudioConfig(bw, aconfig)
|
||||
|
||||
bw = &bytes.Buffer{}
|
||||
WriteElemStreamDescAAC(bw, aconfig, 2)
|
||||
t.Logf("elemDesc=%x", bw.Bytes())
|
||||
data = bw.Bytes()
|
||||
t.Logf("length=%d", len(data))
|
||||
|
||||
if aconfig, err = ReadElemStreamDescAAC(bytes.NewReader(data)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
t.Logf("aconfig=%v", aconfig.Complete())
|
||||
|
||||
//00000000 ff f1 50 80 04 3f fc de 04 00 00 6c 69 62 66 61 |..P..?.....libfa|
|
||||
//00000010 61 63 20 31 2e 32 38 00 00 42 40 93 20 04 32 00 |ac 1.28..B@. .2.|
|
||||
//00000020 47 ff f1 50 80 05 1f fc 21 42 fe ed b2 5c a8 00 |G..P....!B...\..|
|
||||
data, _ = hex.DecodeString("fff15080043ffcde040000")
|
||||
var n, framelen int
|
||||
aconfig, _, n, _, _ = ReadADTSFrame(data)
|
||||
t.Logf("%v n=%d", aconfig.Complete(), n)
|
||||
|
||||
data = MakeADTSHeader(aconfig, 1024*3, 33)
|
||||
data = append(data, []byte{1, 2, 3, 4, 5}...)
|
||||
t.Logf("%x", data)
|
||||
aconfig, _, n, framelen, err = ReadADTSFrame(data)
|
||||
t.Logf("%v n=%d framelen=%d err=%v", aconfig.Complete(), n, framelen, err)
|
||||
}
|
||||
280
mp4/muxer.go
Normal file
280
mp4/muxer.go
Normal file
@ -0,0 +1,280 @@
|
||||
package mp4
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"time"
|
||||
"github.com/nareix/av"
|
||||
"github.com/nareix/pio"
|
||||
"github.com/nareix/codec/aacparser"
|
||||
"github.com/nareix/codec/h264parser"
|
||||
"github.com/nareix/mp4/atom"
|
||||
"github.com/nareix/mp4/isom"
|
||||
"io"
|
||||
)
|
||||
|
||||
type Muxer struct {
|
||||
W io.WriteSeeker
|
||||
streams []*Stream
|
||||
mdatWriter *atom.Writer
|
||||
}
|
||||
|
||||
func (self *Muxer) isCodecSupported(codec av.CodecData) bool {
|
||||
switch codec.Type() {
|
||||
case av.H264, av.AAC:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func (self *Muxer) newStream(codec av.CodecData) (err error) {
|
||||
if !self.isCodecSupported(codec) {
|
||||
err = fmt.Errorf("mp4: codec type=%v is not supported", codec.Type())
|
||||
return
|
||||
}
|
||||
|
||||
stream := &Stream{CodecData: codec}
|
||||
|
||||
stream.sample = &atom.SampleTable{
|
||||
SampleDesc: &atom.SampleDesc{},
|
||||
TimeToSample: &atom.TimeToSample{},
|
||||
SampleToChunk: &atom.SampleToChunk{
|
||||
Entries: []atom.SampleToChunkEntry{
|
||||
{
|
||||
FirstChunk: 1,
|
||||
SampleDescId: 1,
|
||||
SamplesPerChunk: 1,
|
||||
},
|
||||
},
|
||||
},
|
||||
SampleSize: &atom.SampleSize{},
|
||||
ChunkOffset: &atom.ChunkOffset{},
|
||||
}
|
||||
|
||||
stream.trackAtom = &atom.Track{
|
||||
Header: &atom.TrackHeader{
|
||||
TrackId: len(self.streams) + 1,
|
||||
Flags: 0x0003, // Track enabled | Track in movie
|
||||
Duration: 0, // fill later
|
||||
Matrix: [9]int{0x10000, 0, 0, 0, 0x10000, 0, 0, 0, 0x40000000},
|
||||
},
|
||||
Media: &atom.Media{
|
||||
Header: &atom.MediaHeader{
|
||||
TimeScale: 0, // fill later
|
||||
Duration: 0, // fill later
|
||||
Language: 21956,
|
||||
},
|
||||
Info: &atom.MediaInfo{
|
||||
Sample: stream.sample,
|
||||
Data: &atom.DataInfo{
|
||||
Refer: &atom.DataRefer{
|
||||
Url: &atom.DataReferUrl{
|
||||
Flags: 0x000001, // Self reference
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
switch codec.Type() {
|
||||
case av.H264:
|
||||
stream.sample.SyncSample = &atom.SyncSample{}
|
||||
}
|
||||
|
||||
stream.timeScale = 90000
|
||||
stream.muxer = self
|
||||
self.streams = append(self.streams, stream)
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (self *Stream) fillTrackAtom() (err error) {
|
||||
self.trackAtom.Media.Header.TimeScale = int(self.timeScale)
|
||||
self.trackAtom.Media.Header.Duration = int(self.duration)
|
||||
|
||||
if self.Type() == av.H264 {
|
||||
codec := self.CodecData.(h264parser.CodecData)
|
||||
width, height := codec.Width(), codec.Height()
|
||||
self.sample.SampleDesc.Avc1Desc = &atom.Avc1Desc{
|
||||
DataRefIdx: 1,
|
||||
HorizontalResolution: 72,
|
||||
VorizontalResolution: 72,
|
||||
Width: int(width),
|
||||
Height: int(height),
|
||||
FrameCount: 1,
|
||||
Depth: 24,
|
||||
ColorTableId: -1,
|
||||
Conf: &atom.Avc1Conf{Data: codec.AVCDecoderConfRecordBytes()},
|
||||
}
|
||||
self.trackAtom.Media.Handler = &atom.HandlerRefer{
|
||||
SubType: "vide",
|
||||
Name: "Video Media Handler",
|
||||
}
|
||||
self.trackAtom.Media.Info.Video = &atom.VideoMediaInfo{
|
||||
Flags: 0x000001,
|
||||
}
|
||||
self.trackAtom.Header.TrackWidth = atom.IntToFixed(int(width))
|
||||
self.trackAtom.Header.TrackHeight = atom.IntToFixed(int(height))
|
||||
|
||||
} else if self.Type() == av.AAC {
|
||||
codec := self.CodecData.(aacparser.CodecData)
|
||||
buf := &bytes.Buffer{}
|
||||
if err = isom.WriteElemStreamDesc(buf, codec.MPEG4AudioConfigBytes(), uint(self.trackAtom.Header.TrackId)); err != nil {
|
||||
return
|
||||
}
|
||||
self.sample.SampleDesc.Mp4aDesc = &atom.Mp4aDesc{
|
||||
DataRefIdx: 1,
|
||||
NumberOfChannels: codec.ChannelLayout().Count(),
|
||||
SampleSize: codec.SampleFormat().BytesPerSample(),
|
||||
SampleRate: atom.IntToFixed(codec.SampleRate()),
|
||||
Conf: &atom.ElemStreamDesc{
|
||||
Data: buf.Bytes(),
|
||||
},
|
||||
}
|
||||
self.trackAtom.Header.Volume = atom.IntToFixed(1)
|
||||
self.trackAtom.Header.AlternateGroup = 1
|
||||
self.trackAtom.Media.Handler = &atom.HandlerRefer{
|
||||
SubType: "soun",
|
||||
Name: "Sound Handler",
|
||||
}
|
||||
self.trackAtom.Media.Info.Sound = &atom.SoundMediaInfo{}
|
||||
|
||||
} else {
|
||||
err = fmt.Errorf("mp4: codec type=%d invalid", self.Type())
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (self *Muxer) WriteHeader(streams []av.CodecData) (err error) {
|
||||
self.streams = []*Stream{}
|
||||
for _, stream := range streams {
|
||||
if err = self.newStream(stream); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if self.mdatWriter, err = atom.WriteAtomHeader(self.W, "mdat"); err != nil {
|
||||
return
|
||||
}
|
||||
for _, stream := range self.streams {
|
||||
if stream.Type().IsVideo() {
|
||||
stream.sample.CompositionOffset = &atom.CompositionOffset{}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (self *Muxer) WritePacket(pkt av.Packet) (err error) {
|
||||
stream := self.streams[pkt.Idx]
|
||||
if err = stream.writePacket(pkt); err != nil {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (self *Stream) writePacket(pkt av.Packet) (err error) {
|
||||
if self.lasttime == 0 {
|
||||
self.lasttime = pkt.Time
|
||||
return
|
||||
}
|
||||
rawdur := pkt.Time - self.lasttime
|
||||
if rawdur < 0 {
|
||||
err = fmt.Errorf("mp4: stream#%d time=%v < lasttime=%v", pkt.Idx, pkt.Time, self.lasttime)
|
||||
return
|
||||
}
|
||||
self.lasttime = pkt.Time
|
||||
|
||||
var filePos int64
|
||||
var sampleSize int
|
||||
|
||||
if filePos, err = self.muxer.mdatWriter.Seek(0, 1); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
if self.Type() == av.H264 {
|
||||
if typ := h264parser.CheckNALUsType(pkt.Data); typ != h264parser.NALU_RAW {
|
||||
err = fmt.Errorf("mp4: nalu format=%d is not raw", typ)
|
||||
return
|
||||
}
|
||||
var b [4]byte
|
||||
pio.PutU32BE(b[:], uint32(len(pkt.Data)))
|
||||
sampleSize += len(pkt.Data)+4
|
||||
if _, err = self.muxer.mdatWriter.Write(b[:]); err != nil {
|
||||
return
|
||||
}
|
||||
if _, err = self.muxer.mdatWriter.Write(pkt.Data); err != nil {
|
||||
return
|
||||
}
|
||||
} else {
|
||||
sampleSize = len(pkt.Data)
|
||||
if _, err = self.muxer.mdatWriter.Write(pkt.Data); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if pkt.IsKeyFrame && self.sample.SyncSample != nil {
|
||||
self.sample.SyncSample.Entries = append(self.sample.SyncSample.Entries, self.sampleIndex+1)
|
||||
}
|
||||
|
||||
duration := int(self.timeToTs(rawdur))
|
||||
if self.sttsEntry == nil || duration != self.sttsEntry.Duration {
|
||||
self.sample.TimeToSample.Entries = append(self.sample.TimeToSample.Entries, atom.TimeToSampleEntry{Duration: duration})
|
||||
self.sttsEntry = &self.sample.TimeToSample.Entries[len(self.sample.TimeToSample.Entries)-1]
|
||||
}
|
||||
self.sttsEntry.Count++
|
||||
|
||||
if self.sample.CompositionOffset != nil {
|
||||
offset := int(self.timeToTs(pkt.CompositionTime))
|
||||
if self.cttsEntry == nil || offset != self.cttsEntry.Offset {
|
||||
table := self.sample.CompositionOffset
|
||||
table.Entries = append(table.Entries, atom.CompositionOffsetEntry{Offset: offset})
|
||||
self.cttsEntry = &table.Entries[len(table.Entries)-1]
|
||||
}
|
||||
self.cttsEntry.Count++
|
||||
}
|
||||
|
||||
self.duration += int64(duration)
|
||||
self.sampleIndex++
|
||||
self.sample.ChunkOffset.Entries = append(self.sample.ChunkOffset.Entries, int(filePos))
|
||||
self.sample.SampleSize.Entries = append(self.sample.SampleSize.Entries, sampleSize)
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (self *Muxer) WriteTrailer() (err error) {
|
||||
moov := &atom.Movie{}
|
||||
moov.Header = &atom.MovieHeader{
|
||||
PreferredRate: atom.IntToFixed(1),
|
||||
PreferredVolume: atom.IntToFixed(1),
|
||||
Matrix: [9]int{0x10000, 0, 0, 0, 0x10000, 0, 0, 0, 0x40000000},
|
||||
NextTrackId: 2,
|
||||
}
|
||||
|
||||
maxDur := time.Duration(0)
|
||||
timeScale := int64(10000)
|
||||
for _, stream := range self.streams {
|
||||
if err = stream.fillTrackAtom(); err != nil {
|
||||
return
|
||||
}
|
||||
dur := stream.tsToTime(stream.duration)
|
||||
stream.trackAtom.Header.Duration = int(timeToTs(dur, timeScale))
|
||||
if dur > maxDur {
|
||||
maxDur = dur
|
||||
}
|
||||
moov.Tracks = append(moov.Tracks, stream.trackAtom)
|
||||
}
|
||||
moov.Header.TimeScale = int(timeScale)
|
||||
moov.Header.Duration = int(timeToTs(maxDur, timeScale))
|
||||
|
||||
if err = self.mdatWriter.Close(); err != nil {
|
||||
return
|
||||
}
|
||||
if err = atom.WriteMovie(self.W, moov); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
59
mp4/stream.go
Normal file
59
mp4/stream.go
Normal file
@ -0,0 +1,59 @@
|
||||
package mp4
|
||||
|
||||
import (
|
||||
"github.com/nareix/av"
|
||||
"github.com/nareix/mp4/atom"
|
||||
"time"
|
||||
"io"
|
||||
)
|
||||
|
||||
type Stream struct {
|
||||
av.CodecData
|
||||
|
||||
trackAtom *atom.Track
|
||||
r io.ReadSeeker
|
||||
idx int
|
||||
|
||||
lasttime time.Duration
|
||||
|
||||
timeScale int64
|
||||
duration int64
|
||||
|
||||
muxer *Muxer
|
||||
|
||||
sample *atom.SampleTable
|
||||
sampleIndex int
|
||||
|
||||
sampleOffsetInChunk int64
|
||||
syncSampleIndex int
|
||||
|
||||
dts int64
|
||||
sttsEntryIndex int
|
||||
sampleIndexInSttsEntry int
|
||||
|
||||
cttsEntryIndex int
|
||||
sampleIndexInCttsEntry int
|
||||
|
||||
chunkGroupIndex int
|
||||
chunkIndex int
|
||||
sampleIndexInChunk int
|
||||
|
||||
sttsEntry *atom.TimeToSampleEntry
|
||||
cttsEntry *atom.CompositionOffsetEntry
|
||||
}
|
||||
|
||||
func timeToTs(tm time.Duration, timeScale int64) int64 {
|
||||
return int64(tm*time.Duration(timeScale) / time.Second)
|
||||
}
|
||||
|
||||
func tsToTime(ts int64, timeScale int64) time.Duration {
|
||||
return time.Duration(ts)*time.Second / time.Duration(timeScale)
|
||||
}
|
||||
|
||||
func (self *Stream) timeToTs(tm time.Duration) int64 {
|
||||
return int64(tm*time.Duration(self.timeScale) / time.Second)
|
||||
}
|
||||
|
||||
func (self *Stream) tsToTime(ts int64) time.Duration {
|
||||
return time.Duration(ts)*time.Second / time.Duration(self.timeScale)
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user