| /* |
| * Copyright (c) 2015 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 "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" |
| |
| #include <algorithm> |
| #include <cstdint> |
| #include <numeric> |
| #include <utility> |
| |
| #include "absl/algorithm/container.h" |
| #include "modules/include/module_common_types_public.h" |
| #include "modules/rtp_rtcp/source/byte_io.h" |
| #include "modules/rtp_rtcp/source/rtcp_packet/common_header.h" |
| #include "rtc_base/checks.h" |
| #include "rtc_base/logging.h" |
| #include "rtc_base/trace_event.h" |
| |
| namespace webrtc { |
| namespace rtcp { |
| namespace { |
| // Header size: |
| // * 4 bytes Common RTCP Packet Header |
| // * 8 bytes Common Packet Format for RTCP Feedback Messages |
| // * 8 bytes FeedbackPacket header |
| constexpr size_t kTransportFeedbackHeaderSizeBytes = 4 + 8 + 8; |
| constexpr size_t kChunkSizeBytes = 2; |
| // TODO(sprang): Add support for dynamic max size for easier fragmentation, |
| // eg. set it to what's left in the buffer or IP_PACKET_SIZE. |
| // Size constraint imposed by RTCP common header: 16bit size field interpreted |
| // as number of four byte words minus the first header word. |
| constexpr size_t kMaxSizeBytes = (1 << 16) * 4; |
| // Payload size: |
| // * 8 bytes Common Packet Format for RTCP Feedback Messages |
| // * 8 bytes FeedbackPacket header. |
| // * 2 bytes for one chunk. |
| constexpr size_t kMinPayloadSizeBytes = 8 + 8 + 2; |
| constexpr TimeDelta kBaseTimeTick = TransportFeedback::kDeltaTick * (1 << 8); |
| constexpr TimeDelta kTimeWrapPeriod = kBaseTimeTick * (1 << 24); |
| |
| // Message format |
| // |
| // 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| FMT=15 | PT=205 | length | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // 0 | SSRC of packet sender | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // 4 | SSRC of media source | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // 8 | base sequence number | packet status count | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // 12 | reference time | fb pkt. count | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // 16 | packet chunk | packet chunk | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // . . |
| // . . |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // | packet chunk | recv delta | recv delta | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // . . |
| // . . |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // | recv delta | recv delta | zero padding | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| } // namespace |
| constexpr uint8_t TransportFeedback::kFeedbackMessageType; |
| constexpr size_t TransportFeedback::kMaxReportedPackets; |
| |
| constexpr size_t TransportFeedback::LastChunk::kMaxRunLengthCapacity; |
| constexpr size_t TransportFeedback::LastChunk::kMaxOneBitCapacity; |
| constexpr size_t TransportFeedback::LastChunk::kMaxTwoBitCapacity; |
| constexpr size_t TransportFeedback::LastChunk::kMaxVectorCapacity; |
| |
| TransportFeedback::LastChunk::LastChunk() { |
| Clear(); |
| } |
| |
| bool TransportFeedback::LastChunk::Empty() const { |
| return size_ == 0; |
| } |
| |
| void TransportFeedback::LastChunk::Clear() { |
| size_ = 0; |
| all_same_ = true; |
| has_large_delta_ = false; |
| } |
| |
| bool TransportFeedback::LastChunk::CanAdd(DeltaSize delta_size) const { |
| RTC_DCHECK_LE(delta_size, 2); |
| if (size_ < kMaxTwoBitCapacity) |
| return true; |
| if (size_ < kMaxOneBitCapacity && !has_large_delta_ && delta_size != kLarge) |
| return true; |
| if (size_ < kMaxRunLengthCapacity && all_same_ && |
| delta_sizes_[0] == delta_size) |
| return true; |
| return false; |
| } |
| |
| void TransportFeedback::LastChunk::Add(DeltaSize delta_size) { |
| RTC_DCHECK(CanAdd(delta_size)); |
| if (size_ < kMaxVectorCapacity) |
| delta_sizes_[size_] = delta_size; |
| size_++; |
| all_same_ = all_same_ && delta_size == delta_sizes_[0]; |
| has_large_delta_ = has_large_delta_ || delta_size == kLarge; |
| } |
| |
| void TransportFeedback::LastChunk::AddMissingPackets(size_t num_missing) { |
| RTC_DCHECK_EQ(size_, 0); |
| RTC_DCHECK(all_same_); |
| RTC_DCHECK(!has_large_delta_); |
| RTC_DCHECK_LT(num_missing, kMaxRunLengthCapacity); |
| absl::c_fill(delta_sizes_, DeltaSize(0)); |
| size_ = num_missing; |
| } |
| |
| uint16_t TransportFeedback::LastChunk::Emit() { |
| RTC_DCHECK(!CanAdd(0) || !CanAdd(1) || !CanAdd(2)); |
| if (all_same_) { |
| uint16_t chunk = EncodeRunLength(); |
| Clear(); |
| return chunk; |
| } |
| if (size_ == kMaxOneBitCapacity) { |
| uint16_t chunk = EncodeOneBit(); |
| Clear(); |
| return chunk; |
| } |
| RTC_DCHECK_GE(size_, kMaxTwoBitCapacity); |
| uint16_t chunk = EncodeTwoBit(kMaxTwoBitCapacity); |
| // Remove `kMaxTwoBitCapacity` encoded delta sizes: |
| // Shift remaining delta sizes and recalculate all_same_ && has_large_delta_. |
| size_ -= kMaxTwoBitCapacity; |
| all_same_ = true; |
| has_large_delta_ = false; |
| for (size_t i = 0; i < size_; ++i) { |
| DeltaSize delta_size = delta_sizes_[kMaxTwoBitCapacity + i]; |
| delta_sizes_[i] = delta_size; |
| all_same_ = all_same_ && delta_size == delta_sizes_[0]; |
| has_large_delta_ = has_large_delta_ || delta_size == kLarge; |
| } |
| |
| return chunk; |
| } |
| |
| uint16_t TransportFeedback::LastChunk::EncodeLast() const { |
| RTC_DCHECK_GT(size_, 0); |
| if (all_same_) |
| return EncodeRunLength(); |
| if (size_ <= kMaxTwoBitCapacity) |
| return EncodeTwoBit(size_); |
| return EncodeOneBit(); |
| } |
| |
| // Appends content of the Lastchunk to `deltas`. |
| void TransportFeedback::LastChunk::AppendTo( |
| std::vector<DeltaSize>* deltas) const { |
| if (all_same_) { |
| deltas->insert(deltas->end(), size_, delta_sizes_[0]); |
| } else { |
| deltas->insert(deltas->end(), delta_sizes_.begin(), |
| delta_sizes_.begin() + size_); |
| } |
| } |
| |
| void TransportFeedback::LastChunk::Decode(uint16_t chunk, size_t max_size) { |
| if ((chunk & 0x8000) == 0) { |
| DecodeRunLength(chunk, max_size); |
| } else if ((chunk & 0x4000) == 0) { |
| DecodeOneBit(chunk, max_size); |
| } else { |
| DecodeTwoBit(chunk, max_size); |
| } |
| } |
| |
| // One Bit Status Vector Chunk |
| // |
| // 0 1 |
| // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // |T|S| symbol list | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // |
| // T = 1 |
| // S = 0 |
| // Symbol list = 14 entries where 0 = not received, 1 = received 1-byte delta. |
| uint16_t TransportFeedback::LastChunk::EncodeOneBit() const { |
| RTC_DCHECK(!has_large_delta_); |
| RTC_DCHECK_LE(size_, kMaxOneBitCapacity); |
| uint16_t chunk = 0x8000; |
| for (size_t i = 0; i < size_; ++i) |
| chunk |= delta_sizes_[i] << (kMaxOneBitCapacity - 1 - i); |
| return chunk; |
| } |
| |
| void TransportFeedback::LastChunk::DecodeOneBit(uint16_t chunk, |
| size_t max_size) { |
| RTC_DCHECK_EQ(chunk & 0xc000, 0x8000); |
| size_ = std::min(kMaxOneBitCapacity, max_size); |
| has_large_delta_ = false; |
| all_same_ = false; |
| for (size_t i = 0; i < size_; ++i) |
| delta_sizes_[i] = (chunk >> (kMaxOneBitCapacity - 1 - i)) & 0x01; |
| } |
| |
| // Two Bit Status Vector Chunk |
| // |
| // 0 1 |
| // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // |T|S| symbol list | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // |
| // T = 1 |
| // S = 1 |
| // symbol list = 7 entries of two bits each. |
| uint16_t TransportFeedback::LastChunk::EncodeTwoBit(size_t size) const { |
| RTC_DCHECK_LE(size, size_); |
| uint16_t chunk = 0xc000; |
| for (size_t i = 0; i < size; ++i) |
| chunk |= delta_sizes_[i] << 2 * (kMaxTwoBitCapacity - 1 - i); |
| return chunk; |
| } |
| |
| void TransportFeedback::LastChunk::DecodeTwoBit(uint16_t chunk, |
| size_t max_size) { |
| RTC_DCHECK_EQ(chunk & 0xc000, 0xc000); |
| size_ = std::min(kMaxTwoBitCapacity, max_size); |
| has_large_delta_ = true; |
| all_same_ = false; |
| for (size_t i = 0; i < size_; ++i) |
| delta_sizes_[i] = (chunk >> 2 * (kMaxTwoBitCapacity - 1 - i)) & 0x03; |
| } |
| |
| // Run Length Status Vector Chunk |
| // |
| // 0 1 |
| // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // |T| S | Run Length | |
| // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // |
| // T = 0 |
| // S = symbol |
| // Run Length = Unsigned integer denoting the run length of the symbol |
| uint16_t TransportFeedback::LastChunk::EncodeRunLength() const { |
| RTC_DCHECK(all_same_); |
| RTC_DCHECK_LE(size_, kMaxRunLengthCapacity); |
| return (delta_sizes_[0] << 13) | static_cast<uint16_t>(size_); |
| } |
| |
| void TransportFeedback::LastChunk::DecodeRunLength(uint16_t chunk, |
| size_t max_count) { |
| RTC_DCHECK_EQ(chunk & 0x8000, 0); |
| size_ = std::min<size_t>(chunk & 0x1fff, max_count); |
| DeltaSize delta_size = (chunk >> 13) & 0x03; |
| has_large_delta_ = delta_size >= kLarge; |
| all_same_ = true; |
| // To make it consistent with Add function, populate delta_sizes_ beyond 1st. |
| for (size_t i = 0; i < std::min<size_t>(size_, kMaxVectorCapacity); ++i) |
| delta_sizes_[i] = delta_size; |
| } |
| |
| TransportFeedback::TransportFeedback() |
| : TransportFeedback(/*include_timestamps=*/true, /*include_lost=*/true) {} |
| |
| TransportFeedback::TransportFeedback(bool include_timestamps, bool include_lost) |
| : include_lost_(include_lost), |
| base_seq_no_(0), |
| num_seq_no_(0), |
| base_time_ticks_(0), |
| feedback_seq_(0), |
| include_timestamps_(include_timestamps), |
| last_timestamp_(Timestamp::Zero()), |
| size_bytes_(kTransportFeedbackHeaderSizeBytes) {} |
| |
| TransportFeedback::TransportFeedback(const TransportFeedback&) = default; |
| |
| TransportFeedback::TransportFeedback(TransportFeedback&& other) |
| : include_lost_(other.include_lost_), |
| base_seq_no_(other.base_seq_no_), |
| num_seq_no_(other.num_seq_no_), |
| base_time_ticks_(other.base_time_ticks_), |
| feedback_seq_(other.feedback_seq_), |
| include_timestamps_(other.include_timestamps_), |
| last_timestamp_(other.last_timestamp_), |
| received_packets_(std::move(other.received_packets_)), |
| all_packets_(std::move(other.all_packets_)), |
| encoded_chunks_(std::move(other.encoded_chunks_)), |
| last_chunk_(other.last_chunk_), |
| size_bytes_(other.size_bytes_) { |
| other.Clear(); |
| } |
| |
| TransportFeedback::~TransportFeedback() {} |
| |
| void TransportFeedback::SetBase(uint16_t base_sequence, |
| Timestamp ref_timestamp) { |
| RTC_DCHECK_EQ(num_seq_no_, 0); |
| base_seq_no_ = base_sequence; |
| base_time_ticks_ = |
| (ref_timestamp.us() % kTimeWrapPeriod.us()) / kBaseTimeTick.us(); |
| last_timestamp_ = BaseTime(); |
| } |
| |
| void TransportFeedback::SetFeedbackSequenceNumber(uint8_t feedback_sequence) { |
| feedback_seq_ = feedback_sequence; |
| } |
| |
| bool TransportFeedback::AddReceivedPacket(uint16_t sequence_number, |
| Timestamp timestamp) { |
| // Set delta to zero if timestamps are not included, this will simplify the |
| // encoding process. |
| int16_t delta = 0; |
| if (include_timestamps_) { |
| // Convert to ticks and round. |
| if (last_timestamp_ > timestamp) { |
| timestamp += (last_timestamp_ - timestamp).RoundUpTo(kTimeWrapPeriod); |
| } |
| RTC_DCHECK_GE(timestamp, last_timestamp_); |
| int64_t delta_full = |
| (timestamp - last_timestamp_).us() % kTimeWrapPeriod.us(); |
| if (delta_full > kTimeWrapPeriod.us() / 2) { |
| delta_full -= kTimeWrapPeriod.us(); |
| delta_full -= kDeltaTick.us() / 2; |
| } else { |
| delta_full += kDeltaTick.us() / 2; |
| } |
| delta_full /= kDeltaTick.us(); |
| |
| delta = static_cast<int16_t>(delta_full); |
| // If larger than 16bit signed, we can't represent it - need new fb packet. |
| if (delta != delta_full) { |
| RTC_LOG(LS_WARNING) << "Delta value too large ( >= 2^16 ticks )"; |
| return false; |
| } |
| } |
| |
| uint16_t next_seq_no = base_seq_no_ + num_seq_no_; |
| if (sequence_number != next_seq_no) { |
| uint16_t last_seq_no = next_seq_no - 1; |
| if (!IsNewerSequenceNumber(sequence_number, last_seq_no)) |
| return false; |
| uint16_t num_missing_packets = sequence_number - next_seq_no; |
| if (!AddMissingPackets(num_missing_packets)) |
| return false; |
| if (include_lost_) { |
| for (; next_seq_no != sequence_number; ++next_seq_no) { |
| all_packets_.emplace_back(next_seq_no); |
| } |
| } |
| } |
| |
| DeltaSize delta_size = (delta >= 0 && delta <= 0xff) ? 1 : 2; |
| if (!AddDeltaSize(delta_size)) |
| return false; |
| |
| received_packets_.emplace_back(sequence_number, delta); |
| if (include_lost_) |
| all_packets_.emplace_back(sequence_number, delta); |
| last_timestamp_ += delta * kDeltaTick; |
| if (include_timestamps_) { |
| size_bytes_ += delta_size; |
| } |
| return true; |
| } |
| |
| const std::vector<TransportFeedback::ReceivedPacket>& |
| TransportFeedback::GetReceivedPackets() const { |
| return received_packets_; |
| } |
| |
| const std::vector<TransportFeedback::ReceivedPacket>& |
| TransportFeedback::GetAllPackets() const { |
| RTC_DCHECK(include_lost_); |
| return all_packets_; |
| } |
| |
| uint16_t TransportFeedback::GetBaseSequence() const { |
| return base_seq_no_; |
| } |
| |
| Timestamp TransportFeedback::BaseTime() const { |
| // Add an extra kTimeWrapPeriod to allow add received packets arrived earlier |
| // than the first added packet (and thus allow to record negative deltas) |
| // even when base_time_ticks_ == 0. |
| return Timestamp::Zero() + kTimeWrapPeriod + |
| int64_t{base_time_ticks_} * kBaseTimeTick; |
| } |
| |
| TimeDelta TransportFeedback::GetBaseDelta(Timestamp prev_timestamp) const { |
| TimeDelta delta = BaseTime() - prev_timestamp; |
| // Compensate for wrap around. |
| if ((delta - kTimeWrapPeriod).Abs() < delta.Abs()) { |
| delta -= kTimeWrapPeriod; // Wrap backwards. |
| } else if ((delta + kTimeWrapPeriod).Abs() < delta.Abs()) { |
| delta += kTimeWrapPeriod; // Wrap forwards. |
| } |
| return delta; |
| } |
| |
| // De-serialize packet. |
| bool TransportFeedback::Parse(const CommonHeader& packet) { |
| RTC_DCHECK_EQ(packet.type(), kPacketType); |
| RTC_DCHECK_EQ(packet.fmt(), kFeedbackMessageType); |
| TRACE_EVENT0("webrtc", "TransportFeedback::Parse"); |
| |
| if (packet.payload_size_bytes() < kMinPayloadSizeBytes) { |
| RTC_LOG(LS_WARNING) << "Buffer too small (" << packet.payload_size_bytes() |
| << " bytes) to fit a " |
| "FeedbackPacket. Minimum size = " |
| << kMinPayloadSizeBytes; |
| return false; |
| } |
| |
| const uint8_t* const payload = packet.payload(); |
| ParseCommonFeedback(payload); |
| |
| base_seq_no_ = ByteReader<uint16_t>::ReadBigEndian(&payload[8]); |
| uint16_t status_count = ByteReader<uint16_t>::ReadBigEndian(&payload[10]); |
| base_time_ticks_ = ByteReader<uint32_t, 3>::ReadBigEndian(&payload[12]); |
| feedback_seq_ = payload[15]; |
| Clear(); |
| size_t index = 16; |
| const size_t end_index = packet.payload_size_bytes(); |
| |
| if (status_count == 0) { |
| RTC_LOG(LS_WARNING) << "Empty feedback messages not allowed."; |
| return false; |
| } |
| |
| std::vector<uint8_t> delta_sizes; |
| delta_sizes.reserve(status_count); |
| while (delta_sizes.size() < status_count) { |
| if (index + kChunkSizeBytes > end_index) { |
| RTC_LOG(LS_WARNING) << "Buffer overflow while parsing packet."; |
| Clear(); |
| return false; |
| } |
| |
| uint16_t chunk = ByteReader<uint16_t>::ReadBigEndian(&payload[index]); |
| index += kChunkSizeBytes; |
| encoded_chunks_.push_back(chunk); |
| last_chunk_.Decode(chunk, status_count - delta_sizes.size()); |
| last_chunk_.AppendTo(&delta_sizes); |
| } |
| // Last chunk is stored in the `last_chunk_`. |
| encoded_chunks_.pop_back(); |
| RTC_DCHECK_EQ(delta_sizes.size(), status_count); |
| num_seq_no_ = status_count; |
| |
| uint16_t seq_no = base_seq_no_; |
| size_t recv_delta_size = absl::c_accumulate(delta_sizes, 0); |
| |
| // Determine if timestamps, that is, recv_delta are included in the packet. |
| if (end_index >= index + recv_delta_size) { |
| for (size_t delta_size : delta_sizes) { |
| RTC_DCHECK_LE(index + delta_size, end_index); |
| switch (delta_size) { |
| case 0: |
| if (include_lost_) |
| all_packets_.emplace_back(seq_no); |
| break; |
| case 1: { |
| int16_t delta = payload[index]; |
| received_packets_.emplace_back(seq_no, delta); |
| if (include_lost_) |
| all_packets_.emplace_back(seq_no, delta); |
| last_timestamp_ += delta * kDeltaTick; |
| index += delta_size; |
| break; |
| } |
| case 2: { |
| int16_t delta = ByteReader<int16_t>::ReadBigEndian(&payload[index]); |
| received_packets_.emplace_back(seq_no, delta); |
| if (include_lost_) |
| all_packets_.emplace_back(seq_no, delta); |
| last_timestamp_ += delta * kDeltaTick; |
| index += delta_size; |
| break; |
| } |
| case 3: |
| Clear(); |
| RTC_LOG(LS_WARNING) << "Invalid delta_size for seq_no " << seq_no; |
| |
| return false; |
| default: |
| RTC_DCHECK_NOTREACHED(); |
| break; |
| } |
| ++seq_no; |
| } |
| } else { |
| // The packet does not contain receive deltas. |
| include_timestamps_ = false; |
| for (size_t delta_size : delta_sizes) { |
| // Use delta sizes to detect if packet was received. |
| if (delta_size > 0) { |
| received_packets_.emplace_back(seq_no, 0); |
| } |
| if (include_lost_) { |
| if (delta_size > 0) { |
| all_packets_.emplace_back(seq_no, 0); |
| } else { |
| all_packets_.emplace_back(seq_no); |
| } |
| } |
| ++seq_no; |
| } |
| } |
| size_bytes_ = RtcpPacket::kHeaderLength + index; |
| RTC_DCHECK_LE(index, end_index); |
| return true; |
| } |
| |
| std::unique_ptr<TransportFeedback> TransportFeedback::ParseFrom( |
| const uint8_t* buffer, |
| size_t length) { |
| CommonHeader header; |
| if (!header.Parse(buffer, length)) |
| return nullptr; |
| if (header.type() != kPacketType || header.fmt() != kFeedbackMessageType) |
| return nullptr; |
| std::unique_ptr<TransportFeedback> parsed(new TransportFeedback); |
| if (!parsed->Parse(header)) |
| return nullptr; |
| return parsed; |
| } |
| |
| bool TransportFeedback::IsConsistent() const { |
| size_t packet_size = kTransportFeedbackHeaderSizeBytes; |
| std::vector<DeltaSize> delta_sizes; |
| LastChunk chunk_decoder; |
| for (uint16_t chunk : encoded_chunks_) { |
| chunk_decoder.Decode(chunk, kMaxReportedPackets); |
| chunk_decoder.AppendTo(&delta_sizes); |
| packet_size += kChunkSizeBytes; |
| } |
| if (!last_chunk_.Empty()) { |
| last_chunk_.AppendTo(&delta_sizes); |
| packet_size += kChunkSizeBytes; |
| } |
| if (num_seq_no_ != delta_sizes.size()) { |
| RTC_LOG(LS_ERROR) << delta_sizes.size() << " packets encoded. Expected " |
| << num_seq_no_; |
| return false; |
| } |
| Timestamp timestamp = BaseTime(); |
| auto packet_it = received_packets_.begin(); |
| uint16_t seq_no = base_seq_no_; |
| for (DeltaSize delta_size : delta_sizes) { |
| if (delta_size > 0) { |
| if (packet_it == received_packets_.end()) { |
| RTC_LOG(LS_ERROR) << "Failed to find delta for seq_no " << seq_no; |
| return false; |
| } |
| if (packet_it->sequence_number() != seq_no) { |
| RTC_LOG(LS_ERROR) << "Expected to find delta for seq_no " << seq_no |
| << ". Next delta is for " |
| << packet_it->sequence_number(); |
| return false; |
| } |
| if (delta_size == 1 && |
| (packet_it->delta_ticks() < 0 || packet_it->delta_ticks() > 0xff)) { |
| RTC_LOG(LS_ERROR) << "Delta " << packet_it->delta_ticks() |
| << " for seq_no " << seq_no |
| << " doesn't fit into one byte"; |
| return false; |
| } |
| timestamp += packet_it->delta(); |
| ++packet_it; |
| } |
| if (include_timestamps_) { |
| packet_size += delta_size; |
| } |
| ++seq_no; |
| } |
| if (packet_it != received_packets_.end()) { |
| RTC_LOG(LS_ERROR) << "Unencoded delta for seq_no " |
| << packet_it->sequence_number(); |
| return false; |
| } |
| if (timestamp != last_timestamp_) { |
| RTC_LOG(LS_ERROR) << "Last timestamp mismatch. Calculated: " |
| << ToLogString(timestamp) |
| << ". Saved: " << ToLogString(last_timestamp_); |
| return false; |
| } |
| if (size_bytes_ != packet_size) { |
| RTC_LOG(LS_ERROR) << "Rtcp packet size mismatch. Calculated: " |
| << packet_size << ". Saved: " << size_bytes_; |
| return false; |
| } |
| return true; |
| } |
| |
| size_t TransportFeedback::BlockLength() const { |
| // Round size_bytes_ up to multiple of 32bits. |
| return (size_bytes_ + 3) & (~static_cast<size_t>(3)); |
| } |
| |
| size_t TransportFeedback::PaddingLength() const { |
| return BlockLength() - size_bytes_; |
| } |
| |
| // Serialize packet. |
| bool TransportFeedback::Create(uint8_t* packet, |
| size_t* position, |
| size_t max_length, |
| PacketReadyCallback callback) const { |
| if (num_seq_no_ == 0) |
| return false; |
| |
| while (*position + BlockLength() > max_length) { |
| if (!OnBufferFull(packet, position, callback)) |
| return false; |
| } |
| const size_t position_end = *position + BlockLength(); |
| const size_t padding_length = PaddingLength(); |
| bool has_padding = padding_length > 0; |
| CreateHeader(kFeedbackMessageType, kPacketType, HeaderLength(), has_padding, |
| packet, position); |
| CreateCommonFeedback(packet + *position); |
| *position += kCommonFeedbackLength; |
| |
| ByteWriter<uint16_t>::WriteBigEndian(&packet[*position], base_seq_no_); |
| *position += 2; |
| |
| ByteWriter<uint16_t>::WriteBigEndian(&packet[*position], num_seq_no_); |
| *position += 2; |
| |
| ByteWriter<uint32_t, 3>::WriteBigEndian(&packet[*position], base_time_ticks_); |
| *position += 3; |
| |
| packet[(*position)++] = feedback_seq_; |
| |
| for (uint16_t chunk : encoded_chunks_) { |
| ByteWriter<uint16_t>::WriteBigEndian(&packet[*position], chunk); |
| *position += 2; |
| } |
| if (!last_chunk_.Empty()) { |
| uint16_t chunk = last_chunk_.EncodeLast(); |
| ByteWriter<uint16_t>::WriteBigEndian(&packet[*position], chunk); |
| *position += 2; |
| } |
| |
| if (include_timestamps_) { |
| for (const auto& received_packet : received_packets_) { |
| int16_t delta = received_packet.delta_ticks(); |
| if (delta >= 0 && delta <= 0xFF) { |
| packet[(*position)++] = delta; |
| } else { |
| ByteWriter<int16_t>::WriteBigEndian(&packet[*position], delta); |
| *position += 2; |
| } |
| } |
| } |
| |
| if (padding_length > 0) { |
| for (size_t i = 0; i < padding_length - 1; ++i) { |
| packet[(*position)++] = 0; |
| } |
| packet[(*position)++] = padding_length; |
| } |
| RTC_DCHECK_EQ(*position, position_end); |
| return true; |
| } |
| |
| void TransportFeedback::Clear() { |
| num_seq_no_ = 0; |
| last_timestamp_ = BaseTime(); |
| received_packets_.clear(); |
| all_packets_.clear(); |
| encoded_chunks_.clear(); |
| last_chunk_.Clear(); |
| size_bytes_ = kTransportFeedbackHeaderSizeBytes; |
| } |
| |
| bool TransportFeedback::AddDeltaSize(DeltaSize delta_size) { |
| if (num_seq_no_ == kMaxReportedPackets) |
| return false; |
| size_t add_chunk_size = last_chunk_.Empty() ? kChunkSizeBytes : 0; |
| if (size_bytes_ + delta_size + add_chunk_size > kMaxSizeBytes) |
| return false; |
| |
| if (last_chunk_.CanAdd(delta_size)) { |
| size_bytes_ += add_chunk_size; |
| last_chunk_.Add(delta_size); |
| ++num_seq_no_; |
| return true; |
| } |
| if (size_bytes_ + delta_size + kChunkSizeBytes > kMaxSizeBytes) |
| return false; |
| |
| encoded_chunks_.push_back(last_chunk_.Emit()); |
| size_bytes_ += kChunkSizeBytes; |
| last_chunk_.Add(delta_size); |
| ++num_seq_no_; |
| return true; |
| } |
| |
| bool TransportFeedback::AddMissingPackets(size_t num_missing_packets) { |
| size_t new_num_seq_no = num_seq_no_ + num_missing_packets; |
| if (new_num_seq_no > kMaxReportedPackets) { |
| return false; |
| } |
| |
| if (!last_chunk_.Empty()) { |
| while (num_missing_packets > 0 && last_chunk_.CanAdd(0)) { |
| last_chunk_.Add(0); |
| --num_missing_packets; |
| } |
| if (num_missing_packets == 0) { |
| num_seq_no_ = new_num_seq_no; |
| return true; |
| } |
| encoded_chunks_.push_back(last_chunk_.Emit()); |
| } |
| RTC_DCHECK(last_chunk_.Empty()); |
| size_t full_chunks = num_missing_packets / LastChunk::kMaxRunLengthCapacity; |
| size_t partial_chunk = num_missing_packets % LastChunk::kMaxRunLengthCapacity; |
| size_t num_chunks = full_chunks + (partial_chunk > 0 ? 1 : 0); |
| if (size_bytes_ + kChunkSizeBytes * num_chunks > kMaxSizeBytes) { |
| num_seq_no_ = (new_num_seq_no - num_missing_packets); |
| return false; |
| } |
| size_bytes_ += kChunkSizeBytes * num_chunks; |
| // T = 0, S = 0, run length = kMaxRunLengthCapacity, see EncodeRunLength(). |
| encoded_chunks_.insert(encoded_chunks_.end(), full_chunks, |
| LastChunk::kMaxRunLengthCapacity); |
| last_chunk_.AddMissingPackets(partial_chunk); |
| num_seq_no_ = new_num_seq_no; |
| return true; |
| } |
| } // namespace rtcp |
| } // namespace webrtc |