change float64->float32

demuxer.go

@@ -2,8 +2,8 @@ package ts
 
 import (
 	"bytes"
-	"fmt"
 	"encoding/hex"
+	"fmt"
 	"github.com/nareix/av"
 	"github.com/nareix/av/pktqueue"
 	"github.com/nareix/codec/aacparser"
@@ -23,7 +23,7 @@ func Open(R io.Reader) (demuxer *Demuxer, err error) {
 type Demuxer struct {
 	R io.Reader
 
-	gotpkt bool
+	gotpkt  bool
 	pktque  *pktqueue.Queue
 	pat     PAT
 	pmt     *PMT
@@ -41,7 +41,7 @@ func (self *Demuxer) Streams() (streams []av.CodecData, err error) {
 	return
 }
 
-func (self *Demuxer) CurrentTime() (time float64) {
+func (self *Demuxer) CurrentTime() (time float32) {
 	if self.pktque != nil {
 		time = self.pktque.CurrentTime()
 	}
@@ -156,11 +156,11 @@ func (self *Stream) payloadEnd() (err error) {
 
 	pkt := av.Packet{
 		IsKeyFrame: self.tshdr.RandomAccessIndicator,
-		Data: payload,
+		Data:       payload,
 	}
-	time := float64(dts)/float64(PTS_HZ)
+	time := float32(dts) / float32(PTS_HZ)
 	if pts != dts {
-		pkt.CompositionTime = float64(pts-dts)/float64(PTS_HZ)
+		pkt.CompositionTime = float32(pts-dts) / float32(PTS_HZ)
 	}
 	self.demuxer.pktque.WriteTimePacket(self.idx, time, pkt)
 	self.demuxer.gotpkt = true
@@ -188,7 +188,7 @@ func (self *Stream) payloadEnd() (err error) {
 			var sps, pps []byte
 			for _, nalu := range nalus {
 				if len(nalu) > 0 {
-					naltype := nalu[0]&0x1f
+					naltype := nalu[0] & 0x1f
 					if naltype == 7 {
 						sps = nalu
 					} else if naltype == 8 {
@@ -237,4 +237,3 @@ func (self *Stream) handleTSPacket(header TSHeader, tspacket []byte) (err error)
 
 	return
 }
-

muxer.go

@@ -19,12 +19,12 @@ func Create(W io.Writer, streams []av.CodecData) (muxer *Muxer, err error) {
 }
 
 type Muxer struct {
-	W       io.Writer
-	streams []*Stream
+	W                        io.Writer
+	streams                  []*Stream
 	PaddingToMakeCounterCont bool
 
-	tswPAT       *TSWriter
-	tswPMT       *TSWriter
+	tswPAT *TSWriter
+	tswPMT *TSWriter
 }
 
 func (self *Muxer) isCodecSupported(codec av.CodecData) bool {
@@ -43,7 +43,7 @@ func (self *Muxer) newStream(codec av.CodecData) (err error) {
 	}
 
 	stream := &Stream{
-		muxer: self,
+		muxer:     self,
 		CodecData: codec,
 		tsw: &TSWriter{
 			DiscontinuityIndicator: true,
@@ -57,7 +57,7 @@ func (self *Muxer) newStream(codec av.CodecData) (err error) {
 func (self *Muxer) writePaddingTSPackets(tsw *TSWriter) (err error) {
 	for tsw.ContinuityCounter&0xf != 0x0 {
 		header := TSHeader{
-			PID: tsw.PID,
+			PID:               tsw.PID,
 			ContinuityCounter: tsw.ContinuityCounter,
 		}
 		if _, err = WriteTSHeader(self.W, header, 0); err != nil {

reader.go

@@ -133,7 +133,7 @@ func ReadTSHeader(r io.Reader) (self TSHeader, err error) {
 				// clock is 27MHz
 				self.PCR = UIntToPCR(v)
 				if DebugReader {
-					fmt.Fprintf(DebugOutput, "ts: PCR %d %f\n", self.PCR, float64(self.PCR)/PCR_HZ)
+					fmt.Fprintf(DebugOutput, "ts: PCR %d %f\n", self.PCR, float32(self.PCR)/PCR_HZ)
 				}
 			}
 
@@ -572,7 +572,7 @@ func ReadPESHeader(r io.Reader) (res *PESHeader, err error) {
 		self.PTS = PESUIntToTs(v)
 
 		if DebugReader {
-			fmt.Fprintf(DebugOutput, "pes: pts %d %f\n", self.PTS, float64(self.PTS)/float64(PTS_HZ))
+			fmt.Fprintf(DebugOutput, "pes: pts %d %f\n", self.PTS, float32(self.PTS)/float32(PTS_HZ))
 		}
 	}
 
@@ -583,7 +583,7 @@ func ReadPESHeader(r io.Reader) (res *PESHeader, err error) {
 		}
 		self.DTS = PESUIntToTs(v)
 		if DebugReader {
-			fmt.Fprintf(DebugOutput, "pes: dts %d %f\n", self.DTS, float64(self.DTS)/float64(PTS_HZ))
+			fmt.Fprintf(DebugOutput, "pes: dts %d %f\n", self.DTS, float32(self.DTS)/float32(PTS_HZ))
 		}
 	}
 

stream.go

@@ -8,30 +8,30 @@ import (
 type Stream struct {
 	av.CodecData
 
-	pid           uint
-	buf           bytes.Buffer
-	peshdr        *PESHeader
-	tshdr         TSHeader
+	pid    uint
+	buf    bytes.Buffer
+	peshdr *PESHeader
+	tshdr  TSHeader
 
-	demuxer   *Demuxer
-	muxer       *Muxer
+	demuxer *Demuxer
+	muxer   *Muxer
 
-	streamId  uint
+	streamId   uint
 	streamType uint
 
 	tsw       *TSWriter
 	dataBuf   *iovec
 	cacheSize int
 
-	idx int
-	pkt av.Packet
-	time float64
+	idx  int
+	pkt  av.Packet
+	time float32
 }
 
-func timeToPesTs(time float64) uint64 {
+func timeToPesTs(time float32) uint64 {
 	return uint64(time*PTS_HZ) + PTS_HZ
 }
 
-func timeToPCR(time float64) uint64 {
+func timeToPCR(time float32) uint64 {
 	return uint64(time*PCR_HZ) + PCR_HZ
 }