codec/h264.go

package codec

import (
	"bytes"
	"errors"
	"io"

	"m7s.live/engine/v4/util"
	"m7s.live/engine/v4/util/bits/pio"
)

// Start Code + NAL Unit -> NALU Header + NALU Body
// RTP Packet -> NALU Header + NALU Body

// NALU Body -> Slice Header + Slice data
// Slice data -> flags + Macroblock layer1 + Macroblock layer2 + ...
// Macroblock layer1 -> mb_type + PCM Data
// Macroblock layer2 -> mb_type + Sub_mb_pred or mb_pred + Residual Data
// Residual Data ->
type H264NALUType byte

func (b H264NALUType) Or(b2 byte) byte {
	return byte(b) | b2
}

func (b H264NALUType) Offset() int {
	switch b {
	case NALU_STAPA:
		return 1
	case NALU_STAPB:
		return 3
	case NALU_FUA:
		return 2
	case NALU_FUB:
		return 4
	}
	return 0
}

func (b H264NALUType) Byte() byte {
	return byte(b)
}
func ParseH264NALUType(b byte) H264NALUType {
	return H264NALUType(b & 0x1F)
}
func (H264NALUType) Parse(b byte) H264NALUType {
	return H264NALUType(b & 0x1F)
}

func (H264NALUType) ParseBytes(bs []byte) H264NALUType {
	return H264NALUType(bs[0] & 0x1F)
}

const (
	// NALU Type
	NALU_Unspecified           H264NALUType = iota
	NALU_Non_IDR_Picture                    // 1
	NALU_Data_Partition_A                   // 2
	NALU_Data_Partition_B                   // 3
	NALU_Data_Partition_C                   // 4
	NALU_IDR_Picture                        // 5
	NALU_SEI                                // 6
	NALU_SPS                                // 7
	NALU_PPS                                // 8
	NALU_Access_Unit_Delimiter              // 9
	NALU_Sequence_End                       // 10
	NALU_Stream_End                         // 11
	NALU_Filler_Data                        // 12
	NALU_SPS_Extension                      // 13
	NALU_Prefix                             // 14
	NALU_SPS_Subset                         // 15
	NALU_DPS                                // 16
	NALU_Reserved1                          // 17
	NALU_Reserved2                          // 18
	NALU_Not_Auxiliary_Coded                // 19
	NALU_Coded_Slice_Extension              // 20
	NALU_Reserved3                          // 21
	NALU_Reserved4                          // 22
	NALU_Reserved5                          // 23
	NALU_STAPA                              // 24
	NALU_STAPB
	NALU_MTAP16
	NALU_MTAP24
	NALU_FUA // 28
	NALU_FUB
	// 24 - 31 NALU_NotReserved

)

var (
	NALU_AUD_BYTE   = []byte{0x00, 0x00, 0x00, 0x01, 0x09, 0xF0}
	NALU_Delimiter1 = []byte{0x00, 0x00, 0x01}
	NALU_Delimiter2 = []byte{0x00, 0x00, 0x00, 0x01}
	// 0x17 keyframe  7:AVC
	// 0x00 AVC sequence header
	// 0x00 0x00 0x00
	// 0x01 configurationVersion
	// 0x42 AVCProfileIndication
	// 0x00 profile_compatibility
	// 0x1E AVCLevelIndication
	// 0xFF lengthSizeMinusOne
	RTMP_AVC_HEAD         = []byte{0x17, 0x00, 0x00, 0x00, 0x00, 0x01, 0x42, 0x00, 0x1E, 0xFF}
	RTMP_KEYFRAME_HEAD    = []byte{0x17, 0x01, 0x00, 0x00, 0x00}
	RTMP_NORMALFRAME_HEAD = []byte{0x27, 0x01, 0x00, 0x00, 0x00}
)

// H.264/AVC视频编码标准中,整个系统框架被分为了两个层面:视频编码层面(VCL)和网络抽象层面(NAL)
// NAL - Network Abstract Layer
// raw byte sequence payload (RBSP) 原始字节序列载荷

// SplitH264 以0x00000001分割H264裸数据
func SplitH264(payload []byte) (nalus [][]byte) {
	for _, v := range bytes.SplitN(payload, NALU_Delimiter2, -1) {
		if len(v) == 0 {
			continue
		}
		nalus = append(nalus, bytes.SplitN(v, NALU_Delimiter1, -1)...)
	}
	return
}

func BuildH264SeqHeaderFromSpsPps(sps, pps []byte) (seqHeader []byte) {
	lenSPS, lenPPS := len(sps), len(pps)
	seqHeader = append([]byte{}, RTMP_AVC_HEAD...)
	if lenSPS > 3 {
		copy(seqHeader[6:], sps[1:4])
	}
	seqHeader = append(seqHeader, 0xE1, byte(lenSPS>>8), byte(lenSPS))
	seqHeader = append(seqHeader, sps...)
	seqHeader = append(append(seqHeader, 0x01, byte(lenPPS>>8), byte(lenPPS)), pps...)
	return
}

// ISO/IEC 14496-15 11(16)/page
//
// Advanced Video Coding
//

// AVCC
type AVCDecoderConfigurationRecord struct {
	ConfigurationVersion       byte // 8 bits Version
	AVCProfileIndication       byte // 8 bits
	ProfileCompatibility       byte // 8 bits
	AVCLevelIndication         byte // 8 bits
	Reserved1                  byte // 6 bits
	LengthSizeMinusOne         byte // 2 bits 非常重要,每个NALU包前面都(lengthSizeMinusOne & 3)+1个字节的NAL包长度描述
	Reserved2                  byte // 3 bits
	NumOfSequenceParameterSets byte // 5 bits SPS 的个数,计算方法是 numOfSequenceParameterSets & 0x1F
	NumOfPictureParameterSets  byte // 8 bits PPS 的个数

	SequenceParameterSetLength  uint16 // 16 byte SPS Length
	SequenceParameterSetNALUnit []byte // n byte  SPS
	PictureParameterSetLength   uint16 // 16 byte PPS Length
	PictureParameterSetNALUnit  []byte // n byte  PPS
}

func (p *AVCDecoderConfigurationRecord) Marshal(b []byte) (n int) {
	b[0] = 1
	b[1] = p.AVCProfileIndication
	b[2] = p.ProfileCompatibility
	b[3] = p.AVCLevelIndication
	b[4] = p.LengthSizeMinusOne | 0xfc
	b[5] = uint8(1) | 0xe0
	n += 6

	pio.PutU16BE(b[n:], p.SequenceParameterSetLength)
	n += 2
	copy(b[n:], p.SequenceParameterSetNALUnit)
	n += len(p.SequenceParameterSetNALUnit)
	b[n] = uint8(1)
	n++

	pio.PutU16BE(b[n:], p.PictureParameterSetLength)
	n += 2
	copy(b[n:], p.PictureParameterSetNALUnit)
	n += len(p.PictureParameterSetNALUnit)

	return
}

var ErrDecconfInvalid = errors.New("decode error")

func (p *AVCDecoderConfigurationRecord) Unmarshal(b []byte) (n int, err error) {
	if len(b) < 7 {
		err = errors.New("not enough len")
		return
	}

	p.AVCProfileIndication = b[1]
	p.ProfileCompatibility = b[2]
	p.AVCLevelIndication = b[3]
	p.LengthSizeMinusOne = b[4] & 0x03
	spscount := int(b[5] & 0x1f)
	n += 6
	var sps, pps [][]byte
	for i := 0; i < spscount; i++ {
		if len(b) < n+2 {
			err = ErrDecconfInvalid
			return
		}
		spslen := util.ReadBE[int](b[n : n+2])
		n += 2

		if len(b) < n+spslen {
			err = ErrDecconfInvalid
			return
		}
		sps = append(sps, b[n:n+spslen])
		n += spslen
	}
	p.SequenceParameterSetLength = uint16(len(sps[0]))
	p.SequenceParameterSetNALUnit = sps[0]
	if len(b) < n+1 {
		err = ErrDecconfInvalid
		return
	}
	ppscount := int(b[n])
	n++

	for i := 0; i < ppscount; i++ {
		if len(b) < n+2 {
			err = ErrDecconfInvalid
			return
		}
		ppslen := util.ReadBE[int](b[n : n+2])
		n += 2

		if len(b) < n+ppslen {
			err = ErrDecconfInvalid
			return
		}
		pps = append(pps, b[n:n+ppslen])
		n += ppslen
	}
	if ppscount >= 1 {
		p.PictureParameterSetLength = uint16(len(pps[0]))
		p.PictureParameterSetNALUnit = pps[0]
	} else {
		err = ErrDecconfInvalid
	}
	return
}

type NALUnit struct {
	NALUHeader
	RBSP
}

type NALUHeader struct {
	forbidden_zero_bit byte // 1 bit  0
	nal_ref_idc        byte // 2 bits nal_unit_type等于6,9,10,11或12的NAL单元其nal_ref_idc都应等于 0
	nal_uint_type      byte // 5 bits 包含在 NAL 单元中的 RBSP 数据结构的类型
}

type RBSP interface {
}

/*
0      Unspecified                                                    non-VCL
1      Coded slice of a non-IDR picture                               VCL
2      Coded slice data partition A                                   VCL
3      Coded slice data partition B                                   VCL
4      Coded slice data partition C                                   VCL
5      Coded slice of an IDR picture                                  VCL
6      Supplemental enhancement information (SEI)                     non-VCL
7      Sequence parameter set                                         non-VCL
8      Picture parameter set                                          non-VCL
9      Access unit delimiter                                          non-VCL
10     End of sequence                                                non-VCL
11     End of stream                                                  non-VCL
12     Filler data                                                    non-VCL
13     Sequence parameter set extension                               non-VCL
14     Prefix NAL unit                                                non-VCL
15     Subset sequence parameter set                                  non-VCL
16     Depth parameter set                                            non-VCL
17..18 Reserved                                                       non-VCL
19     Coded slice of an auxiliary coded picture without partitioning non-VCL
20     Coded slice extension                                          non-VCL
21     Coded slice extension for depth view components                non-VCL
22..23 Reserved                                                       non-VCL
24..31 Unspecified                                                    non-VCL

0:未规定
1:非IDR图像中不采用数据划分的片段
2:非IDR图像中A类数据划分片段
3:非IDR图像中B类数据划分片段
4:非IDR图像中C类数据划分片段
5:IDR图像的片段
6:补充增强信息（SEI）
7:序列参数集（SPS）
8:图像参数集（PPS）
9:分割符
10:序列结束符
11:流结束符
12:填充数据
13:序列参数集扩展
14:带前缀的NAL单元
15:子序列参数集
16 – 18:保留
19:不采用数据划分的辅助编码图像片段
20:编码片段扩展
21 – 23:保留
24 – 31:未规定

nal_unit_type		NAL类型						nal_reference_bit
0					未使用						0
1					非IDR的片					此片属于参考帧,则不等于0,不属于参考帧，则等与0
2					片数据A分区					同上
3					片数据B分区					同上
4					片数据C分区					同上
5					IDR图像的片					5
6					补充增强信息单元（SEI）		0
7					序列参数集					非0
8					图像参数集					非0
9					分界符						0
10					序列结束					0
11					码流结束					0
12					填充						0
13..23				保留						0
24..31				不保留						0
*/

func ReadPPS(w io.Writer) {

}