thefoxon/joy4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

switch time.Duration

Browse Source
This commit is contained in:
nareix 2016-06-18 10:05:32 +08:00
parent c463a3678f
commit b255ae33bc
3 changed files with 35 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
demuxer.go
View File

@ -2,6 +2,7 @@ package mp4
import (
"bytes"
"time"
"fmt"
"github.com/nareix/av"
"github.com/nareix/codec/aacparser"
@ -322,28 +323,28 @@ func (self *Demuxer) ReadPacket() (streamIndex int, pkt av.Packet, err error) {
return
}
func (self *Demuxer) CurrentTime() (time float32) {
func (self *Demuxer) CurrentTime() (tm time.Duration) {
if len(self.streams) > 0 {
stream := self.streams[0]
time = stream.tsToTime(stream.dts)
tm = stream.tsToTime(stream.dts)
}
return
}
func (self *Demuxer) SeekToTime(time float32) (err error) {
func (self *Demuxer) SeekToTime(tm time.Duration) (err error) {
for _, stream := range self.streams {
if stream.IsVideo() {
if err = stream.seekToTime(time); err != nil {
if stream.Type().IsVideo() {
if err = stream.seekToTime(tm); err != nil {
return
}
time = stream.tsToTime(stream.dts)
tm = stream.tsToTime(stream.dts)
break
}
}
for _, stream := range self.streams {
if !stream.IsVideo() {
if err = stream.seekToTime(time); err != nil {
if !stream.Type().IsVideo() {
if err = stream.seekToTime(tm); err != nil {
return
}
}
@ -395,19 +396,19 @@ func (self *Stream) readPacket() (pkt av.Packet, err error) {
return
}
func (self *Stream) seekToTime(time float32) (err error) {
index := self.timeToSampleIndex(time)
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, time, self.tsToTime(self.dts))
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(time float32) int {
targetTs := self.timeToTs(time)
func (self *Stream) timeToSampleIndex(tm time.Duration) int {
targetTs := self.timeToTs(tm)
targetIndex := 0
startTs := int64(0)

15
muxer.go
View File

@ -3,6 +3,7 @@ package mp4
import (
"bytes"
"fmt"
"time"
"github.com/nareix/av"
"github.com/nareix/codec/aacparser"
"github.com/nareix/codec/h264parser"
@ -162,7 +163,7 @@ func (self *Muxer) WriteHeader(streams []av.CodecData) (err error) {
return
}
for _, stream := range self.streams {
if stream.IsVideo() {
if stream.Type().IsVideo() {
stream.sample.CompositionOffset = &atom.CompositionOffset{}
}
}
@ -184,7 +185,7 @@ func (self *Muxer) WritePacket(streamIndex int, pkt av.Packet) (err error) {
}
newpkt := pkt
newpkt.Data = payload
newpkt.Duration = float32(samples) / float32(sampleRate)
newpkt.Duration = time.Duration(samples)*time.Second / time.Duration(sampleRate)
if err = stream.writePacket(newpkt); err != nil {
return
}
@ -258,21 +259,21 @@ func (self *Muxer) WriteTrailer() (err error) {
NextTrackId: 2,
}
maxDur := float32(0)
timeScale := 10000
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(float32(timeScale) * dur)
stream.trackAtom.Header.Duration = int(timeToTs(dur, timeScale))
if dur > maxDur {
maxDur = dur
}
moov.Tracks = append(moov.Tracks, stream.trackAtom)
}
moov.Header.TimeScale = timeScale
moov.Header.Duration = int(float32(timeScale) * maxDur)
moov.Header.TimeScale = int(timeScale)
moov.Header.Duration = int(timeToTs(maxDur, timeScale))
if err = self.mdatWriter.Close(); err != nil {
return

17
stream.go
View File

@ -3,6 +3,7 @@ package mp4
import (
"github.com/nareix/av"
"github.com/nareix/mp4/atom"
"time"
"io"
)
@ -39,10 +40,18 @@ type Stream struct {
cttsEntry *atom.CompositionOffsetEntry
}
func (self *Stream) timeToTs(time float32) int64 {
return int64(time * float32(self.timeScale))
func timeToTs(tm time.Duration, timeScale int64) int64 {
return int64(tm*time.Duration(timeScale) / time.Second)
}
func (self *Stream) tsToTime(ts int64) float32 {
return float32(ts) / float32(self.timeScale)
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)
}