Use RtpPacketToSend in RtpSenderVideo

webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc

Index: webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
index a7d553781e78d363cf85826ff3d1fdcac780ac82..7ee0c2aca458ebd11db7e11b2f4932150d3b3e90 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
@@ -25,6 +25,8 @@
 #include "webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp9.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h"
 
 namespace webrtc {
 
@@ -72,47 +74,48 @@ RtpUtility::Payload* RTPSenderVideo::CreateVideoPayload(
   return payload;
 }
 
-void RTPSenderVideo::SendVideoPacket(uint8_t* data_buffer,
-                                     size_t payload_length,
-                                     size_t rtp_header_length,
-                                     uint16_t seq_num,
-                                     uint32_t capture_timestamp,
-                                     int64_t capture_time_ms,
+void RTPSenderVideo::SendVideoPacket(std::unique_ptr<RtpPacketToSend> packet,
                                      StorageType storage) {
-  if (!rtp_sender_->SendToNetwork(data_buffer, payload_length,
-                                  rtp_header_length, capture_time_ms, storage,
+  size_t packet_size = packet->size();
+  uint32_t capture_timestamp = packet->Timestamp();
+  if (!rtp_sender_->PrepareToSend(packet.get())) {
+    return;
+  }
+  uint16_t seq_num = packet->SequenceNumber();
+  if (!rtp_sender_->SendToNetwork(std::move(packet), storage,
                                   RtpPacketSender::kLowPriority)) {
     LOG(LS_WARNING) << "Failed to send video packet " << seq_num;
     return;
   }
   rtc::CritScope cs(&stats_crit_);
-  video_bitrate_.Update(payload_length + rtp_header_length,
-                        clock_->TimeInMilliseconds());
+  video_bitrate_.Update(packet_size, clock_->TimeInMilliseconds());
   TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                        "Video::PacketNormal", "timestamp", capture_timestamp,
                        "seqnum", seq_num);
 }
 
-void RTPSenderVideo::SendVideoPacketAsRed(uint8_t* data_buffer,
-                                          size_t payload_length,
-                                          size_t rtp_header_length,
-                                          uint16_t media_seq_num,
-                                          uint32_t capture_timestamp,
-                                          int64_t capture_time_ms,
-                                          StorageType media_packet_storage,
-                                          bool protect) {
-  std::unique_ptr<RedPacket> red_packet;
+void RTPSenderVideo::SendVideoPacketAsRed(
+    std::unique_ptr<RtpPacketToSend> packet,
+    StorageType media_packet_storage,
+    bool protect) {
+  // Do it old, slow way for now.

[brandtr, 2016/08/15 08:31:31]

Not sure what this comment means?

[danilchap, 2016/08/15 08:55:16]

Mean this function is too drafty.
Not relevant any more, replaced with better (TODO) comments.

+  uint32_t capture_timestamp = packet->Timestamp();
+  rtp_sender_->PrepareToSend(packet.get());
+  uint16_t media_seq_num = packet->SequenceNumber();
+
+  std::unique_ptr<RtpPacketToSend> red_packet;
   std::vector<std::unique_ptr<RedPacket>> fec_packets;
   StorageType fec_storage = kDontRetransmit;
   uint16_t next_fec_sequence_number = 0;
   {
     // Only protect while creating RED and FEC packets, not when sending.
+    red_packet = rtp_sender_->AllocatePacket(false);
     rtc::CritScope cs(&crit_);
-    red_packet = ProducerFec::BuildRedPacket(
-        data_buffer, payload_length, rtp_header_length, red_payload_type_);
+    producer_fec_.BuildRedPacket(red_payload_type_, *packet, red_packet.get());
+    red_packet->set_capture_time_ms(packet->capture_time_ms());
     if (protect) {
-      producer_fec_.AddRtpPacketAndGenerateFec(data_buffer, payload_length,
-                                               rtp_header_length);
+      producer_fec_.AddRtpPacketAndGenerateFec(
+          packet->data(), packet->payload_size(), packet->headers_size());
     }
     uint16_t num_fec_packets = producer_fec_.NumAvailableFecPackets();
     if (num_fec_packets > 0) {
@@ -120,18 +123,17 @@ void RTPSenderVideo::SendVideoPacketAsRed(uint8_t* data_buffer,
           rtp_sender_->AllocateSequenceNumber(num_fec_packets);
       fec_packets = producer_fec_.GetFecPacketsAsRed(
           red_payload_type_, fec_payload_type_, next_fec_sequence_number,
-          rtp_header_length);
+          packet->headers_size());
       RTC_DCHECK_EQ(num_fec_packets, fec_packets.size());
       if (retransmission_settings_ & kRetransmitFECPackets)
         fec_storage = kAllowRetransmission;
     }
   }
-  if (rtp_sender_->SendToNetwork(
-          red_packet->data(), red_packet->length() - rtp_header_length,
-          rtp_header_length, capture_time_ms, media_packet_storage,
-          RtpPacketSender::kLowPriority)) {
+  size_t red_packet_size = red_packet->size();
+  if (rtp_sender_->SendToNetwork(std::move(red_packet), media_packet_storage,
+                                 RtpPacketSender::kLowPriority)) {
     rtc::CritScope cs(&stats_crit_);
-    video_bitrate_.Update(red_packet->length(), clock_->TimeInMilliseconds());
+    video_bitrate_.Update(red_packet_size, clock_->TimeInMilliseconds());
     TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                          "Video::PacketRed", "timestamp", capture_timestamp,
                          "seqnum", media_seq_num);
@@ -139,10 +141,14 @@ void RTPSenderVideo::SendVideoPacketAsRed(uint8_t* data_buffer,
     LOG(LS_WARNING) << "Failed to send RED packet " << media_seq_num;
   }
   for (const auto& fec_packet : fec_packets) {
-    if (rtp_sender_->SendToNetwork(
-            fec_packet->data(), fec_packet->length() - rtp_header_length,
-            rtp_header_length, capture_time_ms, fec_storage,
-            RtpPacketSender::kLowPriority)) {
+    // TODO(danilchap): Make producer_fec_ generate rtp::Packets to avoid
+    // reparsing them.
+    std::unique_ptr<RtpPacketToSend> rtp_packet =
+        rtp_sender_->AllocatePacket(false);
+    RTC_CHECK(rtp_packet->Parse(fec_packet->data(), fec_packet->length()));
+    rtp_packet->set_capture_time_ms(packet->capture_time_ms());
+    if (rtp_sender_->SendToNetwork(std::move(rtp_packet), fec_storage,
+                                   RtpPacketSender::kLowPriority)) {
       rtc::CritScope cs(&stats_crit_);
       fec_bitrate_.Update(fec_packet->length(), clock_->TimeInMilliseconds());
       TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
@@ -179,7 +185,6 @@ void RTPSenderVideo::GenericFECStatus(bool* enable,
 
 size_t RTPSenderVideo::FECPacketOverhead() const {
   rtc::CritScope cs(&crit_);
-  size_t overhead = 0;
   if (red_payload_type_ != 0) {
     // Overhead is FEC headers plus RED for FEC header plus anything in RTP
     // header beyond the 12 bytes base header (CSRC list, extensions...)
@@ -190,8 +195,8 @@ size_t RTPSenderVideo::FECPacketOverhead() const {
            (rtp_sender_->RtpHeaderLength() - kRtpHeaderSize);
   }
   if (fec_enabled_)
-    overhead += ForwardErrorCorrection::PacketOverhead();
-  return overhead;
+    return ForwardErrorCorrection::PacketOverhead();
+  return 0;
 }
 
 void RTPSenderVideo::SetFecParameters(const FecProtectionParams* delta_params,
@@ -217,8 +222,25 @@ bool RTPSenderVideo::SendVideo(RtpVideoCodecTypes video_type,
   if (payload_size == 0)
     return false;
 
+  size_t packet_capacity = rtp_sender_->MaxPayloadLength() -
+                           FECPacketOverhead() -
+                           (rtp_sender_->RtxStatus() ? kRtxHeaderSize : 0);
+  std::unique_ptr<RtpPacketToSend> packet = rtp_sender_->AllocatePacket(false);
+  if (!packet)
+    return false;
+
+  RTC_DCHECK_LE(packet_capacity, packet->capacity());
+  packet->SetPayloadType(payload_type);
+  packet->SetTimestamp(capture_timestamp);
+  packet->set_capture_time_ms(capture_time_ms);
+  if (video_header && video_header->rotation != kVideoRotation_0)
+    packet->SetExtension<VideoOrientation>(video_header->rotation);
+  // TODO(danilchap): Optionally set playout delay extension.
+
+  size_t max_data_payload_length = packet_capacity - packet->headers_size();
+
   std::unique_ptr<RtpPacketizer> packetizer(RtpPacketizer::Create(
-      video_type, rtp_sender_->MaxDataPayloadLength(),
+      video_type, max_data_payload_length,
       video_header ? &(video_header->codecHeader) : nullptr, frame_type));
 
   StorageType storage;
@@ -237,78 +259,39 @@ bool RTPSenderVideo::SendVideo(RtpVideoCodecTypes video_type,
     red_payload_type = red_payload_type_;
   }
 
-  // Register CVO rtp header extension at the first time when we receive a frame
-  // with pending rotation.
-  bool video_rotation_active = false;
-  if (video_header && video_header->rotation != kVideoRotation_0) {
-    video_rotation_active = rtp_sender_->ActivateCVORtpHeaderExtension();
-  }
-
-  int rtp_header_length = rtp_sender_->RtpHeaderLength();
-  size_t payload_bytes_to_send = payload_size;
-  const uint8_t* data = payload_data;
-
   // TODO(changbin): we currently don't support to configure the codec to
   // output multiple partitions for VP8. Should remove below check after the
   // issue is fixed.
   const RTPFragmentationHeader* frag =
       (video_type == kRtpVideoVp8) ? NULL : fragmentation;
 
-  packetizer->SetPayloadData(data, payload_bytes_to_send, frag);
+  packetizer->SetPayloadData(payload_data, payload_size, frag);
 
   bool first = true;
   bool last = false;
   while (!last) {
-    uint8_t dataBuffer[IP_PACKET_SIZE] = {0};
     size_t payload_bytes_in_packet = 0;
-
-    if (!packetizer->NextPacket(&dataBuffer[rtp_header_length],
-                                &payload_bytes_in_packet, &last)) {
+    if (!packetizer->NextPacket(
+            packet->AllocatePayload(max_data_payload_length),
+            &payload_bytes_in_packet, &last)) {
       return false;
     }
-
-    // Write RTP header.
-    int32_t header_length = rtp_sender_->BuildRtpHeader(
-        dataBuffer, payload_type, last, capture_timestamp, capture_time_ms);
-    if (header_length <= 0)
-      return false;
-
-    // According to
-    // http://www.etsi.org/deliver/etsi_ts/126100_126199/126114/12.07.00_60/
-    // ts_126114v120700p.pdf Section 7.4.5:
-    // The MTSI client shall add the payload bytes as defined in this clause
-    // onto the last RTP packet in each group of packets which make up a key
-    // frame (I-frame or IDR frame in H.264 (AVC), or an IRAP picture in H.265
-    // (HEVC)). The MTSI client may also add the payload bytes onto the last RTP
-    // packet in each group of packets which make up another type of frame
-    // (e.g. a P-Frame) only if the current value is different from the previous
-    // value sent.
-    // Here we are adding it to every packet of every frame at this point.
-    if (!video_header) {
-      RTC_DCHECK(!rtp_sender_->IsRtpHeaderExtensionRegistered(
-          kRtpExtensionVideoRotation));
-    } else if (video_rotation_active) {
-      // Checking whether CVO header extension is registered will require taking
-      // a lock. It'll be a no-op if it's not registered.
-      // TODO(guoweis): For now, all packets sent will carry the CVO such that
-      // the RTP header length is consistent, although the receiver side will
-      // only exam the packets with marker bit set.
-      size_t packetSize = payload_size + rtp_header_length;
-      RtpUtility::RtpHeaderParser rtp_parser(dataBuffer, packetSize);
-      RTPHeader rtp_header;
-      rtp_parser.Parse(&rtp_header);
-      rtp_sender_->UpdateVideoRotation(dataBuffer, packetSize, rtp_header,
-                                       video_header->rotation);
+    packet->SetPayloadSize(payload_bytes_in_packet);
+    packet->SetMarker(last);
+
+    std::unique_ptr<RtpPacketToSend> packet_to_send = std::move(packet);
+    if (!last) {
+      // Allocate next packet and copy all headers.
+      packet = rtp_sender_->AllocatePacket(false);
+      packet->CopyHeaderFrom(*packet_to_send);
+      packet->set_capture_time_ms(packet_to_send->capture_time_ms());
     }
+
     if (red_payload_type != 0) {
-      SendVideoPacketAsRed(dataBuffer, payload_bytes_in_packet,
-                           rtp_header_length, rtp_sender_->SequenceNumber(),
-                           capture_timestamp, capture_time_ms, storage,
+      SendVideoPacketAsRed(std::move(packet_to_send), storage,
                            packetizer->GetProtectionType() == kProtectedPacket);
     } else {
-      SendVideoPacket(dataBuffer, payload_bytes_in_packet, rtp_header_length,
-                      rtp_sender_->SequenceNumber(), capture_timestamp,
-                      capture_time_ms, storage);
+      SendVideoPacket(std::move(packet_to_send), storage);
     }
 
     if (first_frame) {