Use RtcpPacket classes for SenderReport/ReceiveReport in RTCPSender

webrtc/modules/rtp_rtcp/source/rtcp_sender.cc

 /*
  *  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.
  */
 
@@ skipping 95 matching lines @@
   bool repeat;
   uint64_t picture_id;
   uint8_t* buffer;
   uint32_t buffer_size;
   uint32_t ntp_sec;
   uint32_t ntp_frac;
   uint32_t jitter_transmission_offset;
   uint32_t position;
 };
 
+// TODO(sprang): Once all builders use RtcpPacket, call SendToNetwork() here.
+class RTCPSender::PacketBuiltCallback
+    : public rtcp::RtcpPacket::PacketReadyCallback {
+ public:
+  PacketBuiltCallback(RtcpContext* context) : context_(context) {}
+  virtual ~PacketBuiltCallback() {}
+  void OnPacketReady(uint8_t* data, size_t length) override {
+    context_->position += length;
+  }
+
+ private:
+  RtcpContext* const context_;
+};
+
 RTCPSender::RTCPSender(
     int32_t id,
     bool audio,
     Clock* clock,
     ReceiveStatistics* receive_statistics,
     RtcpPacketTypeCounterObserver* packet_type_counter_observer)
     : id_(id),
       audio_(audio),
       clock_(clock),
       method_(kRtcpOff),
@@ skipping 17 matching lines @@
 
       sequence_number_fir_(0),
 
       remb_bitrate_(0),
 
       tmmbr_help_(),
       tmmbr_send_(0),
       packet_oh_send_(0),
 
       app_sub_type_(0),
+      app_name_(0),
       app_data_(nullptr),
       app_length_(0),
 
       xr_send_receiver_reference_time_enabled_(false),
       packet_type_counter_observer_(packet_type_counter_observer) {
   memset(cname_, 0, sizeof(cname_));
   memset(last_send_report_, 0, sizeof(last_send_report_));
   memset(last_rtcp_time_, 0, sizeof(last_rtcp_time_));
 
   builders_[kRtcpSr] = &RTCPSender::BuildSR;
@@ skipping 11 matching lines @@
   builders_[kRtcpTmmbr] = &RTCPSender::BuildTMMBR;
   builders_[kRtcpTmmbn] = &RTCPSender::BuildTMMBN;
   builders_[kRtcpNack] = &RTCPSender::BuildNACK;
   builders_[kRtcpXrVoipMetric] = &RTCPSender::BuildVoIPMetric;
   builders_[kRtcpXrReceiverReferenceTime] =
       &RTCPSender::BuildReceiverReferenceTime;
   builders_[kRtcpXrDlrrReportBlock] = &RTCPSender::BuildDlrr;
 }
 
 RTCPSender::~RTCPSender() {
-  for (auto it : internal_report_blocks_)
-    delete it.second;
-
   for (auto it : csrc_cnames_)
     delete it.second;
 }
 
 int32_t RTCPSender::RegisterSendTransport(Transport* outgoingTransport) {
   CriticalSectionScoped lock(critical_section_transport_.get());
   cbTransport_ = outgoingTransport;
   return 0;
 }
 
@@ skipping 261 matching lines @@
     return false;
   }
   std::map<uint32_t, int64_t>::const_iterator it = last_xr_rr_.find(mid_ntp);
   if (it == last_xr_rr_.end()) {
     return false;
   }
   *time_ms = it->second;
   return true;
 }
 
-int32_t RTCPSender::AddReportBlock(
-    uint32_t SSRC,
-    std::map<uint32_t, RTCPReportBlock*>* report_blocks,
-    const RTCPReportBlock* reportBlock) {
-  assert(reportBlock);
-
-  if (report_blocks->size() >= RTCP_MAX_REPORT_BLOCKS) {
+int32_t RTCPSender::AddReportBlock(const RTCPReportBlock& report_block) {
+  if (report_blocks_.size() >= RTCP_MAX_REPORT_BLOCKS) {
     LOG(LS_WARNING) << "Too many report blocks.";
     return -1;
   }
-  std::map<uint32_t, RTCPReportBlock*>::iterator it =
-      report_blocks->find(SSRC);
-  if (it != report_blocks->end()) {
-    delete it->second;
-    report_blocks->erase(it);
-  }
-  RTCPReportBlock* copyReportBlock = new RTCPReportBlock();
-  memcpy(copyReportBlock, reportBlock, sizeof(RTCPReportBlock));
-  (*report_blocks)[SSRC] = copyReportBlock;
+  rtcp::ReportBlock* block = &report_blocks_[report_block.remoteSSRC];
+  block->To(report_block.remoteSSRC);
+  block->WithFractionLost(report_block.fractionLost);
+  block->WithCumulativeLost(report_block.cumulativeLost);
+  block->WithExtHighestSeqNum(report_block.extendedHighSeqNum);
+  block->WithJitter(report_block.jitter);
+  block->WithLastSr(report_block.lastSR);
+  block->WithDelayLastSr(report_block.delaySinceLastSR);
+
   return 0;
 }
 
 RTCPSender::BuildResult RTCPSender::BuildSR(RtcpContext* ctx) {
-  // sanity
-  if (ctx->position + 52 >= IP_PACKET_SIZE) {
-    LOG(LS_WARNING) << "Failed to build Sender Report.";
-    return BuildResult::kTruncated;
-  }
-  uint32_t RTPtime;
-
-  uint32_t posNumberOfReportBlocks = ctx->position;
-  *ctx->AllocateData(1) = 0x80;
-
-  // Sender report
-  *ctx->AllocateData(1) = 200;
-
   for (int i = (RTCP_NUMBER_OF_SR - 2); i >= 0; i--) {
     // shift old
     last_send_report_[i + 1] = last_send_report_[i];
     last_rtcp_time_[i + 1] = last_rtcp_time_[i];
   }
 
   last_rtcp_time_[0] = Clock::NtpToMs(ctx->ntp_sec, ctx->ntp_frac);
   last_send_report_[0] = (ctx->ntp_sec << 16) + (ctx->ntp_frac >> 16);
 
   // The timestamp of this RTCP packet should be estimated as the timestamp of
   // the frame being captured at this moment. We are calculating that
   // timestamp as the last frame's timestamp + the time since the last frame
   // was captured.
-  RTPtime = start_timestamp_ + last_rtp_timestamp_ +
-            (clock_->TimeInMilliseconds() - last_frame_capture_time_ms_) *
-                (ctx->feedback_state.frequency_hz / 1000);
+  uint32_t rtp_timestamp =
+      start_timestamp_ + last_rtp_timestamp_ +
+      (clock_->TimeInMilliseconds() - last_frame_capture_time_ms_) *
+          (ctx->feedback_state.frequency_hz / 1000);
 
-  // Add sender data
-  // Save  for our length field
-  ctx->AllocateData(2);
+  rtcp::SenderReport report;
+  report.From(ssrc_);
+  report.WithNtpSec(ctx->ntp_sec);
+  report.WithNtpFrac(ctx->ntp_frac);
+  report.WithRtpTimestamp(rtp_timestamp);
+  report.WithPacketCount(ctx->feedback_state.packets_sent);
+  report.WithOctetCount(ctx->feedback_state.media_bytes_sent);
 
-  // Add our own SSRC
-  ByteWriter<uint32_t>::WriteBigEndian(ctx->AllocateData(4), ssrc_);
-  // NTP
-  ByteWriter<uint32_t>::WriteBigEndian(ctx->AllocateData(4), ctx->ntp_sec);
-  ByteWriter<uint32_t>::WriteBigEndian(ctx->AllocateData(4), ctx->ntp_frac);
-  ByteWriter<uint32_t>::WriteBigEndian(ctx->AllocateData(4), RTPtime);
+  for (auto it : report_blocks_)
+    report.WithReportBlock(it.second);
 
-  // sender's packet count
-  ByteWriter<uint32_t>::WriteBigEndian(ctx->AllocateData(4),
-                                       ctx->feedback_state.packets_sent);
-
-  // sender's octet count
-  ByteWriter<uint32_t>::WriteBigEndian(ctx->AllocateData(4),
-                                       ctx->feedback_state.media_bytes_sent);
-
-  uint8_t numberOfReportBlocks = 0;
-  BuildResult result = WriteAllReportBlocksToBuffer(ctx, &numberOfReportBlocks);
-  switch (result) {
-    case BuildResult::kError:
-    case BuildResult::kTruncated:
-    case BuildResult::kAborted:
-      return result;
-    case BuildResult::kSuccess:
-      break;
-    default:
-      abort();
+  PacketBuiltCallback callback(ctx);
+  if (!report.BuildExternalBuffer(&ctx->buffer[ctx->position],
+                                  ctx->buffer_size - ctx->position,
+                                  &callback)) {
+    return BuildResult::kTruncated;
   }
 
-  ctx->buffer[posNumberOfReportBlocks] += numberOfReportBlocks;
-
-  uint16_t len = static_cast<uint16_t>((ctx->position / 4) - 1);
-  ByteWriter<uint16_t>::WriteBigEndian(&ctx->buffer[2], len);
-
+  report_blocks_.clear();
   return BuildResult::kSuccess;
 }
 
 RTCPSender::BuildResult RTCPSender::BuildSDEC(RtcpContext* ctx) {
   size_t lengthCname = strlen(cname_);
   assert(lengthCname < RTCP_CNAME_SIZE);
 
   // sanity
   if (ctx->position + 12 + lengthCname >= IP_PACKET_SIZE) {
     LOG(LS_WARNING) << "Failed to build SDEC.";
@@ skipping 61 matching lines @@
     SDESLength += padding;
   }
   // in 32-bit words minus one and we don't count the header
   uint16_t buffer_length = (SDESLength / 4) - 1;
   ByteWriter<uint16_t>::WriteBigEndian(&ctx->buffer[SDESLengthPos],
                                        buffer_length);
   return BuildResult::kSuccess;
 }
 
 RTCPSender::BuildResult RTCPSender::BuildRR(RtcpContext* ctx) {
-  // sanity one block
-  if (ctx->position + 32 >= IP_PACKET_SIZE)
+  rtcp::ReceiverReport report;
+  report.From(ssrc_);
+  for (auto it : report_blocks_)
+    report.WithReportBlock(it.second);
+
+  PacketBuiltCallback callback(ctx);
+  if (!report.BuildExternalBuffer(&ctx->buffer[ctx->position],
+                                  ctx->buffer_size - ctx->position,
+                                  &callback)) {
     return BuildResult::kTruncated;
-
-  uint32_t posNumberOfReportBlocks = ctx->position;
-
-  *ctx->AllocateData(1) = 0x80;
-  *ctx->AllocateData(1) = 201;
-
-  // Save  for our length field
-  uint32_t len_pos = ctx->position;
-  ctx->AllocateData(2);
-
-  // Add our own SSRC
-  ByteWriter<uint32_t>::WriteBigEndian(ctx->AllocateData(4), ssrc_);
-
-  uint8_t numberOfReportBlocks = 0;
-  BuildResult result = WriteAllReportBlocksToBuffer(ctx, &numberOfReportBlocks);
-  switch (result) {
-    case BuildResult::kError:
-    case BuildResult::kTruncated:
-    case BuildResult::kAborted:
-      return result;
-    case BuildResult::kSuccess:
-      break;
-    default:
-      abort();
   }
 
-  ctx->buffer[posNumberOfReportBlocks] += numberOfReportBlocks;
-
-  uint16_t len = uint16_t((ctx->position) / 4 - 1);
-  ByteWriter<uint16_t>::WriteBigEndian(&ctx->buffer[len_pos], len);
+  report_blocks_.clear();
 
   return BuildResult::kSuccess;
 }
 
 // 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            |
 //       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ skipping 802 matching lines @@
         minIntervalMs = RTCP_INTERVAL_VIDEO_MS;
       timeToNext = (minIntervalMs / 2) + (minIntervalMs * random / 1000);
     }
     next_time_to_send_rtcp_ = clock_->TimeInMilliseconds() + timeToNext;
 
     StatisticianMap statisticians =
         receive_statistics_->GetActiveStatisticians();
     if (!statisticians.empty()) {
       for (auto it = statisticians.begin(); it != statisticians.end(); ++it) {
         RTCPReportBlock report_block;
-        if (PrepareReport(feedback_state, it->second, &report_block,
-                          &context.ntp_sec, &context.ntp_frac)) {
-          AddReportBlock(it->first, &internal_report_blocks_, &report_block);
+        if (PrepareReport(feedback_state, it->first, it->second,
+                          &report_block)) {
+          AddReportBlock(report_block);
         }
       }
       if (extended_jitter_report_enabled_)
         SetFlag(kRtcpTransmissionTimeOffset, true);
     }
   }
 
   auto it = report_flags_.begin();
   while (it != report_flags_.end()) {
     auto builder = builders_.find(it->type);
@@ skipping 25 matching lines @@
     packet_type_counter_observer_->RtcpPacketTypesCounterUpdated(
         remote_ssrc_, packet_type_counter_);
   }
 
   DCHECK(AllVolatileFlagsConsumed());
 
   return context.position;
 }
 
 bool RTCPSender::PrepareReport(const FeedbackState& feedback_state,
+                               uint32_t ssrc,
                                StreamStatistician* statistician,
-                               RTCPReportBlock* report_block,
-                               uint32_t* ntp_secs, uint32_t* ntp_frac) {
+                               RTCPReportBlock* report_block) {
   // Do we have receive statistics to send?
   RtcpStatistics stats;
   if (!statistician->GetStatistics(&stats, true))
     return false;
   report_block->fractionLost = stats.fraction_lost;
   report_block->cumulativeLost = stats.cumulative_lost;
   report_block->extendedHighSeqNum =
       stats.extended_max_sequence_number;
   report_block->jitter = stats.jitter;
+  report_block->remoteSSRC = ssrc;
 
-  // get our NTP as late as possible to avoid a race
-  clock_->CurrentNtp(*ntp_secs, *ntp_frac);
+  // TODO(sprang): Do we really need separate time stamps for each report?
+  // Get our NTP as late as possible to avoid a race.
+  uint32_t ntp_secs;
+  uint32_t ntp_frac;
+  clock_->CurrentNtp(ntp_secs, ntp_frac);
 
-  // Delay since last received report
+  // Delay since last received report.
   uint32_t delaySinceLastReceivedSR = 0;
   if ((feedback_state.last_rr_ntp_secs != 0) ||
       (feedback_state.last_rr_ntp_frac != 0)) {
-    // get the 16 lowest bits of seconds and the 16 higest bits of fractions
-    uint32_t now = *ntp_secs & 0x0000FFFF;
+    // Get the 16 lowest bits of seconds and the 16 highest bits of fractions.
+    uint32_t now = ntp_secs & 0x0000FFFF;
     now <<= 16;
-    now += (*ntp_frac & 0xffff0000) >> 16;
+    now += (ntp_frac & 0xffff0000) >> 16;
 
     uint32_t receiveTime = feedback_state.last_rr_ntp_secs & 0x0000FFFF;
     receiveTime <<= 16;
     receiveTime += (feedback_state.last_rr_ntp_frac & 0xffff0000) >> 16;
 
     delaySinceLastReceivedSR = now-receiveTime;
   }
   report_block->delaySinceLastSR = delaySinceLastReceivedSR;
   report_block->lastSR = feedback_state.remote_sr;
   return true;
@@ skipping 44 matching lines @@
 void RTCPSender::SendRtcpXrReceiverReferenceTime(bool enable) {
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
   xr_send_receiver_reference_time_enabled_ = enable;
 }
 
 bool RTCPSender::RtcpXrReceiverReferenceTime() const {
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
   return xr_send_receiver_reference_time_enabled_;
 }
 
-// called under critsect critical_section_rtcp_sender_
-RTCPSender::BuildResult RTCPSender::WriteAllReportBlocksToBuffer(
-    RtcpContext* ctx,
-    uint8_t* numberOfReportBlocks) {
-  *numberOfReportBlocks = internal_report_blocks_.size();
-  if ((ctx->position + *numberOfReportBlocks * 24) >= IP_PACKET_SIZE) {
-    LOG(LS_WARNING) << "Can't fit all report blocks.";
-    return BuildResult::kError;
-  }
-  WriteReportBlocksToBuffer(ctx, internal_report_blocks_);
-  while (!internal_report_blocks_.empty()) {
-    delete internal_report_blocks_.begin()->second;
-    internal_report_blocks_.erase(internal_report_blocks_.begin());
-  }
-  return BuildResult::kSuccess;
-}
-
-void RTCPSender::WriteReportBlocksToBuffer(
-    RtcpContext* ctx,
-    const std::map<uint32_t, RTCPReportBlock*>& report_blocks) {
-  std::map<uint32_t, RTCPReportBlock*>::const_iterator it =
-      report_blocks.begin();
-  for (; it != report_blocks.end(); it++) {
-    uint32_t remoteSSRC = it->first;
-    RTCPReportBlock* reportBlock = it->second;
-    if (reportBlock) {
-      // Remote SSRC
-      ByteWriter<uint32_t>::WriteBigEndian(ctx->AllocateData(4), remoteSSRC);
-
-      // fraction lost
-      *ctx->AllocateData(1) = reportBlock->fractionLost;
-
-      // cumulative loss
-      ByteWriter<uint32_t, 3>::WriteBigEndian(ctx->AllocateData(3),
-                                              reportBlock->cumulativeLost);
-
-      // extended highest seq_no, contain the highest sequence number received
-      ByteWriter<uint32_t>::WriteBigEndian(ctx->AllocateData(4),
-                                           reportBlock->extendedHighSeqNum);
-
-      // Jitter
-      ByteWriter<uint32_t>::WriteBigEndian(ctx->AllocateData(4),
-                                           reportBlock->jitter);
-
-      ByteWriter<uint32_t>::WriteBigEndian(ctx->AllocateData(4),
-                                           reportBlock->lastSR);
-
-      ByteWriter<uint32_t>::WriteBigEndian(ctx->AllocateData(4),
-                                           reportBlock->delaySinceLastSR);
-    }
-  }
-}
-
 // no callbacks allowed inside this function
 int32_t RTCPSender::SetTMMBN(const TMMBRSet* boundingSet,
                              uint32_t maxBitrateKbit) {
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
 
   if (0 == tmmbr_help_.SetTMMBRBoundingSetToSend(boundingSet, maxBitrateKbit)) {
     SetFlag(kRtcpTmmbn, true);
     return 0;
   }
   return -1;
@@ skipping 24 matching lines @@
 
 bool RTCPSender::AllVolatileFlagsConsumed() const {
   for (const ReportFlag& flag : report_flags_) {
     if (flag.is_volatile)
       return false;
   }
   return true;
 }
 
 }  // namespace webrtc