Implement FrameMarking header extension support

webrtc/modules/rtp_rtcp/source/rtp_sender_video.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 283 matching lines @@
                                const RTPFragmentationHeader* fragmentation,
                                const RTPVideoHeader* video_header) {
   if (payload_size == 0)
     return false;
 
   // Create header that will be reused in all packets.
   std::unique_ptr<RtpPacketToSend> rtp_header = rtp_sender_->AllocatePacket();
   rtp_header->SetPayloadType(payload_type);
   rtp_header->SetTimestamp(rtp_timestamp);
   rtp_header->set_capture_time_ms(capture_time_ms);
+
+  // Set Frame Marks.
+  FrameMarks frame_marks;
+  bool frame_marking_enabled = true;
+
+  // Common info
+  frame_marks.start_of_frame = true;
+  frame_marks.end_of_frame = false;
+  frame_marks.independent = (frame_type == kVideoFrameKey);
+
+  // Codec specific.
+  switch (video_type) {
+    case kRtpVideoH264:
+      // Nothing to add
+      frame_marks.discardable = false;
+      frame_marks.temporal_layer_id = kNoTemporalIdx;
+      frame_marks.spatial_layer_id = kNoSpatialIdx;
+      frame_marks.tl0_pic_idx = static_cast<uint8_t>(kNoTl0PicIdx);
+      break;
+    case kRtpVideoVp8:
+      frame_marks.discardable = video_header->codecHeader.VP8.nonReference;
+      frame_marks.base_layer_sync = video_header->codecHeader.VP8.layerSync;
+      frame_marks.temporal_layer_id = video_header->codecHeader.VP8.temporalIdx;
+      frame_marks.spatial_layer_id = kNoSpatialIdx;
+      frame_marks.tl0_pic_idx = video_header->codecHeader.VP8.tl0PicIdx;
+      break;
+    case kRtpVideoVp9:
+      frame_marks.discardable = false;
+      frame_marks.temporal_layer_id =
+          video_header->codecHeader.VP9.temporal_idx;
+      frame_marks.spatial_layer_id = kNoSpatialIdx;
+      frame_marks.tl0_pic_idx = video_header->codecHeader.VP9.tl0_pic_idx;
+      // TODO(sergio.garcia.murillo@gmail.com): This will need to be changed to
+      // support VP9 SVC, but videoheader is set per-frame, not per packet,
+      // so we can't have access to this values.
+      // Also, small modifications to the extensions will be needed to not
+      // change size of the extension between sid:0 and sid:1
+      //    frame_marks.start_of_frame =
+      //        video_header->codecHeader.VP9.beginning_of_frame;
+      //    frame_marks.end_of_frame =
+      //    video_header->codecHeader.VP9.end_of_frame;
+      //    frame_marks.spatial_layer_id =
+      //    video_header->codecHeader.VP9.spatial_idx;
+      break;
+    default:
+      // Do not use frame marking.
+      frame_marking_enabled = false;
+  }
+  // Only add frame marking for known codecs.
+  if (frame_marking_enabled)
+    // Add extension header for frame marking.
+    rtp_header->SetExtension<FrameMarking>(frame_marks);
+
   auto last_packet = rtc::MakeUnique<RtpPacketToSend>(*rtp_header);
 
   size_t fec_packet_overhead;
   bool red_enabled;
   int32_t retransmission_settings;
   {
     rtc::CritScope cs(&crit_);
-    // According to
+    // 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.
     if (video_header) {
@@ skipping 48 matching lines @@
   const RTPFragmentationHeader* frag =
       (video_type == kRtpVideoVp8) ? nullptr : fragmentation;
   size_t num_packets =
       packetizer->SetPayloadData(payload_data, payload_size, frag);
 
   if (num_packets == 0)
     return false;
 
   bool first_frame = first_frame_sent_();
   for (size_t i = 0; i < num_packets; ++i) {
+    bool first = (i == 0);
     bool last = (i + 1) == num_packets;
     auto packet = last ? std::move(last_packet)
                        : rtc::MakeUnique<RtpPacketToSend>(*rtp_header);
     if (!packetizer->NextPacket(packet.get()))
       return false;
     RTC_DCHECK_LE(packet->payload_size(),
                   last ? max_data_payload_length - last_packet_reduction_len
                        : max_data_payload_length);
+
+    // Only add frame marking for known codecs.
+    if (frame_marking_enabled) {
+      // Update start and end marks.
+      frame_marks.start_of_frame = first;
+      frame_marks.end_of_frame = last;
+      // Update extension header for frame marking.
+      packet->SetExtension<FrameMarking>(frame_marks);
+    }
+
     if (!rtp_sender_->AssignSequenceNumber(packet.get()))
       return false;
 
     const bool protect_packet =
         (packetizer->GetProtectionType() == kProtectedPacket);
     if (flexfec_enabled()) {
       // TODO(brandtr): Remove the FlexFEC code path when FlexfecSender
       // is wired up to PacedSender instead.
       SendVideoPacketWithFlexfec(std::move(packet), storage, protect_packet);
     } else if (red_enabled) {
@@ skipping 34 matching lines @@
   rtc::CritScope cs(&crit_);
   return retransmission_settings_;
 }
 
 void RTPSenderVideo::SetSelectiveRetransmissions(uint8_t settings) {
   rtc::CritScope cs(&crit_);
   retransmission_settings_ = settings;
 }
 
 }  // namespace webrtc