Add support for creating HW codecs in the VideoProcessor tests.

This CL adds the ability to _create_ HW codecs (Android and iOS) in the
VideoProcessor integration tests. Since the VideoProcessor class is not thread
safe yet, this CL does not add the ability to _use_ HW codecs in the tests. A
follow-up CL is planned that will add this ability.

This CL further adds a separate build target which is used to separate the
"plot" versions of the integration tests from the "correctness" versions. The
former will be run manually on devices, whereas the latter are used on the
trybots/buildbots to find regressions in the SW codecs. The underlying test
is the same, however.

BUG=webrtc:6634

Review-Url: https://codereview.webrtc.org/2695653002
Cr-Commit-Position: refs/heads/master@{#16716}

Author: rasmusbrandt

Diff for: resources/foreman_128x96.yuv.sha1

@@ -0,0 +1 @@
+bf2fe75c6921c2be9c8cfd1cc00c6540133a2931

Diff for: resources/foreman_160x120.yuv.sha1

@@ -0,0 +1 @@
+315d8a7cc06fe15b68a6f2106d59d25b16270552

Diff for: resources/foreman_176x144.yuv.sha1

@@ -0,0 +1 @@
+4a38b5629845646844350a4257a60554888509b9

Diff for: resources/foreman_320x240.yuv.sha1

@@ -0,0 +1 @@
+bb838d60f2a0454af4ca63735d573069858ec004

Diff for: webrtc/modules/video_coding/BUILD.gn

@@ -341,32 +341,137 @@ if (rtc_include_tests) {
     ]
   }
 
-  rtc_source_set("video_coding_modules_tests") {
+  rtc_source_set("video_coding_videoprocessor_integration_test") {
     testonly = true
+
     sources = [
-      "codecs/test/videoprocessor_integrationtest.cc",
       "codecs/test/videoprocessor_integrationtest.h",
-      "codecs/vp8/test/vp8_impl_unittest.cc",
     ]
+
     deps = [
       ":video_codecs_test_framework",
       ":video_coding",
       ":webrtc_h264",
       ":webrtc_vp8",
       ":webrtc_vp9",
       "../..:webrtc_common",
+      "../../base:rtc_base_approved",
+      "../../media:rtc_media",
+      "../../test:test_support",
+      "../../test:video_test_support",
+    ]
+
+    if (is_android) {
+      sources += [
+        "codecs/test/android_test_initializer.cc",
+        "codecs/test/android_test_initializer.h",
+      ]
+
+      deps += [
+        "../../base:rtc_base_approved",
+        "../../sdk/android:libjingle_peerconnection_jni",
+        "//base",
+      ]
+    }
+
+    if (is_ios || is_mac) {
+      deps += [
+        "../../media:rtc_media_base",
+        "../../sdk:webrtc_h264_video_toolbox",
+      ]
+    }
+  }
+
+  rtc_source_set("video_coding_modules_tests") {
+    testonly = true
+
+    sources = [
+      "codecs/test/videoprocessor_integrationtest.cc",
+      "codecs/vp8/test/vp8_impl_unittest.cc",
+    ]
+
+    deps = [
+      ":video_coding_videoprocessor_integration_test",
+      ":webrtc_vp8",
       "../../api:video_frame_api",
       "../../base:rtc_base_approved",
       "../../common_video:common_video",
-      "../../media:rtc_media_base",
       "../../test:test_support",
       "../../test:video_test_common",
-      "../../test:video_test_support",
       "../video_capture",
     ]
+
     if (rtc_use_h264) {
       defines = [ "WEBRTC_VIDEOPROCESSOR_H264_TESTS" ]
     }
+
+    if (!build_with_chromium && is_clang) {
+      # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
+      suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
+    }
+  }
+
+  plot_videoprocessor_integrationtest_resources = [
+    "//resources/foreman_128x96.yuv",
+    "//resources/foreman_160x120.yuv",
+    "//resources/foreman_176x144.yuv",
+    "//resources/foreman_320x240.yuv",
+    "//resources/foreman_cif.yuv",
+  ]
+
+  if (is_ios || is_mac) {
+    bundle_data("plot_videoprocessor_integrationtest_bundle_data") {
+      testonly = true
+      sources = plot_videoprocessor_integrationtest_resources
+      outputs = [
+        "{{bundle_resources_dir}}/{{source_file_part}}",
+      ]
+    }
+  }
+
+  # This executable is meant for local codec perf testing and should not be run
+  # on the trybots/buildbots, hence the existence of this special build target.
+  rtc_test("plot_videoprocessor_integrationtest") {
+    testonly = true
+
+    sources = [
+      "codecs/test/plot_videoprocessor_integrationtest.cc",
+    ]
+
+    deps = [
+      ":video_coding_videoprocessor_integration_test",
+      "../../test:test_main",
+      "../../test:video_test_common",
+      "../video_capture",
+    ]
+
+    data = plot_videoprocessor_integrationtest_resources
+
+    if (is_android) {
+      deps += [
+        "../../base:rtc_base_approved",
+
+        # TODO(brandtr): Figure out if the java dep below could be moved into
+        # :video_coding_videoprocessor_integration_test, where it belongs.
+        # When that is done, support for Android HW codecs can be added to the
+        # modules_tests target as well.
+        "../../sdk/android:libjingle_peerconnection_java",
+        "../../sdk/android:libjingle_peerconnection_jni",
+        "//base",
+        "//testing/android/native_test:native_test_support",
+      ]
+
+      shard_timeout = 900
+    }
+
+    if (is_ios || is_mac) {
+      deps += [ ":plot_videoprocessor_integrationtest_bundle_data" ]
+    }
+
+    # TODO(brandtr): Remove this define when the modules_tests target properly
+    # loads the Java classes mentioned above.
+    defines = [ "WEBRTC_VIDEOPROCESSOR_INTEGRATIONTEST_HW_CODECS_ENABLED" ]
+
     if (!build_with_chromium && is_clang) {
       # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
       suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]

Diff for: webrtc/modules/video_coding/DEPS

@@ -8,3 +8,14 @@ include_rules = [
   "+webrtc/system_wrappers",
   "+webrtc/tools",
 ]
+
+specific_include_rules = {
+  "android_test_initializer\.cc": [
+    "+base/android",
+    "+webrtc/sdk",
+  ],
+  "(.*test\.cc|.*test\.h)": [
+     "+webrtc/media/engine",
+     "+webrtc/sdk",
+  ],
+}

Diff for: webrtc/modules/video_coding/codecs/test/android_test_initializer.cc

@@ -0,0 +1,55 @@
+/*
+ *  Copyright 2017 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 <pthread.h>
+
+#include "webrtc/base/ignore_wundef.h"
+#include "webrtc/modules/video_coding/codecs/test/android_test_initializer.h"
+#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
+#include "webrtc/sdk/android/src/jni/jni_helpers.h"
+
+// Note: this dependency is dangerous since it reaches into Chromium's base.
+// There's a risk of e.g. macro clashes. This file may only be used in tests.
+// Since we use Chrome's build system for creating the gtest binary, this should
+// be fine.
+RTC_PUSH_IGNORING_WUNDEF()
+#include "base/android/jni_android.h"
+RTC_POP_IGNORING_WUNDEF()
+
+#include "webrtc/base/checks.h"
+
+namespace webrtc {
+
+namespace {
+
+static pthread_once_t g_initialize_once = PTHREAD_ONCE_INIT;
+
+// There can only be one JNI_OnLoad in each binary. So since this is a GTEST
+// C++ runner binary, we want to initialize the same global objects we normally
+// do if this had been a Java binary.
+void EnsureInitializedOnce() {
+  RTC_CHECK(::base::android::IsVMInitialized());
+  JNIEnv* jni = ::base::android::AttachCurrentThread();
+  JavaVM* jvm = NULL;
+  RTC_CHECK_EQ(0, jni->GetJavaVM(&jvm));
+
+  jint ret = webrtc_jni::InitGlobalJniVariables(jvm);
+  RTC_DCHECK_GE(ret, 0);
+
+  webrtc_jni::LoadGlobalClassReferenceHolder();
+}
+
+}  // namespace
+
+void InitializeAndroidObjects() {
+  RTC_CHECK_EQ(0, pthread_once(&g_initialize_once, &EnsureInitializedOnce));
+}
+
+}  // namespace webrtc

Diff for: webrtc/modules/video_coding/codecs/test/android_test_initializer.h

@@ -0,0 +1,20 @@
+/*
+ *  Copyright 2017 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_ANDROID_TEST_INITIALIZER_H_
+#define WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_ANDROID_TEST_INITIALIZER_H_
+
+namespace webrtc {
+
+void InitializeAndroidObjects();
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_ANDROID_TEST_INITIALIZER_H_

Diff for: webrtc/modules/video_coding/codecs/test/plot_videoprocessor_integrationtest.cc

@@ -21,6 +21,7 @@ const bool kDenoisingOn = false;
 const bool kFrameDropperOn = true;
 const bool kSpatialResizeOn = false;
 const VideoCodecType kVideoCodecType[] = {kVideoCodecVP8};
+const bool kHwCodec = false;
 
 // Packet loss probability [0.0, 1.0].
 const float kPacketLoss = 0.0f;
@@ -52,7 +53,7 @@ class PlotVideoProcessorIntegrationTest
     rate_profile.num_frames = kNumFramesLong;
     // Codec/network settings.
     CodecConfigPars process_settings;
-    SetCodecParameters(&process_settings, codec_type_, kPacketLoss,
+    SetCodecParameters(&process_settings, codec_type_, kHwCodec, kPacketLoss,
                        -1,  // key_frame_interval
                        1,   // num_temporal_layers
                        kErrorConcealmentOn, kDenoisingOn, kFrameDropperOn,
@@ -87,23 +88,23 @@ INSTANTIATE_TEST_CASE_P(
                        ::testing::ValuesIn(kFps),
                        ::testing::ValuesIn(kVideoCodecType)));
 
-TEST_P(PlotVideoProcessorIntegrationTest, ProcessSQCif) {
+TEST_P(PlotVideoProcessorIntegrationTest, Process128x96) {
   RunTest(128, 96, "foreman_128x96");
 }
 
-TEST_P(PlotVideoProcessorIntegrationTest, ProcessQQVga) {
+TEST_P(PlotVideoProcessorIntegrationTest, Process160x120) {
   RunTest(160, 120, "foreman_160x120");
 }
 
-TEST_P(PlotVideoProcessorIntegrationTest, ProcessQCif) {
+TEST_P(PlotVideoProcessorIntegrationTest, Process176x144) {
   RunTest(176, 144, "foreman_176x144");
 }
 
-TEST_P(PlotVideoProcessorIntegrationTest, ProcessQVga) {
+TEST_P(PlotVideoProcessorIntegrationTest, Process320x240) {
   RunTest(320, 240, "foreman_320x240");
 }
 
-TEST_P(PlotVideoProcessorIntegrationTest, ProcessCif) {
+TEST_P(PlotVideoProcessorIntegrationTest, Process352x288) {
   RunTest(352, 288, "foreman_cif");
 }
 

Diff for: webrtc/modules/video_coding/codecs/test/videoprocessor.cc

@@ -374,7 +374,11 @@ void VideoProcessorImpl::FrameDecoded(const VideoFrame& image) {
                            config_.codec_settings->height));
 
     // Should be the same aspect ratio, no cropping needed.
-    up_image->ScaleFrom(*image.video_frame_buffer());
+    if (image.video_frame_buffer()->native_handle()) {
+      up_image->ScaleFrom(*image.video_frame_buffer()->NativeToI420Buffer());
+    } else {
+      up_image->ScaleFrom(*image.video_frame_buffer());
+    }
 
     // TODO(mikhal): Extracting the buffer for now - need to update test.
     size_t length =
@@ -395,7 +399,15 @@ void VideoProcessorImpl::FrameDecoded(const VideoFrame& image) {
     // TODO(mikhal): Add as a member function, so won't be allocated per frame.
     size_t length = CalcBufferSize(kI420, image.width(), image.height());
     std::unique_ptr<uint8_t[]> image_buffer(new uint8_t[length]);
-    int extracted_length = ExtractBuffer(image, length, image_buffer.get());
+    int extracted_length;
+    if (image.video_frame_buffer()->native_handle()) {
+      extracted_length =
+          ExtractBuffer(image.video_frame_buffer()->NativeToI420Buffer(),
+                        length, image_buffer.get());
+    } else {
+      extracted_length =
+          ExtractBuffer(image.video_frame_buffer(), length, image_buffer.get());
+    }
     RTC_DCHECK_GT(extracted_length, 0);
     memcpy(last_successful_frame_buffer_.get(), image_buffer.get(),
            extracted_length);

Diff for: webrtc/modules/video_coding/codecs/test/videoprocessor.h

@@ -205,13 +205,13 @@ class VideoProcessorImpl : public VideoProcessor {
     }
     int32_t Decoded(webrtc::VideoFrame& image,
                     int64_t decode_time_ms) override {
-      RTC_NOTREACHED();
-      return -1;
+      return Decoded(image);
     }
-    void Decoded(VideoFrame& frame,
+    void Decoded(webrtc::VideoFrame& image,
                  rtc::Optional<int32_t> decode_time_ms,
                  rtc::Optional<uint8_t> qp) override {
-      RTC_NOTREACHED();
+      Decoded(image,
+              decode_time_ms ? static_cast<int32_t>(*decode_time_ms) : -1);
     }
 
    private: