Send Sdes using RtcpPacket

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 152 matching lines @@
       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;
   builders_[kRtcpRr] = &RTCPSender::BuildRR;
-  builders_[kRtcpSdes] = &RTCPSender::BuildSDEC;
+  builders_[kRtcpSdes] = &RTCPSender::BuildSDES;
   builders_[kRtcpTransmissionTimeOffset] =
       &RTCPSender::BuildExtendedJitterReport;
   builders_[kRtcpPli] = &RTCPSender::BuildPLI;
   builders_[kRtcpFir] = &RTCPSender::BuildFIR;
   builders_[kRtcpSli] = &RTCPSender::BuildSLI;
   builders_[kRtcpRpsi] = &RTCPSender::BuildRPSI;
   builders_[kRtcpRemb] = &RTCPSender::BuildREMB;
   builders_[kRtcpBye] = &RTCPSender::BuildBYE;
   builders_[kRtcpApp] = &RTCPSender::BuildAPP;
   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 : csrc_cnames_)
-    delete it.second;
 }
 
 int32_t RTCPSender::RegisterSendTransport(Transport* outgoingTransport) {
   CriticalSectionScoped lock(critical_section_transport_.get());
   cbTransport_ = outgoingTransport;
   return 0;
 }
 
 RTCPMethod RTCPSender::Status() const {
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
@@ skipping 115 matching lines @@
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
   remote_ssrc_ = ssrc;
 }
 
 int32_t RTCPSender::SetCNAME(const char* c_name) {
   if (!c_name)
     return -1;
 
   DCHECK_LT(strlen(c_name), static_cast<size_t>(RTCP_CNAME_SIZE));
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
-  cname_[RTCP_CNAME_SIZE - 1] = 0;
-  strncpy(cname_, c_name, RTCP_CNAME_SIZE - 1);
+  cname_ = c_name;
   return 0;
 }
 
-int32_t RTCPSender::AddMixedCNAME(uint32_t SSRC,
-                                  const char cName[RTCP_CNAME_SIZE]) {
-  assert(cName);
+int32_t RTCPSender::AddMixedCNAME(uint32_t SSRC, const char* c_name) {
+  assert(c_name);
+  DCHECK_LT(strlen(c_name), static_cast<size_t>(RTCP_CNAME_SIZE));
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
-  if (csrc_cnames_.size() >= kRtpCsrcSize) {
+  if (csrc_cnames_.size() >= kRtpCsrcSize)
     return -1;
-  }
-  RTCPCnameInformation* ptr = new RTCPCnameInformation();
-  ptr->name[RTCP_CNAME_SIZE - 1] = 0;
-  strncpy(ptr->name, cName, RTCP_CNAME_SIZE - 1);
-  csrc_cnames_[SSRC] = ptr;
+
+  csrc_cnames_[SSRC] = c_name;
   return 0;
 }
 
 int32_t RTCPSender::RemoveMixedCNAME(uint32_t SSRC) {
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
-  std::map<uint32_t, RTCPCnameInformation*>::iterator it =
-      csrc_cnames_.find(SSRC);
+  auto it = csrc_cnames_.find(SSRC);
 
   if (it == csrc_cnames_.end())
     return -1;
 
-  delete it->second;
   csrc_cnames_.erase(it);
   return 0;
 }
 
 bool RTCPSender::TimeToSendRTCPReport(bool sendKeyframeBeforeRTP) const {
 /*
     For audio we use a fix 5 sec interval
 
     For video we use 1 sec interval fo a BW smaller than 360 kbit/s,
         technicaly we break the max 5% RTCP BW for video below 10 kbit/s but
@@ skipping 154 matching lines @@
   if (!report.BuildExternalBuffer(&ctx->buffer[ctx->position],
                                   ctx->buffer_size - ctx->position,
                                   &callback)) {
     return BuildResult::kTruncated;
   }
 
   report_blocks_.clear();
   return BuildResult::kSuccess;
 }
 
-RTCPSender::BuildResult RTCPSender::BuildSDEC(RtcpContext* ctx) {
-  size_t lengthCname = strlen(cname_);
-  assert(lengthCname < RTCP_CNAME_SIZE);
+RTCPSender::BuildResult RTCPSender::BuildSDES(RtcpContext* ctx) {
+  size_t length_cname = cname_.length();
+  CHECK_LT(length_cname, static_cast<size_t>(RTCP_CNAME_SIZE));
 
-  // sanity
-  if (ctx->position + 12 + lengthCname >= IP_PACKET_SIZE) {
-    LOG(LS_WARNING) << "Failed to build SDEC.";
+  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)) {
     return BuildResult::kTruncated;
   }
-  // SDEC Source Description
 
-  // We always need to add SDES CNAME
-  size_t size = 0x80 + 1 + csrc_cnames_.size();
-  DCHECK_LE(size, std::numeric_limits<uint8_t>::max());
-  *ctx->AllocateData(1) = static_cast<uint8_t>(size);
-  *ctx->AllocateData(1) = 202;
-
-  // handle SDES length later on
-  uint32_t SDESLengthPos = ctx->position;
-  ctx->AllocateData(2);
-
-  // Add our own SSRC
-  ByteWriter<uint32_t>::WriteBigEndian(ctx->AllocateData(4), ssrc_);
-
-  // CNAME = 1
-  *ctx->AllocateData(1) = 1;
-  DCHECK_LE(lengthCname, std::numeric_limits<uint8_t>::max());
-  *ctx->AllocateData(1) = static_cast<uint8_t>(lengthCname);
-
-  uint16_t SDESLength = 10;
-
-  memcpy(ctx->AllocateData(lengthCname), cname_, lengthCname);
-  SDESLength += static_cast<uint16_t>(lengthCname);
-
-  uint16_t padding = 0;
-  // We must have a zero field even if we have an even multiple of 4 bytes
-  do {
-    ++padding;
-    *ctx->AllocateData(1) = 0;
-  } while ((ctx->position % 4) != 0);
-  SDESLength += padding;
-
-  for (auto it = csrc_cnames_.begin(); it != csrc_cnames_.end(); ++it) {
-    RTCPCnameInformation* cname = it->second;
-    uint32_t SSRC = it->first;
-
-    // Add SSRC
-    ByteWriter<uint32_t>::WriteBigEndian(ctx->AllocateData(4), SSRC);
-
-    // CNAME = 1
-    *ctx->AllocateData(1) = 1;
-
-    size_t length = strlen(cname->name);
-    assert(length < RTCP_CNAME_SIZE);
-
-    *ctx->AllocateData(1) = static_cast<uint8_t>(length);
-    SDESLength += 6;
-
-    memcpy(ctx->AllocateData(length), cname->name, length);
-
-    SDESLength += length;
-    uint16_t padding = 0;
-
-    // We must have a zero field even if we have an even multiple of 4 bytes
-    do {
-      ++padding;
-      *ctx->AllocateData(1) = 0;
-    } while ((ctx->position % 4) != 0);
-    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) {
   rtcp::ReceiverReport report;
   report.From(ssrc_);
   for (auto it : report_blocks_)
     report.WithReportBlock(it.second);
 
   PacketBuiltCallback callback(ctx);
@@ skipping 780 matching lines @@
     generate_report = true;
     DCHECK(ConsumeFlag(kRtcpReport) == false);
   } else {
     generate_report =
         (ConsumeFlag(kRtcpReport) && method_ == kRtcpNonCompound) ||
         method_ == kRtcpCompound;
     if (generate_report)
       SetFlag(sending_ ? kRtcpSr : kRtcpRr, true);
   }
 
-  if (IsFlagPresent(kRtcpSr) || (IsFlagPresent(kRtcpRr) && cname_[0] != 0))
+  if (IsFlagPresent(kRtcpSr) || (IsFlagPresent(kRtcpRr) && !cname_.empty()))
     SetFlag(kRtcpSdes, true);
 
   // We need to send our NTP even if we haven't received any reports.
   clock_->CurrentNtp(context.ntp_sec, context.ntp_frac);
 
   if (generate_report) {
     if (!sending_ && xr_send_receiver_reference_time_enabled_)
       SetFlag(kRtcpXrReceiverReferenceTime, true);
     if (feedback_state.has_last_xr_rr)
       SetFlag(kRtcpXrDlrrReportBlock, true);
@@ skipping 39 matching lines @@
   while (it != report_flags_.end()) {
     auto builder = builders_.find(it->type);
     DCHECK(builder != builders_.end());
     if (it->is_volatile) {
       report_flags_.erase(it++);
     } else {
       ++it;
     }
 
     uint32_t start_position = context.position;
-    BuildResult result = (*this.*(builder->second))(&context);
+    BuildResult result = (this->*(builder->second))(&context);
     switch (result) {
       case BuildResult::kError:
         return -1;
       case BuildResult::kTruncated:
         return context.position;
       case BuildResult::kAborted:
         context.position = start_position;
         FALLTHROUGH();
       case BuildResult::kSuccess:
         continue;
@@ skipping 142 matching lines @@
 
 bool RTCPSender::AllVolatileFlagsConsumed() const {
   for (const ReportFlag& flag : report_flags_) {
     if (flag.is_volatile)
       return false;
   }
   return true;
 }
 
 }  // namespace webrtc