H.264 video codec support using OpenH264/FFmpeg

webrtc/modules/video_coding/codecs/test/videoprocessor_integrationtest.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 <math.h>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "webrtc/modules/video_coding/codecs/interface/video_codec_interface.h"
 #include "webrtc/modules/video_coding/codecs/test/packet_manipulator.h"
 #include "webrtc/modules/video_coding/codecs/test/videoprocessor.h"
+#include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
+#include "webrtc/modules/video_coding/codecs/vp8/include/vp8_common_types.h"
 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
-#include "webrtc/modules/video_coding/codecs/vp8/include/vp8_common_types.h"
 #include "webrtc/modules/video_coding/main/interface/video_coding.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/test/testsupport/frame_reader.h"
 #include "webrtc/test/testsupport/frame_writer.h"
 #include "webrtc/test/testsupport/gtest_disable.h"
 #include "webrtc/test/testsupport/metrics/video_metrics.h"
 #include "webrtc/test/testsupport/packet_reader.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
@@ skipping 114 matching lines @@
   bool error_concealment_on_;
   bool denoising_on_;
   bool frame_dropper_on_;
   bool spatial_resize_on_;
 
 
   VideoProcessorIntegrationTest() {}
   virtual ~VideoProcessorIntegrationTest() {}
 
   void SetUpCodecConfig() {
-    if (codec_type_ == kVideoCodecVP8) {
+    if (codec_type_ == kVideoCodecH264) {
+      encoder_ = H264Encoder::Create();
+      decoder_ = H264Decoder::Create();
+      VideoCodingModule::Codec(kVideoCodecH264, &codec_settings_);
+    } else if (codec_type_ == kVideoCodecVP8) {
       encoder_ = VP8Encoder::Create();
       decoder_ = VP8Decoder::Create();
       VideoCodingModule::Codec(kVideoCodecVP8, &codec_settings_);
     } else if (codec_type_ == kVideoCodecVP9) {
       encoder_ = VP9Encoder::Create();
       decoder_ = VP9Decoder::Create();
       VideoCodingModule::Codec(kVideoCodecVP9, &codec_settings_);
     }
 
     // CIF is currently used for all tests below.
@@ skipping 14 matching lines @@
     config_.networking_config.packet_loss_probability = packet_loss_;
 
     // Configure codec settings.
     config_.codec_settings = &codec_settings_;
     config_.codec_settings->startBitrate = start_bitrate_;
     config_.codec_settings->width = kCIFWidth;
     config_.codec_settings->height = kCIFHeight;
 
     // These features may be set depending on the test.
     switch (config_.codec_settings->codecType) {
+     case kVideoCodecH264:
+       config_.codec_settings->codecSpecific.H264.frameDroppingOn =
+           frame_dropper_on_;
+       config_.codec_settings->codecSpecific.H264.keyFrameInterval =
+           kBaseKeyFrameInterval;
+       break;
      case kVideoCodecVP8:
        config_.codec_settings->codecSpecific.VP8.errorConcealmentOn =
            error_concealment_on_;
        config_.codec_settings->codecSpecific.VP8.denoisingOn =
            denoising_on_;
        config_.codec_settings->codecSpecific.VP8.numberOfTemporalLayers =
            num_temporal_layers_;
        config_.codec_settings->codecSpecific.VP8.frameDroppingOn =
            frame_dropper_on_;
        config_.codec_settings->codecSpecific.VP8.automaticResizeOn =
            spatial_resize_on_;
        config_.codec_settings->codecSpecific.VP8.keyFrameInterval =
            kBaseKeyFrameInterval;
        break;
      case kVideoCodecVP9:
        config_.codec_settings->codecSpecific.VP9.denoisingOn =
            denoising_on_;
        config_.codec_settings->codecSpecific.VP9.numberOfTemporalLayers =
            num_temporal_layers_;
        config_.codec_settings->codecSpecific.VP9.frameDroppingOn =
            frame_dropper_on_;
        config_.codec_settings->codecSpecific.VP9.keyFrameInterval =
            kBaseKeyFrameInterval;
        break;
      default:
        assert(false);
        break;
-     }
+    }
     frame_reader_ =
         new webrtc::test::FrameReaderImpl(config_.input_filename,
                                           config_.frame_length_in_bytes);
     frame_writer_ =
         new webrtc::test::FrameWriterImpl(config_.output_filename,
                                           config_.frame_length_in_bytes);
     ASSERT_TRUE(frame_reader_->Init());
     ASSERT_TRUE(frame_writer_->Init());
 
     packet_manipulator_ = new webrtc::test::PacketManipulatorImpl(
@@ skipping 353 matching lines @@
   rc_metrics[update_index].max_key_frame_size_mismatch =
       max_key_frame_size_mismatch;
   rc_metrics[update_index].max_delta_frame_size_mismatch =
       max_delta_frame_size_mismatch;
   rc_metrics[update_index].max_encoding_rate_mismatch =
       max_encoding_rate_mismatch;
   rc_metrics[update_index].max_time_hit_target = max_time_hit_target;
   rc_metrics[update_index].num_spatial_resizes = num_spatial_resizes;
 }
 
+#if defined(WEBRTC_OPENH264)
+
+// H264: Run with no packet loss and fixed bitrate. Quality should be very high.
+// Note(hbos): The PacketManipulatorImpl code used to simulate packet loss in
+// these unittests appears to drop "packets" in a way that is not compatible
+// with H264. Therefore ProcessXPercentPacketLossH264, X != 0, unittests have
+// not been added.
+TEST_F(VideoProcessorIntegrationTest, Process0PercentPacketLossH264) {
+  // Bitrate and frame rate profile.
+  RateProfile rate_profile;
+  SetRateProfilePars(&rate_profile, 0, 500, 30, 0);
+  rate_profile.frame_index_rate_update[1] = kNbrFramesShort + 1;
+  rate_profile.num_frames = kNbrFramesShort;
+  // Codec/network settings.
+  CodecConfigPars process_settings;
+  SetCodecParameters(&process_settings, kVideoCodecH264, 0.0f, -1, 1, false,
+                     false, true, false);
+  // Metrics for expected quality.
+  QualityMetrics quality_metrics;
+  SetQualityMetrics(&quality_metrics, 35.0, 34.0, 0.93, 0.92);
+  // Metrics for rate control.
+  RateControlMetrics rc_metrics[1];
+  SetRateControlMetrics(rc_metrics, 0, 0, 60, 20, 10, 20, 0);
+  ProcessFramesAndVerify(quality_metrics,
+                         rate_profile,
+                         process_settings,
+                         rc_metrics);
+}
+
+#endif  // defined(WEBRTC_OPENH264)
+
 // VP9: Run with no packet loss and fixed bitrate. Quality should be very high.
 // One key frame (first frame only) in sequence. Setting |key_frame_interval|
 // to -1 below means no periodic key frames in test.
 TEST_F(VideoProcessorIntegrationTest, Process0PercentPacketLossVP9) {
   // Bitrate and frame rate profile.
   RateProfile rate_profile;
   SetRateProfilePars(&rate_profile, 0, 500, 30, 0);
   rate_profile.frame_index_rate_update[1] = kNbrFramesShort + 1;
   rate_profile.num_frames = kNbrFramesShort;
   // Codec/network settings.
@@ skipping 326 matching lines @@
   // Metrics for rate control.
   RateControlMetrics rc_metrics[2];
   SetRateControlMetrics(rc_metrics, 0, 0, 20, 30, 10, 10, 0);
   SetRateControlMetrics(rc_metrics, 1, 0, 0, 30, 15, 10, 0);
   ProcessFramesAndVerify(quality_metrics,
                          rate_profile,
                          process_settings,
                          rc_metrics);
 }
 }  // namespace webrtc