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

use AVCC as H264 pkt.Data

Browse Source
This commit is contained in:
nareix 2016-07-03 15:35:12 +08:00
parent 0016af8cb1
commit 9cac7971c4
8 changed files with 22 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
codec/h264parser/parser.go
View File

@ -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

14
format/flv/flv.go
View File

@ -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
if pkt.Data, ok = h264parser.FindDataNALUInAVCCNALUs(tag.Data); !ok {
err = fmt.Errorf("flv: input h264 format invalid")
return
}
pkt.Data = tag.Data
break loop
}

9
format/mp4/demuxer.go
View File

@ -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

12
format/mp4/muxer.go
View File

@ -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 {
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
}
sampleSize += len(pkt.Data)
if _, err = self.muxer.mdatWriter.Write(pkt.Data); err != nil {
return
}

15
format/rtmp/rtmp.go
View File

@ -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
if pkt.Data, ok = h264parser.FindDataNALUInAVCCNALUs(tag.Data); !ok {
err = fmt.Errorf("rtmp: input h264 format invalid")
return
}
pkt.Data = tag.Data
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 {
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 := self.makeH264Videodata(flvio.AVC_NALU, pkt.IsKeyFrame, pkt.Data)
videodata.CompositionTime = int32(timeToTs(pkt.CompositionTime))
w := self.writeVideoDataStart()
videodata.Marshal(w)

7
format/rtsp/client.go
View File

@ -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)

21
format/ts/demuxer.go
View File

@ -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 {
case 7:
switch {
case naltype == 7:
sps = nalu
case 8:
case naltype == 8:
pps = nalu
case 6:
case 9:
default:
if false {
fmt.Println("h264", len(nalus), "\n", hex.Dump(nalu))
}
self.addPacket(nalu, time.Duration(0))
case h264parser.IsDataNALU(nalu):
// raw nalu to avcc
b := make([]byte, 4+len(nalu))
pio.PutU32BE(b[0:4], uint32(len(nalu)))
copy(b[4:], nalu)
self.addPacket(b, time.Duration(0))
}
}
}

6
format/ts/muxer.go
View File

@ -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)
})