Add multiple video encoders/decoders to video encoder/decoder unittest

content/common/gpu/media/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 "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/memory/scoped_vector.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/sys_byteorder.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "content/common/gpu/media/video_accelerator_unittest_helpers.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/test_data_util.h"
 #include "media/filters/h264_parser.h"
 #include "media/video/video_encode_accelerator.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(USE_OZONE)
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
-#if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL)
+#if defined(OS_CHROMEOS)
+#if defined(ARCH_CPU_ARMEL) || (defined(USE_OZONE) && defined(USE_V4L2_CODEC))
 #include "content/common/gpu/media/v4l2_video_encode_accelerator.h"
-#elif defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
+// defined(ARCH_CPU_ARMEL) || (defined(USE_OZONE) && defined(USE_V4L2_CODEC))
+#endif
+#if defined(ARCH_CPU_X86_FAMILY)
 #include "content/common/gpu/media/vaapi_video_encode_accelerator.h"
+#endif  // defined(ARCH_CPU_X86_FAMILY)
 #else
 #error The VideoEncodeAcceleratorUnittest is not supported on this platform.
 #endif
 
 using media::VideoEncodeAccelerator;
 
 namespace content {
 namespace {
 
 const media::VideoFrame::Format kInputFormat = media::VideoFrame::I420;
@@ skipping 475 matching lines @@
                                        const gfx::Size& input_coded_size,
                                        size_t output_buffer_size) override;
   virtual void BitstreamBufferReady(int32 bitstream_buffer_id,
                                     size_t payload_size,
                                     bool key_frame) override;
   virtual void NotifyError(VideoEncodeAccelerator::Error error) override;
 
  private:
   bool has_encoder() { return encoder_.get(); }
 
+  scoped_ptr<media::VideoEncodeAccelerator> CreateV4L2VEA();
+  scoped_ptr<media::VideoEncodeAccelerator> CreateVaapiVEA();
+
   void SetState(ClientState new_state);
 
   // Set current stream parameters to given |bitrate| at |framerate|.
   void SetStreamParameters(unsigned int bitrate, unsigned int framerate);
 
   // Called when encoder is done with a VideoFrame.
   void InputNoLongerNeededCallback(int32 input_id);
 
   // Feed the encoder with one input frame.
   void FeedEncoderWithOneInput();
@@ skipping 182 matching lines @@
   }
 
   // Initialize the parameters of the test streams.
   UpdateTestStreamData(mid_stream_bitrate_switch, mid_stream_framerate_switch);
 
   thread_checker_.DetachFromThread();
 }
 
 VEAClient::~VEAClient() { CHECK(!has_encoder()); }
 
+scoped_ptr<media::VideoEncodeAccelerator> VEAClient::CreateV4L2VEA() {
+  scoped_ptr<media::VideoEncodeAccelerator> encoder;
+#if defined(OS_CHROMEOS) && (defined(ARCH_CPU_ARMEL) || \
+    (defined(USE_OZONE) && defined(USE_V4L2_CODEC)))
+  scoped_ptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kEncoder);
+  if (device)
+    encoder.reset(new V4L2VideoEncodeAccelerator(device.Pass()));
+#endif
+  return encoder.Pass();
+}
+
+scoped_ptr<media::VideoEncodeAccelerator> VEAClient::CreateVaapiVEA() {
+  scoped_ptr<media::VideoEncodeAccelerator> encoder;
+#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
+  encoder.reset(new VaapiVideoEncodeAccelerator());
+#endif
+  return encoder.Pass();
+}
+
 void VEAClient::CreateEncoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   CHECK(!has_encoder());
 
-#if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL)
-  scoped_ptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kEncoder);
-  encoder_.reset(new V4L2VideoEncodeAccelerator(device.Pass()));
-#elif defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
-  encoder_.reset(new VaapiVideoEncodeAccelerator());
-#endif
-
-  SetState(CS_ENCODER_SET);
+  scoped_ptr<media::VideoEncodeAccelerator> encoders[] = {
+    CreateV4L2VEA(),
+    CreateVaapiVEA()
+  };
+  size_t num_encoders = sizeof(encoders) /
+      sizeof(scoped_ptr<media::VideoEncodeAccelerator>);
 
   DVLOG(1) << "Profile: " << test_stream_->requested_profile
            << ", initial bitrate: " << requested_bitrate_;
-  if (!encoder_->Initialize(kInputFormat,
-                            test_stream_->visible_size,
-                            test_stream_->requested_profile,
-                            requested_bitrate_,
-                            this)) {
-    LOG(ERROR) << "VideoEncodeAccelerator::Initialize() failed";
-    SetState(CS_ERROR);
-    return;
+
+  for (size_t i = 0; i < num_encoders; ++i) {
+    if (!encoders[i])
+      continue;
+    encoder_ = encoders[i].Pass();
+    SetState(CS_ENCODER_SET);
+    if (encoder_->Initialize(kInputFormat,
+                             test_stream_->visible_size,
+                             test_stream_->requested_profile,
+                             requested_bitrate_,
+                             this)) {
+      SetStreamParameters(requested_bitrate_, requested_framerate_);
+      SetState(CS_INITIALIZED);
+      return;
+    }
   }
 
-  SetStreamParameters(requested_bitrate_, requested_framerate_);
-  SetState(CS_INITIALIZED);
+  LOG(ERROR) << "VideoEncodeAccelerator::Initialize() failed";
+  SetState(CS_ERROR);
 }
 
 void VEAClient::DestroyEncoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!has_encoder())
     return;
   encoder_.reset();
   input_timer_.reset();
 }
 
@@ skipping 568 matching lines @@
   }
 
   content::g_env =
       reinterpret_cast<content::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new content::VideoEncodeAcceleratorTestEnvironment(
                   test_stream_data.Pass(), run_at_fps)));
 
   return RUN_ALL_TESTS();
 }