1247 lines
41 KiB
C++
1247 lines
41 KiB
C++
//
|
||
// Copyright (c) 2013-2025 The SRS Authors
|
||
//
|
||
// SPDX-License-Identifier: MIT
|
||
//
|
||
|
||
#ifndef SRS_KERNEL_CODEC_HPP
|
||
#define SRS_KERNEL_CODEC_HPP
|
||
|
||
#include <srs_core.hpp>
|
||
|
||
#include <string>
|
||
#include <vector>
|
||
|
||
#include <srs_core_autofree.hpp>
|
||
#include <srs_kernel_buffer.hpp>
|
||
|
||
class SrsBuffer;
|
||
class SrsBitBuffer;
|
||
class SrsFormat;
|
||
|
||
/* Extended VideoTagHeader
|
||
* defined in reference link:
|
||
* https://veovera.org/docs/enhanced/enhanced-rtmp-v1.pdf
|
||
* */
|
||
#define SRS_FLV_IS_EX_HEADER 0x80
|
||
|
||
// @see: https://datatracker.ietf.org/doc/html/rfc6184#section-1.3
|
||
const int SrsAvcNaluHeaderSize = 1;
|
||
// @see: https://datatracker.ietf.org/doc/html/rfc7798#section-1.1.4
|
||
const int SrsHevcNaluHeaderSize = 2;
|
||
|
||
/**
|
||
* The video codec id.
|
||
* @doc video_file_format_spec_v10_1.pdf, page78, E.4.3.1 VIDEODATA
|
||
* CodecID UB [4]
|
||
* Codec Identifier. The following values are defined for FLV:
|
||
* 2 = Sorenson H.263
|
||
* 3 = Screen video
|
||
* 4 = On2 VP6
|
||
* 5 = On2 VP6 with alpha channel
|
||
* 6 = Screen video version 2
|
||
* 7 = AVC
|
||
* 12 = HEVC
|
||
*/
|
||
enum SrsVideoCodecId {
|
||
// set to the zero to reserved, for array map.
|
||
SrsVideoCodecIdReserved = 0,
|
||
SrsVideoCodecIdForbidden = 0,
|
||
SrsVideoCodecIdReserved1 = 1,
|
||
SrsVideoCodecIdReserved2 = 9,
|
||
|
||
// for user to disable video, for example, use pure audio hls.
|
||
SrsVideoCodecIdDisabled = 8,
|
||
|
||
SrsVideoCodecIdSorensonH263 = 2,
|
||
SrsVideoCodecIdScreenVideo = 3,
|
||
SrsVideoCodecIdOn2VP6 = 4,
|
||
SrsVideoCodecIdOn2VP6WithAlphaChannel = 5,
|
||
SrsVideoCodecIdScreenVideoVersion2 = 6,
|
||
SrsVideoCodecIdAVC = 7,
|
||
// See page 79 at @doc https://github.com/CDN-Union/H265/blob/master/Document/video_file_format_spec_v10_1_ksyun_20170615.doc
|
||
SrsVideoCodecIdHEVC = 12,
|
||
// https://mp.weixin.qq.com/s/H3qI7zsON5sdf4oDJ9qlkg
|
||
SrsVideoCodecIdAV1 = 13,
|
||
};
|
||
std::string srs_video_codec_id2str(SrsVideoCodecId codec);
|
||
SrsVideoCodecId srs_video_codec_str2id(const std::string &codec);
|
||
|
||
/**
|
||
* The video AVC frame trait(characteristic).
|
||
* @doc video_file_format_spec_v10_1.pdf, page79, E.4.3.2 AVCVIDEOPACKET
|
||
* AVCPacketType IF CodecID == 7 UI8
|
||
* The following values are defined:
|
||
* 0 = AVC sequence header
|
||
* 1 = AVC NALU
|
||
* 2 = AVC end of sequence (lower level NALU sequence ender is not required or supported)
|
||
*/
|
||
enum SrsVideoAvcFrameTrait {
|
||
// set to the max value to reserved, for array map.
|
||
SrsVideoAvcFrameTraitReserved = 6,
|
||
SrsVideoAvcFrameTraitForbidden = 6,
|
||
|
||
SrsVideoAvcFrameTraitSequenceHeader = 0,
|
||
SrsVideoAvcFrameTraitNALU = 1,
|
||
SrsVideoAvcFrameTraitSequenceHeaderEOF = 2,
|
||
|
||
SrsVideoHEVCFrameTraitPacketTypeSequenceStart = 0,
|
||
SrsVideoHEVCFrameTraitPacketTypeCodedFrames = 1,
|
||
SrsVideoHEVCFrameTraitPacketTypeSequenceEnd = 2,
|
||
// CompositionTime Offset is implied to equal zero. This is
|
||
// an optimization to save putting SI24 composition time value of zero on
|
||
// the wire. See pseudo code below in the VideoTagBody section
|
||
SrsVideoHEVCFrameTraitPacketTypeCodedFramesX = 3,
|
||
// VideoTagBody does not contain video data. VideoTagBody
|
||
// instead contains an AMF encoded metadata. See Metadata Frame
|
||
// section for an illustration of its usage. As an example, the metadata
|
||
// can be HDR information. This is a good way to signal HDR
|
||
// information. This also opens up future ways to express additional
|
||
// metadata that is meant for the next video sequence.
|
||
//
|
||
// note: presence of PacketTypeMetadata means that FrameType
|
||
// flags at the top of this table should be ignored
|
||
SrsVideoHEVCFrameTraitPacketTypeMetadata = 4,
|
||
// Carriage of bitstream in MPEG-2 TS format
|
||
SrsVideoHEVCFrameTraitPacketTypeMPEG2TSSequenceStart = 5,
|
||
};
|
||
|
||
/**
|
||
* The video AVC frame type, such as I/P/B.
|
||
* @doc video_file_format_spec_v10_1.pdf, page78, E.4.3.1 VIDEODATA
|
||
* Frame Type UB [4]
|
||
* Type of video frame. The following values are defined:
|
||
* 1 = key frame (for AVC, a seekable frame)
|
||
* 2 = inter frame (for AVC, a non-seekable frame)
|
||
* 3 = disposable inter frame (H.263 only)
|
||
* 4 = generated key frame (reserved for server use only)
|
||
* 5 = video info/command frame
|
||
*/
|
||
enum SrsVideoAvcFrameType {
|
||
// set to the zero to reserved, for array map.
|
||
SrsVideoAvcFrameTypeReserved = 0,
|
||
SrsVideoAvcFrameTypeForbidden = 0,
|
||
SrsVideoAvcFrameTypeReserved1 = 6,
|
||
|
||
SrsVideoAvcFrameTypeKeyFrame = 1,
|
||
SrsVideoAvcFrameTypeInterFrame = 2,
|
||
SrsVideoAvcFrameTypeDisposableInterFrame = 3,
|
||
SrsVideoAvcFrameTypeGeneratedKeyFrame = 4,
|
||
SrsVideoAvcFrameTypeVideoInfoFrame = 5,
|
||
};
|
||
|
||
/**
|
||
* The audio codec id.
|
||
* @doc video_file_format_spec_v10_1.pdf, page 76, E.4.2 Audio Tags
|
||
* SoundFormat UB [4]
|
||
* Format of SoundData. The following values are defined:
|
||
* 0 = Linear PCM, platform endian
|
||
* 1 = ADPCM
|
||
* 2 = MP3
|
||
* 3 = Linear PCM, little endian
|
||
* 4 = Nellymoser 16 kHz mono
|
||
* 5 = Nellymoser 8 kHz mono
|
||
* 6 = Nellymoser
|
||
* 7 = G.711 A-law logarithmic PCM
|
||
* 8 = G.711 mu-law logarithmic PCM
|
||
* 9 = reserved
|
||
* 10 = AAC
|
||
* 11 = Speex
|
||
* 14 = MP3 8 kHz
|
||
* 15 = Device-specific sound
|
||
* Formats 7, 8, 14, and 15 are reserved.
|
||
* AAC is supported in Flash Player 9,0,115,0 and higher.
|
||
* Speex is supported in Flash Player 10 and higher.
|
||
*/
|
||
enum SrsAudioCodecId {
|
||
// set to the max value to reserved, for array map.
|
||
SrsAudioCodecIdReserved1 = 16,
|
||
SrsAudioCodecIdForbidden = 16,
|
||
|
||
// for user to disable audio, for example, use pure video hls.
|
||
SrsAudioCodecIdDisabled = 17,
|
||
|
||
SrsAudioCodecIdLinearPCMPlatformEndian = 0,
|
||
SrsAudioCodecIdADPCM = 1,
|
||
SrsAudioCodecIdMP3 = 2,
|
||
SrsAudioCodecIdLinearPCMLittleEndian = 3,
|
||
SrsAudioCodecIdNellymoser16kHzMono = 4,
|
||
SrsAudioCodecIdNellymoser8kHzMono = 5,
|
||
SrsAudioCodecIdNellymoser = 6,
|
||
SrsAudioCodecIdReservedG711AlawLogarithmicPCM = 7,
|
||
SrsAudioCodecIdReservedG711MuLawLogarithmicPCM = 8,
|
||
SrsAudioCodecIdReserved = 9,
|
||
SrsAudioCodecIdAAC = 10,
|
||
SrsAudioCodecIdSpeex = 11,
|
||
// For FLV, it's undefined, we define it as Opus for WebRTC.
|
||
SrsAudioCodecIdOpus = 13,
|
||
SrsAudioCodecIdReservedMP3_8kHz = 14,
|
||
SrsAudioCodecIdReservedDeviceSpecificSound = 15,
|
||
};
|
||
std::string srs_audio_codec_id2str(SrsAudioCodecId codec);
|
||
SrsAudioCodecId srs_audio_codec_str2id(const std::string &codec);
|
||
|
||
/**
|
||
* The audio AAC frame trait(characteristic).
|
||
* @doc video_file_format_spec_v10_1.pdf, page 77, E.4.2 Audio Tags
|
||
* AACPacketType IF SoundFormat == 10 or 13 UI8
|
||
* The following values are defined:
|
||
* 0 = AAC sequence header
|
||
* 1 = AAC raw
|
||
*/
|
||
enum SrsAudioAacFrameTrait {
|
||
// set to the max value to reserved, for array map.
|
||
SrsAudioAacFrameTraitReserved = 0xff,
|
||
SrsAudioAacFrameTraitForbidden = 0xff,
|
||
|
||
// For AAC, we detect the sequence header by content.
|
||
SrsAudioAacFrameTraitSequenceHeader = 0,
|
||
SrsAudioAacFrameTraitRawData = 1,
|
||
|
||
// For Opus, the frame trait, may has more than one traits.
|
||
SrsAudioOpusFrameTraitRaw = 2,
|
||
SrsAudioOpusFrameTraitSamplingRate = 4,
|
||
SrsAudioOpusFrameTraitAudioLevel = 8,
|
||
|
||
// 16/32 reserved for g711a/g711u
|
||
|
||
// For MP3 we assume the first packet is sequence header, while it actually is not the same thing, because we do
|
||
// this to simplify the workflow, to make sure we can detect the audio codec from the sequence headers.
|
||
SrsAudioMp3FrameTraitSequenceHeader = 63,
|
||
SrsAudioMp3FrameTraitRawData = 64,
|
||
};
|
||
|
||
/**
|
||
* The audio sample rate.
|
||
* @see srs_flv_srates and srs_aac_srates.
|
||
* @doc video_file_format_spec_v10_1.pdf, page 76, E.4.2 Audio Tags
|
||
* 0 = 5.5 kHz = 5512 Hz
|
||
* 1 = 11 kHz = 11025 Hz
|
||
* 2 = 22 kHz = 22050 Hz
|
||
* 3 = 44 kHz = 44100 Hz
|
||
* However, we can extends this table.
|
||
* @remark Use srs_flv_srates to convert it.
|
||
*/
|
||
enum SrsAudioSampleRate {
|
||
// set to the max value to reserved, for array map.
|
||
SrsAudioSampleRateReserved = 0xff,
|
||
SrsAudioSampleRateForbidden = 0xff,
|
||
|
||
// For FLV, only support 5, 11, 22, 44KHz sampling rate.
|
||
SrsAudioSampleRate5512 = 0,
|
||
SrsAudioSampleRate11025 = 1,
|
||
SrsAudioSampleRate22050 = 2,
|
||
SrsAudioSampleRate44100 = 3,
|
||
|
||
// For MP4, extra sampling rate to FLV.
|
||
SrsAudioSampleRate12000 = 12,
|
||
SrsAudioSampleRate24000 = 24,
|
||
SrsAudioSampleRate48000 = 48,
|
||
|
||
// For Opus, support 8, 12, 16, 24, 48KHz
|
||
// We will write a UINT8 sampling rate after FLV audio tag header.
|
||
// @doc https://tools.ietf.org/html/rfc6716#section-2
|
||
SrsAudioSampleRateNB8kHz = 8, // NB (narrowband)
|
||
SrsAudioSampleRateMB12kHz = 12, // MB (medium-band)
|
||
SrsAudioSampleRateWB16kHz = 16, // WB (wideband)
|
||
SrsAudioSampleRateSWB24kHz = 24, // SWB (super-wideband)
|
||
SrsAudioSampleRateFB48kHz = 48, // FB (fullband)
|
||
};
|
||
SrsAudioSampleRate srs_audio_sample_rate_from_number(uint32_t v);
|
||
SrsAudioSampleRate srs_audio_sample_rate_guess_number(uint32_t v);
|
||
uint32_t srs_audio_sample_rate2number(SrsAudioSampleRate v);
|
||
std::string srs_audio_sample_rate2str(SrsAudioSampleRate v);
|
||
|
||
/**
|
||
* The frame type, for example, audio, video or data.
|
||
* @doc video_file_format_spec_v10_1.pdf, page 75, E.4.1 FLV Tag
|
||
*/
|
||
enum SrsFrameType {
|
||
// set to the zero to reserved, for array map.
|
||
SrsFrameTypeReserved = 0,
|
||
SrsFrameTypeForbidden = 0,
|
||
|
||
// 8 = audio
|
||
SrsFrameTypeAudio = 8,
|
||
// 9 = video
|
||
SrsFrameTypeVideo = 9,
|
||
// 18 = script data
|
||
SrsFrameTypeScript = 18,
|
||
// 20 = command data
|
||
SrsFrameTypeCommand = 20,
|
||
};
|
||
|
||
/**
|
||
* Fast tough the codec of FLV video.
|
||
* @doc video_file_format_spec_v10_1.pdf, page 78, E.4.3 Video Tags
|
||
*/
|
||
class SrsFlvVideo
|
||
{
|
||
public:
|
||
SrsFlvVideo();
|
||
virtual ~SrsFlvVideo();
|
||
// the following function used to finger out the flv/rtmp packet detail.
|
||
public:
|
||
/**
|
||
* only check the frame_type, not check the codec type.
|
||
*/
|
||
static bool keyframe(char *data, int size);
|
||
/**
|
||
* check codec h264, keyframe, sequence header
|
||
*/
|
||
// TODO: FIXME: Remove it, use SrsFormat instead.
|
||
static bool sh(char *data, int size);
|
||
/**
|
||
* check codec h264.
|
||
*/
|
||
static bool h264(char *data, int size);
|
||
// Check whether codec is HEVC(H.265).
|
||
static bool hevc(char *data, int size);
|
||
/**
|
||
* check the video RTMP/flv header info,
|
||
* @return true if video RTMP/flv header is ok.
|
||
* @remark all type of audio is possible, no need to check audio.
|
||
*/
|
||
static bool acceptable(char *data, int size);
|
||
};
|
||
|
||
/**
|
||
* Fast tough the codec of FLV video.
|
||
* @doc video_file_format_spec_v10_1.pdf, page 76, E.4.2 Audio Tags
|
||
*/
|
||
class SrsFlvAudio
|
||
{
|
||
public:
|
||
SrsFlvAudio();
|
||
virtual ~SrsFlvAudio();
|
||
// the following function used to finger out the flv/rtmp packet detail.
|
||
public:
|
||
/**
|
||
* check codec aac, sequence header
|
||
*/
|
||
static bool sh(char *data, int size);
|
||
/**
|
||
* check codec aac.
|
||
*/
|
||
static bool aac(char *data, int size);
|
||
};
|
||
|
||
/**
|
||
* the public data, event HLS disable, others can use it.
|
||
*/
|
||
/**
|
||
* the flv sample rate map
|
||
*/
|
||
extern int srs_flv_srates[];
|
||
|
||
/**
|
||
* the aac sample rate map
|
||
*/
|
||
extern int srs_aac_srates[];
|
||
|
||
// The number of aac samplerates, size for srs_aac_srates.
|
||
#define SrsAAcSampleRateNumbers 16
|
||
|
||
// The impossible aac sample rate index.
|
||
#define SrsAacSampleRateUnset 15
|
||
|
||
// The max number of NALUs in a video, or aac frame in audio packet.
|
||
#define SrsMaxNbSamples 256
|
||
|
||
/**
|
||
* The audio sample size in bits.
|
||
* @doc video_file_format_spec_v10_1.pdf, page 76, E.4.2 Audio Tags
|
||
* Size of each audio sample. This parameter only pertains to
|
||
* uncompressed formats. Compressed formats always decode
|
||
* to 16 bits internally.
|
||
* 0 = 8-bit samples
|
||
* 1 = 16-bit samples
|
||
*/
|
||
enum SrsAudioSampleBits {
|
||
// set to the max value to reserved, for array map.
|
||
SrsAudioSampleBitsReserved = 2,
|
||
SrsAudioSampleBitsForbidden = 2,
|
||
|
||
SrsAudioSampleBits8bit = 0,
|
||
SrsAudioSampleBits16bit = 1,
|
||
};
|
||
std::string srs_audio_sample_bits2str(SrsAudioSampleBits v);
|
||
|
||
/**
|
||
* The audio channels.
|
||
* @doc video_file_format_spec_v10_1.pdf, page 77, E.4.2 Audio Tags
|
||
* Mono or stereo sound
|
||
* 0 = Mono sound
|
||
* 1 = Stereo sound
|
||
*/
|
||
enum SrsAudioChannels {
|
||
// set to the max value to reserved, for array map.
|
||
SrsAudioChannelsReserved = 2,
|
||
SrsAudioChannelsForbidden = 2,
|
||
|
||
SrsAudioChannelsMono = 0,
|
||
SrsAudioChannelsStereo = 1,
|
||
};
|
||
std::string srs_audio_channels2str(SrsAudioChannels v);
|
||
|
||
/**
|
||
* Table 7-1 - NAL unit type codes, syntax element categories, and NAL unit type classes
|
||
* ISO_IEC_14496-10-AVC-2012.pdf, page 83.
|
||
*/
|
||
enum SrsAvcNaluType {
|
||
// Unspecified
|
||
SrsAvcNaluTypeReserved = 0,
|
||
SrsAvcNaluTypeForbidden = 0,
|
||
|
||
// Coded slice of a non-IDR picture slice_layer_without_partitioning_rbsp( )
|
||
SrsAvcNaluTypeNonIDR = 1,
|
||
// Coded slice data partition A slice_data_partition_a_layer_rbsp( )
|
||
SrsAvcNaluTypeDataPartitionA = 2,
|
||
// Coded slice data partition B slice_data_partition_b_layer_rbsp( )
|
||
SrsAvcNaluTypeDataPartitionB = 3,
|
||
// Coded slice data partition C slice_data_partition_c_layer_rbsp( )
|
||
SrsAvcNaluTypeDataPartitionC = 4,
|
||
// Coded slice of an IDR picture slice_layer_without_partitioning_rbsp( )
|
||
SrsAvcNaluTypeIDR = 5,
|
||
// Supplemental enhancement information (SEI) sei_rbsp( )
|
||
SrsAvcNaluTypeSEI = 6,
|
||
// Sequence parameter set seq_parameter_set_rbsp( )
|
||
SrsAvcNaluTypeSPS = 7,
|
||
// Picture parameter set pic_parameter_set_rbsp( )
|
||
SrsAvcNaluTypePPS = 8,
|
||
// Access unit delimiter access_unit_delimiter_rbsp( )
|
||
SrsAvcNaluTypeAccessUnitDelimiter = 9,
|
||
// End of sequence end_of_seq_rbsp( )
|
||
SrsAvcNaluTypeEOSequence = 10,
|
||
// End of stream end_of_stream_rbsp( )
|
||
SrsAvcNaluTypeEOStream = 11,
|
||
// Filler data filler_data_rbsp( )
|
||
SrsAvcNaluTypeFilterData = 12,
|
||
// Sequence parameter set extension seq_parameter_set_extension_rbsp( )
|
||
SrsAvcNaluTypeSPSExt = 13,
|
||
// Prefix NAL unit prefix_nal_unit_rbsp( )
|
||
SrsAvcNaluTypePrefixNALU = 14,
|
||
// Subset sequence parameter set subset_seq_parameter_set_rbsp( )
|
||
SrsAvcNaluTypeSubsetSPS = 15,
|
||
// Coded slice of an auxiliary coded picture without partitioning slice_layer_without_partitioning_rbsp( )
|
||
SrsAvcNaluTypeLayerWithoutPartition = 19,
|
||
// Coded slice extension slice_layer_extension_rbsp( )
|
||
SrsAvcNaluTypeCodedSliceExt = 20,
|
||
};
|
||
// @see https://datatracker.ietf.org/doc/html/rfc6184#section-1.3
|
||
#define SrsAvcNaluTypeParse(code) (SrsAvcNaluType)(code & 0x1F)
|
||
std::string srs_avc_nalu2str(SrsAvcNaluType nalu_type);
|
||
|
||
/**
|
||
* The enum NALU type for HEVC
|
||
* @see Table 7-1 – NAL unit type codes and NAL unit type classes
|
||
* @doc ITU-T-H.265-2021.pdf, page 86.
|
||
*/
|
||
enum SrsHevcNaluType {
|
||
SrsHevcNaluType_CODED_SLICE_TRAIL_N = 0,
|
||
SrsHevcNaluType_CODED_SLICE_TRAIL_R, // 1
|
||
SrsHevcNaluType_CODED_SLICE_TSA_N, // 2
|
||
SrsHevcNaluType_CODED_SLICE_TLA, // 3
|
||
SrsHevcNaluType_CODED_SLICE_STSA_N, // 4
|
||
SrsHevcNaluType_CODED_SLICE_STSA_R, // 5
|
||
SrsHevcNaluType_CODED_SLICE_RADL_N, // 6
|
||
SrsHevcNaluType_CODED_SLICE_DLP, // 7
|
||
SrsHevcNaluType_CODED_SLICE_RASL_N, // 8
|
||
SrsHevcNaluType_CODED_SLICE_TFD, // 9
|
||
SrsHevcNaluType_RESERVED_10,
|
||
SrsHevcNaluType_RESERVED_11,
|
||
SrsHevcNaluType_RESERVED_12,
|
||
SrsHevcNaluType_RESERVED_13,
|
||
SrsHevcNaluType_RESERVED_14,
|
||
SrsHevcNaluType_RESERVED_15,
|
||
SrsHevcNaluType_CODED_SLICE_BLA, // 16
|
||
SrsHevcNaluType_CODED_SLICE_BLANT, // 17
|
||
SrsHevcNaluType_CODED_SLICE_BLA_N_LP, // 18
|
||
SrsHevcNaluType_CODED_SLICE_IDR, // 19
|
||
SrsHevcNaluType_CODED_SLICE_IDR_N_LP, // 20
|
||
SrsHevcNaluType_CODED_SLICE_CRA, // 21
|
||
SrsHevcNaluType_RESERVED_22,
|
||
SrsHevcNaluType_RESERVED_23,
|
||
SrsHevcNaluType_RESERVED_24,
|
||
SrsHevcNaluType_RESERVED_25,
|
||
SrsHevcNaluType_RESERVED_26,
|
||
SrsHevcNaluType_RESERVED_27,
|
||
SrsHevcNaluType_RESERVED_28,
|
||
SrsHevcNaluType_RESERVED_29,
|
||
SrsHevcNaluType_RESERVED_30,
|
||
SrsHevcNaluType_RESERVED_31,
|
||
SrsHevcNaluType_VPS, // 32
|
||
SrsHevcNaluType_SPS, // 33
|
||
SrsHevcNaluType_PPS, // 34
|
||
SrsHevcNaluType_ACCESS_UNIT_DELIMITER, // 35
|
||
SrsHevcNaluType_EOS, // 36
|
||
SrsHevcNaluType_EOB, // 37
|
||
SrsHevcNaluType_FILLER_DATA, // 38
|
||
SrsHevcNaluType_SEI, // 39 Prefix SEI
|
||
SrsHevcNaluType_SEI_SUFFIX, // 40 Suffix SEI
|
||
SrsHevcNaluType_RESERVED_41,
|
||
SrsHevcNaluType_RESERVED_42,
|
||
SrsHevcNaluType_RESERVED_43,
|
||
SrsHevcNaluType_RESERVED_44,
|
||
SrsHevcNaluType_RESERVED_45,
|
||
SrsHevcNaluType_RESERVED_46,
|
||
SrsHevcNaluType_RESERVED_47,
|
||
SrsHevcNaluType_UNSPECIFIED_48,
|
||
SrsHevcNaluType_UNSPECIFIED_49,
|
||
SrsHevcNaluType_UNSPECIFIED_50,
|
||
SrsHevcNaluType_UNSPECIFIED_51,
|
||
SrsHevcNaluType_UNSPECIFIED_52,
|
||
SrsHevcNaluType_UNSPECIFIED_53,
|
||
SrsHevcNaluType_UNSPECIFIED_54,
|
||
SrsHevcNaluType_UNSPECIFIED_55,
|
||
SrsHevcNaluType_UNSPECIFIED_56,
|
||
SrsHevcNaluType_UNSPECIFIED_57,
|
||
SrsHevcNaluType_UNSPECIFIED_58,
|
||
SrsHevcNaluType_UNSPECIFIED_59,
|
||
SrsHevcNaluType_UNSPECIFIED_60,
|
||
SrsHevcNaluType_UNSPECIFIED_61,
|
||
SrsHevcNaluType_UNSPECIFIED_62,
|
||
SrsHevcNaluType_UNSPECIFIED_63,
|
||
SrsHevcNaluType_INVALID,
|
||
};
|
||
// @see https://datatracker.ietf.org/doc/html/rfc7798#section-1.1.4
|
||
#define SrsHevcNaluTypeParse(code) (SrsHevcNaluType)((code & 0x7E) >> 1)
|
||
#define SrsIsIRAP(type) ((type >= SrsHevcNaluType_CODED_SLICE_BLA) && (type <= SrsHevcNaluType_RESERVED_23))
|
||
|
||
/**
|
||
* @see Table 7-7 – Name association to slice_type
|
||
* @doc ITU-T-H.265-2021.pdf, page 116.
|
||
*/
|
||
enum SrsHevcSliceType {
|
||
SrsHevcSliceTypeB = 0,
|
||
SrsHevcSliceTypeP = 1,
|
||
SrsHevcSliceTypeI = 2,
|
||
};
|
||
|
||
struct SrsHevcNalData {
|
||
uint16_t nal_unit_length_;
|
||
std::vector<uint8_t> nal_unit_data_;
|
||
};
|
||
|
||
struct SrsHevcHvccNalu {
|
||
uint8_t array_completeness_;
|
||
uint8_t nal_unit_type_;
|
||
uint16_t num_nalus_;
|
||
std::vector<SrsHevcNalData> nal_data_vec_;
|
||
};
|
||
|
||
/**
|
||
* HEVC Common Max define.
|
||
* @doc ITU-T-H.265-2021.pdf
|
||
*/
|
||
// @see F.7.3.2.1: vps_video_parameter_set_id is u(4).
|
||
// @doc ITU-T-H.265-2021.pdf, page 464.
|
||
const int SrsHevcMax_VPS_COUNT = 16;
|
||
// @see 7.4.3.2.1: sps_seq_parameter_set_id is in [0, 15].
|
||
// @doc ITU-T-H.265-2021.pdf, page 95.
|
||
const int SrsHevcMax_SPS_COUNT = 16;
|
||
// @see 7.4.3.3.1: pps_pic_parameter_set_id is in [0, 63].
|
||
// @doc ITU-T-H.265-2021.pdf, page 102.
|
||
const int SrsHevcMax_PPS_COUNT = 64;
|
||
|
||
/**
|
||
* Profile, tier and level
|
||
* @see 7.3.3 Profile, tier and level syntax
|
||
* @doc ITU-T-H.265-2021.pdf, page 62.
|
||
*/
|
||
struct SrsHevcProfileTierLevel {
|
||
public:
|
||
uint8_t general_profile_space_;
|
||
uint8_t general_tier_flag_;
|
||
uint8_t general_profile_idc_;
|
||
uint8_t general_profile_compatibility_flag_[32];
|
||
uint8_t general_progressive_source_flag_;
|
||
uint8_t general_interlaced_source_flag_;
|
||
uint8_t general_non_packed_constraint_flag_;
|
||
uint8_t general_frame_only_constraint_flag_;
|
||
uint8_t general_max_12bit_constraint_flag_;
|
||
uint8_t general_max_10bit_constraint_flag_;
|
||
uint8_t general_max_8bit_constraint_flag_;
|
||
uint8_t general_max_422chroma_constraint_flag_;
|
||
uint8_t general_max_420chroma_constraint_flag_;
|
||
uint8_t general_max_monochrome_constraint_flag_;
|
||
uint8_t general_intra_constraint_flag_;
|
||
uint8_t general_one_picture_only_constraint_flag_;
|
||
uint8_t general_lower_bit_rate_constraint_flag_;
|
||
uint32_t general_max_14bit_constraint_flag_;
|
||
uint8_t general_reserved_zero_7bits_;
|
||
uint64_t general_reserved_zero_33bits_;
|
||
uint64_t general_reserved_zero_34bits_;
|
||
uint64_t general_reserved_zero_35bits_;
|
||
uint64_t general_reserved_zero_43bits_;
|
||
uint8_t general_inbld_flag_;
|
||
uint8_t general_reserved_zero_bit_;
|
||
uint8_t general_level_idc_;
|
||
std::vector<uint8_t> sub_layer_profile_present_flag_;
|
||
std::vector<uint8_t> sub_layer_level_present_flag_;
|
||
uint8_t reserved_zero_2bits_[8];
|
||
std::vector<uint8_t> sub_layer_profile_space_;
|
||
std::vector<uint8_t> sub_layer_tier_flag_;
|
||
std::vector<uint8_t> sub_layer_profile_idc_;
|
||
std::vector<std::vector<uint8_t> > sub_layer_profile_compatibility_flag_;
|
||
std::vector<uint8_t> sub_layer_progressive_source_flag_;
|
||
std::vector<uint8_t> sub_layer_interlaced_source_flag_;
|
||
std::vector<uint8_t> sub_layer_non_packed_constraint_flag_;
|
||
std::vector<uint8_t> sub_layer_frame_only_constraint_flag_;
|
||
std::vector<uint8_t> sub_layer_max_12bit_constraint_flag_;
|
||
std::vector<uint8_t> sub_layer_max_10bit_constraint_flag_;
|
||
std::vector<uint8_t> sub_layer_max_8bit_constraint_flag_;
|
||
std::vector<uint8_t> sub_layer_max_422chroma_constraint_flag_;
|
||
std::vector<uint8_t> sub_layer_max_420chroma_constraint_flag_;
|
||
std::vector<uint8_t> sub_layer_max_monochrome_constraint_flag_;
|
||
std::vector<uint8_t> sub_layer_intra_constraint_flag_;
|
||
std::vector<uint8_t> sub_layer_one_picture_only_constraint_flag_;
|
||
std::vector<uint8_t> sub_layer_lower_bit_rate_constraint_flag_;
|
||
std::vector<uint8_t> sub_layer_reserved_zero_7bits_;
|
||
std::vector<uint64_t> sub_layer_reserved_zero_33bits_;
|
||
std::vector<uint64_t> sub_layer_reserved_zero_34bits_;
|
||
std::vector<uint64_t> sub_layer_reserved_zero_35bits_;
|
||
std::vector<uint64_t> sub_layer_reserved_zero_43bits_;
|
||
std::vector<uint8_t> sub_layer_inbld_flag_;
|
||
std::vector<uint8_t> sub_layer_reserved_zero_bit_;
|
||
std::vector<uint8_t> sub_layer_level_idc_;
|
||
|
||
public:
|
||
SrsHevcProfileTierLevel();
|
||
virtual ~SrsHevcProfileTierLevel();
|
||
};
|
||
|
||
/**
|
||
* Sub-layer HRD parameters
|
||
* @see E.2.3 Sub-layer HRD parameters syntax
|
||
* @doc ITU-T-H.265-2021.pdf, page 440.
|
||
*/
|
||
struct SrsHevcSubLayerHrdParameters {
|
||
std::vector<int> bit_rate_value_minus1_;
|
||
std::vector<int> cpb_size_value_minus1_;
|
||
std::vector<int> cpb_size_du_value_minus1_;
|
||
std::vector<int> bit_rate_du_value_minus1_;
|
||
std::vector<uint8_t> cbr_flag_;
|
||
};
|
||
|
||
/**
|
||
* HRD parameters
|
||
* @see E.2.2 HRD parameters syntax
|
||
* @doc ITU-T-H.265-2021.pdf, page 439.
|
||
*/
|
||
struct SrsHevcHrdParameters {
|
||
uint8_t nal_hrd_parameters_present_flag_;
|
||
uint8_t vcl_hrd_parameters_present_flag_;
|
||
uint8_t sub_pic_hrd_params_present_flag_;
|
||
uint8_t tick_divisor_minus2_;
|
||
uint8_t du_cpb_removal_delay_increment_length_minus1_;
|
||
uint8_t sub_pic_cpb_params_in_pic_timing_sei_flag_;
|
||
uint8_t dpb_output_delay_du_length_minus1_;
|
||
uint8_t bit_rate_scale_;
|
||
uint8_t cpb_size_scale_;
|
||
uint8_t cpb_size_du_scale_;
|
||
uint8_t initial_cpb_removal_delay_length_minus1_;
|
||
uint8_t au_cpb_removal_delay_length_minus1_;
|
||
uint8_t dpb_output_delay_length_minus1_;
|
||
std::vector<uint8_t> fixed_pic_rate_general_flag_;
|
||
std::vector<uint8_t> fixed_pic_rate_within_cvs_flag_;
|
||
std::vector<int> elemental_duration_in_tc_minus1_;
|
||
std::vector<uint8_t> low_delay_hrd_flag_;
|
||
std::vector<int> cpb_cnt_minus1_;
|
||
SrsHevcSubLayerHrdParameters sub_layer_hrd_parameters_; // nal
|
||
SrsHevcSubLayerHrdParameters sub_layer_hrd_parameters_v_; // vlc
|
||
};
|
||
|
||
/**
|
||
* Scaling list data
|
||
* @see 7.3.4 Scaling list data syntax
|
||
* @doc ITU-T-H.265-2021.pdf, page 65.
|
||
*/
|
||
struct SrsHevcScalingListData {
|
||
uint32_t scaling_list_pred_mode_flag_[4][6];
|
||
uint32_t scaling_list_pred_matrix_id_delta_[4][6];
|
||
int32_t scaling_list_dc_coef_minus8_[4][6];
|
||
uint32_t ScalingList_[4][6][64];
|
||
int32_t coefNum_;
|
||
};
|
||
|
||
/**
|
||
* Sequence parameter set range extension
|
||
* @see 7.3.2.2.2 Sequence parameter set range extension syntax
|
||
* @doc ITU-T-H.265-2021.pdf, page 57.
|
||
*/
|
||
struct SrsHevcSpsRangeExtension {
|
||
uint8_t transform_skip_rotation_enabled_flag_;
|
||
uint8_t transform_skip_context_enabled_flag_;
|
||
uint8_t implicit_rdpcm_enabled_flag_;
|
||
uint8_t explicit_rdpcm_enabled_flag_;
|
||
uint8_t extended_precision_processing_flag_;
|
||
uint8_t intra_smoothing_disabled_flag_;
|
||
uint8_t high_precision_offsets_enabled_flag_;
|
||
uint8_t persistent_rice_adaptation_enabled_flag_;
|
||
uint8_t cabac_bypass_alignment_enabled_flag_;
|
||
};
|
||
|
||
/**
|
||
* Picture parameter set RBSP syntax
|
||
* @see 7.3.2.3.1 General picture parameter set RBSP syntax
|
||
* @doc ITU-T-H.265-2021.pdf, page 57.
|
||
*/
|
||
struct SrsHevcPpsRangeExtension {
|
||
uint32_t log2_max_transform_skip_block_size_minus2_;
|
||
uint8_t cross_component_prediction_enabled_flag_;
|
||
uint8_t chroma_qp_offset_list_enabled_flag_;
|
||
uint32_t diff_cu_chroma_qp_offset_depth_;
|
||
uint32_t chroma_qp_offset_list_len_minus1_;
|
||
std::vector<int> cb_qp_offset_list_;
|
||
std::vector<int> cr_qp_offset_list_;
|
||
uint32_t log2_sao_offset_scale_luma_;
|
||
uint32_t log2_sao_offset_scale_chroma_;
|
||
};
|
||
|
||
/**
|
||
* Short-term reference picture set
|
||
* @see 7.3.7 Short-term reference picture set syntax
|
||
* @doc ITU-T-H.265-2021.pdf, page 70.
|
||
*/
|
||
struct SrsHevcStRefPicSet {
|
||
uint8_t inter_ref_pic_set_prediction_flag_;
|
||
int delta_idx_minus1_;
|
||
uint8_t delta_rps_sign_;
|
||
int abs_delta_rps_minus1_;
|
||
std::vector<uint8_t> used_by_curr_pic_flag_;
|
||
std::vector<uint8_t> use_delta_flag_;
|
||
int num_negative_pics_;
|
||
int num_positive_pics_;
|
||
|
||
std::vector<int> delta_poc_s0_minus1_;
|
||
std::vector<uint8_t> used_by_curr_pic_s0_flag_;
|
||
std::vector<int> delta_poc_s1_minus1_;
|
||
std::vector<uint8_t> used_by_curr_pic_s1_flag_;
|
||
};
|
||
|
||
/**
|
||
* VUI parameters
|
||
* @see E.2.1 VUI parameters syntax
|
||
* @doc ITU-T-H.265-2021.pdf, page 437.
|
||
*/
|
||
struct SrsHevcVuiParameters {
|
||
uint8_t aspect_ratio_info_present_flag_;
|
||
uint8_t aspect_ratio_idc_;
|
||
int sar_width_;
|
||
int sar_height_;
|
||
uint8_t overscan_info_present_flag_;
|
||
uint8_t overscan_appropriate_flag_;
|
||
uint8_t video_signal_type_present_flag_;
|
||
uint8_t video_format_;
|
||
uint8_t video_full_range_flag_;
|
||
uint8_t colour_description_present_flag_;
|
||
uint8_t colour_primaries_;
|
||
uint8_t transfer_characteristics_;
|
||
uint8_t matrix_coeffs_;
|
||
uint8_t chroma_loc_info_present_flag_;
|
||
int chroma_sample_loc_type_top_field_;
|
||
int chroma_sample_loc_type_bottom_field_;
|
||
uint8_t neutral_chroma_indication_flag_;
|
||
uint8_t field_seq_flag_;
|
||
uint8_t frame_field_info_present_flag_;
|
||
uint8_t default_display_window_flag_;
|
||
int def_disp_win_left_offset_;
|
||
int def_disp_win_right_offset_;
|
||
int def_disp_win_top_offset_;
|
||
int def_disp_win_bottom_offset_;
|
||
uint8_t vui_timing_info_present_flag_;
|
||
uint32_t vui_num_units_in_tick_;
|
||
uint32_t vui_time_scale_;
|
||
uint8_t vui_poc_proportional_to_timing_flag_;
|
||
int vui_num_ticks_poc_diff_one_minus1_;
|
||
uint8_t vui_hrd_parameters_present_flag_;
|
||
SrsHevcHrdParameters hrd_parameters_;
|
||
uint8_t bitstream_restriction_flag_;
|
||
uint8_t tiles_fixed_structure_flag_;
|
||
uint8_t motion_vectors_over_pic_boundaries_flag_;
|
||
uint8_t restricted_ref_pic_lists_flag_;
|
||
int min_spatial_segmentation_idc_;
|
||
int max_bytes_per_pic_denom_;
|
||
int max_bits_per_min_cu_denom_;
|
||
int log2_max_mv_length_horizontal_;
|
||
int log2_max_mv_length_vertical_;
|
||
};
|
||
|
||
/**
|
||
* Video Parameter Set
|
||
* @see 7.3.2.1 Video parameter set RBSP syntax
|
||
* @doc ITU-T-H.265-2021.pdf, page 54.
|
||
*/
|
||
struct SrsHevcRbspVps {
|
||
uint8_t vps_video_parameter_set_id_; // u(4)
|
||
uint8_t vps_base_layer_internal_flag_; // u(1)
|
||
uint8_t vps_base_layer_available_flag_; // u(1)
|
||
uint8_t vps_max_layers_minus1_; // u(6)
|
||
uint8_t vps_max_sub_layers_minus1_; // u(3)
|
||
uint8_t vps_temporal_id_nesting_flag_; // u(1)
|
||
int vps_reserved_0xffff_16bits_; // u(16)
|
||
SrsHevcProfileTierLevel ptl_;
|
||
uint8_t vps_sub_layer_ordering_info_present_flag_;
|
||
// Sublayers
|
||
uint32_t vps_max_dec_pic_buffering_minus1_[8]; // max u(3)
|
||
uint32_t vps_max_num_reorder_pics_[8];
|
||
uint32_t vps_max_latency_increase_plus1_[8];
|
||
uint8_t vps_max_layer_id_;
|
||
uint32_t vps_num_layer_sets_minus1_;
|
||
std::vector<std::vector<uint8_t> > layer_id_included_flag_;
|
||
uint8_t vps_timing_info_present_flag_;
|
||
uint32_t vps_num_units_in_tick_;
|
||
uint32_t vps_time_scale_;
|
||
uint8_t vps_poc_proportional_to_timing_flag_;
|
||
uint32_t vps_num_ticks_poc_diff_one_minus1_;
|
||
uint32_t vps_num_hrd_parameters_;
|
||
std::vector<uint32_t> hrd_layer_set_idx_;
|
||
std::vector<uint8_t> cprms_present_flag_;
|
||
SrsHevcHrdParameters hrd_parameters_;
|
||
uint8_t vps_extension_flag_;
|
||
uint8_t vps_extension_data_flag_;
|
||
};
|
||
|
||
/**
|
||
* Sequence Parameter Set
|
||
* @see 7.3.2.2 Sequence parameter set RBSP syntax
|
||
* @doc ITU-T-H.265-2021.pdf, page 55.
|
||
*/
|
||
struct SrsHevcRbspSps {
|
||
uint8_t sps_video_parameter_set_id_;
|
||
uint8_t sps_max_sub_layers_minus1_;
|
||
uint8_t sps_temporal_id_nesting_flag_;
|
||
SrsHevcProfileTierLevel ptl_;
|
||
uint32_t sps_seq_parameter_set_id_;
|
||
uint32_t chroma_format_idc_;
|
||
uint8_t separate_colour_plane_flag_;
|
||
uint32_t pic_width_in_luma_samples_;
|
||
uint32_t pic_height_in_luma_samples_;
|
||
uint32_t conformance_window_flag_;
|
||
uint32_t conf_win_left_offset_;
|
||
uint32_t conf_win_right_offset_;
|
||
uint32_t conf_win_top_offset_;
|
||
uint32_t conf_win_bottom_offset_;
|
||
uint32_t bit_depth_luma_minus8_;
|
||
uint32_t bit_depth_chroma_minus8_;
|
||
uint32_t log2_max_pic_order_cnt_lsb_minus4_;
|
||
uint8_t sps_sub_layer_ordering_info_present_flag_;
|
||
uint32_t sps_max_dec_pic_buffering_minus1_[8]; // max u(3)
|
||
uint32_t sps_max_num_reorder_pics_[8];
|
||
uint32_t sps_max_latency_increase_plus1_[8];
|
||
uint32_t log2_min_luma_coding_block_size_minus3_;
|
||
uint32_t log2_diff_max_min_luma_coding_block_size_;
|
||
uint32_t log2_min_luma_transform_block_size_minus2_;
|
||
uint32_t log2_diff_max_min_luma_transform_block_size_;
|
||
uint32_t max_transform_hierarchy_depth_inter_;
|
||
uint32_t max_transform_hierarchy_depth_intra_;
|
||
uint8_t scaling_list_enabled_flag_;
|
||
uint8_t sps_infer_scaling_list_flag_;
|
||
uint32_t sps_scaling_list_ref_layer_id_;
|
||
uint32_t sps_scaling_list_data_present_flag_;
|
||
SrsHevcScalingListData scaling_list_data_;
|
||
uint8_t amp_enabled_flag_;
|
||
uint8_t sample_adaptive_offset_enabled_flag_;
|
||
uint8_t pcm_enabled_flag_;
|
||
uint8_t pcm_sample_bit_depth_luma_minus1_;
|
||
uint8_t pcm_sample_bit_depth_chroma_minus1_;
|
||
uint32_t log2_min_pcm_luma_coding_block_size_minus3_;
|
||
uint32_t log2_diff_max_min_pcm_luma_coding_block_size_;
|
||
uint8_t pcm_loop_filter_disabled_flag_;
|
||
uint32_t num_short_term_ref_pic_sets_;
|
||
std::vector<SrsHevcStRefPicSet> st_ref_pic_set_;
|
||
uint8_t long_term_ref_pics_present_flag_;
|
||
uint32_t num_long_term_ref_pics_sps_;
|
||
uint32_t lt_ref_pic_poc_lsb_sps_bytes_;
|
||
std::vector<uint32_t> lt_ref_pic_poc_lsb_sps_;
|
||
std::vector<uint8_t> used_by_curr_pic_lt_sps_flag_;
|
||
uint8_t sps_temporal_mvp_enabled_flag_;
|
||
uint8_t strong_intra_smoothing_enabled_flag_;
|
||
uint8_t vui_parameters_present_flag_;
|
||
SrsHevcVuiParameters vui_;
|
||
uint8_t sps_extension_present_flag_;
|
||
uint8_t sps_range_extension_flag_;
|
||
uint8_t sps_multilayer_extension_flag_;
|
||
uint8_t sps_3d_extension_flag_;
|
||
uint8_t sps_extension_5bits_;
|
||
SrsHevcSpsRangeExtension sps_range_extension_;
|
||
uint8_t inter_view_mv_vert_constraint_flag_; // sps_multilayer_extension_t sps_multilayer_extension;
|
||
// sps_3d_extension_t sps_3d_extension;
|
||
// int sps_extension_data_flag; // no need
|
||
// rbsp_trailing_bits()...
|
||
};
|
||
|
||
/**
|
||
* Picture Parameter Set
|
||
* @see 7.3.2.3 Picture parameter set RBSP syntax
|
||
* @doc ITU-T-H.265-2021.pdf, page 57.
|
||
*/
|
||
struct SrsHevcRbspPps {
|
||
uint8_t pps_pic_parameter_set_id_;
|
||
uint8_t pps_seq_parameter_set_id_;
|
||
uint8_t dependent_slice_segments_enabled_flag_;
|
||
uint8_t output_flag_present_flag_;
|
||
uint8_t num_extra_slice_header_bits_;
|
||
uint8_t sign_data_hiding_enabled_flag_;
|
||
uint8_t cabac_init_present_flag_;
|
||
uint32_t num_ref_idx_l0_default_active_minus1_;
|
||
uint32_t num_ref_idx_l1_default_active_minus1_;
|
||
int32_t init_qp_minus26_;
|
||
uint8_t constrained_intra_pred_flag_;
|
||
uint8_t transform_skip_enabled_flag_;
|
||
uint8_t cu_qp_delta_enabled_flag_;
|
||
uint32_t diff_cu_qp_delta_depth_;
|
||
int32_t pps_cb_qp_offset_;
|
||
int32_t pps_cr_qp_offset_;
|
||
uint8_t pps_slice_chroma_qp_offsets_present_flag_;
|
||
uint8_t weighted_pred_flag_;
|
||
uint32_t weighted_bipred_flag_;
|
||
uint8_t transquant_bypass_enabled_flag_;
|
||
uint8_t tiles_enabled_flag_;
|
||
uint8_t entropy_coding_sync_enabled_flag_;
|
||
uint32_t num_tile_columns_minus1_;
|
||
uint32_t num_tile_rows_minus1_;
|
||
uint32_t uniform_spacing_flag_;
|
||
std::vector<uint32_t> column_width_minus1_;
|
||
std::vector<uint32_t> row_height_minus1_;
|
||
uint8_t loop_filter_across_tiles_enabled_flag_;
|
||
uint8_t pps_loop_filter_across_slices_enabled_flag_;
|
||
uint8_t deblocking_filter_control_present_flag_;
|
||
uint8_t deblocking_filter_override_enabled_flag_;
|
||
uint8_t pps_deblocking_filter_disabled_flag_;
|
||
int32_t pps_beta_offset_div2_;
|
||
int32_t pps_tc_offset_div2_;
|
||
uint8_t pps_scaling_list_data_present_flag_;
|
||
SrsHevcScalingListData scaling_list_data_;
|
||
uint8_t lists_modification_present_flag_;
|
||
uint32_t log2_parallel_merge_level_minus2_;
|
||
uint8_t slice_segment_header_extension_present_flag_;
|
||
uint8_t pps_extension_present_flag_;
|
||
uint8_t pps_range_extension_flag_;
|
||
uint8_t pps_multilayer_extension_flag_;
|
||
uint8_t pps_3d_extension_flag_;
|
||
uint8_t pps_scc_extension_flag_;
|
||
uint8_t pps_extension_4bits_;
|
||
SrsHevcPpsRangeExtension pps_range_extension_;
|
||
// pps_multilayer_extension_t pps_multilayer_extension;
|
||
// pps_3d_extension_t pps_3d_extension;
|
||
uint8_t pps_extension_data_flag_;
|
||
// rbsp_trailing_bits( ) ...
|
||
};
|
||
|
||
struct SrsHevcDecoderConfigurationRecord {
|
||
uint8_t configuration_version_;
|
||
uint8_t general_profile_space_;
|
||
uint8_t general_tier_flag_;
|
||
uint8_t general_profile_idc_;
|
||
uint32_t general_profile_compatibility_flags_;
|
||
uint64_t general_constraint_indicator_flags_;
|
||
uint8_t general_level_idc_;
|
||
uint16_t min_spatial_segmentation_idc_;
|
||
uint8_t parallelism_type_;
|
||
uint8_t chroma_format_;
|
||
uint8_t bit_depth_luma_minus8_;
|
||
uint8_t bit_depth_chroma_minus8_;
|
||
uint16_t avg_frame_rate_;
|
||
uint8_t constant_frame_rate_;
|
||
uint8_t num_temporal_layers_;
|
||
uint8_t temporal_id_nested_;
|
||
uint8_t length_size_minus_one_;
|
||
std::vector<SrsHevcHvccNalu> nalu_vec_;
|
||
|
||
SrsHevcRbspVps vps_table_[SrsHevcMax_VPS_COUNT];
|
||
SrsHevcRbspSps sps_table_[SrsHevcMax_SPS_COUNT];
|
||
SrsHevcRbspPps pps_table_[SrsHevcMax_PPS_COUNT];
|
||
};
|
||
|
||
/**
|
||
* Table 7-6 – Name association to slice_type
|
||
* ISO_IEC_14496-10-AVC-2012.pdf, page 105.
|
||
*/
|
||
enum SrsAvcSliceType {
|
||
SrsAvcSliceTypeP = 0,
|
||
SrsAvcSliceTypeB = 1,
|
||
SrsAvcSliceTypeI = 2,
|
||
SrsAvcSliceTypeSP = 3,
|
||
SrsAvcSliceTypeSI = 4,
|
||
SrsAvcSliceTypeP1 = 5,
|
||
SrsAvcSliceTypeB1 = 6,
|
||
SrsAvcSliceTypeI1 = 7,
|
||
SrsAvcSliceTypeSP1 = 8,
|
||
SrsAvcSliceTypeSI1 = 9,
|
||
};
|
||
|
||
/**
|
||
* the avc payload format, must be ibmf or annexb format.
|
||
* we guess by annexb first, then ibmf for the first time,
|
||
* and we always use the guessed format for the next time.
|
||
*/
|
||
enum SrsAvcPayloadFormat {
|
||
SrsAvcPayloadFormatGuess = 0,
|
||
SrsAvcPayloadFormatAnnexb,
|
||
SrsAvcPayloadFormatIbmf,
|
||
};
|
||
|
||
/**
|
||
* the aac profile, for ADTS(HLS/TS)
|
||
* @see https://github.com/ossrs/srs/issues/310
|
||
*/
|
||
enum SrsAacProfile {
|
||
SrsAacProfileReserved = 3,
|
||
|
||
// @see 7.1 Profiles, ISO_IEC_13818-7-AAC-2004.pdf, page 40
|
||
SrsAacProfileMain = 0,
|
||
SrsAacProfileLC = 1,
|
||
SrsAacProfileSSR = 2,
|
||
};
|
||
std::string srs_aac_profile2str(SrsAacProfile aac_profile);
|
||
|
||
/**
|
||
* the aac object type, for RTMP sequence header
|
||
* for AudioSpecificConfig, @see ISO_IEC_14496-3-AAC-2001.pdf, page 33
|
||
* for audioObjectType, @see ISO_IEC_14496-3-AAC-2001.pdf, page 23
|
||
*/
|
||
enum SrsAacObjectType {
|
||
SrsAacObjectTypeReserved = 0,
|
||
SrsAacObjectTypeForbidden = 0,
|
||
|
||
// Table 1.1 - Audio Object Type definition
|
||
// @see @see ISO_IEC_14496-3-AAC-2001.pdf, page 23
|
||
SrsAacObjectTypeAacMain = 1,
|
||
SrsAacObjectTypeAacLC = 2,
|
||
SrsAacObjectTypeAacSSR = 3,
|
||
|
||
// AAC HE = LC+SBR
|
||
SrsAacObjectTypeAacHE = 5,
|
||
// AAC HEv2 = LC+SBR+PS
|
||
SrsAacObjectTypeAacHEV2 = 29,
|
||
};
|
||
std::string srs_aac_object2str(SrsAacObjectType aac_object);
|
||
// ts/hls/adts audio header profile to RTMP sequence header object type.
|
||
SrsAacObjectType srs_aac_ts2rtmp(SrsAacProfile profile);
|
||
// RTMP sequence header object type to ts/hls/adts audio header profile.
|
||
SrsAacProfile srs_aac_rtmp2ts(SrsAacObjectType object_type);
|
||
|
||
/**
|
||
* the profile for avc/h.264.
|
||
* @see Annex A Profiles and levels, ISO_IEC_14496-10-AVC-2003.pdf, page 205.
|
||
*/
|
||
enum SrsAvcProfile {
|
||
SrsAvcProfileReserved = 0,
|
||
|
||
// @see ffmpeg, libavcodec/avcodec.h:2713
|
||
SrsAvcProfileBaseline = 66,
|
||
// FF_PROFILE_H264_CONSTRAINED (1<<9) // 8+1; constraint_set1_flag
|
||
// FF_PROFILE_H264_CONSTRAINED_BASELINE (66|FF_PROFILE_H264_CONSTRAINED)
|
||
SrsAvcProfileConstrainedBaseline = 578,
|
||
SrsAvcProfileMain = 77,
|
||
SrsAvcProfileExtended = 88,
|
||
SrsAvcProfileHigh = 100,
|
||
SrsAvcProfileHigh10 = 110,
|
||
SrsAvcProfileHigh10Intra = 2158,
|
||
SrsAvcProfileHigh422 = 122,
|
||
SrsAvcProfileHigh422Intra = 2170,
|
||
SrsAvcProfileHigh444 = 144,
|
||
SrsAvcProfileHigh444Predictive = 244,
|
||
SrsAvcProfileHigh444Intra = 2192,
|
||
};
|
||
std::string srs_avc_profile2str(SrsAvcProfile profile);
|
||
|
||
/**
|
||
* the level for avc/h.264.
|
||
* @see Annex A Profiles and levels, ISO_IEC_14496-10-AVC-2003.pdf, page 207.
|
||
*/
|
||
enum SrsAvcLevel {
|
||
SrsAvcLevelReserved = 0,
|
||
|
||
SrsAvcLevel_1 = 10,
|
||
SrsAvcLevel_11 = 11,
|
||
SrsAvcLevel_12 = 12,
|
||
SrsAvcLevel_13 = 13,
|
||
SrsAvcLevel_2 = 20,
|
||
SrsAvcLevel_21 = 21,
|
||
SrsAvcLevel_22 = 22,
|
||
SrsAvcLevel_3 = 30,
|
||
SrsAvcLevel_31 = 31,
|
||
SrsAvcLevel_32 = 32,
|
||
SrsAvcLevel_4 = 40,
|
||
SrsAvcLevel_41 = 41,
|
||
SrsAvcLevel_42 = 42,
|
||
SrsAvcLevel_5 = 50,
|
||
SrsAvcLevel_51 = 51,
|
||
SrsAvcLevel_52 = 52,
|
||
SrsAvcLevel_6 = 60,
|
||
SrsAvcLevel_61 = 61,
|
||
SrsAvcLevel_62 = 62,
|
||
};
|
||
std::string srs_avc_level2str(SrsAvcLevel level);
|
||
|
||
/**
|
||
* the profile for hevc/h.265, Annex A Profiles, tiers and levels
|
||
* @see A.3 Profiles
|
||
* @doc ITU-T-H.265-2021.pdf, page 268.
|
||
*/
|
||
enum SrsHevcProfile {
|
||
SrsHevcProfileReserved = 0,
|
||
|
||
// @see ffmpeg, libavcodec/avcodec.h:2986
|
||
SrsHevcProfileMain = 1,
|
||
SrsHevcProfileMain10 = 2,
|
||
SrsHevcProfileMainStillPicture = 3,
|
||
SrsHevcProfileRext = 4,
|
||
};
|
||
std::string srs_hevc_profile2str(SrsHevcProfile profile);
|
||
|
||
/**
|
||
* the level for hevc/h.265, Annex A Profiles, tiers and levels
|
||
* @see A.4 Tiers and levels
|
||
* @doc ITU-T-H.265-2021.pdf, page 283.
|
||
*/
|
||
enum SrsHevcLevel {
|
||
SrsHevcLevelReserved = 0,
|
||
|
||
SrsHevcLevel_1 = 30,
|
||
SrsHevcLevel_2 = 60,
|
||
SrsHevcLevel_21 = 63,
|
||
SrsHevcLevel_3 = 90,
|
||
SrsHevcLevel_31 = 93,
|
||
SrsHevcLevel_4 = 120,
|
||
SrsHevcLevel_41 = 123,
|
||
SrsHevcLevel_5 = 150,
|
||
SrsHevcLevel_51 = 153,
|
||
SrsHevcLevel_52 = 156,
|
||
SrsHevcLevel_6 = 180,
|
||
SrsHevcLevel_61 = 183,
|
||
SrsHevcLevel_62 = 186,
|
||
};
|
||
std::string srs_hevc_level2str(SrsHevcLevel level);
|
||
|
||
/**
|
||
* The codec is the information of encoder,
|
||
* corresponding to the sequence header of FLV,
|
||
* parsed to detail info.
|
||
*/
|
||
class SrsCodecConfig
|
||
{
|
||
public:
|
||
SrsCodecConfig();
|
||
virtual ~SrsCodecConfig();
|
||
};
|
||
|
||
/**
|
||
* The audio codec info.
|
||
*/
|
||
class SrsAudioCodecConfig : public SrsCodecConfig
|
||
{
|
||
// In FLV specification.
|
||
public:
|
||
// The audio codec id; for FLV, it's SoundFormat.
|
||
SrsAudioCodecId id_;
|
||
// The audio sample rate; for FLV, it's SoundRate.
|
||
SrsAudioSampleRate sound_rate_;
|
||
// The audio sample size, such as 16 bits; for FLV, it's SoundSize.
|
||
SrsAudioSampleBits sound_size_;
|
||
// The audio number of channels; for FLV, it's SoundType.
|
||
// TODO: FIXME: Rename to sound_channels.
|
||
SrsAudioChannels sound_type_;
|
||
int audio_data_rate_; // in bps
|
||
// In AAC specification.
|
||
public:
|
||
/**
|
||
* audio specified
|
||
* audioObjectType, in 1.6.2.1 AudioSpecificConfig, page 33,
|
||
* 1.5.1.1 Audio object type definition, page 23,
|
||
* in ISO_IEC_14496-3-AAC-2001.pdf.
|
||
*/
|
||
SrsAacObjectType aac_object_;
|
||
/**
|
||
* samplingFrequencyIndex
|
||
*/
|
||
uint8_t aac_sample_rate_;
|
||
/**
|
||
* channelConfiguration
|
||
*/
|
||
uint8_t aac_channels_;
|
||
// Sequence header payload.
|
||
public:
|
||
/**
|
||
* the aac extra data, the AAC sequence header,
|
||
* without the flv codec header,
|
||
* @see: ffmpeg, AVCodecContext::extradata
|
||
*/
|
||
std::vector<char> aac_extra_data_;
|
||
|
||
public:
|
||
SrsAudioCodecConfig();
|
||
virtual ~SrsAudioCodecConfig();
|
||
|
||
public:
|
||
virtual bool is_aac_codec_ok();
|
||
};
|
||
|
||
/**
|
||
* The video codec info.
|
||
*/
|
||
class SrsVideoCodecConfig : public SrsCodecConfig
|
||
{
|
||
public:
|
||
SrsVideoCodecId id_;
|
||
int video_data_rate_; // in bps
|
||
double frame_rate_;
|
||
double duration_;
|
||
int width_;
|
||
int height_;
|
||
|
||
public:
|
||
/**
|
||
* the avc extra data, the AVC sequence header,
|
||
* without the flv codec header,
|
||
* @see: ffmpeg, AVCodecContext::extradata
|
||
*/
|
||
std::vector<char> avc_extra_data_;
|
||
|
||
public:
|
||
/**
|
||
* video specified
|
||
*/
|
||
// profile_idc, ISO_IEC_14496-10-AVC-2003.pdf, page 45.
|
||
SrsAvcProfile avc_profile_;
|
||
// level_idc, ISO_IEC_14496-10-AVC-2003.pdf, page 45.
|
||
SrsAvcLevel avc_level_;
|
||
// The profile_idc, ITU-T-H.265-2021.pdf, page 62.
|
||
SrsHevcProfile hevc_profile_;
|
||
// The level_idc, ITU-T-H.265-2021.pdf, page 63.
|
||
SrsHevcLevel hevc_level_;
|
||
// lengthSizeMinusOne, ISO_IEC_14496-15-AVC-format-2012.pdf, page 16
|
||
int8_t NAL_unit_length_;
|
||
// Note that we may resize the vector, so the under-layer bytes may change.
|
||
std::vector<char> sequenceParameterSetNALUnit_;
|
||
std::vector<char> pictureParameterSetNALUnit_;
|
||
|
||
public:
|
||
// the avc payload format.
|
||
SrsAvcPayloadFormat payload_format_;
|
||
|
||
public:
|
||
SrsHevcDecoderConfigurationRecord hevc_dec_conf_record_;
|
||
|
||
public:
|
||
SrsVideoCodecConfig();
|
||
virtual ~SrsVideoCodecConfig();
|
||
|
||
public:
|
||
virtual bool is_avc_codec_ok();
|
||
};
|
||
|
||
// To read H.264 NALU uev.
|
||
extern srs_error_t srs_avc_nalu_read_uev(SrsBitBuffer *stream, int32_t &v);
|
||
extern srs_error_t srs_avc_nalu_read_bit(SrsBitBuffer *stream, int8_t &v);
|
||
|
||
// Whether stream starts with the avc NALU in "AnnexB" from ISO_IEC_14496-10-AVC-2003.pdf, page 211.
|
||
// The start code must be "N[00] 00 00 01" where N>=0
|
||
// @param pnb_start_code output the size of start code, must >=3. NULL to ignore.
|
||
extern bool srs_avc_startswith_annexb(SrsBuffer *stream, int *pnb_start_code = NULL);
|
||
|
||
#endif
|