diff --git a/gb28181/mediaserver/conn.go b/gb28181/mediaserver/conn.go index e7f0fff..c359c42 100644 --- a/gb28181/mediaserver/conn.go +++ b/gb28181/mediaserver/conn.go @@ -33,7 +33,7 @@ type Conn struct { conn net.Conn r io.Reader check bool - demuxer *mpegps.PSDemuxer + demuxer *mpegps.PsDemuxer streamName string lalServer logic.ILalServer lalSession logic.ICustomizePubSessionContext @@ -55,7 +55,7 @@ func NewConn(conn net.Conn, observer IGbObserver, lal logic.ILalServer) *Conn { c := &Conn{ conn: conn, r: conn, - demuxer: mpegps.NewPSDemuxer(), + demuxer: mpegps.NewPsDemuxer(), observer: observer, lalServer: lal, buffer: bytes.NewBuffer(nil), @@ -200,7 +200,7 @@ func (c *Conn) Demuxer(data []byte) error { return nil } -func (c *Conn) OnFrame(frame []byte, cid mpegps.PS_STREAM_TYPE, pts uint64, dts uint64) { +func (c *Conn) OnFrame(frame []byte, cid mpegps.PsStreamType, pts uint64, dts uint64) { payloadType := getPayloadType(cid) if payloadType == base.AvPacketPtUnknown { return @@ -254,17 +254,17 @@ func (c *Conn) OnFrame(frame []byte, cid mpegps.PS_STREAM_TYPE, pts uint64, dts } } -func getPayloadType(cid mpegps.PS_STREAM_TYPE) base.AvPacketPt { +func getPayloadType(cid mpegps.PsStreamType) base.AvPacketPt { switch cid { - case mpegps.PS_STREAM_AAC: + case mpegps.PsStreamAac: return base.AvPacketPtAac - case mpegps.PS_STREAM_G711A: + case mpegps.PsStreamG711A: return base.AvPacketPtG711A - case mpegps.PS_STREAM_G711U: + case mpegps.PsStreamG711U: return base.AvPacketPtG711U - case mpegps.PS_STREAM_H264: + case mpegps.PsStreamH264: return base.AvPacketPtAvc - case mpegps.PS_STREAM_H265: + case mpegps.PsStreamH265: return base.AvPacketPtHevc } diff --git a/gb28181/mpegps/bitstream_test.go b/gb28181/mpegps/bitstream_test.go deleted file mode 100644 index c8a39ef..0000000 --- a/gb28181/mpegps/bitstream_test.go +++ /dev/null @@ -1,141 +0,0 @@ -package mpegps - -import ( - "testing" -) - -var testbit []byte = []byte{0x01, 0x44, 0x55} - -func Test_GetBits(t *testing.T) { - bs := NewBitStream(testbit) - t.Log(bs.GetBits(4)) - t.Log(bs.GetBits(4)) - t.Log(bs.GetBit()) - t.Log(bs.GetBits(4)) - t.Log(bs.GetBits(4)) - t.Log(bs.GetBits(4)) - t.Log(bs.GetBits(3)) - -} - -func Test_UnRead(t *testing.T) { - bs := NewBitStream(testbit) - t.Log(bs.GetBits(4)) - t.Log(bs.GetBits(4)) - t.Log(bs.GetBit()) - t.Log(bs.GetBits(4)) - t.Log(bs.GetBits(4)) - t.Log(bs.GetBits(4)) - t.Log(bs.GetBits(3)) - bs.UnRead(3) - t.Log(bs.GetBits(3)) - bs.UnRead(4) - t.Log(bs.GetBits(4)) - bs.UnRead(5) - t.Log(bs.GetBits(5)) - bs.UnRead(15) - t.Log(bs.GetBits(2)) - t.Log(bs.GetBits(3)) -} - -func Test_SkipBits(t *testing.T) { - bs := NewBitStream(testbit) - bs.SkipBits(4) - t.Log(bs.GetBits(4)) -} - -func Test_DistanceFromMarkDot(t *testing.T) { - bs := NewBitStream(testbit) - bs.SkipBits(4) - bs.Markdot() - t.Log(bs.GetBits(4)) - t.Log(bs.GetBits(4)) - t.Log(bs.GetBits(1)) - t.Log(bs.DistanceFromMarkDot()) -} - -func Test_BitStreamWriter(t *testing.T) { - bsw := NewBitStreamWriter(4) - bsw.PutByte(1) - bsw.PutBytes([]byte{0xdd, 0xFF}) - bsw.PutUint8(3, 2) - bsw.PutUint16(0x4c, 7) - bsw.PutUint16(0xED, 6) - t.Logf("%x", bsw.Bits()) -} - -func TestBitStream_RemainBits(t *testing.T) { - type fields struct { - bits []byte - bytesOffset int - bitsOffset int - bitsmark int - bytemark int - } - tests := []struct { - name string - fields fields - want int - }{ - {name: "test1", fields: fields{ - bits: []byte{0x00, 0x01, 0x02, 0x03}, - bytesOffset: 0, - bitsOffset: 0, - bitsmark: 0, - bytemark: 0, - }, want: 32}, - {name: "test2", fields: fields{ - bits: []byte{0x00, 0x01, 0x02, 0x03}, - bytesOffset: 0, - bitsOffset: 1, - bitsmark: 0, - bytemark: 0, - }, want: 31}, - {name: "test2", fields: fields{ - bits: []byte{0x00, 0x01, 0x02, 0x03}, - bytesOffset: 1, - bitsOffset: 1, - bitsmark: 0, - bytemark: 0, - }, want: 23}, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - bs := &BitStream{ - bits: tt.fields.bits, - bytesOffset: tt.fields.bytesOffset, - bitsOffset: tt.fields.bitsOffset, - bitsmark: tt.fields.bitsmark, - bytemark: tt.fields.bytemark, - } - if got := bs.RemainBits(); got != tt.want { - t.Errorf("BitStream.RemainBits() = %v, want %v", got, tt.want) - } - }) - } -} - -var bits []byte = []byte{0x80} -var bits1 []byte = []byte{0x40} -var bits2 []byte = []byte{0x60} -var bits3 []byte = []byte{0x20} - -func TestBitStream_ReadUE(t *testing.T) { - tests := []struct { - name string - bs *BitStream - want uint64 - }{ - {name: "test1", bs: NewBitStream(bits), want: 0}, - {name: "test1", bs: NewBitStream(bits1), want: 1}, - {name: "test1", bs: NewBitStream(bits2), want: 2}, - {name: "test1", bs: NewBitStream(bits3), want: 3}, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - if got := tt.bs.ReadUE(); got != tt.want { - t.Errorf("BitStream.ReadUE() = %v, want %v", got, tt.want) - } - }) - } -} diff --git a/gb28181/mpegps/pes_proto.go b/gb28181/mpegps/pes_proto.go index e46e87f..409d852 100644 --- a/gb28181/mpegps/pes_proto.go +++ b/gb28181/mpegps/pes_proto.go @@ -5,81 +5,80 @@ import ( "os" ) -type TS_STREAM_TYPE int +type TsStreamType int const ( - TS_STREAM_AUDIO_MPEG1 TS_STREAM_TYPE = 0x03 - TS_STREAM_AUDIO_MPEG2 TS_STREAM_TYPE = 0x04 - TS_STREAM_AAC TS_STREAM_TYPE = 0x0F - TS_STREAM_H264 TS_STREAM_TYPE = 0x1B - TS_STREAM_H265 TS_STREAM_TYPE = 0x24 + TsStreamAudioMpeg1 TsStreamType = 0x03 + TsStreamAudioMpeg2 TsStreamType = 0x04 + TsStreamAac TsStreamType = 0x0F + TsStreamH264 TsStreamType = 0x1B + TsStreamH265 TsStreamType = 0x24 ) -var H264_AUD_NALU []byte = []byte{0x00, 0x00, 0x00, 0x01, 0x09, 0xF0} //ffmpeg mpegtsenc.c mpegts_write_packet_internal -var H265_AUD_NALU []byte = []byte{0x00, 0x00, 0x00, 0x01, 0x46, 0x01, 0x50} +var H264AudNalu []byte = []byte{0x00, 0x00, 0x00, 0x01, 0x09, 0xF0} //ffmpeg mpegtsenc.c mpegts_write_packet_internal +var H265AudNalu []byte = []byte{0x00, 0x00, 0x00, 0x01, 0x46, 0x01, 0x50} -type PES_STREMA_ID int +type PesStreamId int const ( - PES_STREAM_END PES_STREMA_ID = 0xB9 - PES_STREAM_START PES_STREMA_ID = 0xBA - PES_STREAM_SYSTEM_HEAD PES_STREMA_ID = 0xBB - PES_STREAM_MAP PES_STREMA_ID = 0xBC - PES_STREAM_PRIVATE PES_STREMA_ID = 0xBD - PES_STREAM_AUDIO PES_STREMA_ID = 0xC0 - PES_STREAM_VIDEO PES_STREMA_ID = 0xE0 + PesStreamEnd PesStreamId = 0xB9 + PesStreamStart PesStreamId = 0xBA + PesStreamSystemHead PesStreamId = 0xBB + PesStreamMap PesStreamId = 0xBC + PesStreamPrivate PesStreamId = 0xBD + PesStreamAudio PesStreamId = 0xC0 + PesStreamVideo PesStreamId = 0xE0 ) type Display interface { PrettyPrint(file *os.File) } -func findPESIDByStreamType(cid TS_STREAM_TYPE) PES_STREMA_ID { - +func findPesIdByStreamType(cid TsStreamType) PesStreamId { switch cid { - case TS_STREAM_AAC, TS_STREAM_AUDIO_MPEG1, TS_STREAM_AUDIO_MPEG2: - return PES_STREAM_AUDIO - case TS_STREAM_H264, TS_STREAM_H265: - return PES_STREAM_VIDEO + case TsStreamAac, TsStreamAudioMpeg1, TsStreamAudioMpeg2: + return PesStreamAudio + case TsStreamH264, TsStreamH265: + return PesStreamVideo default: - return PES_STREAM_PRIVATE + return PesStreamPrivate } } type PesPacket struct { - Stream_id uint8 - PES_packet_length uint16 - PES_scrambling_control uint8 - PES_priority uint8 - Data_alignment_indicator uint8 - Copyright uint8 - Original_or_copy uint8 - PTS_DTS_flags uint8 - ESCR_flag uint8 - ES_rate_flag uint8 - DSM_trick_mode_flag uint8 - Additional_copy_info_flag uint8 - PES_CRC_flag uint8 - PES_extension_flag uint8 - PES_header_data_length uint8 - Pts uint64 - Dts uint64 - ESCR_base uint64 - ESCR_extension uint16 - ES_rate uint32 - Trick_mode_control uint8 - Trick_value uint8 - Additional_copy_info uint8 - Previous_PES_packet_CRC uint16 - Pes_payload []byte + StreamId uint8 + PesPacketLength uint16 + PesScramblingControl uint8 + PesPriority uint8 + DataAlignmentIndicator uint8 + Copyright uint8 + OriginalOrCopy uint8 + PtsDtsFlags uint8 + EscrFlag uint8 + EsRateFlag uint8 + DsmTrickModeFlag uint8 + AdditionalCopyInfoFlag uint8 + PesCrcFlag uint8 + PesExtensionFlag uint8 + PesHeaderDataLength uint8 + Pts uint64 + Dts uint64 + EscrBase uint64 + EscrExtension uint16 + EsRate uint32 + TrickModeControl uint8 + TrickValue uint8 + AdditionalCopyInfo uint8 + PreviousPesPacketCrc uint16 + PesPayload []byte //TODO - //if ( PES_extension_flag == '1') - // PES_private_data_flag uint8 - // pack_header_field_flag uint8 - // program_packet_sequence_counter_flag uint8 - // P_STD_buffer_flag uint8 - // PES_extension_flag_2 uint8 - // PES_private_data [16]byte + //if ( PesExtensionFlag == '1') + // PesPrivateDataFlag uint8 + // PackHeaderFieldFlag uint8 + // ProgramPacketSequenceCounterFlag uint8 + // PStdBufferFlag uint8 + // PesExtensionFlag2 uint8 + // PesPrivateData [16]byte } func NewPesPacket() *PesPacket { @@ -87,57 +86,57 @@ func NewPesPacket() *PesPacket { } func (pkg *PesPacket) PrettyPrint(file *os.File) { - file.WriteString(fmt.Sprintf("stream_id:%d\n", pkg.Stream_id)) - file.WriteString(fmt.Sprintf("PES_packet_length:%d\n", pkg.PES_packet_length)) - file.WriteString(fmt.Sprintf("PES_scrambling_control:%d\n", pkg.PES_scrambling_control)) - file.WriteString(fmt.Sprintf("PES_priority:%d\n", pkg.PES_priority)) - file.WriteString(fmt.Sprintf("data_alignment_indicator:%d\n", pkg.Data_alignment_indicator)) + file.WriteString(fmt.Sprintf("stream id:%d\n", pkg.StreamId)) + file.WriteString(fmt.Sprintf("pes packet length:%d\n", pkg.PesPacketLength)) + file.WriteString(fmt.Sprintf("pes scrambling control:%d\n", pkg.PesScramblingControl)) + file.WriteString(fmt.Sprintf("pes priority:%d\n", pkg.PesPriority)) + file.WriteString(fmt.Sprintf("data alignment indicator:%d\n", pkg.DataAlignmentIndicator)) file.WriteString(fmt.Sprintf("copyright:%d\n", pkg.Copyright)) - file.WriteString(fmt.Sprintf("original_or_copy:%d\n", pkg.Original_or_copy)) - file.WriteString(fmt.Sprintf("PTS_DTS_flags:%d\n", pkg.PTS_DTS_flags)) - file.WriteString(fmt.Sprintf("ESCR_flag:%d\n", pkg.ESCR_flag)) - file.WriteString(fmt.Sprintf("ES_rate_flag:%d\n", pkg.ES_rate_flag)) - file.WriteString(fmt.Sprintf("DSM_trick_mode_flag:%d\n", pkg.DSM_trick_mode_flag)) - file.WriteString(fmt.Sprintf("additional_copy_info_flag:%d\n", pkg.Additional_copy_info_flag)) - file.WriteString(fmt.Sprintf("PES_CRC_flag:%d\n", pkg.PES_CRC_flag)) - file.WriteString(fmt.Sprintf("PES_extension_flag:%d\n", pkg.PES_extension_flag)) - file.WriteString(fmt.Sprintf("PES_header_data_length:%d\n", pkg.PES_header_data_length)) - if pkg.PTS_DTS_flags&0x02 == 0x02 { + file.WriteString(fmt.Sprintf("original or copy:%d\n", pkg.OriginalOrCopy)) + file.WriteString(fmt.Sprintf("pts dts flags:%d\n", pkg.PtsDtsFlags)) + file.WriteString(fmt.Sprintf("escr flag:%d\n", pkg.EscrFlag)) + file.WriteString(fmt.Sprintf("es rate flag:%d\n", pkg.EsRateFlag)) + file.WriteString(fmt.Sprintf("dsm trick mode flag:%d\n", pkg.DsmTrickModeFlag)) + file.WriteString(fmt.Sprintf("additional copy info flag:%d\n", pkg.AdditionalCopyInfoFlag)) + file.WriteString(fmt.Sprintf("pes crc flag:%d\n", pkg.PesCrcFlag)) + file.WriteString(fmt.Sprintf("pes extension flag:%d\n", pkg.PesExtensionFlag)) + file.WriteString(fmt.Sprintf("pes header data length:%d\n", pkg.PesHeaderDataLength)) + if pkg.PtsDtsFlags&0x02 == 0x02 { file.WriteString(fmt.Sprintf("PTS:%d\n", pkg.Pts)) } - if pkg.PTS_DTS_flags&0x03 == 0x03 { + if pkg.PtsDtsFlags&0x03 == 0x03 { file.WriteString(fmt.Sprintf("DTS:%d\n", pkg.Dts)) } - if pkg.ESCR_flag == 1 { - file.WriteString(fmt.Sprintf("ESCR_base:%d\n", pkg.ESCR_base)) - file.WriteString(fmt.Sprintf("ESCR_extension:%d\n", pkg.ESCR_extension)) + if pkg.EscrFlag == 1 { + file.WriteString(fmt.Sprintf("escr base:%d\n", pkg.EscrBase)) + file.WriteString(fmt.Sprintf("escr extension:%d\n", pkg.EscrExtension)) } - if pkg.ES_rate_flag == 1 { - file.WriteString(fmt.Sprintf("ES_rate:%d\n", pkg.ES_rate)) + if pkg.EsRateFlag == 1 { + file.WriteString(fmt.Sprintf("es rate:%d\n", pkg.EsRate)) } - if pkg.DSM_trick_mode_flag == 1 { - file.WriteString(fmt.Sprintf("trick_mode_control:%d\n", pkg.Trick_mode_control)) + if pkg.DsmTrickModeFlag == 1 { + file.WriteString(fmt.Sprintf("trick mode control:%d\n", pkg.TrickModeControl)) } - if pkg.Additional_copy_info_flag == 1 { - file.WriteString(fmt.Sprintf("additional_copy_info:%d\n", pkg.Additional_copy_info)) + if pkg.AdditionalCopyInfoFlag == 1 { + file.WriteString(fmt.Sprintf("additional copy info:%d\n", pkg.AdditionalCopyInfo)) } - if pkg.PES_CRC_flag == 1 { - file.WriteString(fmt.Sprintf("previous_PES_packet_CRC:%d\n", pkg.Previous_PES_packet_CRC)) + if pkg.PesCrcFlag == 1 { + file.WriteString(fmt.Sprintf("previous pes packet crc:%d\n", pkg.PreviousPesPacketCrc)) } - file.WriteString("PES_packet_data_byte:\n") - file.WriteString(fmt.Sprintf(" Size: %d\n", len(pkg.Pes_payload))) + file.WriteString("pes packet data byte:\n") + file.WriteString(fmt.Sprintf(" size: %d\n", len(pkg.PesPayload))) file.WriteString(" data:") - for i := 0; i < 12 && i < len(pkg.Pes_payload); i++ { + for i := 0; i < 12 && i < len(pkg.PesPayload); i++ { if i%4 == 0 { file.WriteString("\n") file.WriteString(" ") } - file.WriteString(fmt.Sprintf("0x%02x ", pkg.Pes_payload[i])) + file.WriteString(fmt.Sprintf("0x%02x ", pkg.PesPayload[i])) } file.WriteString("\n") } @@ -146,29 +145,29 @@ func (pkg *PesPacket) Decode(bs *BitStream) error { if bs.RemainBytes() < 9 { return errNeedMore } - bs.SkipBits(24) //packet_start_code_prefix - pkg.Stream_id = bs.Uint8(8) //stream_id - pkg.PES_packet_length = bs.Uint16(16) + bs.SkipBits(24) //packet_start_code_prefix + pkg.StreamId = bs.Uint8(8) //stream_id + pkg.PesPacketLength = bs.Uint16(16) bs.SkipBits(2) //'10' - pkg.PES_scrambling_control = bs.Uint8(2) - pkg.PES_priority = bs.Uint8(1) - pkg.Data_alignment_indicator = bs.Uint8(1) + pkg.PesScramblingControl = bs.Uint8(2) + pkg.PesPriority = bs.Uint8(1) + pkg.DataAlignmentIndicator = bs.Uint8(1) pkg.Copyright = bs.Uint8(1) - pkg.Original_or_copy = bs.Uint8(1) - pkg.PTS_DTS_flags = bs.Uint8(2) - pkg.ESCR_flag = bs.Uint8(1) - pkg.ES_rate_flag = bs.Uint8(1) - pkg.DSM_trick_mode_flag = bs.Uint8(1) - pkg.Additional_copy_info_flag = bs.Uint8(1) - pkg.PES_CRC_flag = bs.Uint8(1) - pkg.PES_extension_flag = bs.Uint8(1) - pkg.PES_header_data_length = bs.Uint8(8) - if bs.RemainBytes() < int(pkg.PES_header_data_length) { + pkg.OriginalOrCopy = bs.Uint8(1) + pkg.PtsDtsFlags = bs.Uint8(2) + pkg.EscrFlag = bs.Uint8(1) + pkg.EsRateFlag = bs.Uint8(1) + pkg.DsmTrickModeFlag = bs.Uint8(1) + pkg.AdditionalCopyInfoFlag = bs.Uint8(1) + pkg.PesCrcFlag = bs.Uint8(1) + pkg.PesExtensionFlag = bs.Uint8(1) + pkg.PesHeaderDataLength = bs.Uint8(8) + if bs.RemainBytes() < int(pkg.PesHeaderDataLength) { bs.UnRead(9 * 8) return errNeedMore } bs.Markdot() - if pkg.PTS_DTS_flags&0x02 == 0x02 { + if pkg.PtsDtsFlags&0x02 == 0x02 { bs.SkipBits(4) pkg.Pts = bs.GetBits(3) bs.SkipBits(1) @@ -177,7 +176,7 @@ func (pkg *PesPacket) Decode(bs *BitStream) error { pkg.Pts = (pkg.Pts << 15) | bs.GetBits(15) bs.SkipBits(1) } - if pkg.PTS_DTS_flags&0x03 == 0x03 { + if pkg.PtsDtsFlags&0x03 == 0x03 { bs.SkipBits(4) pkg.Dts = bs.GetBits(3) bs.SkipBits(1) @@ -189,56 +188,56 @@ func (pkg *PesPacket) Decode(bs *BitStream) error { pkg.Dts = pkg.Pts } - if pkg.ESCR_flag == 1 { + if pkg.EscrFlag == 1 { bs.SkipBits(2) - pkg.ESCR_base = bs.GetBits(3) + pkg.EscrBase = bs.GetBits(3) bs.SkipBits(1) - pkg.ESCR_base = (pkg.Pts << 15) | bs.GetBits(15) + pkg.EscrBase = (pkg.Pts << 15) | bs.GetBits(15) bs.SkipBits(1) - pkg.ESCR_base = (pkg.Pts << 15) | bs.GetBits(15) + pkg.EscrBase = (pkg.Pts << 15) | bs.GetBits(15) bs.SkipBits(1) - pkg.ESCR_extension = bs.Uint16(9) + pkg.EscrExtension = bs.Uint16(9) bs.SkipBits(1) } - if pkg.ES_rate_flag == 1 { + if pkg.EsRateFlag == 1 { bs.SkipBits(1) - pkg.ES_rate = bs.Uint32(22) + pkg.EsRate = bs.Uint32(22) bs.SkipBits(1) } - if pkg.DSM_trick_mode_flag == 1 { - pkg.Trick_mode_control = bs.Uint8(3) - pkg.Trick_value = bs.Uint8(5) + if pkg.DsmTrickModeFlag == 1 { + pkg.TrickModeControl = bs.Uint8(3) + pkg.TrickValue = bs.Uint8(5) } - if pkg.Additional_copy_info_flag == 1 { - pkg.Additional_copy_info = bs.Uint8(7) + if pkg.AdditionalCopyInfoFlag == 1 { + pkg.AdditionalCopyInfo = bs.Uint8(7) } - if pkg.PES_CRC_flag == 1 { - pkg.Previous_PES_packet_CRC = bs.Uint16(16) + if pkg.PesCrcFlag == 1 { + pkg.PreviousPesPacketCrc = bs.Uint16(16) } loc := bs.DistanceFromMarkDot() - bs.SkipBits(int(pkg.PES_header_data_length)*8 - loc) // skip remaining header + bs.SkipBits(int(pkg.PesHeaderDataLength)*8 - loc) // skip remaining header // the -3 bytes are the combined lengths - // of all fields between PES_packet_length and PES_header_data_length (2 bytes) - // and the PES_header_data_length itself (1 byte) - dataLen := int(pkg.PES_packet_length - 3 - uint16(pkg.PES_header_data_length)) + // of all fields between PesHeaderDataLength and PesHeaderDataLength (2 bytes) + // and the PesHeaderDataLength itself (1 byte) + dataLen := int(pkg.PesPacketLength - 3 - uint16(pkg.PesHeaderDataLength)) if bs.RemainBytes() < dataLen { - pkg.Pes_payload = bs.RemainData() - bs.UnRead((9 + int(pkg.PES_header_data_length)) * 8) + pkg.PesPayload = bs.RemainData() + bs.UnRead((9 + int(pkg.PesHeaderDataLength)) * 8) return errNeedMore } - if pkg.PES_packet_length == 0 || bs.RemainBytes() <= dataLen { - pkg.Pes_payload = bs.RemainData() + if pkg.PesPacketLength == 0 || bs.RemainBytes() <= dataLen { + pkg.PesPayload = bs.RemainData() bs.SkipBits(bs.RemainBits()) } else { - pkg.Pes_payload = bs.RemainData()[:dataLen] + pkg.PesPayload = bs.RemainData()[:dataLen] bs.SkipBits(dataLen * 8) } @@ -249,10 +248,10 @@ func (pkg *PesPacket) DecodeMpeg1(bs *BitStream) error { if bs.RemainBytes() < 6 { return errNeedMore } - bs.SkipBits(24) //packet_start_code_prefix - pkg.Stream_id = bs.Uint8(8) //stream_id - pkg.PES_packet_length = bs.Uint16(16) - if pkg.PES_packet_length != 0 && bs.RemainBytes() < int(pkg.PES_packet_length) { + bs.SkipBits(24) //packet_start_code_prefix + pkg.StreamId = bs.Uint8(8) //stream_id + pkg.PesPacketLength = bs.Uint16(16) + if pkg.PesPacketLength != 0 && bs.RemainBytes() < int(pkg.PesPacketLength) { bs.UnRead(6 * 8) return errNeedMore } @@ -291,39 +290,39 @@ func (pkg *PesPacket) DecodeMpeg1(bs *BitStream) error { return errParser } loc := bs.DistanceFromMarkDot() / 8 - if pkg.PES_packet_length < uint16(loc) { + if pkg.PesPacketLength < uint16(loc) { return errParser } - if pkg.PES_packet_length == 0 || - bs.RemainBits() <= int(pkg.PES_packet_length-uint16(loc))*8 { - pkg.Pes_payload = bs.RemainData() + if pkg.PesPacketLength == 0 || + bs.RemainBits() <= int(pkg.PesPacketLength-uint16(loc))*8 { + pkg.PesPayload = bs.RemainData() bs.SkipBits(bs.RemainBits()) } else { - pkg.Pes_payload = bs.RemainData()[:pkg.PES_packet_length-uint16(loc)] - bs.SkipBits(int(pkg.PES_packet_length-uint16(loc)) * 8) + pkg.PesPayload = bs.RemainData()[:pkg.PesPacketLength-uint16(loc)] + bs.SkipBits(int(pkg.PesPacketLength-uint16(loc)) * 8) } return nil } func (pkg *PesPacket) Encode(bsw *BitStreamWriter) { bsw.PutBytes([]byte{0x00, 0x00, 0x01}) - bsw.PutByte(pkg.Stream_id) - bsw.PutUint16(pkg.PES_packet_length, 16) + bsw.PutByte(pkg.StreamId) + bsw.PutUint16(pkg.PesPacketLength, 16) bsw.PutUint8(0x02, 2) - bsw.PutUint8(pkg.PES_scrambling_control, 2) - bsw.PutUint8(pkg.PES_priority, 1) - bsw.PutUint8(pkg.Data_alignment_indicator, 1) + bsw.PutUint8(pkg.PesScramblingControl, 2) + bsw.PutUint8(pkg.PesPriority, 1) + bsw.PutUint8(pkg.DataAlignmentIndicator, 1) bsw.PutUint8(pkg.Copyright, 1) - bsw.PutUint8(pkg.Original_or_copy, 1) - bsw.PutUint8(pkg.PTS_DTS_flags, 2) - bsw.PutUint8(pkg.ESCR_flag, 1) - bsw.PutUint8(pkg.ES_rate_flag, 1) - bsw.PutUint8(pkg.DSM_trick_mode_flag, 1) - bsw.PutUint8(pkg.Additional_copy_info_flag, 1) - bsw.PutUint8(pkg.PES_CRC_flag, 1) - bsw.PutUint8(pkg.PES_extension_flag, 1) - bsw.PutByte(pkg.PES_header_data_length) - if pkg.PTS_DTS_flags == 0x02 { + bsw.PutUint8(pkg.OriginalOrCopy, 1) + bsw.PutUint8(pkg.PtsDtsFlags, 2) + bsw.PutUint8(pkg.EscrFlag, 1) + bsw.PutUint8(pkg.EsRateFlag, 1) + bsw.PutUint8(pkg.DsmTrickModeFlag, 1) + bsw.PutUint8(pkg.AdditionalCopyInfoFlag, 1) + bsw.PutUint8(pkg.PesCrcFlag, 1) + bsw.PutUint8(pkg.PesExtensionFlag, 1) + bsw.PutByte(pkg.PesHeaderDataLength) + if pkg.PtsDtsFlags == 0x02 { bsw.PutUint8(0x02, 4) bsw.PutUint64(pkg.Pts>>30, 3) bsw.PutUint8(0x01, 1) @@ -333,7 +332,7 @@ func (pkg *PesPacket) Encode(bsw *BitStreamWriter) { bsw.PutUint8(0x01, 1) } - if pkg.PTS_DTS_flags == 0x03 { + if pkg.PtsDtsFlags == 0x03 { bsw.PutUint8(0x03, 4) bsw.PutUint64(pkg.Pts>>30, 3) bsw.PutUint8(0x01, 1) @@ -350,14 +349,14 @@ func (pkg *PesPacket) Encode(bsw *BitStreamWriter) { bsw.PutUint8(0x01, 1) } - if pkg.ESCR_flag == 1 { + if pkg.EscrFlag == 1 { bsw.PutUint8(0x03, 2) - bsw.PutUint64(pkg.ESCR_base>>30, 3) + bsw.PutUint64(pkg.EscrBase>>30, 3) bsw.PutUint8(0x01, 1) - bsw.PutUint64(pkg.ESCR_base>>15, 15) + bsw.PutUint64(pkg.EscrBase>>15, 15) bsw.PutUint8(0x01, 1) - bsw.PutUint64(pkg.ESCR_base, 15) + bsw.PutUint64(pkg.EscrBase, 15) bsw.PutUint8(0x01, 1) } - bsw.PutBytes(pkg.Pes_payload) + bsw.PutBytes(pkg.PesPayload) } diff --git a/gb28181/mpegps/ps.go b/gb28181/mpegps/ps.go deleted file mode 100644 index df842d3..0000000 --- a/gb28181/mpegps/ps.go +++ /dev/null @@ -1,52 +0,0 @@ -package mpegps - -import "errors" - -const ( - PsPackStartCodePackHeader = 0x01ba - PsPackStartCodeSystemHeader = 0x01bb - PsPackStartCodeProgramStreamMap = 0x01bc - PsPackStartCodeAudioStream = 0x01c0 - PsPackStartCodeVideoStream = 0x01e0 - PsPackStartCodeHikStream = 0x01bd - - PsPackStartCodePesPsd = 0x01ff // program_stream_directory - PsPackStartCodePesPadding = 0x01be // padding_stream - PsPackStartCodePesPrivate2 = 0x01bf // padding_stream_2 - PsPackStartCodePesEcm = 0x01f0 // ECM_stream - PsPackStartCodePesEmm = 0x01f1 // EMM_stream - - PsPackStartCodePackEnd = 0x01b9 -) - -const ( - StreamTypeH264 uint8 = 0x1b - StreamTypeH265 = 0x24 - StreamTypeAAC = 0x0f - StreamTypeG711A = 0x90 //PCMA - StreamTypeG7221 = 0x92 - StreamTypeG7231 = 0x93 - StreamTypeG729 = 0x99 - StreamTypeUnknown = 0 -) - -const psbufInitSize = 4096 -const ( - PsHeaderlen int = 14 - SysHeaderlen int = 18 - SysMapHeaderLen int = 24 - PesHeaderLen int = 19 -) -const ( - MaxPesLen = 0xFFFF // 64k pes data - MaxPesPayloadLen = MaxPesLen - PesHeaderLen + 5 // 64k pes data -) -const ( - StreamIdVideo = 0xe0 - StreamIdAudio = 0xc0 -) -const adtsMinLen = 7 -const naluStartCodeLen = 4 - -var maxUnpackRtpListSize = 2048 -var ErrGb28181 = errors.New("tops.gb28181: fxxk") diff --git a/gb28181/mpegps/ps_demuxer.go b/gb28181/mpegps/ps_demuxer.go index 52adf8a..9b78c18 100644 --- a/gb28181/mpegps/ps_demuxer.go +++ b/gb28181/mpegps/ps_demuxer.go @@ -7,58 +7,59 @@ import ( "github.com/q191201771/lal/pkg/hevc" ) -type psstream struct { +type psStream struct { sid uint8 - cid PS_STREAM_TYPE + cid PsStreamType pts uint64 dts uint64 streamBuf []byte } -func newpsstream(sid uint8, cid PS_STREAM_TYPE) *psstream { - return &psstream{ +func newPsStream(sid uint8, cid PsStreamType) *psStream { + return &psStream{ sid: sid, cid: cid, streamBuf: make([]byte, 0, 4096), } } -func (p *psstream) setCid(cid PS_STREAM_TYPE) { +func (p *psStream) setCid(cid PsStreamType) { p.cid = cid } -type PSDemuxer struct { - streamMap map[uint8]*psstream - pkg *PSPacket +type PsDemuxer struct { + streamMap map[uint8]*psStream + pkg *PsPacket mpeg1 bool cache []byte - OnFrame func(frame []byte, cid PS_STREAM_TYPE, pts uint64, dts uint64) + OnFrame func(frame []byte, cid PsStreamType, pts uint64, dts uint64) //解ps包过程中，解码回调psm，system header，pes包等 //decodeResult 解码ps包时的产生的错误 //这个回调主要用于debug，查看是否ps包存在问题 OnPacket func(pkg Display, decodeResult error) } -func NewPSDemuxer() *PSDemuxer { - psdemuxer := &PSDemuxer{ - streamMap: make(map[uint8]*psstream), - pkg: new(PSPacket), +func NewPsDemuxer() *PsDemuxer { + psDemuxer := &PsDemuxer{ + streamMap: make(map[uint8]*psStream), + pkg: new(PsPacket), cache: make([]byte, 0, 256), OnFrame: nil, OnPacket: nil, } //兼容没有发送psm的ps包 - streamH264 := newpsstream(uint8(PES_STREAM_VIDEO), PS_STREAM_H264) - streamG711A := newpsstream(uint8(PES_STREAM_AUDIO), PS_STREAM_G711A) - psdemuxer.streamMap[streamH264.sid] = streamH264 - psdemuxer.streamMap[streamG711A.sid] = streamG711A - return psdemuxer + //兼容没有发送psm的ps包 + streamH264 := newPsStream(uint8(PesStreamVideo), PsStreamH264) + streamG711A := newPsStream(uint8(PesStreamAudio), PsStreamG711A) + psDemuxer.streamMap[streamH264.sid] = streamH264 + psDemuxer.streamMap[streamG711A.sid] = streamG711A + return psDemuxer } -func (psdemuxer *PSDemuxer) Input(data []byte) error { +func (psDemuxer *PsDemuxer) Input(data []byte) error { var bs *BitStream - if len(psdemuxer.cache) > 0 { - psdemuxer.cache = append(psdemuxer.cache, data...) - bs = NewBitStream(psdemuxer.cache) + if len(psDemuxer.cache) > 0 { + psDemuxer.cache = append(psDemuxer.cache, data...) + bs = NewBitStream(psDemuxer.cache) } else { bs = NewBitStream(data) } @@ -66,7 +67,7 @@ func (psdemuxer *PSDemuxer) Input(data []byte) error { saveReseved := func() { tmpcache := make([]byte, bs.RemainBytes()) copy(tmpcache, bs.RemainData()) - psdemuxer.cache = tmpcache + psDemuxer.cache = tmpcache } var ret error = nil @@ -85,83 +86,83 @@ func (psdemuxer *PSDemuxer) Input(data []byte) error { prefix_code := bs.NextBits(32) switch prefix_code { case 0x000001BA: //pack header - if psdemuxer.pkg.Header == nil { - psdemuxer.pkg.Header = new(PSPackHeader) + if psDemuxer.pkg.Header == nil { + psDemuxer.pkg.Header = new(PsPackHeader) } - ret = psdemuxer.pkg.Header.Decode(bs) - psdemuxer.mpeg1 = psdemuxer.pkg.Header.IsMpeg1 - if psdemuxer.OnPacket != nil { - psdemuxer.OnPacket(psdemuxer.pkg.Header, ret) + ret = psDemuxer.pkg.Header.Decode(bs) + psDemuxer.mpeg1 = psDemuxer.pkg.Header.IsMpeg1 + if psDemuxer.OnPacket != nil { + psDemuxer.OnPacket(psDemuxer.pkg.Header, ret) } case 0x000001BB: //system header - if psdemuxer.pkg.Header == nil { - return errors.New("psdemuxer.pkg.Header must not be nil") + if psDemuxer.pkg.Header == nil { + return errors.New("PsDemuxer.pkg.Header must not be nil") } - if psdemuxer.pkg.System == nil { - psdemuxer.pkg.System = new(System_header) + if psDemuxer.pkg.System == nil { + psDemuxer.pkg.System = new(SystemHeader) } - ret = psdemuxer.pkg.System.Decode(bs) - if psdemuxer.OnPacket != nil { - psdemuxer.OnPacket(psdemuxer.pkg.System, ret) + ret = psDemuxer.pkg.System.Decode(bs) + if psDemuxer.OnPacket != nil { + psDemuxer.OnPacket(psDemuxer.pkg.System, ret) } case 0x000001BC: //program stream map - if psdemuxer.pkg.Psm == nil { - psdemuxer.pkg.Psm = new(Program_stream_map) + if psDemuxer.pkg.Psm == nil { + psDemuxer.pkg.Psm = new(ProgramStreamMap) } - if ret = psdemuxer.pkg.Psm.Decode(bs); ret == nil { - for _, streaminfo := range psdemuxer.pkg.Psm.Stream_map { - if _, found := psdemuxer.streamMap[streaminfo.Elementary_stream_id]; !found { - stream := newpsstream(streaminfo.Elementary_stream_id, PS_STREAM_TYPE(streaminfo.Stream_type)) - psdemuxer.streamMap[stream.sid] = stream + if ret = psDemuxer.pkg.Psm.Decode(bs); ret == nil { + for _, streaminfo := range psDemuxer.pkg.Psm.StreamMap { + if _, found := psDemuxer.streamMap[streaminfo.ElementaryStreamId]; !found { + stream := newPsStream(streaminfo.ElementaryStreamId, PsStreamType(streaminfo.StreamType)) + psDemuxer.streamMap[stream.sid] = stream } else { - stream := psdemuxer.streamMap[streaminfo.Elementary_stream_id] - stream.setCid(PS_STREAM_TYPE(streaminfo.Stream_type)) + stream := psDemuxer.streamMap[streaminfo.ElementaryStreamId] + stream.setCid(PsStreamType(streaminfo.StreamType)) } } } - if psdemuxer.OnPacket != nil { - psdemuxer.OnPacket(psdemuxer.pkg.Psm, ret) + if psDemuxer.OnPacket != nil { + psDemuxer.OnPacket(psDemuxer.pkg.Psm, ret) } case 0x000001BD, 0x000001BE, 0x000001BF, 0x000001F0, 0x000001F1, 0x000001F2, 0x000001F3, 0x000001F4, 0x000001F5, 0x000001F6, 0x000001F7, 0x000001F8, 0x000001F9, 0x000001FA, 0x000001FB: - if psdemuxer.pkg.CommPes == nil { - psdemuxer.pkg.CommPes = new(CommonPesPacket) + if psDemuxer.pkg.CommPes == nil { + psDemuxer.pkg.CommPes = new(CommonPesPacket) } - ret = psdemuxer.pkg.CommPes.Decode(bs) + ret = psDemuxer.pkg.CommPes.Decode(bs) case 0x000001FF: //program stream directory - if psdemuxer.pkg.Psd == nil { - psdemuxer.pkg.Psd = new(Program_stream_directory) + if psDemuxer.pkg.Psd == nil { + psDemuxer.pkg.Psd = new(ProgramStreamDirectory) } - ret = psdemuxer.pkg.Psd.Decode(bs) + ret = psDemuxer.pkg.Psd.Decode(bs) case 0x000001B9: //MPEG_program_end_code continue default: if prefix_code&0xFFFFFFE0 == 0x000001C0 || prefix_code&0xFFFFFFE0 == 0x000001E0 { - if psdemuxer.pkg.Pes == nil { - psdemuxer.pkg.Pes = NewPesPacket() + if psDemuxer.pkg.Pes == nil { + psDemuxer.pkg.Pes = NewPesPacket() } - if psdemuxer.mpeg1 { - ret = psdemuxer.pkg.Pes.DecodeMpeg1(bs) + if psDemuxer.mpeg1 { + ret = psDemuxer.pkg.Pes.DecodeMpeg1(bs) } else { - ret = psdemuxer.pkg.Pes.Decode(bs) + ret = psDemuxer.pkg.Pes.Decode(bs) } - if psdemuxer.OnPacket != nil { - psdemuxer.OnPacket(psdemuxer.pkg.Pes, ret) + if psDemuxer.OnPacket != nil { + psDemuxer.OnPacket(psDemuxer.pkg.Pes, ret) } if ret == nil { - if stream, found := psdemuxer.streamMap[psdemuxer.pkg.Pes.Stream_id]; found { - if psdemuxer.mpeg1 && stream.cid == PS_STREAM_UNKNOW { - psdemuxer.guessCodecid(stream) + if stream, found := psDemuxer.streamMap[psDemuxer.pkg.Pes.StreamId]; found { + if psDemuxer.mpeg1 && stream.cid == PsStreamUnknow { + psDemuxer.guessCodecid(stream) } - psdemuxer.demuxPespacket(stream, psdemuxer.pkg.Pes) + psDemuxer.demuxPespacket(stream, psDemuxer.pkg.Pes) } else { - if psdemuxer.mpeg1 { - stream := newpsstream(psdemuxer.pkg.Pes.Stream_id, PS_STREAM_UNKNOW) - psdemuxer.streamMap[stream.sid] = stream - stream.streamBuf = append(stream.streamBuf, psdemuxer.pkg.Pes.Pes_payload...) - stream.pts = psdemuxer.pkg.Pes.Pts - stream.dts = psdemuxer.pkg.Pes.Dts + if psDemuxer.mpeg1 { + stream := newPsStream(psDemuxer.pkg.Pes.StreamId, PsStreamUnknow) + psDemuxer.streamMap[stream.sid] = stream + stream.streamBuf = append(stream.streamBuf, psDemuxer.pkg.Pes.PesPayload...) + stream.pts = psDemuxer.pkg.Pes.Pts + stream.dts = psDemuxer.pkg.Pes.Dts } } } @@ -171,28 +172,28 @@ func (psdemuxer *PSDemuxer) Input(data []byte) error { } } - if ret == nil && len(psdemuxer.cache) > 0 { - psdemuxer.cache = nil + if ret == nil && len(psDemuxer.cache) > 0 { + psDemuxer.cache = nil } return ret } -func (psdemuxer *PSDemuxer) Flush() { - for _, stream := range psdemuxer.streamMap { +func (psDemuxer *PsDemuxer) Flush() { + for _, stream := range psDemuxer.streamMap { if len(stream.streamBuf) == 0 { continue } - if psdemuxer.OnFrame != nil { - psdemuxer.OnFrame(stream.streamBuf, stream.cid, stream.pts/90, stream.dts/90) + if psDemuxer.OnFrame != nil { + psDemuxer.OnFrame(stream.streamBuf, stream.cid, stream.pts/90, stream.dts/90) } } } -func (psdemuxer *PSDemuxer) guessCodecid(stream *psstream) { - if stream.sid&0xE0 == uint8(PES_STREAM_AUDIO) { - stream.cid = PS_STREAM_AAC - } else if stream.sid&0xE0 == uint8(PES_STREAM_VIDEO) { +func (psDemuxer *PsDemuxer) guessCodecid(stream *psStream) { + if stream.sid&0xE0 == uint8(PesStreamAudio) { + stream.cid = PsStreamAac + } else if stream.sid&0xE0 == uint8(PesStreamVideo) { h264score := 0 h265score := 0 SplitFrame(stream.streamBuf, func(nalu []byte) bool { @@ -219,46 +220,46 @@ func (psdemuxer *PSDemuxer) guessCodecid(stream *psstream) { h265score -= 1 } if h264score > h265score && h264score >= 4 { - stream.cid = PS_STREAM_H264 + stream.cid = PsStreamH264 } else if h264score < h265score && h265score >= 4 { - stream.cid = PS_STREAM_H265 + stream.cid = PsStreamH265 } return true }) } } -func (psdemuxer *PSDemuxer) demuxPespacket(stream *psstream, pes *PesPacket) error { +func (psDemuxer *PsDemuxer) demuxPespacket(stream *psStream, pes *PesPacket) error { switch stream.cid { - case PS_STREAM_AAC, PS_STREAM_G711A, PS_STREAM_G711U: - return psdemuxer.demuxAudio(stream, pes) - case PS_STREAM_H264, PS_STREAM_H265: - return psdemuxer.demuxH26x(stream, pes) - case PS_STREAM_UNKNOW: + case PsStreamAac, PsStreamG711A, PsStreamG711U: + return psDemuxer.demuxAudio(stream, pes) + case PsStreamH264, PsStreamH265: + return psDemuxer.demuxH26x(stream, pes) + case PsStreamUnknow: if stream.pts != pes.Pts { stream.streamBuf = nil } - stream.streamBuf = append(stream.streamBuf, pes.Pes_payload...) + stream.streamBuf = append(stream.streamBuf, pes.PesPayload...) stream.pts = pes.Pts stream.dts = pes.Dts } return nil } -func (psdemuxer *PSDemuxer) demuxAudio(stream *psstream, pes *PesPacket) error { - if psdemuxer.OnFrame != nil { - psdemuxer.OnFrame(pes.Pes_payload, stream.cid, pes.Pts/90, pes.Dts/90) +func (psDemuxer *PsDemuxer) demuxAudio(stream *psStream, pes *PesPacket) error { + if psDemuxer.OnFrame != nil { + psDemuxer.OnFrame(pes.PesPayload, stream.cid, pes.Pts/90, pes.Dts/90) } return nil } -func (psdemuxer *PSDemuxer) demuxH26x(stream *psstream, pes *PesPacket) error { +func (psDemuxer *PsDemuxer) demuxH26x(stream *psStream, pes *PesPacket) error { if stream.pts == 0 { - stream.streamBuf = append(stream.streamBuf, pes.Pes_payload...) + stream.streamBuf = append(stream.streamBuf, pes.PesPayload...) stream.pts = pes.Pts stream.dts = pes.Dts } else if stream.pts == pes.Pts || pes.Pts == 0 { - stream.streamBuf = append(stream.streamBuf, pes.Pes_payload...) + stream.streamBuf = append(stream.streamBuf, pes.PesPayload...) } else { start, sc := FindStartCode(stream.streamBuf, 0) for start >= 0 && start < len(stream.streamBuf) { @@ -266,18 +267,18 @@ func (psdemuxer *PSDemuxer) demuxH26x(stream *psstream, pes *PesPacket) error { if end < 0 { end = len(stream.streamBuf) } - if stream.cid == PS_STREAM_H264 { + if stream.cid == PsStreamH264 { naluType := H264NaluType(stream.streamBuf[start:]) if naluType != avc.NaluTypeAud { - if psdemuxer.OnFrame != nil { - psdemuxer.OnFrame(stream.streamBuf[start:end], stream.cid, stream.pts/90, stream.dts/90) + if psDemuxer.OnFrame != nil { + psDemuxer.OnFrame(stream.streamBuf[start:end], stream.cid, stream.pts/90, stream.dts/90) } } - } else if stream.cid == PS_STREAM_H265 { + } else if stream.cid == PsStreamH265 { naluType := H265NaluType(stream.streamBuf[start:]) if naluType != hevc.NaluTypeAud { - if psdemuxer.OnFrame != nil { - psdemuxer.OnFrame(stream.streamBuf[start:end], stream.cid, stream.pts/90, stream.dts/90) + if psDemuxer.OnFrame != nil { + psDemuxer.OnFrame(stream.streamBuf[start:end], stream.cid, stream.pts/90, stream.dts/90) } } } @@ -285,7 +286,7 @@ func (psdemuxer *PSDemuxer) demuxH26x(stream *psstream, pes *PesPacket) error { sc = sc2 } stream.streamBuf = nil - stream.streamBuf = append(stream.streamBuf, pes.Pes_payload...) + stream.streamBuf = append(stream.streamBuf, pes.PesPayload...) stream.pts = pes.Pts stream.dts = pes.Dts } diff --git a/gb28181/mpegps/ps_demuxer_test.go b/gb28181/mpegps/ps_demuxer_test.go index c981d98..f043d65 100644 --- a/gb28181/mpegps/ps_demuxer_test.go +++ b/gb28181/mpegps/ps_demuxer_test.go @@ -3,10 +3,10 @@ package mpegps import ( "encoding/hex" "fmt" - "github.com/q191201771/lal/pkg/base" - "github.com/q191201771/lal/pkg/rtprtcp" - "github.com/q191201771/naza/pkg/nazabytes" - "github.com/q191201771/naza/pkg/nazalog" + "github.com/lalmax-pro/streamsvr/pkg/base" + "github.com/lalmax-pro/streamsvr/pkg/rtprtcp" + "github.com/lalmax-pro/streamsvr/utils/naza/nazabytes" + "github.com/lalmax-pro/streamsvr/utils/naza/nazalog" "io" "os" "testing" @@ -24,10 +24,10 @@ var ps7 []byte = []byte{0x00, 0x00, 0x01, 0xBA, 0x20, 0x0a, 0x00, 0x00, 0x00, 0x func TestPSDemuxer_Input(t *testing.T) { type fields struct { streamMap map[uint8]*psstream - pkg *PSPacket + pkg *PsPacket cache []byte OnPacket func(pkg Display, decodeResult error) - OnFrame func(frame []byte, cid PS_STREAM_TYPE, pts uint64, dts uint64) + OnFrame func(frame []byte, cid PsStreamType, pts uint64, dts uint64) } type args struct { data []byte @@ -40,40 +40,40 @@ func TestPSDemuxer_Input(t *testing.T) { }{ {name: "test1", fields: fields{ streamMap: make(map[uint8]*psstream), - pkg: new(PSPacket), + pkg: new(PsPacket), }, args: args{data: ps1}, wantErr: true}, {name: "test2", fields: fields{ streamMap: make(map[uint8]*psstream), - pkg: new(PSPacket), + pkg: new(PsPacket), }, args: args{data: ps2}, wantErr: false}, {name: "test3", fields: fields{ streamMap: make(map[uint8]*psstream), - pkg: new(PSPacket), + pkg: new(PsPacket), }, args: args{data: ps3}, wantErr: true}, {name: "test4", fields: fields{ streamMap: make(map[uint8]*psstream), - pkg: new(PSPacket), + pkg: new(PsPacket), }, args: args{data: ps4}, wantErr: true}, {name: "test5", fields: fields{ streamMap: make(map[uint8]*psstream), - pkg: new(PSPacket), + pkg: new(PsPacket), }, args: args{data: ps5}, wantErr: false}, {name: "test6", fields: fields{ streamMap: make(map[uint8]*psstream), - pkg: new(PSPacket), + pkg: new(PsPacket), }, args: args{data: ps6}, wantErr: false}, {name: "test-mpeg1", fields: fields{ streamMap: make(map[uint8]*psstream), - pkg: new(PSPacket), + pkg: new(PsPacket), }, args: args{data: ps7}, wantErr: false}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - psdemuxer := &PSDemuxer{ + psdemuxer := &PsDemuxer{ streamMap: tt.fields.streamMap, pkg: tt.fields.pkg, cache: tt.fields.cache, @@ -87,7 +87,7 @@ func TestPSDemuxer_Input(t *testing.T) { } } func TestPSDemuxer(t *testing.T) { - var psUnpacker *PSDemuxer + var psUnpacker *PsDemuxer os.Remove("h.ps") os.Remove("h.h264") os.Remove("ps_demux_result") @@ -97,14 +97,14 @@ func TestPSDemuxer(t *testing.T) { fmt.Println(err) return } - psUnpacker = NewPSDemuxer() - psUnpacker.OnFrame = func(frame []byte, cid PS_STREAM_TYPE, pts uint64, dts uint64) { - if cid == PS_STREAM_H264 || cid == PS_STREAM_H265 { + psUnpacker = NewPsDemuxer() + psUnpacker.OnFrame = func(frame []byte, cid PsStreamType, pts uint64, dts uint64) { + if cid == PsStreamH264 || cid == PsStreamH265 { writeFile("h.h264", frame) } else { - if cid == PS_STREAM_G711A { + if cid == PsStreamG711a { nazalog.Infof("存在音频g711A 大小：%d dts:%d", len(frame), dts) - } else if cid == PS_STREAM_G711U { + } else if cid == PsStreamG711u { nazalog.Infof("存在音频g711U 大小：%d dts:%d", len(frame), dts) } else { nazalog.Infof("存在音频aac 大小：%d dts:%d", len(frame), dts) @@ -120,21 +120,21 @@ func TestPSDemuxer(t *testing.T) { defer fd3.Close() psUnpacker.OnPacket = func(pkg Display, decodeResult error) { switch value := pkg.(type) { - case *PSPackHeader: + case *PsPackHeader: fd3.WriteString("--------------PS Pack Header--------------\n") if decodeResult == nil { value.PrettyPrint(fd3) } else { fd3.WriteString(fmt.Sprintf("Decode Ps Packet Failed %s\n", decodeResult.Error())) } - case *System_header: + case *SystemHeader: fd3.WriteString("--------------System Header--------------\n") if decodeResult == nil { value.PrettyPrint(fd3) } else { fd3.WriteString(fmt.Sprintf("Decode Ps Packet Failed %s\n", decodeResult.Error())) } - case *Program_stream_map: + case *ProgramStreamMap: fd3.WriteString("--------------------PSM-------------------\n") if decodeResult == nil { value.PrettyPrint(fd3) diff --git a/gb28181/mpegps/ps_muxer.go b/gb28181/mpegps/ps_muxer.go index 501e616..aab31c7 100644 --- a/gb28181/mpegps/ps_muxer.go +++ b/gb28181/mpegps/ps_muxer.go @@ -6,51 +6,51 @@ import ( "github.com/q191201771/lal/pkg/hevc" ) -type PSMuxer struct { - system *System_header - psm *Program_stream_map +type PsMuxer struct { + system *SystemHeader + psm *ProgramStreamMap OnPacket func(pkg []byte, pts uint64) firstframe bool } -func NewPsMuxer() *PSMuxer { - muxer := new(PSMuxer) +func NewPsMuxer() *PsMuxer { + muxer := new(PsMuxer) muxer.firstframe = true - muxer.system = new(System_header) - muxer.system.Rate_bound = 26234 - muxer.psm = new(Program_stream_map) - muxer.psm.Current_next_indicator = 1 - muxer.psm.Program_stream_map_version = 1 + muxer.system = new(SystemHeader) + muxer.system.RateBound = 26234 + muxer.psm = new(ProgramStreamMap) + muxer.psm.CurrentNextIndicator = 1 + muxer.psm.ProgramStreamMapVersion = 1 muxer.OnPacket = nil return muxer } -func (muxer *PSMuxer) AddStream(cid PS_STREAM_TYPE) uint8 { - if cid == PS_STREAM_H265 || cid == PS_STREAM_H264 { - es := NewElementary_Stream(uint8(PES_STREAM_VIDEO) + muxer.system.Video_bound) - es.P_STD_buffer_bound_scale = 1 - es.P_STD_buffer_size_bound = 400 +func (muxer *PsMuxer) AddStream(cid PsStreamType) uint8 { + if cid == PsStreamH265 || cid == PsStreamH264 { + es := NewElementaryStream(uint8(PesStreamVideo) + muxer.system.VideoBound) + es.PStdBufferBoundScale = 1 + es.PStdBufferSizeBound = 400 muxer.system.Streams = append(muxer.system.Streams, es) - muxer.system.Video_bound++ - muxer.psm.Stream_map = append(muxer.psm.Stream_map, NewElementary_stream_elem(uint8(cid), es.Stream_id)) - muxer.psm.Program_stream_map_version++ - return es.Stream_id + muxer.system.VideoBound++ + muxer.psm.StreamMap = append(muxer.psm.StreamMap, NewElementaryStreamElem(uint8(cid), es.StreamId)) + muxer.psm.ProgramStreamMapVersion++ + return es.StreamId } else { - es := NewElementary_Stream(uint8(PES_STREAM_AUDIO) + muxer.system.Audio_bound) - es.P_STD_buffer_bound_scale = 0 - es.P_STD_buffer_size_bound = 32 + es := NewElementaryStream(uint8(PesStreamAudio) + muxer.system.AudioBound) + es.PStdBufferBoundScale = 0 + es.PStdBufferSizeBound = 32 muxer.system.Streams = append(muxer.system.Streams, es) - muxer.system.Audio_bound++ - muxer.psm.Stream_map = append(muxer.psm.Stream_map, NewElementary_stream_elem(uint8(cid), es.Stream_id)) - muxer.psm.Program_stream_map_version++ - return es.Stream_id + muxer.system.AudioBound++ + muxer.psm.StreamMap = append(muxer.psm.StreamMap, NewElementaryStreamElem(uint8(cid), es.StreamId)) + muxer.psm.ProgramStreamMapVersion++ + return es.StreamId } } -func (muxer *PSMuxer) Write(sid uint8, frame []byte, pts uint64, dts uint64) error { - var stream *Elementary_stream_elem = nil - for _, es := range muxer.psm.Stream_map { - if es.Elementary_stream_id == sid { +func (muxer *PsMuxer) Write(sid uint8, frame []byte, pts uint64, dts uint64) error { + var stream *ElementaryStreamElem = nil + for _, es := range muxer.psm.StreamMap { + if es.ElementaryStreamId == sid { stream = es break } @@ -62,33 +62,33 @@ func (muxer *PSMuxer) Write(sid uint8, frame []byte, pts uint64, dts uint64) err return nil } var withaud bool = false - var idr_flag bool = false + var idrFlag bool = false var first bool = true var vcl bool = false - if stream.Stream_type == uint8(PS_STREAM_H264) || stream.Stream_type == uint8(PS_STREAM_H265) { + if stream.StreamType == uint8(PsStreamH264) || stream.StreamType == uint8(PsStreamH265) { SplitFrame(frame, func(nalu []byte) bool { - if stream.Stream_type == uint8(PS_STREAM_H264) { - nalu_type := avc.ParseNaluType(nalu[0]) - if nalu_type == avc.NaluTypeAud { + if stream.StreamType == uint8(PsStreamH264) { + naluType := avc.ParseNaluType(nalu[0]) + if naluType == avc.NaluTypeAud { withaud = true return false - } else if nalu_type >= avc.NaluTypeSlice && nalu_type <= avc.NaluTypeIdrSlice { - if nalu_type == avc.NaluTypeIdrSlice { - idr_flag = true + } else if naluType >= avc.NaluTypeSlice && naluType <= avc.NaluTypeIdrSlice { + if naluType == avc.NaluTypeIdrSlice { + idrFlag = true } vcl = true return false } return true } else { - nalu_type := hevc.ParseNaluType(nalu[0]) - if nalu_type == hevc.NaluTypeAud { + naluType := hevc.ParseNaluType(nalu[0]) + if naluType == hevc.NaluTypeAud { withaud = true return false - } else if nalu_type >= hevc.NaluTypeSliceBlaWlp && nalu_type <= hevc.NaluTypeSliceRsvIrapVcl23 || - nalu_type >= hevc.NaluTypeSliceTrailN && nalu_type <= hevc.NaluTypeSliceRaslR { - if nalu_type >= hevc.NaluTypeSliceBlaWlp && nalu_type <= hevc.NaluTypeSliceRsvIrapVcl23 { - idr_flag = true + } else if naluType >= hevc.NaluTypeSliceBlaWlp && naluType <= hevc.NaluTypeSliceRsvIrapVcl23 || + naluType >= hevc.NaluTypeSliceTrailN && naluType <= hevc.NaluTypeSliceRaslR { + if naluType >= hevc.NaluTypeSliceBlaWlp && naluType <= hevc.NaluTypeSliceRsvIrapVcl23 { + idrFlag = true } vcl = true return false @@ -101,12 +101,12 @@ func (muxer *PSMuxer) Write(sid uint8, frame []byte, pts uint64, dts uint64) err dts = dts * 90 pts = pts * 90 bsw := NewBitStreamWriter(1024) - var pack PSPackHeader - pack.System_clock_reference_base = dts - 3600 - pack.System_clock_reference_extension = 0 - pack.Program_mux_rate = 6106 + var pack PsPackHeader + pack.SystemClockReferenceBase = dts - 3600 + pack.SystemClockReferenceExtension = 0 + pack.ProgramMuxRate = 6106 pack.Encode(bsw) - if muxer.firstframe || idr_flag { + if muxer.firstframe || idrFlag { muxer.system.Encode(bsw) muxer.psm.Encode(bsw) muxer.firstframe = false @@ -114,34 +114,34 @@ func (muxer *PSMuxer) Write(sid uint8, frame []byte, pts uint64, dts uint64) err pespkg := NewPesPacket() for len(frame) > 0 { peshdrlen := 13 - pespkg.Stream_id = sid - pespkg.PTS_DTS_flags = 0x03 - pespkg.PES_header_data_length = 10 + pespkg.StreamId = sid + pespkg.PtsDtsFlags = 0x03 + pespkg.PesHeaderDataLength = 10 pespkg.Pts = pts pespkg.Dts = dts - if idr_flag { - pespkg.Data_alignment_indicator = 1 + if idrFlag { + pespkg.DataAlignmentIndicator = 1 } if first && !withaud && vcl { - if stream.Stream_type == uint8(PS_STREAM_H264) { - pespkg.Pes_payload = append(pespkg.Pes_payload, H264_AUD_NALU...) + if stream.StreamType == uint8(PsStreamH264) { + pespkg.PesPayload = append(pespkg.PesPayload, H264AudNalu...) peshdrlen += 6 - } else if stream.Stream_type == uint8(PS_STREAM_H265) { - pespkg.Pes_payload = append(pespkg.Pes_payload, H265_AUD_NALU...) + } else if stream.StreamType == uint8(PsStreamH265) { + pespkg.PesPayload = append(pespkg.PesPayload, H265AudNalu...) peshdrlen += 7 } } if peshdrlen+len(frame) >= 0xFFFF { - pespkg.PES_packet_length = 0xFFFF - pespkg.Pes_payload = append(pespkg.Pes_payload, frame[0:0xFFFF-peshdrlen]...) + pespkg.PesPacketLength = 0xFFFF + pespkg.PesPayload = append(pespkg.PesPayload, frame[0:0xFFFF-peshdrlen]...) frame = frame[0xFFFF-peshdrlen:] } else { - pespkg.PES_packet_length = uint16(peshdrlen + len(frame)) - pespkg.Pes_payload = append(pespkg.Pes_payload, frame[0:]...) + pespkg.PesPacketLength = uint16(peshdrlen + len(frame)) + pespkg.PesPayload = append(pespkg.PesPayload, frame[0:]...) frame = frame[:0] } pespkg.Encode(bsw) - pespkg.Pes_payload = pespkg.Pes_payload[:0] + pespkg.PesPayload = pespkg.PesPayload[:0] if muxer.OnPacket != nil { muxer.OnPacket(bsw.Bits(), pts) } diff --git a/gb28181/mpegps/ps_proto.go b/gb28181/mpegps/ps_proto.go index e764cdd..0c1298f 100644 --- a/gb28181/mpegps/ps_proto.go +++ b/gb28181/mpegps/ps_proto.go @@ -40,15 +40,15 @@ func (e *sidNotFoundError) NeedMore() bool { return false } func (e *sidNotFoundError) ParserError() bool { return false } func (e *sidNotFoundError) StreamIdNotFound() bool { return true } -type PS_STREAM_TYPE int +type PsStreamType int const ( - PS_STREAM_UNKNOW PS_STREAM_TYPE = 0xFF - PS_STREAM_AAC PS_STREAM_TYPE = 0x0F - PS_STREAM_H264 PS_STREAM_TYPE = 0x1B - PS_STREAM_H265 PS_STREAM_TYPE = 0x24 - PS_STREAM_G711A PS_STREAM_TYPE = 0x90 - PS_STREAM_G711U PS_STREAM_TYPE = 0x91 + PsStreamUnknow PsStreamType = 0xFF + PsStreamAac PsStreamType = 0x0F + PsStreamH264 PsStreamType = 0x1B + PsStreamH265 PsStreamType = 0x24 + PsStreamG711A PsStreamType = 0x90 + PsStreamG711U PsStreamType = 0x91 ) // Table 2-33 – Program Stream pack header @@ -71,28 +71,28 @@ const ( // for (i = 0; i < pack_stuffing_length; i++) { // stuffing_byte 8 bslbf // } -// if (nextbits() == system_header_start_code) { -// system_header () +// if (nextbits() == SystemHeader_start_code) { +// SystemHeader () // } // } -type PSPackHeader struct { - IsMpeg1 bool - System_clock_reference_base uint64 //33 bits - System_clock_reference_extension uint16 //9 bits - Program_mux_rate uint32 //22 bits - Pack_stuffing_length uint8 //3 bitss +type PsPackHeader struct { + IsMpeg1 bool + SystemClockReferenceBase uint64 //33 bits + SystemClockReferenceExtension uint16 //9 bits + ProgramMuxRate uint32 //22 bits + PackStuffingLength uint8 //3 bitss } -func (ps_pkg_hdr *PSPackHeader) PrettyPrint(file *os.File) { - file.WriteString(fmt.Sprintf("IsMpeg1:%t\n", ps_pkg_hdr.IsMpeg1)) - file.WriteString(fmt.Sprintf("System_clock_reference_base:%d\n", ps_pkg_hdr.System_clock_reference_base)) - file.WriteString(fmt.Sprintf("System_clock_reference_extension:%d\n", ps_pkg_hdr.System_clock_reference_extension)) - file.WriteString(fmt.Sprintf("Program_mux_rate:%d\n", ps_pkg_hdr.Program_mux_rate)) - file.WriteString(fmt.Sprintf("Pack_stuffing_length:%d\n", ps_pkg_hdr.Pack_stuffing_length)) +func (psPackHeader *PsPackHeader) PrettyPrint(file *os.File) { + file.WriteString(fmt.Sprintf("IsMpeg1:%t\n", psPackHeader.IsMpeg1)) + file.WriteString(fmt.Sprintf("system clock reference base:%d\n", psPackHeader.SystemClockReferenceBase)) + file.WriteString(fmt.Sprintf("system clock reference extension:%d\n", psPackHeader.SystemClockReferenceExtension)) + file.WriteString(fmt.Sprintf("program mux rate:%d\n", psPackHeader.ProgramMuxRate)) + file.WriteString(fmt.Sprintf("pack stuffing length:%d\n", psPackHeader.PackStuffingLength)) } -func (ps_pkg_hdr *PSPackHeader) Decode(bs *BitStream) error { +func (psPackHeader *PsPackHeader) Decode(bs *BitStream) error { if bs.RemainBytes() < 5 { return errNeedMore } @@ -104,90 +104,90 @@ func (ps_pkg_hdr *PSPackHeader) Decode(bs *BitStream) error { if bs.RemainBytes() < 10 { return errNeedMore } - return ps_pkg_hdr.decodeMpeg2(bs) + return psPackHeader.decodeMpeg2(bs) } else if bs.NextBits(4) == 0x02 { //mpeg1 if bs.RemainBytes() < 8 { return errNeedMore } - ps_pkg_hdr.IsMpeg1 = true - return ps_pkg_hdr.decodeMpeg1(bs) + psPackHeader.IsMpeg1 = true + return psPackHeader.decodeMpeg1(bs) } else { return errParser } } -func (ps_pkg_hdr *PSPackHeader) decodeMpeg2(bs *BitStream) error { +func (psPackHeader *PsPackHeader) decodeMpeg2(bs *BitStream) error { bs.SkipBits(2) - ps_pkg_hdr.System_clock_reference_base = bs.GetBits(3) + psPackHeader.SystemClockReferenceBase = bs.GetBits(3) bs.SkipBits(1) - ps_pkg_hdr.System_clock_reference_base = ps_pkg_hdr.System_clock_reference_base<<15 | bs.GetBits(15) + psPackHeader.SystemClockReferenceBase = psPackHeader.SystemClockReferenceBase<<15 | bs.GetBits(15) bs.SkipBits(1) - ps_pkg_hdr.System_clock_reference_base = ps_pkg_hdr.System_clock_reference_base<<15 | bs.GetBits(15) + psPackHeader.SystemClockReferenceBase = psPackHeader.SystemClockReferenceBase<<15 | bs.GetBits(15) bs.SkipBits(1) - ps_pkg_hdr.System_clock_reference_extension = bs.Uint16(9) + psPackHeader.SystemClockReferenceExtension = bs.Uint16(9) bs.SkipBits(1) - ps_pkg_hdr.Program_mux_rate = bs.Uint32(22) + psPackHeader.ProgramMuxRate = bs.Uint32(22) bs.SkipBits(1) bs.SkipBits(1) bs.SkipBits(5) - ps_pkg_hdr.Pack_stuffing_length = bs.Uint8(3) - if bs.RemainBytes() < int(ps_pkg_hdr.Pack_stuffing_length) { + psPackHeader.PackStuffingLength = bs.Uint8(3) + if bs.RemainBytes() < int(psPackHeader.PackStuffingLength) { bs.UnRead(10 * 8) return errNeedMore } - bs.SkipBits(int(ps_pkg_hdr.Pack_stuffing_length) * 8) + bs.SkipBits(int(psPackHeader.PackStuffingLength) * 8) return nil } -func (ps_pkg_hdr *PSPackHeader) decodeMpeg1(bs *BitStream) error { +func (psPackHeader *PsPackHeader) decodeMpeg1(bs *BitStream) error { bs.SkipBits(4) - ps_pkg_hdr.System_clock_reference_base = bs.GetBits(3) + psPackHeader.SystemClockReferenceBase = bs.GetBits(3) bs.SkipBits(1) - ps_pkg_hdr.System_clock_reference_base = ps_pkg_hdr.System_clock_reference_base<<15 | bs.GetBits(15) + psPackHeader.SystemClockReferenceBase = psPackHeader.SystemClockReferenceBase<<15 | bs.GetBits(15) bs.SkipBits(1) - ps_pkg_hdr.System_clock_reference_base = ps_pkg_hdr.System_clock_reference_base<<15 | bs.GetBits(15) + psPackHeader.SystemClockReferenceBase = psPackHeader.SystemClockReferenceBase<<15 | bs.GetBits(15) bs.SkipBits(1) - ps_pkg_hdr.System_clock_reference_extension = 1 - ps_pkg_hdr.Program_mux_rate = bs.Uint32(7) + psPackHeader.SystemClockReferenceExtension = 1 + psPackHeader.ProgramMuxRate = bs.Uint32(7) bs.SkipBits(1) - ps_pkg_hdr.Program_mux_rate = ps_pkg_hdr.Program_mux_rate<<15 | bs.Uint32(15) + psPackHeader.ProgramMuxRate = psPackHeader.ProgramMuxRate<<15 | bs.Uint32(15) bs.SkipBits(1) return nil } -func (ps_pkg_hdr *PSPackHeader) Encode(bsw *BitStreamWriter) { +func (psPackHeader *PsPackHeader) Encode(bsw *BitStreamWriter) { bsw.PutBytes([]byte{0x00, 0x00, 0x01, 0xBA}) bsw.PutUint8(1, 2) - bsw.PutUint64(ps_pkg_hdr.System_clock_reference_base>>30, 3) + bsw.PutUint64(psPackHeader.SystemClockReferenceBase>>30, 3) bsw.PutUint8(1, 1) - bsw.PutUint64(ps_pkg_hdr.System_clock_reference_base>>15, 15) + bsw.PutUint64(psPackHeader.SystemClockReferenceBase>>15, 15) bsw.PutUint8(1, 1) - bsw.PutUint64(ps_pkg_hdr.System_clock_reference_base, 15) + bsw.PutUint64(psPackHeader.SystemClockReferenceBase, 15) bsw.PutUint8(1, 1) - bsw.PutUint16(ps_pkg_hdr.System_clock_reference_extension, 9) + bsw.PutUint16(psPackHeader.SystemClockReferenceExtension, 9) bsw.PutUint8(1, 1) - bsw.PutUint32(ps_pkg_hdr.Program_mux_rate, 22) + bsw.PutUint32(psPackHeader.ProgramMuxRate, 22) bsw.PutUint8(1, 1) bsw.PutUint8(1, 1) bsw.PutUint8(0x1F, 5) - bsw.PutUint8(ps_pkg_hdr.Pack_stuffing_length, 3) - bsw.PutRepetValue(0xFF, int(ps_pkg_hdr.Pack_stuffing_length)) + bsw.PutUint8(psPackHeader.PackStuffingLength, 3) + bsw.PutRepetValue(0xFF, int(psPackHeader.PackStuffingLength)) } -type Elementary_Stream struct { - Stream_id uint8 - P_STD_buffer_bound_scale uint8 - P_STD_buffer_size_bound uint16 +type ElementaryStream struct { + StreamId uint8 + PStdBufferBoundScale uint8 + PStdBufferSizeBound uint16 } -func NewElementary_Stream(sid uint8) *Elementary_Stream { - return &Elementary_Stream{ - Stream_id: sid, +func NewElementaryStream(sid uint8) *ElementaryStream { + return &ElementaryStream{ + StreamId: sid, } } -// system_header () { -// system_header_start_code 32 bslbf +// SystemHeader () { +// SystemHeader_start_code 32 bslbf // header_length 16 uimsbf // marker_bit 1 bslbf // rate_bound 22 uimsbf @@ -209,99 +209,99 @@ func NewElementary_Stream(sid uint8) *Elementary_Stream { // } // } -type System_header struct { - Header_length uint16 - Rate_bound uint32 - Audio_bound uint8 - Fixed_flag uint8 - CSPS_flag uint8 - System_audio_lock_flag uint8 - System_video_lock_flag uint8 - Video_bound uint8 - Packet_rate_restriction_flag uint8 - Streams []*Elementary_Stream +type SystemHeader struct { + HeaderLength uint16 + RateBound uint32 + AudioBound uint8 + FixedFlag uint8 + CspsFlag uint8 + SystemAudioLockFlag uint8 + SystemVideoLockFlag uint8 + VideoBound uint8 + PacketRateRestrictionFlag uint8 + Streams []*ElementaryStream } -func (sh *System_header) PrettyPrint(file *os.File) { - file.WriteString(fmt.Sprintf("Header_length:%d\n", sh.Header_length)) - file.WriteString(fmt.Sprintf("Rate_bound:%d\n", sh.Rate_bound)) - file.WriteString(fmt.Sprintf("Audio_bound:%d\n", sh.Audio_bound)) - file.WriteString(fmt.Sprintf("Fixed_flag:%d\n", sh.Fixed_flag)) - file.WriteString(fmt.Sprintf("CSPS_flag:%d\n", sh.CSPS_flag)) - file.WriteString(fmt.Sprintf("System_audio_lock_flag:%d\n", sh.System_audio_lock_flag)) - file.WriteString(fmt.Sprintf("System_video_lock_flag:%d\n", sh.System_video_lock_flag)) - file.WriteString(fmt.Sprintf("Video_bound:%d\n", sh.Video_bound)) - file.WriteString(fmt.Sprintf("Packet_rate_restriction_flag:%d\n", sh.Packet_rate_restriction_flag)) +func (sh *SystemHeader) PrettyPrint(file *os.File) { + file.WriteString(fmt.Sprintf("header length:%d\n", sh.HeaderLength)) + file.WriteString(fmt.Sprintf("rate bound:%d\n", sh.RateBound)) + file.WriteString(fmt.Sprintf("audio bound:%d\n", sh.AudioBound)) + file.WriteString(fmt.Sprintf("fixed flag:%d\n", sh.FixedFlag)) + file.WriteString(fmt.Sprintf("csps flag:%d\n", sh.CspsFlag)) + file.WriteString(fmt.Sprintf("system audio lock flag:%d\n", sh.SystemAudioLockFlag)) + file.WriteString(fmt.Sprintf("system video lock flag:%d\n", sh.SystemVideoLockFlag)) + file.WriteString(fmt.Sprintf("video bound:%d\n", sh.VideoBound)) + file.WriteString(fmt.Sprintf("packet rate restriction flag:%d\n", sh.PacketRateRestrictionFlag)) for i, es := range sh.Streams { file.WriteString(fmt.Sprintf("----streams %d\n", i)) - file.WriteString(fmt.Sprintf(" Stream_id:%d\n", es.Stream_id)) - file.WriteString(fmt.Sprintf(" P_STD_buffer_bound_scale:%d\n", es.P_STD_buffer_bound_scale)) - file.WriteString(fmt.Sprintf(" P_STD_buffer_size_bound:%d\n", es.P_STD_buffer_size_bound)) + file.WriteString(fmt.Sprintf(" stream id:%d\n", es.StreamId)) + file.WriteString(fmt.Sprintf(" PStdBufferBoundScale:%d\n", es.PStdBufferBoundScale)) + file.WriteString(fmt.Sprintf(" PStdBufferSizeBound:%d\n", es.PStdBufferSizeBound)) } } -func (sh *System_header) Encode(bsw *BitStreamWriter) { +func (sh *SystemHeader) Encode(bsw *BitStreamWriter) { bsw.PutBytes([]byte{0x00, 0x00, 0x01, 0xBB}) loc := bsw.ByteOffset() bsw.PutUint16(0, 16) bsw.Markdot() bsw.PutUint8(1, 1) - bsw.PutUint32(sh.Rate_bound, 22) + bsw.PutUint32(sh.RateBound, 22) bsw.PutUint8(1, 1) - bsw.PutUint8(sh.Audio_bound, 6) - bsw.PutUint8(sh.Fixed_flag, 1) - bsw.PutUint8(sh.CSPS_flag, 1) - bsw.PutUint8(sh.System_audio_lock_flag, 1) - bsw.PutUint8(sh.System_video_lock_flag, 1) + bsw.PutUint8(sh.AudioBound, 6) + bsw.PutUint8(sh.FixedFlag, 1) + bsw.PutUint8(sh.CspsFlag, 1) + bsw.PutUint8(sh.SystemAudioLockFlag, 1) + bsw.PutUint8(sh.SystemVideoLockFlag, 1) bsw.PutUint8(1, 1) - bsw.PutUint8(sh.Video_bound, 5) - bsw.PutUint8(sh.Packet_rate_restriction_flag, 1) + bsw.PutUint8(sh.VideoBound, 5) + bsw.PutUint8(sh.PacketRateRestrictionFlag, 1) bsw.PutUint8(0x7F, 7) for _, stream := range sh.Streams { - bsw.PutUint8(stream.Stream_id, 8) + bsw.PutUint8(stream.StreamId, 8) bsw.PutUint8(3, 2) - bsw.PutUint8(stream.P_STD_buffer_bound_scale, 1) - bsw.PutUint16(stream.P_STD_buffer_size_bound, 13) + bsw.PutUint8(stream.PStdBufferBoundScale, 1) + bsw.PutUint16(stream.PStdBufferSizeBound, 13) } length := bsw.DistanceFromMarkDot() / 8 bsw.SetUint16(uint16(length), loc) } -func (sh *System_header) Decode(bs *BitStream) error { +func (sh *SystemHeader) Decode(bs *BitStream) error { if bs.RemainBytes() < 12 { return errNeedMore } if bs.Uint32(32) != 0x000001BB { return errors.New("system header must start with 000001BB") } - sh.Header_length = bs.Uint16(16) - if bs.RemainBytes() < int(sh.Header_length) { + sh.HeaderLength = bs.Uint16(16) + if bs.RemainBytes() < int(sh.HeaderLength) { bs.UnRead(6 * 8) return errNeedMore } - if sh.Header_length < 6 || (sh.Header_length-6)%3 != 0 { + if sh.HeaderLength < 6 || (sh.HeaderLength-6)%3 != 0 { return errParser } bs.SkipBits(1) - sh.Rate_bound = bs.Uint32(22) + sh.RateBound = bs.Uint32(22) bs.SkipBits(1) - sh.Audio_bound = bs.Uint8(6) - sh.Fixed_flag = bs.Uint8(1) - sh.CSPS_flag = bs.Uint8(1) - sh.System_audio_lock_flag = bs.Uint8(1) - sh.System_video_lock_flag = bs.Uint8(1) + sh.AudioBound = bs.Uint8(6) + sh.FixedFlag = bs.Uint8(1) + sh.CspsFlag = bs.Uint8(1) + sh.SystemAudioLockFlag = bs.Uint8(1) + sh.SystemVideoLockFlag = bs.Uint8(1) bs.SkipBits(1) - sh.Video_bound = bs.Uint8(5) - sh.Packet_rate_restriction_flag = bs.Uint8(1) + sh.VideoBound = bs.Uint8(5) + sh.PacketRateRestrictionFlag = bs.Uint8(1) bs.SkipBits(7) sh.Streams = sh.Streams[:0] - least := sh.Header_length - 6 + least := sh.HeaderLength - 6 for least > 0 && bs.NextBits(1) == 0x01 { - es := new(Elementary_Stream) - es.Stream_id = bs.Uint8(8) + es := new(ElementaryStream) + es.StreamId = bs.Uint8(8) bs.SkipBits(2) - es.P_STD_buffer_bound_scale = bs.GetBit() - es.P_STD_buffer_size_bound = bs.Uint16(13) + es.PStdBufferBoundScale = bs.GetBit() + es.PStdBufferSizeBound = bs.Uint16(13) sh.Streams = append(sh.Streams, es) least -= 3 } @@ -311,16 +311,16 @@ func (sh *System_header) Decode(bs *BitStream) error { return nil } -type Elementary_stream_elem struct { - Stream_type uint8 - Elementary_stream_id uint8 - Elementary_stream_info_length uint16 +type ElementaryStreamElem struct { + StreamType uint8 + ElementaryStreamId uint8 + ElementaryStreamInfoLength uint16 } -func NewElementary_stream_elem(stype uint8, esid uint8) *Elementary_stream_elem { - return &Elementary_stream_elem{ - Stream_type: stype, - Elementary_stream_id: esid, +func NewElementaryStreamElem(stype uint8, esid uint8) *ElementaryStreamElem { + return &ElementaryStreamElem{ + StreamType: stype, + ElementaryStreamId: esid, } } @@ -349,57 +349,57 @@ func NewElementary_stream_elem(stype uint8, esid uint8) *Elementary_stream_elem // CRC_32 32 rpchof // } -type Program_stream_map struct { - Map_stream_id uint8 - Program_stream_map_length uint16 - Current_next_indicator uint8 - Program_stream_map_version uint8 - Program_stream_info_length uint16 - Elementary_stream_map_length uint16 - Stream_map []*Elementary_stream_elem +type ProgramStreamMap struct { + MapStreamId uint8 + ProgramStreamMapLength uint16 + CurrentNextIndicator uint8 + ProgramStreamMapVersion uint8 + ProgramStreamInfoLength uint16 + ElementaryStreamMapLength uint16 + StreamMap []*ElementaryStreamElem } -func (psm *Program_stream_map) PrettyPrint(file *os.File) { - file.WriteString(fmt.Sprintf("map_stream_id:%d\n", psm.Map_stream_id)) - file.WriteString(fmt.Sprintf("program_stream_map_length:%d\n", psm.Program_stream_map_length)) - file.WriteString(fmt.Sprintf("current_next_indicator:%d\n", psm.Current_next_indicator)) - file.WriteString(fmt.Sprintf("program_stream_map_version:%d\n", psm.Program_stream_map_version)) - file.WriteString(fmt.Sprintf("program_stream_info_length:%d\n", psm.Program_stream_info_length)) - file.WriteString(fmt.Sprintf("elementary_stream_map_length:%d\n", psm.Elementary_stream_map_length)) - for i, es := range psm.Stream_map { +func (psm *ProgramStreamMap) PrettyPrint(file *os.File) { + file.WriteString(fmt.Sprintf("map stream id:%d\n", psm.MapStreamId)) + file.WriteString(fmt.Sprintf("program stream map length:%d\n", psm.ProgramStreamMapLength)) + file.WriteString(fmt.Sprintf("current next indicator:%d\n", psm.CurrentNextIndicator)) + file.WriteString(fmt.Sprintf("program stream map version:%d\n", psm.ProgramStreamMapVersion)) + file.WriteString(fmt.Sprintf("program stream info length:%d\n", psm.ProgramStreamInfoLength)) + file.WriteString(fmt.Sprintf("elementary stream map length:%d\n", psm.ElementaryStreamMapLength)) + for i, es := range psm.StreamMap { file.WriteString(fmt.Sprintf("----ES stream %d\n", i)) - if es.Stream_type == uint8(PS_STREAM_AAC) { - file.WriteString(" stream_type:AAC\n") - } else if es.Stream_type == uint8(PS_STREAM_G711A) { - file.WriteString(" stream_type:G711A\n") - } else if es.Stream_type == uint8(PS_STREAM_G711U) { - file.WriteString(" stream_type:G711U\n") - } else if es.Stream_type == uint8(PS_STREAM_H264) { - file.WriteString(" stream_type:H264\n") - } else if es.Stream_type == uint8(PS_STREAM_H265) { - file.WriteString(" stream_type:H265\n") + if es.StreamType == uint8(PsStreamAac) { + file.WriteString(" streamType:AAC\n") + } else if es.StreamType == uint8(PsStreamG711A) { + file.WriteString(" streamType:G711A\n") + } else if es.StreamType == uint8(PsStreamG711U) { + file.WriteString(" streamType:G711U\n") + } else if es.StreamType == uint8(PsStreamH264) { + file.WriteString(" streamType:H264\n") + } else if es.StreamType == uint8(PsStreamH265) { + file.WriteString(" streamType:H265\n") } - file.WriteString(fmt.Sprintf(" elementary_stream_id:%d\n", es.Elementary_stream_id)) - file.WriteString(fmt.Sprintf(" elementary_stream_info_length:%d\n", es.Elementary_stream_info_length)) + file.WriteString(fmt.Sprintf(" elementary stream id:%d\n", es.ElementaryStreamId)) + file.WriteString(fmt.Sprintf(" elementary stream info length:%d\n", es.ElementaryStreamInfoLength)) } } -func (psm *Program_stream_map) Encode(bsw *BitStreamWriter) { +func (psm *ProgramStreamMap) Encode(bsw *BitStreamWriter) { bsw.PutBytes([]byte{0x00, 0x00, 0x01, 0xBC}) loc := bsw.ByteOffset() - bsw.PutUint16(psm.Program_stream_map_length, 16) + bsw.PutUint16(psm.ElementaryStreamMapLength, 16) bsw.Markdot() - bsw.PutUint8(psm.Current_next_indicator, 1) + bsw.PutUint8(psm.CurrentNextIndicator, 1) bsw.PutUint8(3, 2) - bsw.PutUint8(psm.Program_stream_map_version, 5) + bsw.PutUint8(psm.ProgramStreamMapVersion, 5) bsw.PutUint8(0x7F, 7) bsw.PutUint8(1, 1) bsw.PutUint16(0, 16) - psm.Elementary_stream_map_length = uint16(len(psm.Stream_map) * 4) - bsw.PutUint16(psm.Elementary_stream_map_length, 16) - for _, streaminfo := range psm.Stream_map { - bsw.PutUint8(streaminfo.Stream_type, 8) - bsw.PutUint8(streaminfo.Elementary_stream_id, 8) + psm.ElementaryStreamMapLength = uint16(len(psm.StreamMap) * 4) + bsw.PutUint16(psm.ElementaryStreamMapLength, 16) + for _, streaminfo := range psm.StreamMap { + bsw.PutUint8(streaminfo.StreamType, 8) + bsw.PutUint8(streaminfo.ElementaryStreamId, 8) bsw.PutUint16(0, 16) } length := bsw.DistanceFromMarkDot()/8 + 4 @@ -410,58 +410,58 @@ func (psm *Program_stream_map) Encode(bsw *BitStreamWriter) { bsw.PutBytes(tmpcrc) } -func (psm *Program_stream_map) Decode(bs *BitStream) error { +func (psm *ProgramStreamMap) Decode(bs *BitStream) error { if bs.RemainBytes() < 16 { return errNeedMore } if bs.Uint32(24) != 0x000001 { return errors.New("program stream map must startwith 0x000001") } - psm.Map_stream_id = bs.Uint8(8) - if psm.Map_stream_id != 0xBC { + psm.MapStreamId = bs.Uint8(8) + if psm.MapStreamId != 0xBC { return errors.New("map stream id must be 0xBC") } - psm.Program_stream_map_length = bs.Uint16(16) - if bs.RemainBytes() < int(psm.Program_stream_map_length) { + psm.ProgramStreamMapLength = bs.Uint16(16) + if bs.RemainBytes() < int(psm.ProgramStreamMapLength) { bs.UnRead(6 * 8) return errNeedMore } - psm.Current_next_indicator = bs.Uint8(1) + psm.CurrentNextIndicator = bs.Uint8(1) bs.SkipBits(2) - psm.Program_stream_map_version = bs.Uint8(5) + psm.ProgramStreamMapVersion = bs.Uint8(5) bs.SkipBits(8) - psm.Program_stream_info_length = bs.Uint16(16) - if bs.RemainBytes() < int(psm.Program_stream_info_length)+2 { + psm.ProgramStreamInfoLength = bs.Uint16(16) + if bs.RemainBytes() < int(psm.ProgramStreamInfoLength)+2 { bs.UnRead(10 * 8) return errNeedMore } - bs.SkipBits(int(psm.Program_stream_info_length) * 8) - psm.Elementary_stream_map_length = bs.Uint16(16) + bs.SkipBits(int(psm.ProgramStreamInfoLength) * 8) + psm.ElementaryStreamMapLength = bs.Uint16(16) - psm.Elementary_stream_map_length = psm.Program_stream_map_length - psm.Program_stream_info_length - 10 + psm.ElementaryStreamMapLength = psm.ProgramStreamMapLength - psm.ProgramStreamInfoLength - 10 - if bs.RemainBytes() < int(psm.Elementary_stream_map_length)+4 { - bs.UnRead(12*8 + int(psm.Program_stream_info_length)*8) + if bs.RemainBytes() < int(psm.ElementaryStreamMapLength)+4 { + bs.UnRead(12*8 + int(psm.ProgramStreamInfoLength)*8) return errNeedMore } i := 0 - psm.Stream_map = psm.Stream_map[:0] - for i < int(psm.Elementary_stream_map_length) { - elem := new(Elementary_stream_elem) - elem.Stream_type = bs.Uint8(8) - elem.Elementary_stream_id = bs.Uint8(8) - elem.Elementary_stream_info_length = bs.Uint16(16) + psm.StreamMap = psm.StreamMap[:0] + for i < int(psm.ElementaryStreamMapLength) { + elem := new(ElementaryStreamElem) + elem.StreamType = bs.Uint8(8) + elem.ElementaryStreamId = bs.Uint8(8) + elem.ElementaryStreamInfoLength = bs.Uint16(16) //TODO Parser descriptor - if bs.RemainBytes() < int(elem.Elementary_stream_info_length) { + if bs.RemainBytes() < int(elem.ElementaryStreamInfoLength) { return errParser } - bs.SkipBits(int(elem.Elementary_stream_info_length) * 8) - i += int(4 + elem.Elementary_stream_info_length) - psm.Stream_map = append(psm.Stream_map, elem) + bs.SkipBits(int(elem.ElementaryStreamInfoLength) * 8) + i += int(4 + elem.ElementaryStreamInfoLength) + psm.StreamMap = append(psm.StreamMap, elem) } - if i != int(psm.Elementary_stream_map_length) { + if i != int(psm.ElementaryStreamMapLength) { return errParser } @@ -469,30 +469,30 @@ func (psm *Program_stream_map) Decode(bs *BitStream) error { return nil } -type Program_stream_directory struct { - PES_packet_length uint16 +type ProgramStreamDirectory struct { + PesPacketLength uint16 } -func (psd *Program_stream_directory) Decode(bs *BitStream) error { +func (psd *ProgramStreamDirectory) Decode(bs *BitStream) error { if bs.RemainBytes() < 6 { return errNeedMore } if bs.Uint32(32) != 0x000001FF { return errors.New("program stream directory 000001FF") } - psd.PES_packet_length = bs.Uint16(16) - if bs.RemainBytes() < int(psd.PES_packet_length) { + psd.PesPacketLength = bs.Uint16(16) + if bs.RemainBytes() < int(psd.PesPacketLength) { bs.UnRead(6 * 8) return errNeedMore } //TODO Program Stream directory - bs.SkipBits(int(psd.PES_packet_length) * 8) + bs.SkipBits(int(psd.PesPacketLength) * 8) return nil } type CommonPesPacket struct { - Stream_id uint8 - PES_packet_length uint16 + StreamId uint8 + PesPacketLength uint16 } func (compes *CommonPesPacket) Decode(bs *BitStream) error { @@ -500,21 +500,21 @@ func (compes *CommonPesPacket) Decode(bs *BitStream) error { return errNeedMore } bs.SkipBits(24) - compes.Stream_id = bs.Uint8(8) - compes.PES_packet_length = bs.Uint16(16) - if bs.RemainBytes() < int(compes.PES_packet_length) { + compes.StreamId = bs.Uint8(8) + compes.PesPacketLength = bs.Uint16(16) + if bs.RemainBytes() < int(compes.PesPacketLength) { bs.UnRead(6 * 8) return errNeedMore } - bs.SkipBits(int(compes.PES_packet_length) * 8) + bs.SkipBits(int(compes.PesPacketLength) * 8) return nil } -type PSPacket struct { - Header *PSPackHeader - System *System_header - Psm *Program_stream_map - Psd *Program_stream_directory +type PsPacket struct { + Header *PsPackHeader + System *SystemHeader + Psm *ProgramStreamMap + Psd *ProgramStreamDirectory CommPes *CommonPesPacket Pes *PesPacket } diff --git a/gb28181/mpegps/util.go b/gb28181/mpegps/util.go index 060e19c..0e004f8 100644 --- a/gb28181/mpegps/util.go +++ b/gb28181/mpegps/util.go @@ -56,25 +56,25 @@ func CalcCrc32(crc uint32, buffer []byte) uint32 { return crc } -type START_CODE_TYPE int +type StartCodeType int const ( - START_CODE_3 START_CODE_TYPE = 3 - START_CODE_4 START_CODE_TYPE = 4 + StartCode3 StartCodeType = 3 + STartCode4 StartCodeType = 4 ) -func FindStartCode(nalu []byte, offset int) (int, START_CODE_TYPE) { +func FindStartCode(nalu []byte, offset int) (int, StartCodeType) { idx := bytes.Index(nalu[offset:], []byte{0x00, 0x00, 0x01}) switch { case idx > 0: if nalu[offset+idx-1] == 0x00 { - return offset + idx - 1, START_CODE_4 + return offset + idx - 1, STartCode4 } fallthrough case idx == 0: - return offset + idx, START_CODE_3 + return offset + idx, StartCode3 } - return -1, START_CODE_3 + return -1, StartCode3 } func SplitFrame(frames []byte, onFrame func(nalu []byte) bool) {