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 124 matching lines @@
 
  private:
   base::Thread rendering_thread_;
 #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.
+// A helper class used to manage the lifetime of a Texture. Can be backed by
+// either a buffer allocated by the VDA, or by a preallocated pixmap.
 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) {}
+  static scoped_refptr<TextureRef> Create(
+      uint32_t texture_id,
+      const base::Closure& no_longer_needed_cb);
+
+  static scoped_refptr<TextureRef> CreatePreallocated(
+      uint32_t texture_id,
+      const base::Closure& no_longer_needed_cb,
+      media::VideoPixelFormat pixel_format,
+      const gfx::Size& size);
+
+  std::vector<gfx::GpuMemoryBufferHandle> ExportGpuMemoryBufferHandles() const;
 
   int32_t texture_id() const { return texture_id_; }
 
  private:
   friend class base::RefCounted<TextureRef>;
+
+  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_;
   base::Closure no_longer_needed_cb_;
+#if defined(USE_OZONE)
+  scoped_refptr<ui::NativePixmap> pixmap_;
+#endif
 };
 
 TextureRef::~TextureRef() {
   base::ResetAndReturn(&no_longer_needed_cb_).Run();
 }
 
+// static
+scoped_refptr<TextureRef> TextureRef::Create(
+    uint32_t texture_id,
+    const base::Closure& no_longer_needed_cb) {
+  return make_scoped_refptr(new TextureRef(texture_id, no_longer_needed_cb));
+}
+
+#if defined(USE_OZONE)
+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;
+  }
+}
+#endif
+
+// static
+scoped_refptr<TextureRef> TextureRef::CreatePreallocated(
+    uint32_t texture_id,
+    const base::Closure& no_longer_needed_cb,
+    media::VideoPixelFormat pixel_format,
+    const gfx::Size& size) {
+  scoped_refptr<TextureRef> texture_ref;
+#if defined(USE_OZONE)
+  texture_ref = TextureRef::Create(texture_id, no_longer_needed_cb);
+  LOG_ASSERT(texture_ref);
+
+  ui::OzonePlatform* platform = ui::OzonePlatform::GetInstance();
+  ui::SurfaceFactoryOzone* factory = platform->GetSurfaceFactoryOzone();
+  gfx::BufferFormat buffer_format =
+      VideoPixelFormatToGfxBufferFormat(pixel_format);
+  texture_ref->pixmap_ =
+      factory->CreateNativePixmap(gfx::kNullAcceleratedWidget, size,
+                                  buffer_format, gfx::BufferUsage::SCANOUT);
+  LOG_ASSERT(texture_ref->pixmap_);
+#endif
+
+  return texture_ref;
+}
+
+std::vector<gfx::GpuMemoryBufferHandle>
+TextureRef::ExportGpuMemoryBufferHandles() const {
+  std::vector<gfx::GpuMemoryBufferHandle> handles;
+#if defined(USE_OZONE)
+  CHECK(pixmap_);
+  int duped_fd = HANDLE_EINTR(dup(pixmap_->GetDmaBufFd()));
+  LOG_ASSERT(duped_fd != -1) << "Failed duplicating dmabuf fd";
+  gfx::GpuMemoryBufferHandle handle;
+  handle.type = gfx::OZONE_NATIVE_PIXMAP;
+  handle.native_pixmap_handle.fd = base::FileDescriptor(duped_fd, true);
+  handles.push_back(handle);
+#endif
+  return handles;
+}
+
 // Client that can accept callbacks from a VideoDecodeAccelerator and is used by
 // the TESTs below.
 class GLRenderingVDAClient
     : public VideoDecodeAccelerator::Client,
       public base::SupportsWeakPtr<GLRenderingVDAClient> {
  public:
   // |window_id| the window_id of the client, which is used to identify the
   // rendering area in the |rendering_helper|.
   // Doesn't take ownership of |rendering_helper| or |note|, which must outlive
   // |*this|.
@@ skipping 222 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);
@@ skipping 13 matching lines @@
   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<TextureRef> texture_ref;
+    base::Closure delete_texture_cb =
+        base::Bind(&RenderingHelper::DeleteTexture,
+                   base::Unretained(rendering_helper_), texture_id);
+
+    if (g_test_import) {
+      media::VideoPixelFormat pixel_format = decoder_->GetOutputFormat();
+      if (pixel_format == media::PIXEL_FORMAT_UNKNOWN)
+        pixel_format = media::PIXEL_FORMAT_ARGB;
+      texture_ref = TextureRef::CreatePreallocated(
+          texture_id, delete_texture_cb, pixel_format, dimensions);
+    } else {
+      texture_ref = TextureRef::Create(texture_id, delete_texture_cb);
+    }
+
+    LOG_ASSERT(texture_ref);
+
     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, texture_ref))
+            .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);
+
+      std::vector<gfx::GpuMemoryBufferHandle> handles =
+          texture_it->second->ExportGpuMemoryBufferHandles();
+      LOG_ASSERT(!handles.empty()) << "Failed producing GMB handles";
+
+      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();
 }