use AVCC as H264 pkt.Data

codec/h264parser/parser.go

@@ -225,20 +225,6 @@ func CheckNALUsType(b []byte) (typ int) {
 	return
 }
 
-func FindDataNALUInAVCCNALUs(b []byte) (data []byte, ok bool) {
-	var typ int
-	var nalus [][]byte
-	if nalus, typ = SplitNALUs(b); typ != NALU_AVCC {
-		return
-	}
-	for _, nalu := range nalus {
-		if IsDataNALU(nalu) {
-			return nalu, true
-		}
-	}
-	return
-}
-
 const (
 	NALU_RAW = iota
 	NALU_AVCC

format/flv/flv.go

@@ -77,16 +77,10 @@ func (self *Muxer) WritePacket(pkt av.Packet) (err error) {
 
 	switch stream.Type() {
 	case av.H264:
-		if typ := h264parser.CheckNALUsType(pkt.Data); typ != h264parser.NALU_RAW {
-			err = fmt.Errorf("flv: h264 nalu format=%d invalid", typ)
-			return
-		}
-		var b [4]byte
-		pio.PutU32BE(b[:], uint32(len(pkt.Data)))
 		tag := &flvio.Videodata{
 			AVCPacketType: flvio.AVC_NALU,
 			CodecID: flvio.VIDEO_H264,
-			Datav: [][]byte{b[:], pkt.Data},
+			Data: pkt.Data,
 			CompositionTime: timeToTs(pkt.CompositionTime),
 		}
 		if pkt.IsKeyFrame {
@@ -251,11 +245,7 @@ func (self *Demuxer) ReadPacket() (pkt av.Packet, err error) {
 				pkt.Idx = int8(self.videostreamidx)
 				pkt.CompositionTime = tsToTime(tag.CompositionTime)
 				pkt.IsKeyFrame = tag.FrameType == flvio.FRAME_KEY
-				var ok bool
+				pkt.Data = tag.Data
-				if pkt.Data, ok = h264parser.FindDataNALUInAVCCNALUs(tag.Data); !ok {
-					err = fmt.Errorf("flv: input h264 format invalid")
-					return
-				}
 				break loop
 			}
 

format/mp4/demuxer.go

@@ -382,15 +382,6 @@ func (self *Stream) readPacket() (pkt av.Packet, err error) {
 		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

format/mp4/muxer.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"time"
 	"github.com/nareix/joy4/av"
-	"github.com/nareix/pio"
 	"github.com/nareix/joy4/codec/aacparser"
 	"github.com/nareix/joy4/codec/h264parser"
 	"github.com/nareix/joy4/format/mp4/atom"
@@ -195,16 +194,7 @@ func (self *Stream) writePacket(pkt av.Packet) (err error) {
 	}
 
 	if self.Type() == av.H264 {
-		if typ := h264parser.CheckNALUsType(pkt.Data); typ != h264parser.NALU_RAW {
+		sampleSize += len(pkt.Data)
-			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
 		}

format/rtmp/rtmp.go

@@ -775,11 +775,7 @@ func (self *Conn) ReadPacket() (pkt av.Packet, err error) {
 		switch tag := _tag.(type) {
 		case *flvio.Videodata:
 			pkt.CompositionTime = tsToTime(uint32(tag.CompositionTime))
-			var ok bool
+			pkt.Data = tag.Data
-			if pkt.Data, ok = h264parser.FindDataNALUInAVCCNALUs(tag.Data); !ok {
-				err = fmt.Errorf("rtmp: input h264 format invalid")
-				return
-			}
 			pkt.IsKeyFrame = tag.FrameType == flvio.FRAME_KEY
 			pkt.Idx = int8(self.videostreamidx)
 			break poll
@@ -881,14 +877,7 @@ func (self *Conn) WritePacket(pkt av.Packet) (err error) {
 		}
 
 	case av.H264:
-		if typ := h264parser.CheckNALUsType(pkt.Data); typ != h264parser.NALU_RAW {
+		videodata := self.makeH264Videodata(flvio.AVC_NALU, pkt.IsKeyFrame, pkt.Data)
-			err = fmt.Errorf("rtmp: h264 nalu format=%d invalid", typ)
-			return
-		}
-		var b [4]byte
-		pio.PutU32BE(b[:], uint32(len(pkt.Data)))
-		videodata := self.makeH264Videodata(flvio.AVC_NALU, pkt.IsKeyFrame, []byte{})
-		videodata.Datav = [][]byte{b[:], pkt.Data}
 		videodata.CompositionTime = int32(timeToTs(pkt.CompositionTime))
 		w := self.writeVideoDataStart()
 		videodata.Marshal(w)

format/rtsp/client.go

@@ -8,6 +8,7 @@ import (
 	"encoding/binary"
 	"encoding/hex"
 	"fmt"
+	"github.com/nareix/pio"
 	"github.com/nareix/joy4/av"
 	"github.com/nareix/joy4/av/avutil"
 	"github.com/nareix/joy4/codec"
@@ -821,7 +822,11 @@ func (self *Stream) handleH264Payload(timestamp uint32, packet []byte) (err erro
 				self.pkt.IsKeyFrame = true
 			}
 			self.gotpkt = true
-			self.pkt.Data = packet
+			// raw nalu to avcc
+			b := make([]byte, 4+len(packet))
+			pio.PutU32BE(b[0:4], uint32(len(packet)))
+			copy(b[4:], packet)
+			self.pkt.Data = b
 			self.timestamp = timestamp
 		} else {
 			err = fmt.Errorf("rtsp: unsupported H264 naluType=%d", naluType)

format/ts/demuxer.go

@@ -2,9 +2,9 @@ package ts
 
 import (
 	"bytes"
-	"encoding/hex"
 	"fmt"
 	"time"
+	"github.com/nareix/pio"
 	"github.com/nareix/joy4/av"
 	"github.com/nareix/joy4/codec/aacparser"
 	"github.com/nareix/joy4/codec/h264parser"
@@ -203,18 +203,17 @@ func (self *Stream) payloadEnd() (err error) {
 		for _, nalu := range nalus {
 			if len(nalu) > 0 {
 				naltype := nalu[0] & 0x1f
-				switch naltype {
+				switch {
-				case 7:
+				case naltype == 7:
 					sps = nalu
-				case 8:
+				case naltype == 8:
 					pps = nalu
-				case 6:
+				case h264parser.IsDataNALU(nalu):
-				case 9:
+					// raw nalu to avcc
-				default:
+					b := make([]byte, 4+len(nalu))
-					if false {
+					pio.PutU32BE(b[0:4], uint32(len(nalu)))
-						fmt.Println("h264", len(nalus), "\n", hex.Dump(nalu))
+					copy(b[4:], nalu)
-					}
+					self.addPacket(b, time.Duration(0))
-					self.addPacket(nalu, time.Duration(0))
 				}
 			}
 		}

format/ts/muxer.go

@@ -172,15 +172,11 @@ func (self *Muxer) writePacket(pkt av.Packet) (err error) {
 		}
 		WritePESHeader(buf, pes, 0)
 
-		if typ := h264parser.CheckNALUsType(pkt.Data); typ != h264parser.NALU_RAW {
-			err = fmt.Errorf("ts: h264 nalu format=%d invalid", typ)
-			return
-		}
 		nalus := [][]byte{}
 		if pkt.IsKeyFrame {
 			nalus = append([][]byte{codec.SPS(), codec.PPS()})
 		}
-		nalus = append(nalus, pkt.Data)
+		nalus = append(nalus, pkt.Data[4:])
 		h264parser.WalkNALUsAnnexb(nalus, func(b []byte) {
 			buf.Write(b)
 		})