Follow standard sending CVO rtp header extension

webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.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 224 matching lines @@
 
 class RtpSenderVideoTest : public RtpSenderTest {
  protected:
   void SetUp() override {
     // TODO(pbos): Set up to use pacer.
     SetUpRtpSender(false);
     rtp_sender_video_.reset(
         new RTPSenderVideo(&fake_clock_, rtp_sender_.get()));
   }
   std::unique_ptr<RTPSenderVideo> rtp_sender_video_;
-
-  void VerifyCVOPacket(const RtpPacketReceived& rtp_packet,
-                       bool expect_cvo,
-                       uint16_t seq_num,
-                       VideoRotation expected_rotation) {
-    EXPECT_EQ(payload_, rtp_packet.PayloadType());
-    EXPECT_EQ(seq_num, rtp_packet.SequenceNumber());
-    EXPECT_EQ(kTimestamp, rtp_packet.Timestamp());
-    EXPECT_EQ(rtp_sender_->SSRC(), rtp_packet.Ssrc());
-    EXPECT_EQ(0U, rtp_packet.Csrcs().size());
-    EXPECT_EQ(0U, rtp_packet.padding_size());
-    VideoRotation actual_rotation;
-    EXPECT_TRUE(rtp_packet.GetExtension<VideoOrientation>(&actual_rotation));
-    EXPECT_EQ(expected_rotation, actual_rotation);
-  }
 };
 
 TEST_F(RtpSenderTestWithoutPacer,
        RegisterRtpTransmissionTimeOffsetHeaderExtension) {
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionLength());
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransmissionTimeOffset,
                    kTransmissionTimeOffsetExtensionId));
   EXPECT_EQ(kRtpOneByteHeaderLength + kTransmissionTimeOffsetLength,
             rtp_sender_->RtpHeaderExtensionLength());
@@ skipping 1047 matching lines @@
   EXPECT_EQ(kNumPackets * 2, transport_.packets_sent());
 
   // Must be at least 5ms in between retransmission attempts.
   fake_clock_.AdvanceTimeMilliseconds(5);
 
   // Resending should not work, bandwidth exceeded.
   rtp_sender_->OnReceivedNack(sequence_numbers, 0);
   EXPECT_EQ(kNumPackets * 2, transport_.packets_sent());
 }
 
-// Verify that all packets of a frame have CVO byte set.
-TEST_F(RtpSenderVideoTest, SendVideoWithCVO) {
+TEST_F(RtpSenderVideoTest, KeyFrameHasCVO) {
   uint8_t kFrame[kMaxPacketLength];
-  RTPVideoHeader hdr = {0};
-  hdr.rotation = kVideoRotation_90;
-
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoRotation, kVideoRotationExtensionId));
-  EXPECT_EQ(
-      RtpUtility::Word32Align(kRtpOneByteHeaderLength + kVideoRotationLength),
-      rtp_sender_->RtpHeaderExtensionLength());
 
+  RTPVideoHeader hdr = {0};
+  hdr.rotation = kVideoRotation_0;
   rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameKey, kPayload,
                                kTimestamp, 0, kFrame, sizeof(kFrame), nullptr,
                                &hdr);
 
-  // Verify that this packet does have CVO byte.
-  VerifyCVOPacket(transport_.sent_packets_[0], true, kSeqNum, hdr.rotation);
+  VideoRotation rotation;
+  EXPECT_TRUE(
+      transport_.last_sent_packet().GetExtension<VideoOrientation>(&rotation));
+  EXPECT_EQ(kVideoRotation_0, rotation);
+}
 
-  // Verify that this packet does have CVO byte.
-  VerifyCVOPacket(transport_.sent_packets_[1], true, kSeqNum + 1, hdr.rotation);
+TEST_F(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) {
+  uint8_t kFrame[kMaxPacketLength];
+  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
+                   kRtpExtensionVideoRotation, kVideoRotationExtensionId));
+
+  RTPVideoHeader hdr = {0};
+  hdr.rotation = kVideoRotation_90;
+  EXPECT_TRUE(rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameKey,
+                                           kPayload, kTimestamp, 0, kFrame,
+                                           sizeof(kFrame), nullptr, &hdr));
+
+  hdr.rotation = kVideoRotation_0;
+  EXPECT_TRUE(rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameDelta,
+                                           kPayload, kTimestamp + 1, 0, kFrame,
+                                           sizeof(kFrame), nullptr, &hdr));
+
+  VideoRotation rotation;
+  EXPECT_TRUE(
+      transport_.last_sent_packet().GetExtension<VideoOrientation>(&rotation));
+  EXPECT_EQ(kVideoRotation_0, rotation);
+}
+
+TEST_F(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) {
+  uint8_t kFrame[kMaxPacketLength];
+  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
+                   kRtpExtensionVideoRotation, kVideoRotationExtensionId));
+
+  RTPVideoHeader hdr = {0};
+  hdr.rotation = kVideoRotation_90;
+  EXPECT_TRUE(rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameKey,
+                                           kPayload, kTimestamp, 0, kFrame,
+                                           sizeof(kFrame), nullptr, &hdr));
+
+  EXPECT_TRUE(rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameDelta,
+                                           kPayload, kTimestamp + 1, 0, kFrame,
+                                           sizeof(kFrame), nullptr, &hdr));
+
+  VideoRotation rotation;
+  EXPECT_TRUE(
+      transport_.last_sent_packet().GetExtension<VideoOrientation>(&rotation));
+  EXPECT_EQ(kVideoRotation_90, rotation);
 }
 
 // Make sure rotation is parsed correctly when the Camera (C) and Flip (F) bits
 // are set in the CVO byte.
 TEST_F(RtpSenderVideoTest, SendVideoWithCameraAndFlipCVO) {
   // Test extracting rotation when Camera (C) and Flip (F) bits are zero.
   EXPECT_EQ(kVideoRotation_0, ConvertCVOByteToVideoRotation(0));
   EXPECT_EQ(kVideoRotation_90, ConvertCVOByteToVideoRotation(1));
   EXPECT_EQ(kVideoRotation_180, ConvertCVOByteToVideoRotation(2));
   EXPECT_EQ(kVideoRotation_270, ConvertCVOByteToVideoRotation(3));
   // Test extracting rotation when Camera (C) and Flip (F) bits are set.
   const int flip_bit = 1 << 2;
   const int camera_bit = 1 << 3;
   EXPECT_EQ(kVideoRotation_0,
             ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 0));
   EXPECT_EQ(kVideoRotation_90,
             ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 1));
   EXPECT_EQ(kVideoRotation_180,
             ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 2));
   EXPECT_EQ(kVideoRotation_270,
             ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 3));
 }
 
 }  // namespace webrtc