| /* |
| * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h" |
| |
| #include <assert.h> |
| #include <math.h> // ceil |
| #include <string.h> // memcpy |
| |
| #include <limits> |
| |
| #include "webrtc/base/checks.h" |
| #include "webrtc/base/logging.h" |
| #include "webrtc/modules/rtp_rtcp/source/byte_io.h" |
| #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" |
| |
| namespace webrtc { |
| namespace { |
| constexpr uint64_t kMaxBitrateBps = std::numeric_limits<uint32_t>::max(); |
| } // namespace |
| |
| namespace RTCPUtility { |
| |
| NackStats::NackStats() |
| : max_sequence_number_(0), |
| requests_(0), |
| unique_requests_(0) {} |
| |
| NackStats::~NackStats() {} |
| |
| void NackStats::ReportRequest(uint16_t sequence_number) { |
| if (requests_ == 0 || |
| webrtc::IsNewerSequenceNumber(sequence_number, max_sequence_number_)) { |
| max_sequence_number_ = sequence_number; |
| ++unique_requests_; |
| } |
| ++requests_; |
| } |
| |
| uint32_t MidNtp(uint32_t ntp_sec, uint32_t ntp_frac) { |
| return (ntp_sec << 16) + (ntp_frac >> 16); |
| } |
| } // namespace RTCPUtility |
| |
| // RTCPParserV2 : currently read only |
| RTCPUtility::RTCPParserV2::RTCPParserV2(const uint8_t* rtcpData, |
| size_t rtcpDataLength, |
| bool rtcpReducedSizeEnable) |
| : _ptrRTCPDataBegin(rtcpData), |
| _RTCPReducedSizeEnable(rtcpReducedSizeEnable), |
| _ptrRTCPDataEnd(rtcpData + rtcpDataLength), |
| _validPacket(false), |
| _ptrRTCPData(rtcpData), |
| _ptrRTCPBlockEnd(NULL), |
| _state(ParseState::State_TopLevel), |
| _numberOfBlocks(0), |
| num_skipped_blocks_(0), |
| _packetType(RTCPPacketTypes::kInvalid) { |
| Validate(); |
| } |
| |
| RTCPUtility::RTCPParserV2::~RTCPParserV2() { |
| } |
| |
| ptrdiff_t |
| RTCPUtility::RTCPParserV2::LengthLeft() const |
| { |
| return (_ptrRTCPDataEnd- _ptrRTCPData); |
| } |
| |
| RTCPUtility::RTCPPacketTypes |
| RTCPUtility::RTCPParserV2::PacketType() const |
| { |
| return _packetType; |
| } |
| |
| const RTCPUtility::RTCPPacket& |
| RTCPUtility::RTCPParserV2::Packet() const |
| { |
| return _packet; |
| } |
| |
| rtcp::RtcpPacket* RTCPUtility::RTCPParserV2::ReleaseRtcpPacket() { |
| return rtcp_packet_.release(); |
| } |
| RTCPUtility::RTCPPacketTypes |
| RTCPUtility::RTCPParserV2::Begin() |
| { |
| _ptrRTCPData = _ptrRTCPDataBegin; |
| |
| return Iterate(); |
| } |
| |
| RTCPUtility::RTCPPacketTypes |
| RTCPUtility::RTCPParserV2::Iterate() |
| { |
| // Reset packet type |
| _packetType = RTCPPacketTypes::kInvalid; |
| |
| if (IsValid()) |
| { |
| switch (_state) |
| { |
| case ParseState::State_TopLevel: |
| IterateTopLevel(); |
| break; |
| case ParseState::State_ReportBlockItem: |
| IterateReportBlockItem(); |
| break; |
| case ParseState::State_SDESChunk: |
| IterateSDESChunk(); |
| break; |
| case ParseState::State_BYEItem: |
| IterateBYEItem(); |
| break; |
| case ParseState::State_ExtendedJitterItem: |
| IterateExtendedJitterItem(); |
| break; |
| case ParseState::State_RTPFB_NACKItem: |
| IterateNACKItem(); |
| break; |
| case ParseState::State_RTPFB_TMMBRItem: |
| IterateTMMBRItem(); |
| break; |
| case ParseState::State_RTPFB_TMMBNItem: |
| IterateTMMBNItem(); |
| break; |
| case ParseState::State_PSFB_SLIItem: |
| IterateSLIItem(); |
| break; |
| case ParseState::State_PSFB_RPSIItem: |
| IterateRPSIItem(); |
| break; |
| case ParseState::State_PSFB_FIRItem: |
| IterateFIRItem(); |
| break; |
| case ParseState::State_PSFB_AppItem: |
| IteratePsfbAppItem(); |
| break; |
| case ParseState::State_PSFB_REMBItem: |
| IteratePsfbREMBItem(); |
| break; |
| case ParseState::State_XRItem: |
| IterateXrItem(); |
| break; |
| case ParseState::State_XR_DLLRItem: |
| IterateXrDlrrItem(); |
| break; |
| case ParseState::State_AppItem: |
| IterateAppItem(); |
| break; |
| default: |
| RTC_NOTREACHED() << "Invalid state!"; |
| break; |
| } |
| } |
| return _packetType; |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::IterateTopLevel() |
| { |
| for (;;) |
| { |
| RtcpCommonHeader header; |
| if (_ptrRTCPDataEnd <= _ptrRTCPData) |
| return; |
| |
| if (!RtcpParseCommonHeader(_ptrRTCPData, _ptrRTCPDataEnd - _ptrRTCPData, |
| &header)) { |
| return; |
| } |
| _ptrRTCPBlockEnd = _ptrRTCPData + header.BlockSize(); |
| if (_ptrRTCPBlockEnd > _ptrRTCPDataEnd) |
| { |
| ++num_skipped_blocks_; |
| return; |
| } |
| |
| switch (header.packet_type) { |
| case PT_SR: |
| { |
| // number of Report blocks |
| _numberOfBlocks = header.count_or_format; |
| ParseSR(); |
| return; |
| } |
| case PT_RR: |
| { |
| // number of Report blocks |
| _numberOfBlocks = header.count_or_format; |
| ParseRR(); |
| return; |
| } |
| case PT_SDES: |
| { |
| // number of SDES blocks |
| _numberOfBlocks = header.count_or_format; |
| const bool ok = ParseSDES(); |
| if (!ok) |
| { |
| // Nothing supported found, continue to next block! |
| break; |
| } |
| return; |
| } |
| case PT_BYE: |
| { |
| _numberOfBlocks = header.count_or_format; |
| const bool ok = ParseBYE(); |
| if (!ok) |
| { |
| // Nothing supported found, continue to next block! |
| break; |
| } |
| return; |
| } |
| case PT_IJ: |
| { |
| // number of Report blocks |
| _numberOfBlocks = header.count_or_format; |
| ParseIJ(); |
| return; |
| } |
| case PT_RTPFB: |
| FALLTHROUGH(); |
| case PT_PSFB: |
| { |
| if (!ParseFBCommon(header)) { |
| // Nothing supported found, continue to next block! |
| EndCurrentBlock(); |
| break; |
| } |
| return; |
| } |
| case PT_APP: |
| { |
| const bool ok = ParseAPP(header); |
| if (!ok) |
| { |
| // Nothing supported found, continue to next block! |
| break; |
| } |
| return; |
| } |
| case PT_XR: |
| { |
| const bool ok = ParseXr(); |
| if (!ok) |
| { |
| // Nothing supported found, continue to next block! |
| break; |
| } |
| return; |
| } |
| default: |
| // Not supported! Skip! |
| ++num_skipped_blocks_; |
| EndCurrentBlock(); |
| break; |
| } |
| } |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::IterateXrItem() |
| { |
| const bool success = ParseXrItem(); |
| if (!success) |
| { |
| Iterate(); |
| } |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::IterateXrDlrrItem() |
| { |
| const bool success = ParseXrDlrrItem(); |
| if (!success) |
| { |
| Iterate(); |
| } |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::IterateReportBlockItem() |
| { |
| const bool success = ParseReportBlockItem(); |
| if (!success) |
| { |
| Iterate(); |
| } |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::IterateSDESChunk() |
| { |
| const bool success = ParseSDESChunk(); |
| if (!success) |
| { |
| Iterate(); |
| } |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::IterateBYEItem() |
| { |
| const bool success = ParseBYEItem(); |
| if (!success) |
| { |
| Iterate(); |
| } |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::IterateExtendedJitterItem() |
| { |
| const bool success = ParseIJItem(); |
| if (!success) |
| { |
| Iterate(); |
| } |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::IterateNACKItem() |
| { |
| const bool success = ParseNACKItem(); |
| if (!success) |
| { |
| Iterate(); |
| } |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::IterateTMMBRItem() |
| { |
| const bool success = ParseTMMBRItem(); |
| if (!success) |
| { |
| Iterate(); |
| } |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::IterateTMMBNItem() |
| { |
| const bool success = ParseTMMBNItem(); |
| if (!success) |
| { |
| Iterate(); |
| } |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::IterateSLIItem() |
| { |
| const bool success = ParseSLIItem(); |
| if (!success) |
| { |
| Iterate(); |
| } |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::IterateRPSIItem() |
| { |
| const bool success = ParseRPSIItem(); |
| if (!success) |
| { |
| Iterate(); |
| } |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::IterateFIRItem() |
| { |
| const bool success = ParseFIRItem(); |
| if (!success) |
| { |
| Iterate(); |
| } |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::IteratePsfbAppItem() |
| { |
| const bool success = ParsePsfbAppItem(); |
| if (!success) |
| { |
| Iterate(); |
| } |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::IteratePsfbREMBItem() |
| { |
| const bool success = ParsePsfbREMBItem(); |
| if (!success) |
| { |
| Iterate(); |
| } |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::IterateAppItem() |
| { |
| const bool success = ParseAPPItem(); |
| if (!success) |
| { |
| Iterate(); |
| } |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::Validate() |
| { |
| if (_ptrRTCPData == nullptr) |
| return; // NOT VALID |
| |
| RtcpCommonHeader header; |
| if (_ptrRTCPDataEnd <= _ptrRTCPDataBegin) |
| return; // NOT VALID |
| |
| if (!RtcpParseCommonHeader(_ptrRTCPDataBegin, |
| _ptrRTCPDataEnd - _ptrRTCPDataBegin, &header)) |
| return; // NOT VALID! |
| |
| // * if (!reducedSize) : first packet must be RR or SR. |
| // |
| // * The padding bit (P) should be zero for the first packet of a |
| // compound RTCP packet because padding should only be applied, |
| // if it is needed, to the last packet. (NOT CHECKED!) |
| // |
| // * The length fields of the individual RTCP packets must add up |
| // to the overall length of the compound RTCP packet as |
| // received. This is a fairly strong check. (NOT CHECKED!) |
| |
| if (!_RTCPReducedSizeEnable) |
| { |
| if ((header.packet_type != PT_SR) && (header.packet_type != PT_RR)) { |
| return; // NOT VALID |
| } |
| } |
| |
| _validPacket = true; |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::IsValid() const |
| { |
| return _validPacket; |
| } |
| |
| void |
| RTCPUtility::RTCPParserV2::EndCurrentBlock() |
| { |
| _ptrRTCPData = _ptrRTCPBlockEnd; |
| } |
| |
| // 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| IC | PT | length | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // |
| // Common header for all RTCP packets, 4 octets. |
| |
| bool RTCPUtility::RtcpParseCommonHeader(const uint8_t* packet, |
| size_t size_bytes, |
| RtcpCommonHeader* parsed_header) { |
| RTC_DCHECK(parsed_header != nullptr); |
| if (size_bytes < RtcpCommonHeader::kHeaderSizeBytes) { |
| LOG(LS_WARNING) << "Too little data (" << size_bytes << " byte" |
| << (size_bytes != 1 ? "s" : "") |
| << ") remaining in buffer to parse RTCP header (4 bytes)."; |
| return false; |
| } |
| |
| const uint8_t kRtcpVersion = 2; |
| uint8_t version = packet[0] >> 6; |
| if (version != kRtcpVersion) { |
| LOG(LS_WARNING) << "Invalid RTCP header: Version must be " |
| << static_cast<int>(kRtcpVersion) << " but was " |
| << static_cast<int>(version); |
| return false; |
| } |
| |
| bool has_padding = (packet[0] & 0x20) != 0; |
| uint8_t format = packet[0] & 0x1F; |
| uint8_t packet_type = packet[1]; |
| size_t packet_size_words = |
| ByteReader<uint16_t>::ReadBigEndian(&packet[2]) + 1; |
| |
| if (size_bytes < packet_size_words * 4) { |
| LOG(LS_WARNING) << "Buffer too small (" << size_bytes |
| << " bytes) to fit an RtcpPacket of " << packet_size_words |
| << " 32bit words."; |
| return false; |
| } |
| |
| size_t payload_size = packet_size_words * 4; |
| size_t padding_bytes = 0; |
| if (has_padding) { |
| if (payload_size <= RtcpCommonHeader::kHeaderSizeBytes) { |
| LOG(LS_WARNING) << "Invalid RTCP header: Padding bit set but 0 payload " |
| "size specified."; |
| return false; |
| } |
| |
| padding_bytes = packet[payload_size - 1]; |
| if (RtcpCommonHeader::kHeaderSizeBytes + padding_bytes > payload_size) { |
| LOG(LS_WARNING) << "Invalid RTCP header: Too many padding bytes (" |
| << padding_bytes << ") for a packet size of " |
| << payload_size << "bytes."; |
| return false; |
| } |
| payload_size -= padding_bytes; |
| } |
| payload_size -= RtcpCommonHeader::kHeaderSizeBytes; |
| |
| parsed_header->version = kRtcpVersion; |
| parsed_header->count_or_format = format; |
| parsed_header->packet_type = packet_type; |
| parsed_header->payload_size_bytes = payload_size; |
| parsed_header->padding_bytes = padding_bytes; |
| |
| return true; |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParseRR() |
| { |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| |
| if (length < 8) |
| { |
| return false; |
| } |
| |
| |
| _ptrRTCPData += 4; // Skip header |
| |
| _packetType = RTCPPacketTypes::kRr; |
| |
| _packet.RR.SenderSSRC = *_ptrRTCPData++ << 24; |
| _packet.RR.SenderSSRC += *_ptrRTCPData++ << 16; |
| _packet.RR.SenderSSRC += *_ptrRTCPData++ << 8; |
| _packet.RR.SenderSSRC += *_ptrRTCPData++; |
| |
| _packet.RR.NumberOfReportBlocks = _numberOfBlocks; |
| |
| // State transition |
| _state = ParseState::State_ReportBlockItem; |
| |
| return true; |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParseSR() |
| { |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| |
| if (length < 28) |
| { |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| _ptrRTCPData += 4; // Skip header |
| |
| _packetType = RTCPPacketTypes::kSr; |
| |
| _packet.SR.SenderSSRC = *_ptrRTCPData++ << 24; |
| _packet.SR.SenderSSRC += *_ptrRTCPData++ << 16; |
| _packet.SR.SenderSSRC += *_ptrRTCPData++ << 8; |
| _packet.SR.SenderSSRC += *_ptrRTCPData++; |
| |
| _packet.SR.NTPMostSignificant = *_ptrRTCPData++ << 24; |
| _packet.SR.NTPMostSignificant += *_ptrRTCPData++ << 16; |
| _packet.SR.NTPMostSignificant += *_ptrRTCPData++ << 8; |
| _packet.SR.NTPMostSignificant += *_ptrRTCPData++; |
| |
| _packet.SR.NTPLeastSignificant = *_ptrRTCPData++ << 24; |
| _packet.SR.NTPLeastSignificant += *_ptrRTCPData++ << 16; |
| _packet.SR.NTPLeastSignificant += *_ptrRTCPData++ << 8; |
| _packet.SR.NTPLeastSignificant += *_ptrRTCPData++; |
| |
| _packet.SR.RTPTimestamp = *_ptrRTCPData++ << 24; |
| _packet.SR.RTPTimestamp += *_ptrRTCPData++ << 16; |
| _packet.SR.RTPTimestamp += *_ptrRTCPData++ << 8; |
| _packet.SR.RTPTimestamp += *_ptrRTCPData++; |
| |
| _packet.SR.SenderPacketCount = *_ptrRTCPData++ << 24; |
| _packet.SR.SenderPacketCount += *_ptrRTCPData++ << 16; |
| _packet.SR.SenderPacketCount += *_ptrRTCPData++ << 8; |
| _packet.SR.SenderPacketCount += *_ptrRTCPData++; |
| |
| _packet.SR.SenderOctetCount = *_ptrRTCPData++ << 24; |
| _packet.SR.SenderOctetCount += *_ptrRTCPData++ << 16; |
| _packet.SR.SenderOctetCount += *_ptrRTCPData++ << 8; |
| _packet.SR.SenderOctetCount += *_ptrRTCPData++; |
| |
| _packet.SR.NumberOfReportBlocks = _numberOfBlocks; |
| |
| // State transition |
| if(_numberOfBlocks != 0) |
| { |
| _state = ParseState::State_ReportBlockItem; |
| }else |
| { |
| // don't go to state report block item if 0 report blocks |
| _state = ParseState::State_TopLevel; |
| EndCurrentBlock(); |
| } |
| return true; |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParseReportBlockItem() |
| { |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| |
| if (length < 24 || _numberOfBlocks <= 0) |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| _packet.ReportBlockItem.SSRC = *_ptrRTCPData++ << 24; |
| _packet.ReportBlockItem.SSRC += *_ptrRTCPData++ << 16; |
| _packet.ReportBlockItem.SSRC += *_ptrRTCPData++ << 8; |
| _packet.ReportBlockItem.SSRC += *_ptrRTCPData++; |
| |
| _packet.ReportBlockItem.FractionLost = *_ptrRTCPData++; |
| |
| _packet.ReportBlockItem.CumulativeNumOfPacketsLost = *_ptrRTCPData++ << 16; |
| _packet.ReportBlockItem.CumulativeNumOfPacketsLost += *_ptrRTCPData++ << 8; |
| _packet.ReportBlockItem.CumulativeNumOfPacketsLost += *_ptrRTCPData++; |
| |
| _packet.ReportBlockItem.ExtendedHighestSequenceNumber = *_ptrRTCPData++ << 24; |
| _packet.ReportBlockItem.ExtendedHighestSequenceNumber += *_ptrRTCPData++ << 16; |
| _packet.ReportBlockItem.ExtendedHighestSequenceNumber += *_ptrRTCPData++ << 8; |
| _packet.ReportBlockItem.ExtendedHighestSequenceNumber += *_ptrRTCPData++; |
| |
| _packet.ReportBlockItem.Jitter = *_ptrRTCPData++ << 24; |
| _packet.ReportBlockItem.Jitter += *_ptrRTCPData++ << 16; |
| _packet.ReportBlockItem.Jitter += *_ptrRTCPData++ << 8; |
| _packet.ReportBlockItem.Jitter += *_ptrRTCPData++; |
| |
| _packet.ReportBlockItem.LastSR = *_ptrRTCPData++ << 24; |
| _packet.ReportBlockItem.LastSR += *_ptrRTCPData++ << 16; |
| _packet.ReportBlockItem.LastSR += *_ptrRTCPData++ << 8; |
| _packet.ReportBlockItem.LastSR += *_ptrRTCPData++; |
| |
| _packet.ReportBlockItem.DelayLastSR = *_ptrRTCPData++ << 24; |
| _packet.ReportBlockItem.DelayLastSR += *_ptrRTCPData++ << 16; |
| _packet.ReportBlockItem.DelayLastSR += *_ptrRTCPData++ << 8; |
| _packet.ReportBlockItem.DelayLastSR += *_ptrRTCPData++; |
| |
| _numberOfBlocks--; |
| _packetType = RTCPPacketTypes::kReportBlockItem; |
| return true; |
| } |
| |
| /* From RFC 5450: Transmission Time Offsets in RTP Streams. |
| 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 |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| hdr |V=2|P| RC | PT=IJ=195 | length | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | inter-arrival jitter | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| . . |
| . . |
| . . |
| | inter-arrival jitter | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| */ |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParseIJ() |
| { |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| |
| if (length < 4) |
| { |
| return false; |
| } |
| |
| _ptrRTCPData += 4; // Skip header |
| |
| _packetType = RTCPPacketTypes::kExtendedIj; |
| |
| // State transition |
| _state = ParseState::State_ExtendedJitterItem; |
| return true; |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParseIJItem() |
| { |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| |
| if (length < 4 || _numberOfBlocks <= 0) |
| { |
| _state = ParseState::State_TopLevel; |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| _packet.ExtendedJitterReportItem.Jitter = *_ptrRTCPData++ << 24; |
| _packet.ExtendedJitterReportItem.Jitter += *_ptrRTCPData++ << 16; |
| _packet.ExtendedJitterReportItem.Jitter += *_ptrRTCPData++ << 8; |
| _packet.ExtendedJitterReportItem.Jitter += *_ptrRTCPData++; |
| |
| _numberOfBlocks--; |
| _packetType = RTCPPacketTypes::kExtendedIjItem; |
| return true; |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParseSDES() |
| { |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| |
| if (length < 8) |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| _ptrRTCPData += 4; // Skip header |
| |
| _state = ParseState::State_SDESChunk; |
| _packetType = RTCPPacketTypes::kSdes; |
| return true; |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParseSDESChunk() |
| { |
| if(_numberOfBlocks <= 0) |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| _numberOfBlocks--; |
| |
| // Find CName item in a SDES chunk. |
| while (_ptrRTCPData < _ptrRTCPBlockEnd) |
| { |
| const ptrdiff_t dataLen = _ptrRTCPBlockEnd - _ptrRTCPData; |
| if (dataLen < 4) |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| uint32_t SSRC = *_ptrRTCPData++ << 24; |
| SSRC += *_ptrRTCPData++ << 16; |
| SSRC += *_ptrRTCPData++ << 8; |
| SSRC += *_ptrRTCPData++; |
| |
| const bool foundCname = ParseSDESItem(); |
| if (foundCname) |
| { |
| _packet.CName.SenderSSRC = SSRC; // Add SSRC |
| return true; |
| } |
| } |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParseSDESItem() |
| { |
| // Find CName |
| // Only the CNAME item is mandatory. RFC 3550 page 46 |
| bool foundCName = false; |
| |
| size_t itemOctetsRead = 0; |
| while (_ptrRTCPData < _ptrRTCPBlockEnd) |
| { |
| const uint8_t tag = *_ptrRTCPData++; |
| ++itemOctetsRead; |
| |
| if (tag == 0) |
| { |
| // End tag! 4 oct aligned |
| while ((itemOctetsRead++ % 4) != 0) |
| { |
| ++_ptrRTCPData; |
| } |
| return foundCName; |
| } |
| |
| if (_ptrRTCPData < _ptrRTCPBlockEnd) |
| { |
| const uint8_t len = *_ptrRTCPData++; |
| ++itemOctetsRead; |
| |
| if (tag == 1) |
| { |
| // CNAME |
| |
| // Sanity |
| if ((_ptrRTCPData + len) >= _ptrRTCPBlockEnd) |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| uint8_t i = 0; |
| for (; i < len; ++i) |
| { |
| const uint8_t c = _ptrRTCPData[i]; |
| if ((c < ' ') || (c > '{') || (c == '%') || (c == '\\')) |
| { |
| // Illegal char |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| _packet.CName.CName[i] = c; |
| } |
| // Make sure we are null terminated. |
| _packet.CName.CName[i] = 0; |
| _packetType = RTCPPacketTypes::kSdesChunk; |
| |
| foundCName = true; |
| } |
| _ptrRTCPData += len; |
| itemOctetsRead += len; |
| } |
| } |
| |
| // No end tag found! |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParseBYE() |
| { |
| _ptrRTCPData += 4; // Skip header |
| |
| _state = ParseState::State_BYEItem; |
| |
| return ParseBYEItem(); |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParseBYEItem() |
| { |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| if (length < 4 || _numberOfBlocks == 0) |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| _packetType = RTCPPacketTypes::kBye; |
| |
| _packet.BYE.SenderSSRC = *_ptrRTCPData++ << 24; |
| _packet.BYE.SenderSSRC += *_ptrRTCPData++ << 16; |
| _packet.BYE.SenderSSRC += *_ptrRTCPData++ << 8; |
| _packet.BYE.SenderSSRC += *_ptrRTCPData++; |
| |
| // we can have several CSRCs attached |
| |
| // sanity |
| if(length >= 4*_numberOfBlocks) |
| { |
| _ptrRTCPData += (_numberOfBlocks -1)*4; |
| } |
| _numberOfBlocks = 0; |
| |
| return true; |
| } |
| /* |
| 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|reserved | PT=XR=207 | length | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | SSRC | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| : report blocks : |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| */ |
| bool RTCPUtility::RTCPParserV2::ParseXr() |
| { |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| if (length < 8) |
| { |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| _ptrRTCPData += 4; // Skip header |
| |
| _packet.XR.OriginatorSSRC = *_ptrRTCPData++ << 24; |
| _packet.XR.OriginatorSSRC += *_ptrRTCPData++ << 16; |
| _packet.XR.OriginatorSSRC += *_ptrRTCPData++ << 8; |
| _packet.XR.OriginatorSSRC += *_ptrRTCPData++; |
| |
| _packetType = RTCPPacketTypes::kXrHeader; |
| _state = ParseState::State_XRItem; |
| return true; |
| } |
| |
| /* Extended report block format (RFC 3611). |
| BT: block type. |
| block length: length of report block in 32-bits words minus one (including |
| the header). |
| 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 |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | BT | type-specific | block length | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| : type-specific block contents : |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| */ |
| bool RTCPUtility::RTCPParserV2::ParseXrItem() { |
| const int kBlockHeaderLengthInBytes = 4; |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| if (length < kBlockHeaderLengthInBytes) { |
| _state = ParseState::State_TopLevel; |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| uint8_t block_type = *_ptrRTCPData++; |
| _ptrRTCPData++; // Ignore reserved. |
| |
| uint16_t block_length_in_4bytes = *_ptrRTCPData++ << 8; |
| block_length_in_4bytes += *_ptrRTCPData++; |
| |
| switch (block_type) { |
| case kBtReceiverReferenceTime: |
| return ParseXrReceiverReferenceTimeItem(block_length_in_4bytes); |
| case kBtDlrr: |
| return ParseXrDlrr(block_length_in_4bytes); |
| case kBtVoipMetric: |
| return ParseXrVoipMetricItem(block_length_in_4bytes); |
| default: |
| return ParseXrUnsupportedBlockType(block_length_in_4bytes); |
| } |
| } |
| |
| /* Receiver Reference Time Report Block. |
| 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 |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | BT=4 | reserved | block length = 2 | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | NTP timestamp, most significant word | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | NTP timestamp, least significant word | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| */ |
| bool RTCPUtility::RTCPParserV2::ParseXrReceiverReferenceTimeItem( |
| int block_length_4bytes) { |
| const int kBlockLengthIn4Bytes = 2; |
| const int kBlockLengthInBytes = kBlockLengthIn4Bytes * 4; |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| if (block_length_4bytes != kBlockLengthIn4Bytes || |
| length < kBlockLengthInBytes) { |
| _state = ParseState::State_TopLevel; |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| _packet.XRReceiverReferenceTimeItem.NTPMostSignificant = *_ptrRTCPData++<<24; |
| _packet.XRReceiverReferenceTimeItem.NTPMostSignificant+= *_ptrRTCPData++<<16; |
| _packet.XRReceiverReferenceTimeItem.NTPMostSignificant+= *_ptrRTCPData++<<8; |
| _packet.XRReceiverReferenceTimeItem.NTPMostSignificant+= *_ptrRTCPData++; |
| |
| _packet.XRReceiverReferenceTimeItem.NTPLeastSignificant = *_ptrRTCPData++<<24; |
| _packet.XRReceiverReferenceTimeItem.NTPLeastSignificant+= *_ptrRTCPData++<<16; |
| _packet.XRReceiverReferenceTimeItem.NTPLeastSignificant+= *_ptrRTCPData++<<8; |
| _packet.XRReceiverReferenceTimeItem.NTPLeastSignificant+= *_ptrRTCPData++; |
| |
| _packetType = RTCPPacketTypes::kXrReceiverReferenceTime; |
| _state = ParseState::State_XRItem; |
| return true; |
| } |
| |
| /* DLRR Report Block. |
| 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 |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | BT=5 | reserved | block length | |
| +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+ |
| | SSRC_1 (SSRC of first receiver) | sub- |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ block |
| | last RR (LRR) | 1 |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | delay since last RR (DLRR) | |
| +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+ |
| | SSRC_2 (SSRC of second receiver) | sub- |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ block |
| : ... : 2 |
| +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+ |
| */ |
| bool RTCPUtility::RTCPParserV2::ParseXrDlrr(int block_length_4bytes) { |
| const int kSubBlockLengthIn4Bytes = 3; |
| if (block_length_4bytes < 0 || |
| (block_length_4bytes % kSubBlockLengthIn4Bytes) != 0) { |
| _state = ParseState::State_TopLevel; |
| EndCurrentBlock(); |
| return false; |
| } |
| _packetType = RTCPPacketTypes::kXrDlrrReportBlock; |
| _state = ParseState::State_XR_DLLRItem; |
| _numberOfBlocks = block_length_4bytes / kSubBlockLengthIn4Bytes; |
| return true; |
| } |
| |
| bool RTCPUtility::RTCPParserV2::ParseXrDlrrItem() { |
| if (_numberOfBlocks == 0) { |
| _state = ParseState::State_XRItem; |
| return false; |
| } |
| const int kSubBlockLengthInBytes = 12; |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| if (length < kSubBlockLengthInBytes) { |
| _state = ParseState::State_TopLevel; |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| _packet.XRDLRRReportBlockItem.SSRC = *_ptrRTCPData++ << 24; |
| _packet.XRDLRRReportBlockItem.SSRC += *_ptrRTCPData++ << 16; |
| _packet.XRDLRRReportBlockItem.SSRC += *_ptrRTCPData++ << 8; |
| _packet.XRDLRRReportBlockItem.SSRC += *_ptrRTCPData++; |
| |
| _packet.XRDLRRReportBlockItem.LastRR = *_ptrRTCPData++ << 24; |
| _packet.XRDLRRReportBlockItem.LastRR += *_ptrRTCPData++ << 16; |
| _packet.XRDLRRReportBlockItem.LastRR += *_ptrRTCPData++ << 8; |
| _packet.XRDLRRReportBlockItem.LastRR += *_ptrRTCPData++; |
| |
| _packet.XRDLRRReportBlockItem.DelayLastRR = *_ptrRTCPData++ << 24; |
| _packet.XRDLRRReportBlockItem.DelayLastRR += *_ptrRTCPData++ << 16; |
| _packet.XRDLRRReportBlockItem.DelayLastRR += *_ptrRTCPData++ << 8; |
| _packet.XRDLRRReportBlockItem.DelayLastRR += *_ptrRTCPData++; |
| |
| _packetType = RTCPPacketTypes::kXrDlrrReportBlockItem; |
| --_numberOfBlocks; |
| _state = ParseState::State_XR_DLLRItem; |
| return true; |
| } |
| /* VoIP Metrics Report Block. |
| 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 |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | BT=7 | reserved | block length = 8 | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | SSRC of source | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | loss rate | discard rate | burst density | gap density | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | burst duration | gap duration | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | round trip delay | end system delay | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | signal level | noise level | RERL | Gmin | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | R factor | ext. R factor | MOS-LQ | MOS-CQ | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | RX config | reserved | JB nominal | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | JB maximum | JB abs max | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| */ |
| |
| bool RTCPUtility::RTCPParserV2::ParseXrVoipMetricItem(int block_length_4bytes) { |
| const int kBlockLengthIn4Bytes = 8; |
| const int kBlockLengthInBytes = kBlockLengthIn4Bytes * 4; |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| if (block_length_4bytes != kBlockLengthIn4Bytes || |
| length < kBlockLengthInBytes) { |
| _state = ParseState::State_TopLevel; |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| _packet.XRVOIPMetricItem.SSRC = *_ptrRTCPData++ << 24; |
| _packet.XRVOIPMetricItem.SSRC += *_ptrRTCPData++ << 16; |
| _packet.XRVOIPMetricItem.SSRC += *_ptrRTCPData++ << 8; |
| _packet.XRVOIPMetricItem.SSRC += *_ptrRTCPData++; |
| |
| _packet.XRVOIPMetricItem.lossRate = *_ptrRTCPData++; |
| _packet.XRVOIPMetricItem.discardRate = *_ptrRTCPData++; |
| _packet.XRVOIPMetricItem.burstDensity = *_ptrRTCPData++; |
| _packet.XRVOIPMetricItem.gapDensity = *_ptrRTCPData++; |
| |
| _packet.XRVOIPMetricItem.burstDuration = *_ptrRTCPData++ << 8; |
| _packet.XRVOIPMetricItem.burstDuration += *_ptrRTCPData++; |
| |
| _packet.XRVOIPMetricItem.gapDuration = *_ptrRTCPData++ << 8; |
| _packet.XRVOIPMetricItem.gapDuration += *_ptrRTCPData++; |
| |
| _packet.XRVOIPMetricItem.roundTripDelay = *_ptrRTCPData++ << 8; |
| _packet.XRVOIPMetricItem.roundTripDelay += *_ptrRTCPData++; |
| |
| _packet.XRVOIPMetricItem.endSystemDelay = *_ptrRTCPData++ << 8; |
| _packet.XRVOIPMetricItem.endSystemDelay += *_ptrRTCPData++; |
| |
| _packet.XRVOIPMetricItem.signalLevel = *_ptrRTCPData++; |
| _packet.XRVOIPMetricItem.noiseLevel = *_ptrRTCPData++; |
| _packet.XRVOIPMetricItem.RERL = *_ptrRTCPData++; |
| _packet.XRVOIPMetricItem.Gmin = *_ptrRTCPData++; |
| _packet.XRVOIPMetricItem.Rfactor = *_ptrRTCPData++; |
| _packet.XRVOIPMetricItem.extRfactor = *_ptrRTCPData++; |
| _packet.XRVOIPMetricItem.MOSLQ = *_ptrRTCPData++; |
| _packet.XRVOIPMetricItem.MOSCQ = *_ptrRTCPData++; |
| _packet.XRVOIPMetricItem.RXconfig = *_ptrRTCPData++; |
| _ptrRTCPData++; // skip reserved |
| |
| _packet.XRVOIPMetricItem.JBnominal = *_ptrRTCPData++ << 8; |
| _packet.XRVOIPMetricItem.JBnominal += *_ptrRTCPData++; |
| |
| _packet.XRVOIPMetricItem.JBmax = *_ptrRTCPData++ << 8; |
| _packet.XRVOIPMetricItem.JBmax += *_ptrRTCPData++; |
| |
| _packet.XRVOIPMetricItem.JBabsMax = *_ptrRTCPData++ << 8; |
| _packet.XRVOIPMetricItem.JBabsMax += *_ptrRTCPData++; |
| |
| _packetType = RTCPPacketTypes::kXrVoipMetric; |
| _state = ParseState::State_XRItem; |
| return true; |
| } |
| |
| bool RTCPUtility::RTCPParserV2::ParseXrUnsupportedBlockType( |
| int block_length_4bytes) { |
| const int32_t kBlockLengthInBytes = block_length_4bytes * 4; |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| if (length < kBlockLengthInBytes) { |
| _state = ParseState::State_TopLevel; |
| EndCurrentBlock(); |
| return false; |
| } |
| // Skip block. |
| _ptrRTCPData += kBlockLengthInBytes; |
| _state = ParseState::State_XRItem; |
| return false; |
| } |
| |
| bool RTCPUtility::RTCPParserV2::ParseFBCommon(const RtcpCommonHeader& header) { |
| RTC_CHECK((header.packet_type == PT_RTPFB) || |
| (header.packet_type == PT_PSFB)); // Parser logic check |
| |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| |
| // 4 * 3, RFC4585 section 6.1 |
| if (length < 12) { |
| LOG(LS_WARNING) |
| << "Invalid RTCP packet: Too little data (" << length |
| << " bytes) left in buffer to parse a 12 byte RTPFB/PSFB message."; |
| return false; |
| } |
| |
| _ptrRTCPData += 4; // Skip RTCP header |
| |
| uint32_t senderSSRC = ByteReader<uint32_t>::ReadBigEndian(_ptrRTCPData); |
| _ptrRTCPData += 4; |
| |
| uint32_t mediaSSRC = ByteReader<uint32_t>::ReadBigEndian(_ptrRTCPData); |
| _ptrRTCPData += 4; |
| |
| if (header.packet_type == PT_RTPFB) { |
| // Transport layer feedback |
| |
| switch (header.count_or_format) { |
| case 1: |
| { |
| // NACK |
| _packetType = RTCPPacketTypes::kRtpfbNack; |
| _packet.NACK.SenderSSRC = senderSSRC; |
| _packet.NACK.MediaSSRC = mediaSSRC; |
| |
| _state = ParseState::State_RTPFB_NACKItem; |
| |
| return true; |
| } |
| case 3: |
| { |
| // TMMBR |
| _packetType = RTCPPacketTypes::kRtpfbTmmbr; |
| _packet.TMMBR.SenderSSRC = senderSSRC; |
| _packet.TMMBR.MediaSSRC = mediaSSRC; |
| |
| _state = ParseState::State_RTPFB_TMMBRItem; |
| |
| return true; |
| } |
| case 4: |
| { |
| // TMMBN |
| _packetType = RTCPPacketTypes::kRtpfbTmmbn; |
| _packet.TMMBN.SenderSSRC = senderSSRC; |
| _packet.TMMBN.MediaSSRC = mediaSSRC; |
| |
| _state = ParseState::State_RTPFB_TMMBNItem; |
| |
| return true; |
| } |
| case 5: |
| { |
| // RTCP-SR-REQ Rapid Synchronisation of RTP Flows |
| // draft-perkins-avt-rapid-rtp-sync-03.txt |
| // trigger a new RTCP SR |
| _packetType = RTCPPacketTypes::kRtpfbSrReq; |
| |
| // Note: No state transition, SR REQ is empty! |
| return true; |
| } |
| case 15: { |
| rtcp_packet_ = |
| rtcp::TransportFeedback::ParseFrom(_ptrRTCPData - 12, length); |
| // Since we parse the whole packet here, keep the TopLevel state and |
| // just end the current block. |
| EndCurrentBlock(); |
| if (rtcp_packet_.get()) { |
| _packetType = RTCPPacketTypes::kTransportFeedback; |
| return true; |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| // Unsupported RTPFB message. Skip and move to next block. |
| ++num_skipped_blocks_; |
| return false; |
| } else if (header.packet_type == PT_PSFB) { |
| // Payload specific feedback |
| switch (header.count_or_format) { |
| case 1: |
| // PLI |
| _packetType = RTCPPacketTypes::kPsfbPli; |
| _packet.PLI.SenderSSRC = senderSSRC; |
| _packet.PLI.MediaSSRC = mediaSSRC; |
| |
| // Note: No state transition, PLI FCI is empty! |
| return true; |
| case 2: |
| // SLI |
| _packetType = RTCPPacketTypes::kPsfbSli; |
| _packet.SLI.SenderSSRC = senderSSRC; |
| _packet.SLI.MediaSSRC = mediaSSRC; |
| |
| _state = ParseState::State_PSFB_SLIItem; |
| |
| return true; |
| case 3: |
| _packetType = RTCPPacketTypes::kPsfbRpsi; |
| _packet.RPSI.SenderSSRC = senderSSRC; |
| _packet.RPSI.MediaSSRC = mediaSSRC; |
| |
| _state = ParseState::State_PSFB_RPSIItem; |
| return true; |
| case 4: |
| // FIR |
| _packetType = RTCPPacketTypes::kPsfbFir; |
| _packet.FIR.SenderSSRC = senderSSRC; |
| _packet.FIR.MediaSSRC = mediaSSRC; |
| |
| _state = ParseState::State_PSFB_FIRItem; |
| return true; |
| case 15: |
| _packetType = RTCPPacketTypes::kPsfbApp; |
| _packet.PSFBAPP.SenderSSRC = senderSSRC; |
| _packet.PSFBAPP.MediaSSRC = mediaSSRC; |
| |
| _state = ParseState::State_PSFB_AppItem; |
| return true; |
| default: |
| break; |
| } |
| |
| return false; |
| } |
| else |
| { |
| RTC_NOTREACHED(); |
| return false; |
| } |
| } |
| |
| bool RTCPUtility::RTCPParserV2::ParseRPSIItem() { |
| |
| // RFC 4585 6.3.3. Reference Picture Selection Indication (RPSI). |
| // |
| // 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 |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // | PB |0| Payload Type| Native RPSI bit string | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // | defined per codec ... | Padding (0) | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| |
| if (length < 4) { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| if (length > 2 + RTCP_RPSI_DATA_SIZE) { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| |
| uint8_t padding_bits = *_ptrRTCPData++; |
| _packet.RPSI.PayloadType = *_ptrRTCPData++; |
| |
| if (padding_bits > static_cast<uint16_t>(length - 2) * 8) { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| _packetType = RTCPPacketTypes::kPsfbRpsiItem; |
| |
| memcpy(_packet.RPSI.NativeBitString, _ptrRTCPData, length - 2); |
| _ptrRTCPData += length - 2; |
| |
| _packet.RPSI.NumberOfValidBits = |
| static_cast<uint16_t>(length - 2) * 8 - padding_bits; |
| return true; |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParseNACKItem() |
| { |
| // RFC 4585 6.2.1. Generic NACK |
| |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| |
| if (length < 4) |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| _packetType = RTCPPacketTypes::kRtpfbNackItem; |
| |
| _packet.NACKItem.PacketID = *_ptrRTCPData++ << 8; |
| _packet.NACKItem.PacketID += *_ptrRTCPData++; |
| |
| _packet.NACKItem.BitMask = *_ptrRTCPData++ << 8; |
| _packet.NACKItem.BitMask += *_ptrRTCPData++; |
| |
| return true; |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParsePsfbAppItem() |
| { |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| |
| if (length < 4) |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| if(*_ptrRTCPData++ != 'R') |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| if(*_ptrRTCPData++ != 'E') |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| if(*_ptrRTCPData++ != 'M') |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| if(*_ptrRTCPData++ != 'B') |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| _packetType = RTCPPacketTypes::kPsfbRemb; |
| _state = ParseState::State_PSFB_REMBItem; |
| return true; |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParsePsfbREMBItem() |
| { |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| |
| if (length < 4) |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| _packet.REMBItem.NumberOfSSRCs = *_ptrRTCPData++; |
| const uint8_t exp = (_ptrRTCPData[0] >> 2) & 0x3F; |
| |
| uint64_t mantissa = (_ptrRTCPData[0] & 0x03) << 16; |
| mantissa += (_ptrRTCPData[1] << 8); |
| mantissa += (_ptrRTCPData[2]); |
| |
| _ptrRTCPData += 3; // Fwd read data |
| uint64_t bitrate_bps = (mantissa << exp); |
| bool shift_overflow = exp > 0 && (mantissa >> (64 - exp)) != 0; |
| if (shift_overflow || bitrate_bps > kMaxBitrateBps) { |
| LOG(LS_ERROR) << "Unhandled remb bitrate value : " << mantissa |
| << "*2^" << static_cast<int>(exp); |
| _state = ParseState::State_TopLevel; |
| EndCurrentBlock(); |
| return false; |
| } |
| _packet.REMBItem.BitRate = bitrate_bps; |
| |
| const ptrdiff_t length_ssrcs = _ptrRTCPBlockEnd - _ptrRTCPData; |
| if (length_ssrcs < 4 * _packet.REMBItem.NumberOfSSRCs) |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| _packetType = RTCPPacketTypes::kPsfbRembItem; |
| |
| for (int i = 0; i < _packet.REMBItem.NumberOfSSRCs; i++) |
| { |
| _packet.REMBItem.SSRCs[i] = *_ptrRTCPData++ << 24; |
| _packet.REMBItem.SSRCs[i] += *_ptrRTCPData++ << 16; |
| _packet.REMBItem.SSRCs[i] += *_ptrRTCPData++ << 8; |
| _packet.REMBItem.SSRCs[i] += *_ptrRTCPData++; |
| } |
| return true; |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParseTMMBRItem() |
| { |
| // RFC 5104 4.2.1. Temporary Maximum Media Stream Bit Rate Request (TMMBR) |
| |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| |
| if (length < 8) |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| _packetType = RTCPPacketTypes::kRtpfbTmmbrItem; |
| |
| _packet.TMMBRItem.SSRC = *_ptrRTCPData++ << 24; |
| _packet.TMMBRItem.SSRC += *_ptrRTCPData++ << 16; |
| _packet.TMMBRItem.SSRC += *_ptrRTCPData++ << 8; |
| _packet.TMMBRItem.SSRC += *_ptrRTCPData++; |
| |
| uint8_t exp = (_ptrRTCPData[0] >> 2) & 0x3F; |
| |
| uint64_t mantissa = (_ptrRTCPData[0] & 0x03) << 15; |
| mantissa += (_ptrRTCPData[1] << 7); |
| mantissa += (_ptrRTCPData[2] >> 1) & 0x7F; |
| |
| uint32_t measuredOH = (_ptrRTCPData[2] & 0x01) << 8; |
| measuredOH += _ptrRTCPData[3]; |
| |
| _ptrRTCPData += 4; // Fwd read data |
| |
| uint64_t bitrate_bps = (mantissa << exp); |
| bool shift_overflow = exp > 0 && (mantissa >> (64 - exp)) != 0; |
| if (shift_overflow || bitrate_bps > kMaxBitrateBps) { |
| LOG(LS_ERROR) << "Unhandled tmmbr bitrate value : " << mantissa |
| << "*2^" << static_cast<int>(exp); |
| _state = ParseState::State_TopLevel; |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| _packet.TMMBRItem.MaxTotalMediaBitRate = bitrate_bps / 1000; |
| _packet.TMMBRItem.MeasuredOverhead = measuredOH; |
| |
| return true; |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParseTMMBNItem() |
| { |
| // RFC 5104 4.2.2. Temporary Maximum Media Stream Bit Rate Notification (TMMBN) |
| |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| |
| if (length < 8) |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| _packetType = RTCPPacketTypes::kRtpfbTmmbnItem; |
| |
| _packet.TMMBNItem.SSRC = *_ptrRTCPData++ << 24; |
| _packet.TMMBNItem.SSRC += *_ptrRTCPData++ << 16; |
| _packet.TMMBNItem.SSRC += *_ptrRTCPData++ << 8; |
| _packet.TMMBNItem.SSRC += *_ptrRTCPData++; |
| |
| uint8_t exp = (_ptrRTCPData[0] >> 2) & 0x3F; |
| |
| uint64_t mantissa = (_ptrRTCPData[0] & 0x03) << 15; |
| mantissa += (_ptrRTCPData[1] << 7); |
| mantissa += (_ptrRTCPData[2] >> 1) & 0x7F; |
| |
| uint32_t measuredOH = (_ptrRTCPData[2] & 0x01) << 8; |
| measuredOH += _ptrRTCPData[3]; |
| |
| _ptrRTCPData += 4; // Fwd read data |
| |
| uint64_t bitrate_bps = (mantissa << exp); |
| bool shift_overflow = exp > 0 && (mantissa >> (64 - exp)) != 0; |
| if (shift_overflow || bitrate_bps > kMaxBitrateBps) { |
| LOG(LS_ERROR) << "Unhandled tmmbn bitrate value : " << mantissa |
| << "*2^" << static_cast<int>(exp); |
| _state = ParseState::State_TopLevel; |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| _packet.TMMBNItem.MaxTotalMediaBitRate = bitrate_bps / 1000; |
| _packet.TMMBNItem.MeasuredOverhead = measuredOH; |
| |
| return true; |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParseSLIItem() |
| { |
| // RFC 5104 6.3.2. Slice Loss Indication (SLI) |
| /* |
| 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 |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | First | Number | PictureID | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| */ |
| |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| |
| if (length < 4) |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| _packetType = RTCPPacketTypes::kPsfbSliItem; |
| |
| uint32_t buffer; |
| buffer = *_ptrRTCPData++ << 24; |
| buffer += *_ptrRTCPData++ << 16; |
| buffer += *_ptrRTCPData++ << 8; |
| buffer += *_ptrRTCPData++; |
| |
| _packet.SLIItem.FirstMB = uint16_t((buffer>>19) & 0x1fff); |
| _packet.SLIItem.NumberOfMB = uint16_t((buffer>>6) & 0x1fff); |
| _packet.SLIItem.PictureId = uint8_t(buffer & 0x3f); |
| |
| return true; |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParseFIRItem() |
| { |
| // RFC 5104 4.3.1. Full Intra Request (FIR) |
| |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| |
| if (length < 8) |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| _packetType = RTCPPacketTypes::kPsfbFirItem; |
| |
| _packet.FIRItem.SSRC = *_ptrRTCPData++ << 24; |
| _packet.FIRItem.SSRC += *_ptrRTCPData++ << 16; |
| _packet.FIRItem.SSRC += *_ptrRTCPData++ << 8; |
| _packet.FIRItem.SSRC += *_ptrRTCPData++; |
| |
| _packet.FIRItem.CommandSequenceNumber = *_ptrRTCPData++; |
| _ptrRTCPData += 3; // Skip "Reserved" bytes. |
| return true; |
| } |
| |
| bool RTCPUtility::RTCPParserV2::ParseAPP(const RtcpCommonHeader& header) { |
| ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| |
| if (length < 12) // 4 * 3, RFC 3550 6.7 APP: Application-Defined RTCP Packet |
| { |
| EndCurrentBlock(); |
| return false; |
| } |
| |
| _ptrRTCPData += 4; // Skip RTCP header |
| |
| uint32_t senderSSRC = *_ptrRTCPData++ << 24; |
| senderSSRC += *_ptrRTCPData++ << 16; |
| senderSSRC += *_ptrRTCPData++ << 8; |
| senderSSRC += *_ptrRTCPData++; |
| |
| uint32_t name = *_ptrRTCPData++ << 24; |
| name += *_ptrRTCPData++ << 16; |
| name += *_ptrRTCPData++ << 8; |
| name += *_ptrRTCPData++; |
| |
| length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| |
| _packetType = RTCPPacketTypes::kApp; |
| |
| _packet.APP.SubType = header.count_or_format; |
| _packet.APP.Name = name; |
| |
| _state = ParseState::State_AppItem; |
| return true; |
| } |
| |
| bool |
| RTCPUtility::RTCPParserV2::ParseAPPItem() |
| { |
| const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData; |
| if (length < 4) |
| { |
| _state = ParseState::State_TopLevel; |
| |
| EndCurrentBlock(); |
| return false; |
| } |
| _packetType = RTCPPacketTypes::kAppItem; |
| |
| if(length > kRtcpAppCode_DATA_SIZE) |
| { |
| memcpy(_packet.APP.Data, _ptrRTCPData, kRtcpAppCode_DATA_SIZE); |
| _packet.APP.Size = kRtcpAppCode_DATA_SIZE; |
| _ptrRTCPData += kRtcpAppCode_DATA_SIZE; |
| }else |
| { |
| memcpy(_packet.APP.Data, _ptrRTCPData, length); |
| _packet.APP.Size = (uint16_t)length; |
| _ptrRTCPData += length; |
| } |
| return true; |
| } |
| |
| size_t RTCPUtility::RTCPParserV2::NumSkippedBlocks() const { |
| return num_skipped_blocks_; |
| } |
| |
| RTCPUtility::RTCPPacketIterator::RTCPPacketIterator(uint8_t* rtcpData, |
| size_t rtcpDataLength) |
| : _ptrBegin(rtcpData), |
| _ptrEnd(rtcpData + rtcpDataLength), |
| _ptrBlock(NULL) { |
| memset(&_header, 0, sizeof(_header)); |
| } |
| |
| RTCPUtility::RTCPPacketIterator::~RTCPPacketIterator() { |
| } |
| |
| const RTCPUtility::RtcpCommonHeader* RTCPUtility::RTCPPacketIterator::Begin() { |
| _ptrBlock = _ptrBegin; |
| |
| return Iterate(); |
| } |
| |
| const RTCPUtility::RtcpCommonHeader* |
| RTCPUtility::RTCPPacketIterator::Iterate() { |
| if ((_ptrEnd <= _ptrBlock) || |
| !RtcpParseCommonHeader(_ptrBlock, _ptrEnd - _ptrBlock, &_header)) { |
| _ptrBlock = nullptr; |
| return nullptr; |
| } |
| _ptrBlock += _header.BlockSize(); |
| |
| if (_ptrBlock > _ptrEnd) { |
| _ptrBlock = nullptr; |
| return nullptr; |
| } |
| |
| return &_header; |
| } |
| |
| const RTCPUtility::RtcpCommonHeader* |
| RTCPUtility::RTCPPacketIterator::Current() { |
| if (!_ptrBlock) |
| { |
| return NULL; |
| } |
| |
| return &_header; |
| } |
| } // namespace webrtc |
