880 lines
20 KiB
C++
880 lines
20 KiB
C++
/**
|
|
* The MIT License (MIT)
|
|
*
|
|
* Copyright (c) 2013-2020 Winlin
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
|
* this software and associated documentation files (the "Software"), to deal in
|
|
* the Software without restriction, including without limitation the rights to
|
|
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
|
* the Software, and to permit persons to whom the Software is furnished to do so,
|
|
* subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
|
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
|
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
|
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include <srs_kernel_rtc_rtp.hpp>
|
|
|
|
#include <fcntl.h>
|
|
#include <sstream>
|
|
using namespace std;
|
|
|
|
#include <srs_kernel_log.hpp>
|
|
#include <srs_kernel_error.hpp>
|
|
#include <srs_kernel_buffer.hpp>
|
|
#include <srs_kernel_utility.hpp>
|
|
|
|
SrsRtpHeader::SrsRtpHeader()
|
|
{
|
|
padding = false;
|
|
padding_length = 0;
|
|
extension = false;
|
|
cc = 0;
|
|
marker = false;
|
|
payload_type = 0;
|
|
sequence = 0;
|
|
timestamp = 0;
|
|
ssrc = 0;
|
|
extension_length = 0;
|
|
}
|
|
|
|
void SrsRtpHeader::reset()
|
|
{
|
|
// We only reset the optional fields, the required field such as ssrc
|
|
// will always be set by user.
|
|
padding = false;
|
|
extension = false;
|
|
cc = 0;
|
|
marker = false;
|
|
extension_length = 0;
|
|
}
|
|
|
|
SrsRtpHeader::~SrsRtpHeader()
|
|
{
|
|
}
|
|
|
|
srs_error_t SrsRtpHeader::decode(SrsBuffer* buf)
|
|
{
|
|
srs_error_t err = srs_success;
|
|
|
|
if (!buf->require(kRtpHeaderFixedSize)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d+ bytes", kRtpHeaderFixedSize);
|
|
}
|
|
|
|
/*
|
|
0 1 2 3
|
|
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
|
|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
|V=2|P|X| CC |M| PT | sequence number |
|
|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
| timestamp |
|
|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
| synchronization source (SSRC) identifier |
|
|
+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
|
|
| contributing source (CSRC) identifiers |
|
|
| .... |
|
|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
*/
|
|
|
|
uint8_t first = buf->read_1bytes();
|
|
padding = (first & 0x20);
|
|
extension = (first & 0x10);
|
|
cc = (first & 0x0F);
|
|
|
|
uint8_t second = buf->read_1bytes();
|
|
marker = (second & 0x80);
|
|
payload_type = (second & 0x7F);
|
|
|
|
sequence = buf->read_2bytes();
|
|
timestamp = buf->read_4bytes();
|
|
ssrc = buf->read_4bytes();
|
|
|
|
int ext_bytes = nb_bytes() - kRtpHeaderFixedSize;
|
|
if (!buf->require(ext_bytes)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d+ bytes", ext_bytes);
|
|
}
|
|
|
|
for (uint8_t i = 0; i < cc; ++i) {
|
|
csrc[i] = buf->read_4bytes();
|
|
}
|
|
|
|
if (extension) {
|
|
uint16_t profile_id = buf->read_2bytes();
|
|
extension_length = buf->read_2bytes();
|
|
|
|
// TODO: FIXME: Read extensions.
|
|
// @see: https://tools.ietf.org/html/rfc3550#section-5.3.1
|
|
buf->skip(extension_length * 4);
|
|
|
|
// @see: https://tools.ietf.org/html/rfc5285#section-4.2
|
|
if (profile_id == 0xBEDE) {
|
|
// TODO: FIXME: Implements it.
|
|
}
|
|
}
|
|
|
|
if (padding && !buf->empty()) {
|
|
padding_length = *(reinterpret_cast<uint8_t*>(buf->data() + buf->size() - 1));
|
|
if (!buf->require(padding_length)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "padding requires %d bytes", padding_length);
|
|
}
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
srs_error_t SrsRtpHeader::encode(SrsBuffer* buf)
|
|
{
|
|
srs_error_t err = srs_success;
|
|
|
|
// Encode the RTP fix header, 12bytes.
|
|
// @see https://tools.ietf.org/html/rfc1889#section-5.1
|
|
char* op = buf->head();
|
|
char* p = op;
|
|
|
|
// The version, padding, extension and cc, total 1 byte.
|
|
uint8_t v = 0x80 | cc;
|
|
if (padding) {
|
|
v |= 0x20;
|
|
}
|
|
if (extension) {
|
|
v |= 0x10;
|
|
}
|
|
*p++ = v;
|
|
|
|
// The marker and payload type, total 1 byte.
|
|
v = payload_type;
|
|
if (marker) {
|
|
v |= kRtpMarker;
|
|
}
|
|
*p++ = v;
|
|
|
|
// The sequence number, 2 bytes.
|
|
char* pp = (char*)&sequence;
|
|
*p++ = pp[1];
|
|
*p++ = pp[0];
|
|
|
|
// The timestamp, 4 bytes.
|
|
pp = (char*)×tamp;
|
|
*p++ = pp[3];
|
|
*p++ = pp[2];
|
|
*p++ = pp[1];
|
|
*p++ = pp[0];
|
|
|
|
// The SSRC, 4 bytes.
|
|
pp = (char*)&ssrc;
|
|
*p++ = pp[3];
|
|
*p++ = pp[2];
|
|
*p++ = pp[1];
|
|
*p++ = pp[0];
|
|
|
|
// The CSRC list: 0 to 15 items, each is 4 bytes.
|
|
for (size_t i = 0; i < cc; ++i) {
|
|
pp = (char*)&csrc[i];
|
|
*p++ = pp[3];
|
|
*p++ = pp[2];
|
|
*p++ = pp[1];
|
|
*p++ = pp[0];
|
|
}
|
|
|
|
// TODO: Write exteinsion field.
|
|
if (extension) {
|
|
}
|
|
|
|
// Consume the data.
|
|
buf->skip(p - op);
|
|
|
|
return err;
|
|
}
|
|
|
|
int SrsRtpHeader::nb_bytes()
|
|
{
|
|
return kRtpHeaderFixedSize + cc * 4 + (extension ? (extension_length + 1) * 4 : 0);
|
|
}
|
|
|
|
void SrsRtpHeader::set_marker(bool v)
|
|
{
|
|
marker = v;
|
|
}
|
|
|
|
bool SrsRtpHeader::get_marker() const
|
|
{
|
|
return marker;
|
|
}
|
|
|
|
void SrsRtpHeader::set_payload_type(uint8_t v)
|
|
{
|
|
payload_type = v;
|
|
}
|
|
|
|
uint8_t SrsRtpHeader::get_payload_type() const
|
|
{
|
|
return payload_type;
|
|
}
|
|
|
|
void SrsRtpHeader::set_sequence(uint16_t v)
|
|
{
|
|
sequence = v;
|
|
}
|
|
|
|
uint16_t SrsRtpHeader::get_sequence() const
|
|
{
|
|
return sequence;
|
|
}
|
|
|
|
void SrsRtpHeader::set_timestamp(uint32_t v)
|
|
{
|
|
timestamp = v;
|
|
}
|
|
|
|
uint32_t SrsRtpHeader::get_timestamp() const
|
|
{
|
|
return timestamp;
|
|
}
|
|
|
|
void SrsRtpHeader::set_ssrc(uint32_t v)
|
|
{
|
|
ssrc = v;
|
|
}
|
|
|
|
uint32_t SrsRtpHeader::get_ssrc() const
|
|
{
|
|
return ssrc;
|
|
}
|
|
|
|
void SrsRtpHeader::set_padding(bool v)
|
|
{
|
|
padding = v;
|
|
}
|
|
|
|
void SrsRtpHeader::set_padding_length(uint8_t v)
|
|
{
|
|
padding_length = v;
|
|
}
|
|
|
|
uint8_t SrsRtpHeader::get_padding_length() const
|
|
{
|
|
return padding_length;
|
|
}
|
|
|
|
ISrsRtpPacketDecodeHandler::ISrsRtpPacketDecodeHandler()
|
|
{
|
|
}
|
|
|
|
ISrsRtpPacketDecodeHandler::~ISrsRtpPacketDecodeHandler()
|
|
{
|
|
}
|
|
|
|
SrsRtpPacket2::SrsRtpPacket2()
|
|
{
|
|
padding = 0;
|
|
payload = NULL;
|
|
decode_handler = NULL;
|
|
|
|
nalu_type = SrsAvcNaluTypeReserved;
|
|
original_bytes = NULL;
|
|
|
|
cache_raw = new SrsRtpRawPayload();
|
|
cache_fua = new SrsRtpFUAPayload2();
|
|
cache_payload = 0;
|
|
}
|
|
|
|
SrsRtpPacket2::~SrsRtpPacket2()
|
|
{
|
|
// We may use the cache as payload.
|
|
if (payload == cache_raw || payload == cache_fua) {
|
|
payload = NULL;
|
|
}
|
|
|
|
srs_freep(payload);
|
|
srs_freep(cache_raw);
|
|
srs_freep(cache_fua);
|
|
|
|
srs_freepa(original_bytes);
|
|
}
|
|
|
|
void SrsRtpPacket2::set_padding(int size)
|
|
{
|
|
rtp_header.set_padding(size > 0);
|
|
rtp_header.set_padding_length(size);
|
|
if (cache_payload) {
|
|
cache_payload += size - padding;
|
|
}
|
|
padding = size;
|
|
}
|
|
|
|
void SrsRtpPacket2::add_padding(int size)
|
|
{
|
|
rtp_header.set_padding(padding + size > 0);
|
|
rtp_header.set_padding_length(rtp_header.get_padding_length() + size);
|
|
if (cache_payload) {
|
|
cache_payload += size;
|
|
}
|
|
padding += size;
|
|
}
|
|
|
|
void SrsRtpPacket2::reset()
|
|
{
|
|
rtp_header.reset();
|
|
padding = 0;
|
|
cache_payload = 0;
|
|
|
|
// We may use the cache as payload.
|
|
if (payload == cache_raw || payload == cache_fua) {
|
|
payload = NULL;
|
|
}
|
|
srs_freep(payload);
|
|
}
|
|
|
|
SrsRtpRawPayload* SrsRtpPacket2::reuse_raw()
|
|
{
|
|
payload = cache_raw;
|
|
return cache_raw;
|
|
}
|
|
|
|
SrsRtpFUAPayload2* SrsRtpPacket2::reuse_fua()
|
|
{
|
|
payload = cache_fua;
|
|
return cache_fua;
|
|
}
|
|
|
|
void SrsRtpPacket2::set_decode_handler(ISrsRtpPacketDecodeHandler* h)
|
|
{
|
|
decode_handler = h;
|
|
}
|
|
|
|
int SrsRtpPacket2::nb_bytes()
|
|
{
|
|
if (!cache_payload) {
|
|
cache_payload = rtp_header.nb_bytes() + (payload? payload->nb_bytes():0) + padding;
|
|
}
|
|
return cache_payload;
|
|
}
|
|
|
|
srs_error_t SrsRtpPacket2::encode(SrsBuffer* buf)
|
|
{
|
|
srs_error_t err = srs_success;
|
|
|
|
if ((err = rtp_header.encode(buf)) != srs_success) {
|
|
return srs_error_wrap(err, "rtp header");
|
|
}
|
|
|
|
if (payload && (err = payload->encode(buf)) != srs_success) {
|
|
return srs_error_wrap(err, "rtp payload");
|
|
}
|
|
|
|
if (padding > 0) {
|
|
if (!buf->require(padding)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", padding);
|
|
}
|
|
memset(buf->data() + buf->pos(), padding, padding);
|
|
buf->skip(padding);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
srs_error_t SrsRtpPacket2::decode(SrsBuffer* buf)
|
|
{
|
|
srs_error_t err = srs_success;
|
|
|
|
if ((err = rtp_header.decode(buf)) != srs_success) {
|
|
return srs_error_wrap(err, "rtp header");
|
|
}
|
|
|
|
// We must skip the padding bytes before parsing payload.
|
|
padding = rtp_header.get_padding_length();
|
|
if (!buf->require(padding)) {
|
|
return srs_error_wrap(err, "requires padding %d bytes", padding);
|
|
}
|
|
buf->set_size(buf->size() - padding);
|
|
|
|
// Try to parse the NALU type for video decoder.
|
|
if (!buf->empty()) {
|
|
nalu_type = SrsAvcNaluType((uint8_t)(buf->head()[0] & kNalTypeMask));
|
|
}
|
|
|
|
// If user set the decode handler, call it to set the payload.
|
|
if (decode_handler) {
|
|
decode_handler->on_before_decode_payload(this, buf, &payload);
|
|
}
|
|
|
|
// By default, we always use the RAW payload.
|
|
if (!payload) {
|
|
payload = reuse_raw();
|
|
}
|
|
|
|
if ((err = payload->decode(buf)) != srs_success) {
|
|
return srs_error_wrap(err, "rtp payload");
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
SrsRtpRawPayload::SrsRtpRawPayload()
|
|
{
|
|
payload = NULL;
|
|
nn_payload = 0;
|
|
}
|
|
|
|
SrsRtpRawPayload::~SrsRtpRawPayload()
|
|
{
|
|
}
|
|
|
|
int SrsRtpRawPayload::nb_bytes()
|
|
{
|
|
return nn_payload;
|
|
}
|
|
|
|
srs_error_t SrsRtpRawPayload::encode(SrsBuffer* buf)
|
|
{
|
|
if (nn_payload <= 0) {
|
|
return srs_success;
|
|
}
|
|
|
|
if (!buf->require(nn_payload)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", nn_payload);
|
|
}
|
|
|
|
buf->write_bytes(payload, nn_payload);
|
|
|
|
return srs_success;
|
|
}
|
|
|
|
srs_error_t SrsRtpRawPayload::decode(SrsBuffer* buf)
|
|
{
|
|
if (buf->empty()) {
|
|
return srs_success;
|
|
}
|
|
|
|
payload = buf->head();
|
|
nn_payload = buf->left();
|
|
|
|
return srs_success;
|
|
}
|
|
|
|
SrsRtpRawNALUs::SrsRtpRawNALUs()
|
|
{
|
|
cursor = 0;
|
|
nn_bytes = 0;
|
|
}
|
|
|
|
SrsRtpRawNALUs::~SrsRtpRawNALUs()
|
|
{
|
|
int nn_nalus = (int)nalus.size();
|
|
for (int i = 0; i < nn_nalus; i++) {
|
|
SrsSample* p = nalus[i];
|
|
srs_freep(p);
|
|
}
|
|
}
|
|
|
|
void SrsRtpRawNALUs::push_back(SrsSample* sample)
|
|
{
|
|
if (sample->size <= 0) {
|
|
return;
|
|
}
|
|
|
|
if (!nalus.empty()) {
|
|
SrsSample* p = new SrsSample();
|
|
p->bytes = (char*)"\0\0\1";
|
|
p->size = 3;
|
|
nn_bytes += 3;
|
|
nalus.push_back(p);
|
|
}
|
|
|
|
nn_bytes += sample->size;
|
|
nalus.push_back(sample);
|
|
}
|
|
|
|
uint8_t SrsRtpRawNALUs::skip_first_byte()
|
|
{
|
|
srs_assert (cursor >= 0 && nn_bytes > 0 && cursor < nn_bytes);
|
|
cursor++;
|
|
return uint8_t(nalus[0]->bytes[0]);
|
|
}
|
|
|
|
srs_error_t SrsRtpRawNALUs::read_samples(vector<SrsSample*>& samples, int packet_size)
|
|
{
|
|
if (cursor + packet_size < 0 || cursor + packet_size > nn_bytes) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "cursor=%d, max=%d, size=%d", cursor, nn_bytes, packet_size);
|
|
}
|
|
|
|
int pos = cursor;
|
|
cursor += packet_size;
|
|
int left = packet_size;
|
|
|
|
int nn_nalus = (int)nalus.size();
|
|
for (int i = 0; left > 0 && i < nn_nalus; i++) {
|
|
SrsSample* p = nalus[i];
|
|
|
|
// Ignore previous consumed samples.
|
|
if (pos && pos - p->size >= 0) {
|
|
pos -= p->size;
|
|
continue;
|
|
}
|
|
|
|
// Now, we are working at the sample.
|
|
int nn = srs_min(left, p->size - pos);
|
|
srs_assert(nn > 0);
|
|
|
|
SrsSample* sample = new SrsSample();
|
|
samples.push_back(sample);
|
|
|
|
sample->bytes = p->bytes + pos;
|
|
sample->size = nn;
|
|
|
|
left -= nn;
|
|
pos = 0;
|
|
}
|
|
|
|
return srs_success;
|
|
}
|
|
|
|
int SrsRtpRawNALUs::nb_bytes()
|
|
{
|
|
int size = 0;
|
|
|
|
int nn_nalus = (int)nalus.size();
|
|
for (int i = 0; i < nn_nalus; i++) {
|
|
SrsSample* p = nalus[i];
|
|
size += p->size;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
srs_error_t SrsRtpRawNALUs::encode(SrsBuffer* buf)
|
|
{
|
|
int nn_nalus = (int)nalus.size();
|
|
for (int i = 0; i < nn_nalus; i++) {
|
|
SrsSample* p = nalus[i];
|
|
|
|
if (!buf->require(p->size)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", p->size);
|
|
}
|
|
|
|
buf->write_bytes(p->bytes, p->size);
|
|
}
|
|
|
|
return srs_success;
|
|
}
|
|
|
|
srs_error_t SrsRtpRawNALUs::decode(SrsBuffer* buf)
|
|
{
|
|
if (buf->empty()) {
|
|
return srs_success;
|
|
}
|
|
|
|
SrsSample* sample = new SrsSample();
|
|
sample->bytes = buf->head();
|
|
sample->size = buf->left();
|
|
buf->skip(sample->size);
|
|
|
|
nalus.push_back(sample);
|
|
|
|
return srs_success;
|
|
}
|
|
|
|
SrsRtpSTAPPayload::SrsRtpSTAPPayload()
|
|
{
|
|
nri = (SrsAvcNaluType)0;
|
|
}
|
|
|
|
SrsRtpSTAPPayload::~SrsRtpSTAPPayload()
|
|
{
|
|
int nn_nalus = (int)nalus.size();
|
|
for (int i = 0; i < nn_nalus; i++) {
|
|
SrsSample* p = nalus[i];
|
|
srs_freep(p);
|
|
}
|
|
}
|
|
|
|
SrsSample* SrsRtpSTAPPayload::get_sps()
|
|
{
|
|
int nn_nalus = (int)nalus.size();
|
|
for (int i = 0; i < nn_nalus; i++) {
|
|
SrsSample* p = nalus[i];
|
|
if (!p || !p->size) {
|
|
continue;
|
|
}
|
|
|
|
SrsAvcNaluType nalu_type = (SrsAvcNaluType)(p->bytes[0] & kNalTypeMask);
|
|
if (nalu_type == SrsAvcNaluTypeSPS) {
|
|
return p;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
SrsSample* SrsRtpSTAPPayload::get_pps()
|
|
{
|
|
int nn_nalus = (int)nalus.size();
|
|
for (int i = 0; i < nn_nalus; i++) {
|
|
SrsSample* p = nalus[i];
|
|
if (!p || !p->size) {
|
|
continue;
|
|
}
|
|
|
|
SrsAvcNaluType nalu_type = (SrsAvcNaluType)(p->bytes[0] & kNalTypeMask);
|
|
if (nalu_type == SrsAvcNaluTypePPS) {
|
|
return p;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int SrsRtpSTAPPayload::nb_bytes()
|
|
{
|
|
int size = 1;
|
|
|
|
int nn_nalus = (int)nalus.size();
|
|
for (int i = 0; i < nn_nalus; i++) {
|
|
SrsSample* p = nalus[i];
|
|
size += 2 + p->size;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
srs_error_t SrsRtpSTAPPayload::encode(SrsBuffer* buf)
|
|
{
|
|
if (!buf->require(1)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", 1);
|
|
}
|
|
|
|
// STAP header, RTP payload format for aggregation packets
|
|
// @see https://tools.ietf.org/html/rfc6184#section-5.7
|
|
uint8_t v = kStapA;
|
|
v |= (nri & (~kNalTypeMask));
|
|
buf->write_1bytes(v);
|
|
|
|
// NALUs.
|
|
int nn_nalus = (int)nalus.size();
|
|
for (int i = 0; i < nn_nalus; i++) {
|
|
SrsSample* p = nalus[i];
|
|
|
|
if (!buf->require(2 + p->size)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", 2 + p->size);
|
|
}
|
|
|
|
buf->write_2bytes(p->size);
|
|
buf->write_bytes(p->bytes, p->size);
|
|
}
|
|
|
|
return srs_success;
|
|
}
|
|
|
|
srs_error_t SrsRtpSTAPPayload::decode(SrsBuffer* buf)
|
|
{
|
|
if (!buf->require(1)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", 1);
|
|
}
|
|
|
|
// STAP header, RTP payload format for aggregation packets
|
|
// @see https://tools.ietf.org/html/rfc6184#section-5.7
|
|
uint8_t v = buf->read_1bytes();
|
|
nri = SrsAvcNaluType(v & (~kNalTypeMask));
|
|
|
|
// NALUs.
|
|
while (!buf->empty()) {
|
|
if (!buf->require(2)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", 2);
|
|
}
|
|
|
|
int size = buf->read_2bytes();
|
|
if (!buf->require(size)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", size);
|
|
}
|
|
|
|
SrsSample* sample = new SrsSample();
|
|
sample->bytes = buf->head();
|
|
sample->size = size;
|
|
buf->skip(size);
|
|
|
|
nalus.push_back(sample);
|
|
}
|
|
|
|
return srs_success;
|
|
}
|
|
|
|
SrsRtpFUAPayload::SrsRtpFUAPayload()
|
|
{
|
|
start = end = false;
|
|
nri = nalu_type = (SrsAvcNaluType)0;
|
|
}
|
|
|
|
SrsRtpFUAPayload::~SrsRtpFUAPayload()
|
|
{
|
|
int nn_nalus = (int)nalus.size();
|
|
for (int i = 0; i < nn_nalus; i++) {
|
|
SrsSample* p = nalus[i];
|
|
srs_freep(p);
|
|
}
|
|
}
|
|
|
|
int SrsRtpFUAPayload::nb_bytes()
|
|
{
|
|
int size = 2;
|
|
|
|
int nn_nalus = (int)nalus.size();
|
|
for (int i = 0; i < nn_nalus; i++) {
|
|
SrsSample* p = nalus[i];
|
|
size += p->size;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
srs_error_t SrsRtpFUAPayload::encode(SrsBuffer* buf)
|
|
{
|
|
if (!buf->require(2)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", 1);
|
|
}
|
|
|
|
// FU indicator, @see https://tools.ietf.org/html/rfc6184#section-5.8
|
|
uint8_t fu_indicate = kFuA;
|
|
fu_indicate |= (nri & (~kNalTypeMask));
|
|
buf->write_1bytes(fu_indicate);
|
|
|
|
// FU header, @see https://tools.ietf.org/html/rfc6184#section-5.8
|
|
uint8_t fu_header = nalu_type;
|
|
if (start) {
|
|
fu_header |= kStart;
|
|
}
|
|
if (end) {
|
|
fu_header |= kEnd;
|
|
}
|
|
buf->write_1bytes(fu_header);
|
|
|
|
// FU payload, @see https://tools.ietf.org/html/rfc6184#section-5.8
|
|
int nn_nalus = (int)nalus.size();
|
|
for (int i = 0; i < nn_nalus; i++) {
|
|
SrsSample* p = nalus[i];
|
|
|
|
if (!buf->require(p->size)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", p->size);
|
|
}
|
|
|
|
buf->write_bytes(p->bytes, p->size);
|
|
}
|
|
|
|
return srs_success;
|
|
}
|
|
|
|
srs_error_t SrsRtpFUAPayload::decode(SrsBuffer* buf)
|
|
{
|
|
if (!buf->require(2)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", 2);
|
|
}
|
|
|
|
// FU indicator, @see https://tools.ietf.org/html/rfc6184#section-5.8
|
|
uint8_t v = buf->read_1bytes();
|
|
nri = SrsAvcNaluType(v & (~kNalTypeMask));
|
|
|
|
// FU header, @see https://tools.ietf.org/html/rfc6184#section-5.8
|
|
v = buf->read_1bytes();
|
|
start = v & kStart;
|
|
end = v & kEnd;
|
|
nalu_type = SrsAvcNaluType(v & kNalTypeMask);
|
|
|
|
if (!buf->require(1)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", 1);
|
|
}
|
|
|
|
SrsSample* sample = new SrsSample();
|
|
sample->bytes = buf->head();
|
|
sample->size = buf->left();
|
|
buf->skip(sample->size);
|
|
|
|
nalus.push_back(sample);
|
|
|
|
return srs_success;
|
|
}
|
|
|
|
SrsRtpFUAPayload2::SrsRtpFUAPayload2()
|
|
{
|
|
start = end = false;
|
|
nri = nalu_type = (SrsAvcNaluType)0;
|
|
|
|
payload = NULL;
|
|
size = 0;
|
|
}
|
|
|
|
SrsRtpFUAPayload2::~SrsRtpFUAPayload2()
|
|
{
|
|
}
|
|
|
|
int SrsRtpFUAPayload2::nb_bytes()
|
|
{
|
|
return 2 + size;
|
|
}
|
|
|
|
srs_error_t SrsRtpFUAPayload2::encode(SrsBuffer* buf)
|
|
{
|
|
if (!buf->require(2 + size)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", 1);
|
|
}
|
|
|
|
// Fast encoding.
|
|
char* p = buf->head();
|
|
|
|
// FU indicator, @see https://tools.ietf.org/html/rfc6184#section-5.8
|
|
uint8_t fu_indicate = kFuA;
|
|
fu_indicate |= (nri & (~kNalTypeMask));
|
|
*p++ = fu_indicate;
|
|
|
|
// FU header, @see https://tools.ietf.org/html/rfc6184#section-5.8
|
|
uint8_t fu_header = nalu_type;
|
|
if (start) {
|
|
fu_header |= kStart;
|
|
}
|
|
if (end) {
|
|
fu_header |= kEnd;
|
|
}
|
|
*p++ = fu_header;
|
|
|
|
// FU payload, @see https://tools.ietf.org/html/rfc6184#section-5.8
|
|
memcpy(p, payload, size);
|
|
|
|
// Consume bytes.
|
|
buf->skip(2 + size);
|
|
|
|
return srs_success;
|
|
}
|
|
|
|
srs_error_t SrsRtpFUAPayload2::decode(SrsBuffer* buf)
|
|
{
|
|
if (!buf->require(2)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", 2);
|
|
}
|
|
|
|
// FU indicator, @see https://tools.ietf.org/html/rfc6184#section-5.8
|
|
uint8_t v = buf->read_1bytes();
|
|
nri = SrsAvcNaluType(v & (~kNalTypeMask));
|
|
|
|
// FU header, @see https://tools.ietf.org/html/rfc6184#section-5.8
|
|
v = buf->read_1bytes();
|
|
start = v & kStart;
|
|
end = v & kEnd;
|
|
nalu_type = SrsAvcNaluType(v & kNalTypeMask);
|
|
|
|
if (!buf->require(1)) {
|
|
return srs_error_new(ERROR_RTC_RTP_MUXER, "requires %d bytes", 1);
|
|
}
|
|
|
|
payload = buf->head();
|
|
size = buf->left();
|
|
buf->skip(size);
|
|
|
|
return srs_success;
|
|
}
|