/* NAME encoder.go DESCRIPTION See Readme.md AUTHOR Dan Kortschak <dan@ausocean.org> Saxon Nelson-Milton <saxon@ausocean.org> LICENSE encoder.go is Copyright (C) 2017-2018 the Australian Ocean Lab (AusOcean) It is free software: you can redistribute it and/or modify them under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. It is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with revid in gpl.txt. If not, see http://www.gnu.org/licenses. */ package mts import ( "io" "time" "bitbucket.org/ausocean/av/stream/mts/pes" "bitbucket.org/ausocean/av/stream/mts/psi" ) const ( psiPacketSize = 184 psiSendCount = 7 ) type MetaData struct { time uint64 location string } var metaData = MetaData{time: 0, location: ""} func SetTimeStamp(t uint64) { metaData.time = t } func SetLocation(g string) { metaData.location = g } var ( patTable = psi.StdPat.Bytes() pmtTable = psi.StdPmtTimeLocation.Bytes() ) const ( sdtPid = 17 patPid = 0 pmtPid = 4096 videoPid = 256 streamID = 0xe0 // First video stream ID. ) // Time related constants. const ( // ptsOffset is the offset added to the clock to determine // the current presentation timestamp, ptsOffset = 700 * time.Millisecond // pcrFreq is the base Program Clock Reference frequency. pcrFreq = 90000 // Hz ) // Encoder encapsulates properties of an mpegts generator. type Encoder struct { dst io.Writer clock time.Duration frameInterval time.Duration ptsOffset time.Duration psiCount int continuity map[int]byte } // NewEncoder returns an Encoder with the specified frame rate. func NewEncoder(dst io.Writer, fps float64) *Encoder { return &Encoder{ dst: dst, frameInterval: time.Duration(float64(time.Second) / fps), ptsOffset: ptsOffset, continuity: map[int]byte{ patPid: 0, pmtPid: 0, videoPid: 0, }, } } const ( hasPayload = 0x1 hasAdaptationField = 0x2 ) const ( hasDTS = 0x1 hasPTS = 0x2 ) // generate handles the incoming data and generates equivalent mpegts packets - // sending them to the output channel func (e *Encoder) Encode(nalu []byte) error { // Prepare PES data. pesPkt := pes.Packet{ StreamID: streamID, PDI: hasPTS, PTS: e.pts(), Data: nalu, HeaderLength: 5, } buf := pesPkt.Bytes() pusi := true for len(buf) != 0 { pkt := Packet{ PUSI: pusi, PID: videoPid, RAI: pusi, CC: e.ccFor(videoPid), AFC: hasAdaptationField | hasPayload, PCRF: pusi, } n := pkt.FillPayload(buf) buf = buf[n:] if pusi { // If the packet has a Payload Unit Start Indicator // flag set then we need to write a PCR. pkt.PCR = e.pcr() pusi = false } if e.psiCount <= 0 { err := e.writePSI() if err != nil { return err } } e.psiCount-- _, err := e.dst.Write(pkt.Bytes()) if err != nil { return err } } e.tick() return nil } // writePSI creates mpegts with pat and pmt tables - with pmt table having updated // location and time data. func (e *Encoder) writePSI() error { // Write PAT patPkt := Packet{ PUSI: true, PID: patPid, CC: e.ccFor(patPid), AFC: hasPayload, Payload: addPadding(patTable), } _, err := e.dst.Write(patPkt.Bytes()) if err != nil { return err } // Update pmt table time and location err = psi.UpdateTime(pmtTable, metaData.time) if err != nil { return err } err = psi.UpdateLocation(pmtTable, metaData.location) if err != nil { return nil } // Create mts packet from pmt table pmtPkt := Packet{ PUSI: true, PID: pmtPid, CC: e.ccFor(pmtPid), AFC: hasPayload, Payload: addPadding(pmtTable), } _, err = e.dst.Write(pmtPkt.Bytes()) if err != nil { return err } e.psiCount = psiSendCount return nil } // addPadding adds an appropriate amount of padding to a pat or pmt table for // addition to an mpegts packet func addPadding(d []byte) []byte { for len(d) < psiPacketSize { d = append(d, 0xff) } return d } // tick advances the clock one frame interval. func (e *Encoder) tick() { e.clock += e.frameInterval } // pts retuns the current presentation timestamp. func (e *Encoder) pts() uint64 { return uint64((e.clock + e.ptsOffset).Seconds() * pcrFreq) } // pcr returns the current program clock reference. func (e *Encoder) pcr() uint64 { return uint64(e.clock.Seconds() * pcrFreq) } // ccFor returns the next continuity counter for pid. func (e *Encoder) ccFor(pid int) byte { cc := e.continuity[pid] const continuityCounterMask = 0xf e.continuity[pid] = (cc + 1) & continuityCounterMask return cc }