remove unused code

writer.go

@@ -553,148 +553,4 @@ func WritePMTPacket(w io.Writer, pmt PMT, pid uint) (err error) {
 	return
 }
 
-type SimpleH264Writer struct {
-	W         io.Writer
-	TimeScale int
 
-	SPS []byte
-	PPS []byte
-
-	tswPAT  *TSWriter
-	tswPMT  *TSWriter
-	tswH264 *TSWriter
-
-	PTS int64
-	PCR int64
-
-	prepared bool
-	writeSPS bool
-
-	pesBuf *bytes.Buffer
-	patBuf []byte
-	pmtBuf []byte
-}
-
-func (self *SimpleH264Writer) prepare() (err error) {
-	pat := PAT{
-		Entries: []PATEntry{
-			{ProgramNumber: 1, ProgramMapPID: 0x1000},
-		},
-	}
-	bw := &bytes.Buffer{}
-	if err = WritePAT(bw, pat); err != nil {
-		return
-	}
-	self.patBuf = bw.Bytes()
-
-	pmt := PMT{
-		PCRPID: 0x100,
-		ElementaryStreamInfos: []ElementaryStreamInfo{
-			{StreamType: ElementaryStreamTypeH264, ElementaryPID: 0x100},
-		},
-	}
-	bw = &bytes.Buffer{}
-	if err = WritePMT(bw, pmt); err != nil {
-		return
-	}
-	self.pmtBuf = bw.Bytes()
-
-	self.tswPMT = &TSWriter{
-		PID: 0x1000,
-		DiscontinuityIndicator: true,
-	}
-	self.tswPAT = &TSWriter{
-		PID: 0,
-		DiscontinuityIndicator: true,
-	}
-	self.tswH264 = &TSWriter{
-		PID: 0x100,
-		DiscontinuityIndicator: true,
-	}
-
-	self.tswH264.EnableVecWriter()
-
-	if self.PTS == 0 {
-		// 1s
-		self.PTS = int64(self.TimeScale)
-	}
-	if self.PCR == 0 {
-		// 1s
-		self.PCR = int64(self.TimeScale)
-	}
-
-	self.pesBuf = &bytes.Buffer{}
-
-	self.prepared = true
-	return
-}
-
-func (self *SimpleH264Writer) WriteHeader() (err error) {
-	if !self.prepared {
-		if err = self.prepare(); err != nil {
-			return
-		}
-	}
-	self.tswPAT.W = self.W
-	if err = self.tswPAT.Write(self.patBuf); err != nil {
-		return
-	}
-	self.tswPMT.W = self.W
-	if err = self.tswPMT.Write(self.pmtBuf); err != nil {
-		return
-	}
-	self.writeSPS = true
-	return
-}
-
-func (self *SimpleH264Writer) WriteNALU(sync bool, duration int, nalu []byte) (err error) {
-	nalus := [][]byte{}
-
-	if !self.prepared {
-		if err = self.WriteHeader(); err != nil {
-			return
-		}
-	}
-
-	if self.writeSPS {
-		self.writeSPS = false
-		nalus = append(nalus, self.SPS)
-		nalus = append(nalus, self.PPS)
-	}
-	nalus = append(nalus, nalu)
-
-	pes := PESHeader{
-		StreamId: StreamIdH264,
-		PTS:      uint64(self.PTS) * PTS_HZ / uint64(self.TimeScale),
-	}
-	if err = WritePESHeader(self.pesBuf, pes, 0); err != nil {
-		return
-	}
-
-	data := &iovec{}
-	data.Append(self.pesBuf.Bytes())
-	for i, nalu := range nalus {
-		var startCode []byte
-		if i == 0 {
-			startCode = []byte{0, 0, 0, 1, 0x9, 0xf0, 0, 0, 0, 1} // AUD
-		} else {
-			startCode = []byte{0, 0, 1}
-		}
-		data.Append(startCode)
-		data.Append(nalu)
-	}
-
-	self.tswH264.RandomAccessIndicator = sync
-	self.tswH264.PCR = uint64(self.PCR) * PCR_HZ / uint64(self.TimeScale)
-
-	self.tswH264.W = self.W
-	if err = self.tswH264.WriteIovec(data); err != nil {
-		return
-	}
-
-	self.PTS += int64(duration)
-	self.PCR += int64(duration)
-	self.pesBuf.Reset()
-
-	return
-}