Add support for creating HW codecs in VideoProcessor tests.

webrtc/modules/video_coding/codecs/test/videoprocessor_integrationtest.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_INTEGRATIONTEST_H_
 #define WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_INTEGRATIONTEST_H_
 
 #include <math.h>
 
 #include <memory>
 #include <string>
 
+#if defined(WEBRTC_ANDROID)
+#include "webrtc/modules/video_coding/codecs/test/android_test_initializer.h"
+#include "webrtc/sdk/android/src/jni/androidmediadecoder_jni.h"
+#include "webrtc/sdk/android/src/jni/androidmediaencoder_jni.h"
+#elif defined(WEBRTC_IOS)
+#include "webrtc/sdk/objc/Framework/Classes/h264_video_toolbox_decoder.h"
+#include "webrtc/sdk/objc/Framework/Classes/h264_video_toolbox_encoder.h"
+#endif
+
 #include "webrtc/base/checks.h"
+#include "webrtc/media/engine/webrtcvideodecoderfactory.h"
+#include "webrtc/media/engine/webrtcvideoencoderfactory.h"
 #include "webrtc/modules/video_coding/codecs/h264/include/h264.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/vp8/include/vp8.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8_common_types.h"
 #include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h"
 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/include/video_coding.h"
 #include "webrtc/test/gtest.h"
@@ skipping 14 matching lines @@
 const int kBaseKeyFrameInterval = 3000;
 
 // Default sequence is foreman (CIF): may be better to use VGA for resize test.
 const int kCifWidth = 352;
 const int kCifHeight = 288;
 const char kFilenameForemanCif[] = "foreman_cif";
 
 // Codec and network settings.
 struct CodecConfigPars {
   VideoCodecType codec_type;
+  bool hw_codec;
   float packet_loss;
   int num_temporal_layers;
   int key_frame_interval;
   bool error_concealment_on;
   bool denoising_on;
   bool frame_dropper_on;
   bool spatial_resize_on;
   int width;
   int height;
   std::string filename;
@@ skipping 46 matching lines @@
 // Integration test for video processor. Encodes+decodes a clip and
 // writes it to the output directory. After completion, quality metrics
 // (PSNR and SSIM) and rate control metrics are computed to verify that the
 // quality and encoder response is acceptable. The rate control tests allow us
 // to verify the behavior for changing bitrate, changing frame rate, frame
 // dropping/spatial resize, and temporal layers. The limits for the rate
 // control metrics are set to be fairly conservative, so failure should only
 // happen when some significant regression or breakdown occurs.
 class VideoProcessorIntegrationTest : public testing::Test {
  protected:
-  VideoProcessorIntegrationTest() {}
-  virtual ~VideoProcessorIntegrationTest() {}
+  VideoProcessorIntegrationTest() {
+#if defined(WEBRTC_VIDEOPROCESSOR_INTEGRATIONTEST_HW_CODECS_ENABLED) && \
+    defined(WEBRTC_ANDROID)
+    InitializeAndroidObjects();
+
+    external_encoder_factory_.reset(
+        new webrtc_jni::MediaCodecVideoEncoderFactory());
+    external_decoder_factory_.reset(
+        new webrtc_jni::MediaCodecVideoDecoderFactory());
+#endif
+  }
+  virtual ~VideoProcessorIntegrationTest() = default;
 
   void SetUpCodecConfig(const std::string& filename,
                         int width,
                         int height,
                         bool verbose_logging) {
-    if (codec_type_ == kVideoCodecH264) {
-      encoder_.reset(H264Encoder::Create(cricket::VideoCodec("H264")));
-      decoder_.reset(H264Decoder::Create());
-      VideoCodingModule::Codec(kVideoCodecH264, &codec_settings_);
-    } else if (codec_type_ == kVideoCodecVP8) {
-      encoder_.reset(VP8Encoder::Create());
-      decoder_.reset(VP8Decoder::Create());
-      VideoCodingModule::Codec(kVideoCodecVP8, &codec_settings_);
-    } else if (codec_type_ == kVideoCodecVP9) {
-      encoder_.reset(VP9Encoder::Create());
-      decoder_.reset(VP9Decoder::Create());
-      VideoCodingModule::Codec(kVideoCodecVP9, &codec_settings_);
+    if (hw_codec_) {
+#if defined(WEBRTC_VIDEOPROCESSOR_INTEGRATIONTEST_HW_CODECS_ENABLED)
+#if defined(WEBRTC_ANDROID)
+      // In general, external codecs should be destroyed by the factories that
+      // allocated them. For the particular case of the Android
+      // MediaCodecVideo{En,De}coderFactory's, however, it turns out that it is
+      // fine for the std::unique_ptr to destroy the owned codec directly.
+      if (codec_type_ == kVideoCodecH264) {
+        encoder_.reset(external_encoder_factory_->CreateVideoEncoder(
+            cricket::VideoCodec(cricket::kH264CodecName)));
+        decoder_.reset(
+            external_decoder_factory_->CreateVideoDecoder(kVideoCodecH264));
+      } else if (codec_type_ == kVideoCodecVP8) {
+        encoder_.reset(external_encoder_factory_->CreateVideoEncoder(
+            cricket::VideoCodec(cricket::kVp8CodecName)));
+        decoder_.reset(
+            external_decoder_factory_->CreateVideoDecoder(kVideoCodecVP8));
+      } else if (codec_type_ == kVideoCodecVP9) {
+        encoder_.reset(external_encoder_factory_->CreateVideoEncoder(
+            cricket::VideoCodec(cricket::kVp9CodecName)));
+        decoder_.reset(
+            external_decoder_factory_->CreateVideoDecoder(kVideoCodecVP9));
+      }
+#elif defined(WEBRTC_IOS)
+      RTC_DCHECK_EQ(kVideoCodecH264, codec_type_)
+          << "iOS HW codecs only support H264.";
+      encoder_.reset(new H264VideoToolboxEncoder(
+          cricket::VideoCodec(cricket::kH264CodecName)));
+      decoder_.reset(new H264VideoToolboxDecoder());
+#else
+      RTC_NOTREACHED() << "Only support HW codecs on Android and iOS.";
+#endif
+#endif  // WEBRTC_VIDEOPROCESSOR_INTEGRATIONTEST_HW_CODECS_ENABLED
+      RTC_DCHECK(encoder_) << "HW encoder not successfully created.";
+      RTC_DCHECK(decoder_) << "HW decoder not successfully created.";
+    } else {
+      // SW codecs.
+      if (codec_type_ == kVideoCodecH264) {
+        encoder_.reset(
+            H264Encoder::Create(cricket::VideoCodec(cricket::kH264CodecName)));
+        decoder_.reset(H264Decoder::Create());
+      } else if (codec_type_ == kVideoCodecVP8) {
+        encoder_.reset(VP8Encoder::Create());
+        decoder_.reset(VP8Decoder::Create());
+      } else if (codec_type_ == kVideoCodecVP9) {
+        encoder_.reset(VP9Encoder::Create());
+        decoder_.reset(VP9Decoder::Create());
+      }
     }
 
+    VideoCodingModule::Codec(codec_type_, &codec_settings_);
+
     // Configure input filename.
     config_.input_filename = test::ResourcePath(filename, "yuv");
     if (verbose_logging)
       printf("Filename: %s\n", filename.c_str());
     // Generate an output filename in a safe way.
     config_.output_filename = test::TempFilename(
         test::OutputPath(), "videoprocessor_integrationtest");
     config_.frame_length_in_bytes = CalcBufferSize(kI420, width, height);
     config_.verbose = verbose_logging;
     // Only allow encoder/decoder to use single core, for predictability.
@@ skipping 231 matching lines @@
     }
   }
 
   // Processes all frames in the clip and verifies the result.
   void ProcessFramesAndVerify(QualityMetrics quality_metrics,
                               RateProfile rate_profile,
                               CodecConfigPars process,
                               RateControlMetrics* rc_metrics) {
     // Codec/config settings.
     codec_type_ = process.codec_type;
+    hw_codec_ = process.hw_codec;
     start_bitrate_ = rate_profile.target_bit_rate[0];
     packet_loss_ = process.packet_loss;
     key_frame_interval_ = process.key_frame_interval;
     num_temporal_layers_ = process.num_temporal_layers;
     error_concealment_on_ = process.error_concealment_on;
     denoising_on_ = process.denoising_on;
     frame_dropper_on_ = process.frame_dropper_on;
     spatial_resize_on_ = process.spatial_resize_on;
     SetUpCodecConfig(process.filename, process.width, process.height,
                      process.verbose_logging);
@@ skipping 92 matching lines @@
                                  int frame_rate,
                                  int frame_index_rate_update) {
     rate_profile->target_bit_rate[update_index] = bit_rate;
     rate_profile->input_frame_rate[update_index] = frame_rate;
     rate_profile->frame_index_rate_update[update_index] =
         frame_index_rate_update;
   }
 
   static void SetCodecParameters(CodecConfigPars* process_settings,
                                  VideoCodecType codec_type,
+                                 bool hw_codec,
                                  float packet_loss,
                                  int key_frame_interval,
                                  int num_temporal_layers,
                                  bool error_concealment_on,
                                  bool denoising_on,
                                  bool frame_dropper_on,
                                  bool spatial_resize_on,
                                  int width,
                                  int height,
                                  const std::string& filename,
                                  bool verbose_logging) {
     process_settings->codec_type = codec_type;
+    process_settings->hw_codec = hw_codec;
     process_settings->packet_loss = packet_loss;
     process_settings->key_frame_interval = key_frame_interval;
     process_settings->num_temporal_layers = num_temporal_layers,
     process_settings->error_concealment_on = error_concealment_on;
     process_settings->denoising_on = denoising_on;
     process_settings->frame_dropper_on = frame_dropper_on;
     process_settings->spatial_resize_on = spatial_resize_on;
     process_settings->width = width;
     process_settings->height = height;
     process_settings->filename = filename;
     process_settings->verbose_logging = verbose_logging;
   }
 
   static void SetCodecParameters(CodecConfigPars* process_settings,
                                  VideoCodecType codec_type,
+                                 bool hw_codec,
                                  float packet_loss,
                                  int key_frame_interval,
                                  int num_temporal_layers,
                                  bool error_concealment_on,
                                  bool denoising_on,
                                  bool frame_dropper_on,
                                  bool spatial_resize_on) {
-    SetCodecParameters(process_settings, codec_type, packet_loss,
+    SetCodecParameters(process_settings, codec_type, hw_codec, packet_loss,
                        key_frame_interval, num_temporal_layers,
                        error_concealment_on, denoising_on, frame_dropper_on,
                        spatial_resize_on, kCifWidth, kCifHeight,
                        kFilenameForemanCif, false /* verbose_logging */);
   }
 
   static void SetQualityMetrics(QualityMetrics* quality_metrics,
                                 double minimum_avg_psnr,
                                 double minimum_min_psnr,
                                 double minimum_avg_ssim,
@@ skipping 19 matching lines @@
     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;
     rc_metrics[update_index].num_key_frames = num_key_frames;
   }
 
   std::unique_ptr<VideoEncoder> encoder_;
+  std::unique_ptr<cricket::WebRtcVideoEncoderFactory> external_encoder_factory_;
   std::unique_ptr<VideoDecoder> decoder_;
+  std::unique_ptr<cricket::WebRtcVideoDecoderFactory> external_decoder_factory_;
   std::unique_ptr<test::FrameReader> frame_reader_;
   std::unique_ptr<test::FrameWriter> frame_writer_;
   test::PacketReader packet_reader_;
   std::unique_ptr<test::PacketManipulator> packet_manipulator_;
   test::Stats stats_;
   test::TestConfig config_;
   VideoCodec codec_settings_;
+  // Must be destroyed before |encoder_| and |decoder_|.
   std::unique_ptr<test::VideoProcessor> processor_;
   TemporalLayersFactory tl_factory_;
 
   // Quantities defined/updated for every encoder rate update.
   // Some quantities defined per temporal layer (at most 3 layers in this test).
   int num_frames_per_update_[3];
   float sum_frame_size_mismatch_[3];
   float sum_encoded_frame_size_[3];
   float encoding_bitrate_[3];
   float per_frame_bandwidth_[3];
   float bit_rate_layer_[3];
   float frame_rate_layer_[3];
   int num_frames_total_;
   float sum_encoded_frame_size_total_;
   float encoding_bitrate_total_;
   float perc_encoding_rate_mismatch_;
   int num_frames_to_hit_target_;
   bool encoding_rate_within_target_;
   int bit_rate_;
   int frame_rate_;
   int layer_;
   float target_size_key_frame_initial_;
   float target_size_key_frame_;
   float sum_key_frame_size_mismatch_;
   int num_key_frames_;
   float start_bitrate_;
 
   // Codec and network settings.
   VideoCodecType codec_type_;
+  bool hw_codec_;
   float packet_loss_;
   int num_temporal_layers_;
   int key_frame_interval_;
   bool error_concealment_on_;
   bool denoising_on_;
   bool frame_dropper_on_;
   bool spatial_resize_on_;
 };
 
 }  // namespace test
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_INTEGRATIONTEST_H_