H.264 packetization mode 0 (try 2)

webrtc/video/video_send_stream_tests.cc

 /*
  *  Copyright (c) 2013 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 <algorithm>  // max
@@ skipping 1910 matching lines @@
   VideoCodecConfigObserver(VideoCodecType video_codec_type,
                            const char* codec_name)
       : SendTest(VideoSendStreamTest::kDefaultTimeoutMs),
         FakeEncoder(Clock::GetRealTimeClock()),
         video_codec_type_(video_codec_type),
         codec_name_(codec_name),
         init_encode_event_(false, false),
         num_initializations_(0),
         stream_(nullptr) {
     memset(&encoder_settings_, 0, sizeof(encoder_settings_));
+    InitCodecSpecifics();
   }
 
  private:
   class VideoStreamFactory
       : public VideoEncoderConfig::VideoStreamFactoryInterface {
    public:
     VideoStreamFactory() {}
 
    private:
     std::vector<VideoStream> CreateEncoderStreams(
         int width,
         int height,
         const VideoEncoderConfig& encoder_config) override {
       std::vector<VideoStream> streams =
           test::CreateVideoStreams(width, height, encoder_config);
       for (size_t i = 0; i < streams.size(); ++i) {
         streams[i].temporal_layer_thresholds_bps.resize(
             kVideoCodecConfigObserverNumberOfTemporalLayers - 1);
       }
       return streams;
     }
   };
 
+  void InitCodecSpecifics();
+
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
       std::vector<VideoReceiveStream::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     send_config->encoder_settings.encoder = this;
     send_config->encoder_settings.payload_name = codec_name_;
 
     encoder_config->encoder_specific_settings = GetEncoderSpecificSettings();
     encoder_config->video_stream_factory =
         new rtc::RefCountedObject<VideoStreamFactory>();
@@ skipping 44 matching lines @@
 
   T encoder_settings_;
   const VideoCodecType video_codec_type_;
   const char* const codec_name_;
   rtc::Event init_encode_event_;
   size_t num_initializations_;
   VideoSendStream* stream_;
   VideoEncoderConfig encoder_config_;
 };
 
+template <typename T>
+void VideoCodecConfigObserver<T>::InitCodecSpecifics() {}
+
+template <>
+void VideoCodecConfigObserver<VideoCodecH264>::InitCodecSpecifics() {
+  encoder_settings_.packetization_mode = kH264PacketizationMode1;
+}
 template <>
 void VideoCodecConfigObserver<VideoCodecH264>::VerifyCodecSpecifics(
     const VideoCodec& config) const {
   EXPECT_EQ(
       0, memcmp(&config.H264(), &encoder_settings_, sizeof(encoder_settings_)));
+  // Check that packetization mode has propagated.
+  EXPECT_EQ(kH264PacketizationMode1,
+            config.codecSpecific.H264.packetization_mode);
 }
 
 template <>
 rtc::scoped_refptr<VideoEncoderConfig::EncoderSpecificSettings>
 VideoCodecConfigObserver<VideoCodecH264>::GetEncoderSpecificSettings() const {
   return new rtc::RefCountedObject<
       VideoEncoderConfig::H264EncoderSpecificSettings>(encoder_settings_);
 }
 
 template <>
@@ skipping 910 matching lines @@
        RequestSourceRotateIfVideoOrientationExtensionNotSupported) {
   TestRequestSourceRotateVideo(false);
 }
 
 TEST_F(VideoSendStreamTest,
        DoNotRequestsRotationIfVideoOrientationExtensionSupported) {
   TestRequestSourceRotateVideo(true);
 }
 
 }  // namespace webrtc