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.
  */
 
 #include <memory>
 #include <vector>
 
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/rate_limiter.h"
 #include "webrtc/call/mock/mock_rtc_event_log.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/system_wrappers/include/stl_util.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/mock_transport.h"
 #include "webrtc/typedefs.h"
 
@@ skipping 1383 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);
 
   RtpHeaderExtensionMap map;
   map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId);
+  const auto& last_raw_packet = *transport_.sent_packets_.back();
+  RtpPacketReceived last_parsed_packet(&map);
+  last_parsed_packet.Parse(last_raw_packet.data(), last_raw_packet.size());
+  VideoRotation rotation;
+  EXPECT_TRUE(last_parsed_packet.GetExtension<VideoOrientation>(&rotation));
+  EXPECT_EQ(kVideoRotation_0, rotation);
+}
 
-  // Verify that this packet does have CVO byte.
-  VerifyCVOPacket(
-      reinterpret_cast<uint8_t*>(transport_.sent_packets_[0]->data()),
-      transport_.sent_packets_[0]->size(), true, &map, kSeqNum, hdr.rotation);
+TEST_F(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) {
+  uint8_t kFrame[kMaxPacketLength];
+  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
+                   kRtpExtensionVideoRotation, kVideoRotationExtensionId));
 
-  // Verify that this packet does have CVO byte.
-  VerifyCVOPacket(
-      reinterpret_cast<uint8_t*>(transport_.sent_packets_[1]->data()),
-      transport_.sent_packets_[1]->size(), true, &map, kSeqNum + 1,
-      hdr.rotation);
+  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));
+
+  RtpHeaderExtensionMap map;
+  map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId);
+  const auto& last_raw_packet = *transport_.sent_packets_.back();
+  RtpPacketReceived last_parsed_packet(&map);
+  last_parsed_packet.Parse(last_raw_packet.data(), last_raw_packet.size());
+  VideoRotation rotation;
+  EXPECT_TRUE(last_parsed_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));
+
+  RtpHeaderExtensionMap map;
+  map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId);
+  const auto& last_raw_packet = *transport_.sent_packets_.back();
+  RtpPacketReceived last_parsed_packet(&map);
+  last_parsed_packet.Parse(last_raw_packet.data(), last_raw_packet.size());
+  VideoRotation rotation;
+  EXPECT_TRUE(last_parsed_packet.GetExtension<VideoOrientation>(&rotation));
+  EXPECT_EQ(kVideoRotation_90, rotation);

[sprang_webrtc, 2016/10/25 13:39:02]

There seems to be a bunch of code duplication between the test cases here. Can
you create a subclass or helper class with the common bits?

 }
 
 // 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