Add rtcp::TransportFeedback::GetReceivedPackets()

webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc

 /*
  *  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.
  */
 
@@ skipping 348 matching lines @@
   DeltaSize delta_size = (delta >= 0 && delta <= 0xff) ? 1 : 2;
   if (!AddDeltaSize(delta_size))
     return false;
 
   packets_.emplace_back(sequence_number, delta);
   last_timestamp_us_ += delta * kDeltaScaleFactor;
   size_bytes_ += delta_size;
   return true;
 }
 
+const std::vector<TransportFeedback::ReceivedPacket>&
+TransportFeedback::GetReceivedPackets() const {
+  return packets_;
+}
+
 uint16_t TransportFeedback::GetBaseSequence() const {
   return base_seq_no_;
 }
 
 std::vector<TransportFeedback::StatusSymbol>
 TransportFeedback::GetStatusVector() const {
   std::vector<TransportFeedback::StatusSymbol> symbols;
   uint16_t seq_no = GetBaseSequence();
   for (const auto& packet : packets_) {
-    for (; seq_no != packet.sequence_number; ++seq_no)
+    for (; seq_no != packet.sequence_number(); ++seq_no)
       symbols.push_back(StatusSymbol::kNotReceived);
-    if (packet.delta_ticks >= 0x00 && packet.delta_ticks <= 0xff) {
+    if (packet.delta_ticks() >= 0x00 && packet.delta_ticks() <= 0xff) {
       symbols.push_back(StatusSymbol::kReceivedSmallDelta);
     } else {
       symbols.push_back(StatusSymbol::kReceivedLargeDelta);
     }
     ++seq_no;
   }
   return symbols;
 }
 
 std::vector<int16_t> TransportFeedback::GetReceiveDeltas() const {
   std::vector<int16_t> deltas;
   for (const auto& packet : packets_)
-    deltas.push_back(packet.delta_ticks);
+    deltas.push_back(packet.delta_ticks());
   return deltas;
 }
 
 int64_t TransportFeedback::GetBaseTimeUs() const {
   return static_cast<int64_t>(base_time_ticks_) * kBaseScaleFactor;
 }
 
 std::vector<int64_t> TransportFeedback::GetReceiveDeltasUs() const {
   std::vector<int64_t> us_deltas;
   for (const auto& packet : packets_)
-    us_deltas.push_back(packet.delta_ticks * kDeltaScaleFactor);
+    us_deltas.push_back(packet.delta_us());
   return us_deltas;
 }
 
 // De-serialize packet.
 bool TransportFeedback::Parse(const CommonHeader& packet) {
   RTC_DCHECK_EQ(packet.type(), kPacketType);
   RTC_DCHECK_EQ(packet.fmt(), kFeedbackMessageType);
 
   if (packet.payload_size_bytes() < kMinPayloadSizeBytes) {
     LOG(LS_WARNING) << "Buffer too small (" << packet.payload_size_bytes()
@@ skipping 112 matching lines @@
   }
   int64_t timestamp_us = base_time_ticks_ * kBaseScaleFactor;
   auto packet_it = packets_.begin();
   uint16_t seq_no = base_seq_no_;
   for (DeltaSize delta_size : delta_sizes) {
     if (delta_size > 0) {
       if (packet_it == packets_.end()) {
         LOG(LS_ERROR) << "Failed to find delta for seq_no " << seq_no;
         return false;
       }
-      if (packet_it->sequence_number != seq_no) {
+      if (packet_it->sequence_number() != seq_no) {
         LOG(LS_ERROR) << "Expected to find delta for seq_no " << seq_no
-                      << ". Next delta is for " << packet_it->sequence_number;
+                      << ". Next delta is for " << packet_it->sequence_number();
         return false;
       }
       if (delta_size == 1 &&
-          (packet_it->delta_ticks < 0 || packet_it->delta_ticks > 0xff)) {
-        LOG(LS_ERROR) << "Delta " << packet_it->delta_ticks << " for seq_no "
+          (packet_it->delta_ticks() < 0 || packet_it->delta_ticks() > 0xff)) {
+        LOG(LS_ERROR) << "Delta " << packet_it->delta_ticks() << " for seq_no "
                       << seq_no << " doesn't fit into one byte";
         return false;
       }
-      timestamp_us += packet_it->delta_ticks * kDeltaScaleFactor;
+      timestamp_us += packet_it->delta_us();
       ++packet_it;
     }
     packet_size += delta_size;
     ++seq_no;
   }
   if (packet_it != packets_.end()) {
     LOG(LS_ERROR) << "Unencoded delta for seq_no "
-                  << packet_it->sequence_number;
+                  << packet_it->sequence_number();
     return false;
   }
   if (timestamp_us != last_timestamp_us_) {
     LOG(LS_ERROR) << "Last timestamp mismatch. Calculated: " << timestamp_us
                   << ". Saved: " << last_timestamp_us_;
     return false;
   }
   if (size_bytes_ != packet_size) {
     LOG(LS_ERROR) << "Rtcp packet size mismatch. Calculated: " << packet_size
                   << ". Saved: " << size_bytes_;
@@ skipping 36 matching lines @@
     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;
   }
 
   for (const auto& received_packet : packets_) {
-    int16_t delta = received_packet.delta_ticks;
+    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;
     }
   }
 
   while ((*position % 4) != 0)
     packet[(*position)++] = 0;
@@ skipping 34 matching lines @@
 
   encoded_chunks_.push_back(last_chunk_->Emit());
   size_bytes_ += kChunkSizeBytes;
   last_chunk_->Add(delta_size);
   ++num_seq_no_;
   return true;
 }
 
 }  // namespace rtcp
 }  // namespace webrtc