Use RtcpPacket to send PLI 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 102 matching lines @@
 
 // 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;
   }
+  bool BuildPacket(const rtcp::RtcpPacket& packet) {
+    return packet.BuildExternalBuffer(
+        &context_->buffer[context_->position],
+        context_->buffer_size - context_->position,
+         this);

[åsapersson, 2015/07/31 13:36:42]

nit: remove extra space

[sprang_webrtc, 2015/07/31 14:15:53]

Done.

+  }
 
  private:
   RtcpContext* const context_;
 };
 
 RTCPSender::RTCPSender(
     int32_t id,
     bool audio,
     Clock* clock,
     ReceiveStatistics* receive_statistics,
@@ skipping 361 matching lines @@
   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);
 
   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)) {
+  if (!callback.BuildPacket(report))
     return BuildResult::kTruncated;
-  }
 
   report_blocks_.clear();
   return BuildResult::kSuccess;
 }
 
 RTCPSender::BuildResult RTCPSender::BuildSDES(RtcpContext* ctx) {
   size_t length_cname = cname_.length();
   CHECK_LT(length_cname, static_cast<size_t>(RTCP_CNAME_SIZE));
 
   rtcp::Sdes sdes;
   sdes.WithCName(ssrc_, cname_);
 
   for (const auto it : csrc_cnames_)
     sdes.WithCName(it.first, it.second);
 
   PacketBuiltCallback callback(ctx);
-  if (!sdes.BuildExternalBuffer(&ctx->buffer[ctx->position],
-                                ctx->buffer_size - ctx->position, &callback)) {
+  if (!callback.BuildPacket(sdes))
     return BuildResult::kTruncated;
-  }
 
   return BuildResult::kSuccess;
 }
 
 RTCPSender::BuildResult RTCPSender::BuildRR(RtcpContext* ctx) {
   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)) {
+  if (!callback.BuildPacket(report))
     return BuildResult::kTruncated;
-  }
 
   report_blocks_.clear();
 
   return BuildResult::kSuccess;
 }
 
 RTCPSender::BuildResult RTCPSender::BuildPLI(RtcpContext* ctx) {
-  // sanity
-  if (ctx->position + 12 >= IP_PACKET_SIZE)
+  rtcp::Pli pli;
+  pli.From(ssrc_);
+  pli.To(remote_ssrc_);
+
+  PacketBuiltCallback callback(ctx);
+  if (!callback.BuildPacket(pli))
     return BuildResult::kTruncated;
 
-  // add picture loss indicator
-  uint8_t FMT = 1;
-  *ctx->AllocateData(1) = 0x80 + FMT;
-  *ctx->AllocateData(1) = 206;
-
-  // Used fixed length of 2
-  *ctx->AllocateData(1) = 0;
-  *ctx->AllocateData(1) = 2;
-
-  // Add our own SSRC
-  ByteWriter<uint32_t>::WriteBigEndian(ctx->AllocateData(4), ssrc_);
-
-  // Add the remote SSRC
-  ByteWriter<uint32_t>::WriteBigEndian(ctx->AllocateData(4), remote_ssrc_);
-
   TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                        "RTCPSender::PLI");
   ++packet_type_counter_.pli_packets;
   TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_PLICount",
                     ssrc_, packet_type_counter_.pli_packets);
 
   return BuildResult::kSuccess;
 }
 
 RTCPSender::BuildResult RTCPSender::BuildFIR(RtcpContext* ctx) {
@@ skipping 921 matching lines @@
 
 bool RTCPSender::AllVolatileFlagsConsumed() const {
   for (const ReportFlag& flag : report_flags_) {
     if (flag.is_volatile)
       return false;
   }
   return true;
 }
 
 }  // namespace webrtc