Support external buffer import in VDA interface and add a V4L2SVDA impl.

content/common/gpu/media/video_decode_accelerator_unittest.cc

 // Copyright (c) 2012 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.
 //
 // The bulk of this file is support code; sorry about that.  Here's an overview
 // to hopefully help readers of this code:
 // - RenderingHelper is charged with interacting with X11/{EGL/GLES2,GLX/GL} or
 //   Win/EGL.
 // - ClientState is an enum for the state of the decode client used by the test.
 // - ClientStateNotification is a barrier abstraction that allows the test code
@@ skipping 56 matching lines @@
 #endif
 #if defined(ARCH_CPU_X86_FAMILY)
 #include "content/common/gpu/media/vaapi_video_decode_accelerator.h"
 #include "content/common/gpu/media/vaapi_wrapper.h"
 #endif  // defined(ARCH_CPU_X86_FAMILY)
 #else
 #error The VideoAccelerator tests are not supported on this platform.
 #endif  // OS_WIN
 
 #if defined(USE_OZONE)
+#include "ui/ozone/public/native_pixmap.h"
 #include "ui/ozone/public/ozone_gpu_test_helper.h"
 #include "ui/ozone/public/ozone_platform.h"
+#include "ui/ozone/public/surface_factory_ozone.h"
 #endif  // defined(USE_OZONE)
 
 using media::VideoDecodeAccelerator;
 
 namespace content {
 namespace {
 
 using base::MakeTuple;
 
 // Values optionally filled in from flags; see main() below.
@@ skipping 29 matching lines @@
 int g_rendering_warm_up = 0;
 
 // The value is set by the switch "--num_play_throughs". The video will play
 // the specified number of times. In different test cases, we have different
 // values for |num_play_throughs|. This setting will override the value. A
 // special value "0" means no override.
 int g_num_play_throughs = 0;
 // Fake decode
 int g_fake_decoder = 0;
 
+// Test buffer import into VDA, providing buffers allocated by us, instead of
+// requesting the VDA itself to allocate buffers.
+bool g_test_import = false;
+
 // Environment to store rendering thread.
 class VideoDecodeAcceleratorTestEnvironment;
 VideoDecodeAcceleratorTestEnvironment* g_env;
 
 // Magic constants for differentiating the reasons for NotifyResetDone being
 // called.
 enum ResetPoint {
   // Reset() just after calling Decode() with a fragment containing config info.
   RESET_AFTER_FIRST_CONFIG_INFO = -4,
   START_OF_STREAM_RESET = -3,
@@ skipping 127 matching lines @@
 #if defined(USE_OZONE)
   std::unique_ptr<ui::OzoneGpuTestHelper> gpu_helper_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(VideoDecodeAcceleratorTestEnvironment);
 };
 
 // A helper class used to manage the lifetime of a Texture.
 class TextureRef : public base::RefCounted<TextureRef> {
  public:
-  TextureRef(uint32_t texture_id, const base::Closure& no_longer_needed_cb)
-      : texture_id_(texture_id), no_longer_needed_cb_(no_longer_needed_cb) {}
+  TextureRef(uint32_t texture_id,
+             const scoped_refptr<ui::NativePixmap>& pixmap,
+             const base::Closure& no_longer_needed_cb)
+      : texture_id_(texture_id),
+        pixmap_(pixmap),
+        no_longer_needed_cb_(no_longer_needed_cb) {}
 
   int32_t texture_id() const { return texture_id_; }
+  scoped_refptr<ui::NativePixmap> pixmap() { return pixmap_; }
 
  private:
   friend class base::RefCounted<TextureRef>;
   ~TextureRef();
 
   uint32_t texture_id_;
+  scoped_refptr<ui::NativePixmap> pixmap_;
   base::Closure no_longer_needed_cb_;
 };
 
 TextureRef::~TextureRef() {
   base::ResetAndReturn(&no_longer_needed_cb_).Run();
 }
 
 // Client that can accept callbacks from a VideoDecodeAccelerator and is used by
 // the TESTs below.
 class GLRenderingVDAClient
@@ skipping 229 matching lines @@
   } else {
     if (!vda_factory_) {
       vda_factory_ = GpuVideoDecodeAcceleratorFactoryImpl::Create(
           base::Bind(&RenderingHelper::GetGLContext,
                      base::Unretained(rendering_helper_)),
           base::Bind(&DoNothingReturnTrue), base::Bind(&DummyBindImage));
       LOG_ASSERT(vda_factory_);
     }
 
     VideoDecodeAccelerator::Config config(profile_);
+    if (g_test_import) {
+      config.output_mode =
+          media::VideoDecodeAccelerator::Config::OutputMode::IMPORT;
+    }
     gpu::GpuPreferences gpu_preferences;
     decoder_ = vda_factory_->CreateVDA(this, config, gpu_preferences);
   }
 
   LOG_ASSERT(decoder_) << "Failed creating a VDA";
 
   decoder_->TryToSetupDecodeOnSeparateThread(
       weak_this_, base::ThreadTaskRunnerHandle::Get());
 
   SetState(CS_DECODER_SET);
   FinishInitialization();
 }
 
+namespace {
+gfx::BufferFormat VideoPixelFormatToGfxBufferFormat(
+    media::VideoPixelFormat pixel_format) {
+  switch (pixel_format) {
+    case media::VideoPixelFormat::PIXEL_FORMAT_ARGB:
+      return gfx::BufferFormat::BGRA_8888;
+    case media::VideoPixelFormat::PIXEL_FORMAT_XRGB:
+      return gfx::BufferFormat::BGRX_8888;
+    case media::VideoPixelFormat::PIXEL_FORMAT_NV12:
+      return gfx::BufferFormat::YUV_420_BIPLANAR;
+    default:
+      LOG_ASSERT(false) << "Unknown VideoPixelFormat";
+      return gfx::BufferFormat::BGRX_8888;
+  }
+}
+}
+
 void GLRenderingVDAClient::ProvidePictureBuffers(
     uint32_t requested_num_of_buffers,
     uint32_t textures_per_buffer,
     const gfx::Size& dimensions,
     uint32_t texture_target) {
   if (decoder_deleted())
     return;
   LOG_ASSERT(textures_per_buffer == 1u);
   std::vector<media::PictureBuffer> buffers;
 
   requested_num_of_buffers += kExtraPictureBuffers;
 
   texture_target_ = texture_target;
   for (uint32_t i = 0; i < requested_num_of_buffers; ++i) {
     uint32_t texture_id;
     base::WaitableEvent done(false, false);
     rendering_helper_->CreateTexture(
         texture_target_, &texture_id, dimensions, &done);
     done.Wait();
 
+    scoped_refptr<ui::NativePixmap> pixmap;
+    if (g_test_import) {
+      ui::OzonePlatform* platform = ui::OzonePlatform::GetInstance();
+      ui::SurfaceFactoryOzone* factory = platform->GetSurfaceFactoryOzone();
+      media::VideoPixelFormat pixel_format = decoder_->GetOutputFormat();
+      if (pixel_format == media::PIXEL_FORMAT_UNKNOWN)
+        pixel_format = media::PIXEL_FORMAT_ARGB;
+      gfx::BufferFormat buffer_format =
+          VideoPixelFormatToGfxBufferFormat(pixel_format);
+      pixmap =
+          factory->CreateNativePixmap(gfx::kNullAcceleratedWidget, dimensions,
+                                      buffer_format, gfx::BufferUsage::SCANOUT);
+      LOG_ASSERT(pixmap);
+    }
+
     int32_t picture_buffer_id = next_picture_buffer_id_++;
-    LOG_ASSERT(active_textures_
-              .insert(std::make_pair(
-                  picture_buffer_id,
-                  new TextureRef(texture_id,
-                                 base::Bind(&RenderingHelper::DeleteTexture,
-                                            base::Unretained(rendering_helper_),
-                                            texture_id))))
-              .second);
+    LOG_ASSERT(
+        active_textures_
+            .insert(std::make_pair(
+                picture_buffer_id,
+                new TextureRef(texture_id, pixmap,
+                               base::Bind(&RenderingHelper::DeleteTexture,
+                                          base::Unretained(rendering_helper_),
+                                          texture_id))))
+            .second);
 
     media::PictureBuffer::TextureIds ids;
     ids.push_back(texture_id);
     buffers.push_back(media::PictureBuffer(picture_buffer_id, dimensions, ids));
   }
   decoder_->AssignPictureBuffers(buffers);
+
+  if (g_test_import) {
+    for (const auto& buffer : buffers) {
+      TextureRefMap::iterator texture_it = active_textures_.find(buffer.id());
+      ASSERT_NE(active_textures_.end(), texture_it);
+
+      scoped_refptr<ui::NativePixmap> pixmap = texture_it->second->pixmap();
+      int duped_fd = HANDLE_EINTR(dup(pixmap->GetDmaBufFd()));
+      ASSERT_NE(duped_fd, -1);
+      gfx::GpuMemoryBufferHandle handle;
+      handle.type = gfx::OZONE_NATIVE_PIXMAP;
+      handle.native_pixmap_handle.fd = base::FileDescriptor(duped_fd, true);
+      std::vector<gfx::GpuMemoryBufferHandle> handles;
+      handles.push_back(handle);
+      decoder_->ImportBufferForPicture(buffer.id(), handles);
+    }
+  }
 }
 
 void GLRenderingVDAClient::DismissPictureBuffer(int32_t picture_buffer_id) {
   LOG_ASSERT(1U == active_textures_.erase(picture_buffer_id));
 }
 
 void GLRenderingVDAClient::PictureReady(const media::Picture& picture) {
   // We shouldn't be getting pictures delivered after Reset has completed.
   LOG_ASSERT(state_ < CS_RESET);
 
@@ skipping 958 matching lines @@
       continue;
     }
     if (it->first == "fake_decoder") {
       content::g_fake_decoder = 1;
       continue;
     }
     if (it->first == "v" || it->first == "vmodule")
       continue;
     if (it->first == "ozone-platform" || it->first == "ozone-use-surfaceless")
       continue;
+    if (it->first == "test_import") {
+      content::g_test_import = true;
+      continue;
+    }
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
 
   base::ShadowingAtExitManager at_exit_manager;
 #if defined(OS_WIN) || defined(USE_OZONE)
   // For windows the decoding thread initializes the media foundation decoder
   // which uses COM. We need the thread to be a UI thread.
   // On Ozone, the backend initializes the event system using a UI
   // thread.
   base::MessageLoopForUI main_loop;
 #else
   base::MessageLoop main_loop;
 #endif  // OS_WIN || USE_OZONE
 
 #if defined(USE_OZONE)
   ui::OzonePlatform::InitializeForUI();
 #endif
 
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   content::VaapiWrapper::PreSandboxInitialization();
 #endif
 
   content::g_env =
       reinterpret_cast<content::VideoDecodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new content::VideoDecodeAcceleratorTestEnvironment()));
 
   return RUN_ALL_TESTS();
 }