Refactor: Extract gpu_video_encode_accelerator_factory.

media/gpu/video_encode_accelerator_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <inttypes.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 30 matching lines @@
 #include "media/base/decoder_buffer.h"
 #include "media/base/media_log.h"
 #include "media/base/media_util.h"
 #include "media/base/test_data_util.h"
 #include "media/base/video_decoder.h"
 #include "media/base/video_frame.h"
 #include "media/filters/ffmpeg_glue.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #include "media/filters/h264_parser.h"
 #include "media/filters/ivf_parser.h"
+#include "media/gpu/gpu_video_encode_accelerator_factory.h"
 #include "media/gpu/video_accelerator_unittest_helpers.h"
 #include "media/video/fake_video_encode_accelerator.h"
 #include "media/video/video_encode_accelerator.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-#if defined(OS_CHROMEOS)
-#if defined(USE_V4L2_CODEC)
-#include "base/threading/thread_task_runner_handle.h"
-#include "media/gpu/v4l2_video_encode_accelerator.h"
-#endif
-#if defined(ARCH_CPU_X86_FAMILY)
-#include "media/gpu/vaapi_video_encode_accelerator.h"
+#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
 #include "media/gpu/vaapi_wrapper.h"
-// Status has been defined as int in Xlib.h.
-#undef Status
-#endif  // defined(ARCH_CPU_X86_FAMILY)
-#elif defined(OS_MACOSX)
-#include "media/gpu/vt_video_encode_accelerator_mac.h"
-#elif defined(OS_WIN)
-#include "media/gpu/media_foundation_video_encode_accelerator_win.h"
-#else
-#error The VideoEncodeAcceleratorUnittest is not supported on this platform.
 #endif
 
 namespace media {
 namespace {
 
 const VideoPixelFormat kInputFormat = PIXEL_FORMAT_I420;
 
 // The absolute differences between original frame and decoded frame usually
 // ranges aroud 1 ~ 7. So we pick 10 as an extreme value to detect abnormal
 // decoded frames.
@@ skipping 352 matching lines @@
     }
 
     if (fields.size() >= 9 && !fields[8].empty()) {
       LOG_ASSERT(base::StringToUint(
           fields[8], &test_stream->requested_subsequent_framerate));
     }
     test_streams->push_back(test_stream);
   }
 }
 
-static std::unique_ptr<VideoEncodeAccelerator> CreateFakeVEA() {
-  std::unique_ptr<VideoEncodeAccelerator> encoder;
-  if (g_fake_encoder) {
-    encoder.reset(new FakeVideoEncodeAccelerator(
-        scoped_refptr<base::SingleThreadTaskRunner>(
-            base::ThreadTaskRunnerHandle::Get())));
-  }
-  return encoder;
-}
-
-static std::unique_ptr<VideoEncodeAccelerator> CreateV4L2VEA() {
-  std::unique_ptr<VideoEncodeAccelerator> encoder;
-#if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
-  scoped_refptr<V4L2Device> device = V4L2Device::Create();
-  if (device)
-    encoder.reset(new V4L2VideoEncodeAccelerator(device));
-#endif
-  return encoder;
-}
-
-static std::unique_ptr<VideoEncodeAccelerator> CreateVaapiVEA() {
-  std::unique_ptr<VideoEncodeAccelerator> encoder;
-#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
-  encoder.reset(new VaapiVideoEncodeAccelerator());
-#endif
-  return encoder;
-}
-
-static std::unique_ptr<VideoEncodeAccelerator> CreateVTVEA() {
-  std::unique_ptr<VideoEncodeAccelerator> encoder;
-#if defined(OS_MACOSX)
-  encoder.reset(new VTVideoEncodeAccelerator());
-#endif
-  return encoder;
-}
-
-static std::unique_ptr<VideoEncodeAccelerator> CreateMFVEA() {
-  std::unique_ptr<VideoEncodeAccelerator> encoder;
-#if defined(OS_WIN)
-  MediaFoundationVideoEncodeAccelerator::PreSandboxInitialization();
-  encoder.reset(new MediaFoundationVideoEncodeAccelerator());
-#endif
-  return encoder;
-}
-
 // Basic test environment shared across multiple test cases. We only need to
 // setup it once for all test cases.
 // It helps
 // - maintain test stream data and other test settings.
 // - clean up temporary aligned files.
 // - output log to file.
 class VideoEncodeAcceleratorTestEnvironment : public ::testing::Environment {
  public:
   VideoEncodeAcceleratorTestEnvironment(
       std::unique_ptr<base::FilePath::StringType> data,
@@ skipping 715 matching lines @@
     // Without it, AppendToFile() will not work.
     EXPECT_EQ(0, base::WriteFile(out_filename, NULL, 0));
   }
 
   // Initialize the parameters of the test streams.
   UpdateTestStreamData(mid_stream_bitrate_switch, mid_stream_framerate_switch);
 
   thread_checker_.DetachFromThread();
 }
 
+// Helper function to create VEA.
+static std::unique_ptr<VideoEncodeAccelerator> CreateVideoEncodeAccelerator(
+    VideoPixelFormat input_format,
+    const gfx::Size& input_visible_size,
+    VideoCodecProfile output_profile,
+    uint32_t initial_bitrate,
+    VideoEncodeAccelerator::Client* client,
+    const gpu::GpuPreferences& gpu_preferences) {
+  if (g_fake_encoder) {
+    std::unique_ptr<VideoEncodeAccelerator> encoder(
+        new FakeVideoEncodeAccelerator(
+            scoped_refptr<base::SingleThreadTaskRunner>(
+                base::ThreadTaskRunnerHandle::Get())));
+    if (encoder->Initialize(input_format, input_visible_size, output_profile,
+                            initial_bitrate, client))
+      return encoder;
+    return nullptr;
+  } else {
+    return GpuVideoEncodeAcceleratorFactory::CreateVEA(
+        input_format, input_visible_size, output_profile, initial_bitrate,
+        client, gpu_preferences);
+  }
+}
+
 void VEAClient::CreateEncoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   LOG_ASSERT(!has_encoder());
 
   vea_client_task_runner_ = base::ThreadTaskRunnerHandle::Get();
   encode_task_runner_ = vea_client_task_runner_;
 
-  std::unique_ptr<VideoEncodeAccelerator> encoders[] = {
-      CreateFakeVEA(), CreateV4L2VEA(), CreateVaapiVEA(), CreateVTVEA(),
-      CreateMFVEA()};
-
   DVLOG(1) << "Profile: " << test_stream_->requested_profile
            << ", initial bitrate: " << requested_bitrate_;
 
-  for (size_t i = 0; i < arraysize(encoders); ++i) {
-    if (!encoders[i])
-      continue;
-    encoder_ = std::move(encoders[i]);
-    if (encoder_->Initialize(kInputFormat, test_stream_->visible_size,
-                             test_stream_->requested_profile,
-                             requested_bitrate_, this)) {
-      encoder_weak_factory_.reset(
-          new base::WeakPtrFactory<VideoEncodeAccelerator>(encoder_.get()));
-      TryToSetupEncodeOnSeparateThread();
-      SetStreamParameters(requested_bitrate_, requested_framerate_);
-      SetState(CS_INITIALIZED);
+  encoder_ = CreateVideoEncodeAccelerator(
+      kInputFormat, test_stream_->visible_size, test_stream_->requested_profile,
+      requested_bitrate_, this, gpu::GpuPreferences());
+  if (!encoder_) {
+    LOG(ERROR) << "Failed creating a VideoEncodeAccelerator.";
+    SetState(CS_ERROR);
+    return;
+  }
+  encoder_weak_factory_.reset(
+      new base::WeakPtrFactory<VideoEncodeAccelerator>(encoder_.get()));
+  TryToSetupEncodeOnSeparateThread();
+  SetStreamParameters(requested_bitrate_, requested_framerate_);
+  SetState(CS_INITIALIZED);
 
-      if (verify_output_ && !g_fake_encoder)
-        quality_validator_.reset(new VideoFrameQualityValidator(
-            test_stream_->requested_profile,
-            base::Bind(&VEAClient::DecodeCompleted, base::Unretained(this)),
-            base::Bind(&VEAClient::DecodeFailed, base::Unretained(this))));
-      return;
-    }
-  }
-  encoder_.reset();
-  LOG(ERROR) << "VideoEncodeAccelerator::Initialize() failed";
-  SetState(CS_ERROR);
+  if (verify_output_ && !g_fake_encoder)
+    quality_validator_.reset(new VideoFrameQualityValidator(
+        test_stream_->requested_profile,
+        base::Bind(&VEAClient::DecodeCompleted, base::Unretained(this)),
+        base::Bind(&VEAClient::DecodeFailed, base::Unretained(this))));
 }
 
 void VEAClient::DecodeCompleted() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   SetState(CS_VALIDATED);
 }
 
 void VEAClient::TryToSetupEncodeOnSeparateThread() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 576 matching lines @@
       bitrate_(200000),
       fps_(30) {
   thread_checker_.DetachFromThread();
 }
 
 void SimpleVEAClientBase::CreateEncoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   LOG_ASSERT(!has_encoder());
   LOG_ASSERT(g_env->test_streams_.size());
 
-  std::unique_ptr<VideoEncodeAccelerator> encoders[] = {
-      CreateFakeVEA(), CreateV4L2VEA(), CreateVaapiVEA(), CreateVTVEA(),
-      CreateMFVEA()};
-
   gfx::Size visible_size(width_, height_);
-  for (auto& encoder : encoders) {
-    if (!encoder)
-      continue;
-    encoder_ = std::move(encoder);
-    if (encoder_->Initialize(kInputFormat, visible_size,
-                             g_env->test_streams_[0]->requested_profile,
-                             bitrate_, this)) {
-      encoder_->RequestEncodingParametersChange(bitrate_, fps_);
-      SetState(CS_INITIALIZED);
-      return;
-    }
+  encoder_ = CreateVideoEncodeAccelerator(
+      kInputFormat, visible_size, g_env->test_streams_[0]->requested_profile,
+      bitrate_, this, gpu::GpuPreferences());
+  if (!encoder_) {
+    LOG(ERROR) << "Failed creating a VideoEncodeAccelerator.";
+    SetState(CS_ERROR);
+    return;
   }
-  encoder_.reset();
-  LOG(ERROR) << "VideoEncodeAccelerator::Initialize() failed";
-  SetState(CS_ERROR);
+  encoder_->RequestEncodingParametersChange(bitrate_, fps_);
+  SetState(CS_INITIALIZED);
 }
 
 void SimpleVEAClientBase::DestroyEncoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!has_encoder())
     return;
   // Clear the objects that should be destroyed on the same thread as creation.
   encoder_.reset();
 }
 
@@ skipping 478 matching lines @@
 
   if (needs_encode_latency && !run_at_fps) {
     // Encode latency can only be measured with --run_at_fps. Otherwise, we get
     // skewed results since it may queue too many frames at once with the same
     // encode start time.
     LOG(FATAL) << "--measure_latency requires --run_at_fps enabled to work.";
   }
 
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   media::VaapiWrapper::PreSandboxInitialization();
+#elif defined(OS_WIN)
+  MediaFoundationVideoEncodeAccelerator::PreSandboxInitialization();
 #endif
 
   media::g_env =
       reinterpret_cast<media::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new media::VideoEncodeAcceleratorTestEnvironment(
                   std::move(test_stream_data), log_path, run_at_fps,
                   needs_encode_latency, verify_all_output)));
 
   return RUN_ALL_TESTS();
 }