diff --git a/trunk/src/kernel/srs_kernel_ts.cpp b/trunk/src/kernel/srs_kernel_ts.cpp index 9ff4e5c9bb..93b3b426d2 100644 --- a/trunk/src/kernel/srs_kernel_ts.cpp +++ b/trunk/src/kernel/srs_kernel_ts.cpp @@ -408,6 +408,12 @@ SrsTsContext::SrsTsContext() SrsTsContext::~SrsTsContext() { + std::map::iterator it; + for (it = pids.begin(); it != pids.end(); ++it) { + SrsTsChannel* channel = it->second; + srs_freep(channel); + } + pids.clear(); } int SrsTsContext::decode(SrsStream* stream) @@ -429,17 +435,28 @@ int SrsTsContext::decode(SrsStream* stream) return ret; } -SrsTsPidApply SrsTsContext::get(int pid) +SrsTsChannel* SrsTsContext::get(int pid) { if (pids.find(pid) == pids.end()) { - return SrsTsPidApplyReserved; + return NULL; } return pids[pid]; } -void SrsTsContext::set(int pid, SrsTsPidApply apply_pid) +void SrsTsContext::set(int pid, SrsTsPidApply apply_pid, SrsTsStream stream) { - pids[pid] = apply_pid; + SrsTsChannel* channel = NULL; + + if (pids.find(pid) == pids.end()) { + channel = new SrsTsChannel(); + pids[pid] = channel; + } else { + channel = pids[pid]; + } + + channel->pid = pid; + channel->apply = apply_pid; + channel->stream = stream; } SrsTsPacket::SrsTsPacket(SrsTsContext* c) @@ -523,11 +540,15 @@ int SrsTsPacket::decode(SrsStream* stream) srs_freep(payload); payload = new SrsTsPayloadPAT(this); } else { - SrsTsPidApply apply_pid = context->get(pid); - if (apply_pid == SrsTsPidApplyPMT) { + SrsTsChannel* channel = context->get(pid); + if (channel && channel->apply == SrsTsPidApplyPMT) { // 2.4.4.8 Program Map Table srs_freep(payload); payload = new SrsTsPayloadPMT(this); + } else if (channel && (channel->apply == SrsTsPidApplyVideo || channel->apply == SrsTsPidApplyAudio)) { + // 2.4.3.6 PES packet + srs_freep(payload); + payload = new SrsTsPayloadPES(this); } else { // left bytes as reserved. stream->skip(nb_payload); @@ -793,6 +814,31 @@ SrsTsPayload::~SrsTsPayload() { } +SrsTsPayloadPES::SrsTsPayloadPES(SrsTsPacket* p) : SrsTsPayload(p) +{ + PES_private_data = NULL; + pack_field = NULL; + PES_extension_field = NULL; + nb_stuffings = 0; + nb_bytes = 0; + bytes = NULL; + nb_paddings = 0; +} + +SrsTsPayloadPES::~SrsTsPayloadPES() +{ + srs_freep(PES_private_data); + srs_freep(pack_field); + srs_freep(PES_extension_field); + srs_freep(bytes); +} + +int SrsTsPayloadPES::decode(SrsStream* stream) +{ + int ret = ERROR_SUCCESS; + return ret; +} + SrsTsPayloadPSI::SrsTsPayloadPSI(SrsTsPacket* p) : SrsTsPayload(p) { pointer_field = 0; @@ -879,7 +925,19 @@ int SrsTsPayloadPSI::decode(SrsStream* stream) // consume left stuffings if (!stream->empty()) { - stream->skip(stream->size() - stream->pos()); + int nb_stuffings = stream->size() - stream->pos(); + char* stuffing = stream->data() + stream->pos(); + + // all stuffing must be 0xff. + // TODO: FIXME: maybe need to remove the following. + for (int i = 0; i < nb_stuffings; i++) { + if ((u_int8_t)stuffing[i] != 0xff) { + srs_warn("ts: stuff is not 0xff, actual=%#x", stuffing[i]); + break; + } + } + + stream->skip(nb_stuffings); } return ret; @@ -1049,7 +1107,7 @@ int SrsTsPayloadPMT::psi_decode(SrsStream* stream) return ret; } - info->stream_type = stream->read_1bytes(); + info->stream_type = (SrsTsStream)stream->read_1bytes(); info->elementary_PID = stream->read_2bytes(); info->ES_info_length = stream->read_2bytes(); @@ -1066,6 +1124,23 @@ int SrsTsPayloadPMT::psi_decode(SrsStream* stream) info->ES_info = new char[info->ES_info_length]; stream->read_bytes(info->ES_info, info->ES_info_length); } + + // update the apply pid table + switch (info->stream_type) { + case SrsTsStreamVideoH264: + case SrsTsStreamVideoMpeg4: + packet->context->set(info->elementary_PID, SrsTsPidApplyVideo, info->stream_type); + break; + case SrsTsStreamAudioAAC: + case SrsTsStreamAudioAC3: + case SrsTsStreamAudioDTS: + case SrsTsStreamAudioMp3: + packet->context->set(info->elementary_PID, SrsTsPidApplyAudio, info->stream_type); + break; + default: + srs_warn("ts: drop pid=%#x, stream=%#x", info->elementary_PID, info->stream_type); + break; + } } // update the apply pid table. diff --git a/trunk/src/kernel/srs_kernel_ts.hpp b/trunk/src/kernel/srs_kernel_ts.hpp index fd2f90d260..0ff626b05b 100644 --- a/trunk/src/kernel/srs_kernel_ts.hpp +++ b/trunk/src/kernel/srs_kernel_ts.hpp @@ -65,8 +65,8 @@ class SrsMpegtsFrame /** * the pid of ts packet, -* Table 2-3 ¨C PID table, hls-mpeg-ts-iso13818-1.pdf, page 37 -* NOTE ¨C The transport packets with PID values 0x0000, 0x0001, and 0x0010-0x1FFE are allowed to carry a PCR. +* Table 2-3 - PID table, hls-mpeg-ts-iso13818-1.pdf, page 37 +* NOTE - The transport packets with PID values 0x0000, 0x0001, and 0x0010-0x1FFE are allowed to carry a PCR. */ enum SrsTsPid { @@ -88,7 +88,7 @@ enum SrsTsPid /** * the transport_scrambling_control of ts packet, -* Table 2-4 ¨C Scrambling control values, hls-mpeg-ts-iso13818-1.pdf, page 38 +* Table 2-4 - Scrambling control values, hls-mpeg-ts-iso13818-1.pdf, page 38 */ enum SrsTsScrambled { @@ -104,7 +104,7 @@ enum SrsTsScrambled /** * the adaption_field_control of ts packet, -* Table 2-5 ¨C Adaptation field control values, hls-mpeg-ts-iso13818-1.pdf, page 38 +* Table 2-5 - Adaptation field control values, hls-mpeg-ts-iso13818-1.pdf, page 38 */ enum SrsTsAdaptationFieldType { @@ -133,13 +133,62 @@ enum SrsTsPidApply SrsTsPidApplyAudio, // vor audio }; +/** +* Table 2-29 - Stream type assignments +*/ +enum SrsTsStream +{ + // ITU-T | ISO/IEC Reserved + SrsTsStreamReserved = 0x00, + // ISO/IEC 11172 Video + // ITU-T Rec. H.262 | ISO/IEC 13818-2 Video or ISO/IEC 11172-2 constrained parameter video stream + // ISO/IEC 11172 Audio + // ISO/IEC 13818-3 Audio + SrsTsStreamAudioMp3 = 0x04, + // ITU-T Rec. H.222.0 | ISO/IEC 13818-1 private_sections + // ITU-T Rec. H.222.0 | ISO/IEC 13818-1 PES packets containing private data + // ISO/IEC 13522 MHEG + // ITU-T Rec. H.222.0 | ISO/IEC 13818-1 Annex A DSM-CC + // ITU-T Rec. H.222.1 + // ISO/IEC 13818-6 type A + // ISO/IEC 13818-6 type B + // ISO/IEC 13818-6 type C + // ISO/IEC 13818-6 type D + // ITU-T Rec. H.222.0 | ISO/IEC 13818-1 auxiliary + // ISO/IEC 13818-7 Audio with ADTS transport syntax + SrsTsStreamAudioAAC = 0x0f, + // ISO/IEC 14496-2 Visual + SrsTsStreamVideoMpeg4 = 0x10, + // ISO/IEC 14496-3 Audio with the LATM transport syntax as defined in ISO/IEC 14496-3 / AMD 1 + // ISO/IEC 14496-1 SL-packetized stream or FlexMux stream carried in PES packets + // ISO/IEC 14496-1 SL-packetized stream or FlexMux stream carried in ISO/IEC14496_sections. + // ISO/IEC 13818-6 Synchronized Download Protocol + // ITU-T Rec. H.222.0 | ISO/IEC 13818-1 Reserved + // 0x15-0x7F + SrsTsStreamVideoH264 = 0x1b, + // User Private + // 0x80-0xFF + SrsTsStreamAudioAC3 = 0x81, + SrsTsStreamAudioDTS = 0x8a, +}; + +/** +* the ts channel. +*/ +struct SrsTsChannel +{ + int pid; + SrsTsPidApply apply; + SrsTsStream stream; +}; + /** * the context of ts, to decode the ts stream. */ class SrsTsContext { private: - std::map pids; + std::map pids; public: SrsTsContext(); virtual ~SrsTsContext(); @@ -152,13 +201,13 @@ class SrsTsContext public: /** * get the pid apply, the parsed pid. - * @return the apply pid; SrsTsPidApplyReserved for invalid. + * @return the apply channel; NULL for invalid. */ - virtual SrsTsPidApply get(int pid); + virtual SrsTsChannel* get(int pid); /** * set the pid apply, the parsed pid. */ - virtual void set(int pid, SrsTsPidApply apply_pid); + virtual void set(int pid, SrsTsPidApply apply_pid, SrsTsStream stream = SrsTsStreamReserved); }; /** @@ -216,7 +265,7 @@ class SrsTsPacket /** * The PID is a 13-bit field, indicating the type of the data stored in the packet payload. PID value 0x0000 is * reserved for the Program Association Table (see Table 2-25). PID value 0x0001 is reserved for the Conditional Access - * Table (see Table 2-27). PID values 0x0002 ¨C 0x000F are reserved. PID value 0x1FFF is reserved for null packets (see + * Table (see Table 2-27). PID values 0x0002 - 0x000F are reserved. PID value 0x1FFF is reserved for null packets (see * Table 2-3). */ SrsTsPid pid; //13bits @@ -269,7 +318,7 @@ class SrsTsPacket /** * the adaption field of ts packet. * 2.4.3.5 Semantic definition of fields in adaptation field, hls-mpeg-ts-iso13818-1.pdf, page 39 -* Table 2-6 ¨C Transport Stream adaptation field, hls-mpeg-ts-iso13818-1.pdf, page 40 +* Table 2-6 - Transport Stream adaptation field, hls-mpeg-ts-iso13818-1.pdf, page 40 */ class SrsTsAdaptationField { @@ -329,8 +378,8 @@ class SrsTsAdaptationField * same PID. * * For the purpose of this clause, an elementary stream access point is defined as follows: - * Video ¨C The first byte of a video sequence header. - * Audio ¨C The first byte of an audio frame. + * Video - The first byte of a video sequence header. + * Audio - The first byte of an audio frame. * * After a continuity counter discontinuity in a Transport packet which is designated as containing elementary stream data, * the first byte of elementary stream data in a Transport Stream packet of the same PID shall be the first byte of an @@ -454,8 +503,8 @@ class SrsTsAdaptationField * being excluded). * * For the purposes of this subclause, an access point is defined as follows: - * Video ¨C The first byte of a video_sequence_header. - * Audio ¨C The first byte of an audio frame. + * Video - The first byte of a video_sequence_header. + * Audio - The first byte of an audio frame. */ int8_t splice_countdown; //8bits @@ -497,15 +546,15 @@ class SrsTsAdaptationField //5bits reserved // if ltw_flag, 2B /** - * (legal time window_valid_flag) ¨C This is a 1-bit field which when set to '1' indicates that the value of the + * (legal time window_valid_flag) - This is a 1-bit field which when set to '1' indicates that the value of the * ltw_offset shall be valid. A value of '0' indicates that the value in the ltw_offset field is undefined. */ int8_t ltw_valid_flag; //1bit /** - * (legal time window offset) ¨C This is a 15-bit field, the value of which is defined only if the ltw_valid flag has + * (legal time window offset) - This is a 15-bit field, the value of which is defined only if the ltw_valid flag has * a value of '1'. When defined, the legal time window offset is in units of (300/fs) seconds, where fs is the system clock * frequency of the program that this PID belongs to, and fulfils: - * offset = t1(i) ¨C t(i) + * offset = t1(i) - t(i) * ltw_offset = offset//1 * where i is the index of the first byte of this Transport Stream packet, offset is the value encoded in this field, t(i) is the * arrival time of byte i in the T-STD, and t1(i) is the upper bound in time of a time interval called the Legal Time Window @@ -532,7 +581,7 @@ class SrsTsAdaptationField */ int8_t splice_type; //4bits /** - * (decoding time stamp next access unit) ¨C This is a 33-bit field, coded in three parts. In the case of + * (decoding time stamp next access unit) - This is a 33-bit field, coded in three parts. In the case of * continuous and periodic decoding through this splicing point it indicates the decoding time of the first access unit * following the splicing point. This decoding time is expressed in the time base which is valid in the Transport Stream * packet in which the splice_countdown reaches zero. From the first occurrence of this field onwards, it shall have the @@ -612,6 +661,312 @@ class SrsTsPayload virtual int decode(SrsStream* stream) = 0; }; +/** +* the PES payload of ts packet. +* 2.4.3.6 PES packet, hls-mpeg-ts-iso13818-1.pdf, page 49 +*/ +class SrsTsPayloadPES : public SrsTsPayload +{ +public: + // 3B + /** + * The packet_start_code_prefix is a 24-bit code. Together with the stream_id that follows it + * constitutes a packet start code that identifies the beginning of a packet. The packet_start_code_prefix is the bit string + * '0000 0000 0000 0000 0000 0001' (0x000001). + */ + int32_t packet_start_code_prefix; //24bits + // 1B + /** + * In Program Streams, the stream_id specifies the type and number of the elementary stream as defined by the + * stream_id Table 2-18. In Transport Streams, the stream_id may be set to any valid value which correctly describes the + * elementary stream type as defined in Table 2-18. In Transport Streams, the elementary stream type is specified in the + * Program Specific Information as specified in 2.4.4. + */ + u_int8_t stream_id; //8bits + // 2B + /** + * A 16-bit field specifying the number of bytes in the PES packet following the last byte of the + * field. A value of 0 indicates that the PES packet length is neither specified nor bounded and is allowed only in + * PES packets whose payload consists of bytes from a video elementary stream contained in Transport Stream packets. + */ + u_int16_t PES_packet_length; //16bits + + // 1B + // 2bits const '10' + /** + * The 2-bit PES_scrambling_control field indicates the scrambling mode of the PES packet + * payload. When scrambling is performed at the PES level, the PES packet header, including the optional fields when + * present, shall not be scrambled (see Table 2-19). + */ + int8_t PES_scrambling_control; //2bits + /** + * This is a 1-bit field indicating the priority of the payload in this PES packet. A '1' indicates a higher + * priority of the payload of the PES packet payload than a PES packet payload with this field set to '0'. A multiplexor can + * use the PES_priority bit to prioritize its data within an elementary stream. This field shall not be changed by the transport + * mechanism. + */ + int8_t PES_priority; //1bit + /** + * This is a 1-bit flag. When set to a value of '1' it indicates that the PES packet header is + * immediately followed by the video start code or audio syncword indicated in the data_stream_alignment_descriptor + * in 2.6.10 if this descriptor is present. If set to a value of '1' and the descriptor is not present, alignment as indicated in + * alignment_type '01' in Table 2-47 and Table 2-48 is required. When set to a value of '0' it is not defined whether any such + * alignment occurs or not. + */ + int8_t data_alignment_indicator; //1bit + /** + * This is a 1-bit field. When set to '1' it indicates that the material of the associated PES packet payload is + * protected by copyright. When set to '0' it is not defined whether the material is protected by copyright. A copyright + * descriptor described in 2.6.24 is associated with the elementary stream which contains this PES packet and the copyright + * flag is set to '1' if the descriptor applies to the material contained in this PES packet + */ + int8_t copyright; //1bit + /** + * This is a 1-bit field. When set to '1' the contents of the associated PES packet payload is an original. + * When set to '0' it indicates that the contents of the associated PES packet payload is a copy. + */ + int8_t original_or_copy; //1bit + + // 1B + /** + * This is a 2-bit field. When the PTS_DTS_flags field is set to '10', the PTS fields shall be present in + * the PES packet header. When the PTS_DTS_flags field is set to '11', both the PTS fields and DTS fields shall be present + * in the PES packet header. When the PTS_DTS_flags field is set to '00' no PTS or DTS fields shall be present in the PES + * packet header. The value '01' is forbidden. + */ + int8_t PTS_DTS_flags; //2bits + /** + * A 1-bit flag, which when set to '1' indicates that ESCR base and extension fields are present in the PES + * packet header. When set to '0' it indicates that no ESCR fields are present. + */ + int8_t ESCR_flag; //1bit + /** + * A 1-bit flag, which when set to '1' indicates that the ES_rate field is present in the PES packet header. + * When set to '0' it indicates that no ES_rate field is present. + */ + int8_t ES_rate_flag; //1bit + /** + * A 1-bit flag, which when set to '1' it indicates the presence of an 8-bit trick mode field. When + * set to '0' it indicates that this field is not present. + */ + int8_t DSM_trick_mode_flag; //1bit + /** + * A 1-bit flag, which when set to '1' indicates the presence of the additional_copy_info field. + * When set to '0' it indicates that this field is not present. + */ + int8_t additional_copy_info_flag; //1bit + /** + * A 1-bit flag, which when set to '1' indicates that a CRC field is present in the PES packet. When set to + * '0' it indicates that this field is not present. + */ + int8_t PES_CRC_flag; //1bit + /** + * A 1-bit flag, which when set to '1' indicates that an extension field exists in this PES packet + * header. When set to '0' it indicates that this field is not present. + */ + int8_t PES_extension_flag; //1bit + + // 1B + /** + * An 8-bit field specifying the total number of bytes occupied by the optional fields and any + * stuffing bytes contained in this PES packet header. The presence of optional fields is indicated in the byte that precedes + * the PES_header_data_length field. + */ + u_int8_t PES_header_data_length; //8bits + + // 8B + /** + * Presentation times shall be related to decoding times as follows: The PTS is a 33-bit + * number coded in three separate fields. It indicates the time of presentation, tp n (k), in the system target decoder of a + * presentation unit k of elementary stream n. The value of PTS is specified in units of the period of the system clock + * frequency divided by 300 (yielding 90 kHz). The presentation time is derived from the PTS according to equation 2-11 + * below. Refer to 2.7.4 for constraints on the frequency of coding presentation timestamps. + */ + int64_t pts; // 33bits + /** + * The DTS is a 33-bit number coded in three separate fields. It indicates the decoding time, + * td n (j), in the system target decoder of an access unit j of elementary stream n. The value of DTS is specified in units of + * the period of the system clock frequency divided by 300 (yielding 90 kHz). + */ + int64_t dts; // 33bits + + // 8B + /** + * The elementary stream clock reference is a 42-bit field coded in two parts. The first + * part, ESCR_base, is a 33-bit field whose value is given by ESCR_base(i), as given in equation 2-14. The second part, + * ESCR_ext, is a 9-bit field whose value is given by ESCR_ext(i), as given in equation 2-15. The ESCR field indicates the + * intended time of arrival of the byte containing the last bit of the ESCR_base at the input of the PES-STD for PES streams + * (refer to 2.5.2.4). + */ + int16_t ESCR_extension; //9bits + int64_t ESCR_base; //33bits + /** + * The ES_rate field is a 22-bit unsigned integer specifying the rate at which the + * system target decoder receives bytes of the PES packet in the case of a PES stream. The ES_rate is valid in the PES + * packet in which it is included and in subsequent PES packets of the same PES stream until a new ES_rate field is + * encountered. The value of the ES_rate is measured in units of 50 bytes/second. The value 0 is forbidden. The value of the + * ES_rate is used to define the time of arrival of bytes at the input of a P-STD for PES streams defined in 2.5.2.4. The + * value encoded in the ES_rate field may vary from PES_packet to PES_packet. + */ + int32_t ES_rate; //22bits + + // 1B + /** + * A 3-bit field that indicates which trick mode is applied to the associated video stream. In cases of + * other types of elementary streams, the meanings of this field and those defined by the following five bits are undefined. + * For the definition of trick_mode status, refer to the trick mode section of 2.4.2.3. + */ + int8_t trick_mode_control; //3bits + int8_t trick_mode_value; //5bits + + // 1B + // 1bit const '1' + /** + * This 7-bit field contains private data relating to copyright information. + */ + int8_t additional_copy_info; //7bits + + // 2B + /** + * The previous_PES_packet_CRC is a 16-bit field that contains the CRC value that yields + * a zero output of the 16 registers in the decoder similar to the one defined in Annex A, + */ + int16_t previous_PES_packet_CRC; //16bits + + // 1B + /** + * A 1-bit flag which when set to '1' indicates that the PES packet header contains private data. + * When set to a value of '0' it indicates that private data is not present in the PES header. + */ + int8_t PES_private_data_flag; //1bit + /** + * A 1-bit flag which when set to '1' indicates that an ISO/IEC 11172-1 pack header or a + * Program Stream pack header is stored in this PES packet header. If this field is in a PES packet that is contained in a + * Program Stream, then this field shall be set to '0'. In a Transport Stream, when set to the value '0' it indicates that no pack + * header is present in the PES header. + */ + int8_t pack_header_field_flag; //1bit + /** + * A 1-bit flag which when set to '1' indicates that the + * program_packet_sequence_counter, MPEG1_MPEG2_identifier, and original_stuff_length fields are present in this + * PES packet. When set to a value of '0' it indicates that these fields are not present in the PES header. + */ + int8_t program_packet_sequence_counter_flag; //1bit + /** + * A 1-bit flag which when set to '1' indicates that the P-STD_buffer_scale and P-STD_buffer_size + * are present in the PES packet header. When set to a value of '0' it indicates that these fields are not present in the + * PES header. + */ + int8_t P_STD_buffer_flag; //1bit + // reserved 3bits + /** + * A 1-bit field which when set to '1' indicates the presence of the PES_extension_field_length + * field and associated fields. When set to a value of '0' this indicates that the PES_extension_field_length field and any + * associated fields are not present. + */ + int8_t PES_extension_flag_2; //1bit + + // 16B + /** + * This is a 16-byte field which contains private data. This data, combined with the fields before and + * after, shall not emulate the packet_start_code_prefix (0x000001). + */ + char* PES_private_data; //128bits + + // (1+x)B + /** + * This is an 8-bit field which indicates the length, in bytes, of the pack_header_field(). + */ + int8_t pack_field_length; //8bits + char* pack_field; //[pack_field_length] bytes + + // 2B + // 1bit const '1' + /** + * The program_packet_sequence_counter field is a 7-bit field. It is an optional + * counter that increments with each successive PES packet from a Program Stream or from an ISO/IEC 11172-1 Stream or + * the PES packets associated with a single program definition in a Transport Stream, providing functionality similar to a + * continuity counter (refer to 2.4.3.2). This allows an application to retrieve the original PES packet sequence of a Program + * Stream or the original packet sequence of the original ISO/IEC 11172-1 stream. The counter will wrap around to 0 after + * its maximum value. Repetition of PES packets shall not occur. Consequently, no two consecutive PES packets in the + * program multiplex shall have identical program_packet_sequence_counter values. + */ + int8_t program_packet_sequence_counter; //7bits + // 1bit const '1' + /** + * A 1-bit flag which when set to '1' indicates that this PES packet carries information from + * an ISO/IEC 11172-1 stream. When set to '0' it indicates that this PES packet carries information from a Program Stream. + */ + int8_t MPEG1_MPEG2_identifier; //1bit + /** + * This 6-bit field specifies the number of stuffing bytes used in the original ITU-T + * Rec. H.222.0 | ISO/IEC 13818-1 PES packet header or in the original ISO/IEC 11172-1 packet header. + */ + int8_t original_stuff_length; //6bits + + // 2B + // 2bits const '01' + /** + * The P-STD_buffer_scale is a 1-bit field, the meaning of which is only defined if this PES packet + * is contained in a Program Stream. It indicates the scaling factor used to interpret the subsequent P-STD_buffer_size field. + * If the preceding stream_id indicates an audio stream, P-STD_buffer_scale shall have the value '0'. If the preceding + * stream_id indicates a video stream, P-STD_buffer_scale shall have the value '1'. For all other stream types, the value + * may be either '1' or '0'. + */ + int8_t P_STD_buffer_scale; //1bit + /** + * The P-STD_buffer_size is a 13-bit unsigned integer, the meaning of which is only defined if this + * PES packet is contained in a Program Stream. It defines the size of the input buffer, BS n , in the P-STD. If + * P-STD_buffer_scale has the value '0', then the P-STD_buffer_size measures the buffer size in units of 128 bytes. If + * P-STD_buffer_scale has the value '1', then the P-STD_buffer_size measures the buffer size in units of 1024 bytes. + */ + int16_t P_STD_buffer_size; //13bits + + // (1+x)B + // 1bit const '1' + /** + * This is a 7-bit field which specifies the length, in bytes, of the data following this field in + * the PES extension field up to and including any reserved bytes. + */ + int8_t PES_extension_field_length; //7bits + char* PES_extension_field; //[PES_extension_field_length] bytes + + // NB + /** + * This is a fixed 8-bit value equal to '1111 1111' that can be inserted by the encoder, for example to meet + * the requirements of the channel. It is discarded by the decoder. No more than 32 stuffing bytes shall be present in one + * PES packet header. + */ + int nb_stuffings; + + // NB + /** + * PES_packet_data_bytes shall be contiguous bytes of data from the elementary stream + * indicated by the packet’s stream_id or PID. When the elementary stream data conforms to ITU-T + * Rec. H.262 | ISO/IEC 13818-2 or ISO/IEC 13818-3, the PES_packet_data_bytes shall be byte aligned to the bytes of this + * Recommendation | International Standard. The byte-order of the elementary stream shall be preserved. The number of + * PES_packet_data_bytes, N, is specified by the PES_packet_length field. N shall be equal to the value indicated in the + * PES_packet_length minus the number of bytes between the last byte of the PES_packet_length field and the first + * PES_packet_data_byte. + * + * In the case of a private_stream_1, private_stream_2, ECM_stream, or EMM_stream, the contents of the + * PES_packet_data_byte field are user definable and will not be specified by ITU-T | ISO/IEC in the future. + */ + int nb_bytes; + char* bytes; + + // NB + /** + * This is a fixed 8-bit value equal to '1111 1111'. It is discarded by the decoder. + */ + int nb_paddings; +public: + SrsTsPayloadPES(SrsTsPacket* p); + virtual ~SrsTsPayloadPES(); +public: + virtual int decode(SrsStream* stream); +}; + /** * the PSI payload of ts packet. * 2.4.4 Program specific information, hls-mpeg-ts-iso13818-1.pdf, page 59 @@ -687,7 +1042,7 @@ class SrsTsPayloadPATProgram // reserved 3bits /** * program_map_PID/network_PID 13bits - * network_PID ¨C The network_PID is a 13-bit field, which is used only in conjunction with the value of the + * network_PID - The network_PID is a 13-bit field, which is used only in conjunction with the value of the * program_number set to 0x0000, specifies the PID of the Transport Stream packets which shall contain the Network * Information Table. The value of the network_PID field is defined by the user, but shall only take values as specified in * Table 2-3. The presence of the network_PID is optional. @@ -767,7 +1122,7 @@ class SrsTsPayloadPMTESInfo * This is an 8-bit field specifying the type of program element carried within the packets with the PID * whose value is specified by the elementary_PID. The values of stream_type are specified in Table 2-29. */ - u_int8_t stream_type; //8bits + SrsTsStream stream_type; //8bits // 2B // 3bits reserved