Copy NV12 picture buffers on demand on the main thread.

media/gpu/dxva_picture_buffer_win.cc

 // Copyright 2016 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 "media/gpu/dxva_picture_buffer_win.h"
 
 #include "media/gpu/dxva_video_decode_accelerator_win.h"
 #include "third_party/angle/include/EGL/egl.h"
 #include "third_party/angle/include/EGL/eglext.h"
 #include "ui/gl/gl_bindings.h"
@@ skipping 14 matching lines @@
 
 // These GLImage subclasses are just used to hold references to the underlying
 // image content so it can be destroyed when the textures are.
 class DummyGLImage : public gl::GLImage {
  public:
   DummyGLImage(const gfx::Size& size) : size_(size) {}
 
   // gl::GLImage implementation.
   gfx::Size GetSize() override { return size_; }
   unsigned GetInternalFormat() override { return GL_BGRA_EXT; }
-  bool BindTexImage(unsigned target) override { return false; }
+  // PbufferPictureBuffer::CopySurfaceComplete does the actual binding, so
+  // this doesn't do anything and always succeeds.
+  bool BindTexImage(unsigned target) override { return true; }
   void ReleaseTexImage(unsigned target) override {}
   bool CopyTexImage(unsigned target) override { return false; }
   bool CopyTexSubImage(unsigned target,
                        const gfx::Point& offset,
                        const gfx::Rect& rect) override {
     return false;
   }
   bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                             int z_order,
                             gfx::OverlayTransform transform,
@@ skipping 49 matching lines @@
   // The keyed mutex should always be released before the other thread
   // attempts to acquire it, so AcquireSync should always return immediately.
   kAcquireSyncWaitMs = 0,
 };
 
 // static
 linked_ptr<DXVAPictureBuffer> DXVAPictureBuffer::Create(
     const DXVAVideoDecodeAccelerator& decoder,
     const PictureBuffer& buffer,
     EGLConfig egl_config) {
-  if (decoder.share_nv12_textures_) {
-    linked_ptr<EGLStreamPictureBuffer> picture_buffer(
-        new EGLStreamPictureBuffer(buffer));
-    if (!picture_buffer->Initialize())
-      return linked_ptr<DXVAPictureBuffer>(nullptr);
+  switch (decoder.GetPictureBufferMechanism()) {
+    case DXVAVideoDecodeAccelerator::PictureBufferMechanism::BIND: {
+      linked_ptr<EGLStreamPictureBuffer> picture_buffer(
+          new EGLStreamPictureBuffer(buffer));
+      if (!picture_buffer->Initialize())
+        return linked_ptr<DXVAPictureBuffer>(nullptr);
 
-    return picture_buffer;
+      return picture_buffer;
+    }
+    case DXVAVideoDecodeAccelerator::PictureBufferMechanism::
+        DELAYED_COPY_TO_NV12: {
+      linked_ptr<EGLStreamDelayedCopyPictureBuffer> picture_buffer(
+          new EGLStreamDelayedCopyPictureBuffer(buffer));
+      if (!picture_buffer->Initialize(decoder))
+        return linked_ptr<DXVAPictureBuffer>(nullptr);
+
+      return picture_buffer;
+    }
+    case DXVAVideoDecodeAccelerator::PictureBufferMechanism::COPY_TO_NV12: {
+      linked_ptr<EGLStreamCopyPictureBuffer> picture_buffer(
+          new EGLStreamCopyPictureBuffer(buffer));
+      if (!picture_buffer->Initialize(decoder))
+        return linked_ptr<DXVAPictureBuffer>(nullptr);
+
+      return picture_buffer;
+    }
+    case DXVAVideoDecodeAccelerator::PictureBufferMechanism::COPY_TO_RGB: {
+      linked_ptr<PbufferPictureBuffer> picture_buffer(
+          new PbufferPictureBuffer(buffer));
+
+      if (!picture_buffer->Initialize(decoder, egl_config))
+        return linked_ptr<DXVAPictureBuffer>(nullptr);
+
+      return picture_buffer;
+    }
   }
-  if (decoder.copy_nv12_textures_) {
-    linked_ptr<EGLStreamCopyPictureBuffer> picture_buffer(
-        new EGLStreamCopyPictureBuffer(buffer));
-    if (!picture_buffer->Initialize(decoder))
-      return linked_ptr<DXVAPictureBuffer>(nullptr);
-
-    return picture_buffer;
-  }
-  linked_ptr<PbufferPictureBuffer> picture_buffer(
-      new PbufferPictureBuffer(buffer));
-
-  if (!picture_buffer->Initialize(decoder, egl_config))
-    return linked_ptr<DXVAPictureBuffer>(nullptr);
-
-  return picture_buffer;
+  NOTREACHED();
+  return linked_ptr<DXVAPictureBuffer>(nullptr);
 }
 
 DXVAPictureBuffer::~DXVAPictureBuffer() {}
 
 void DXVAPictureBuffer::ResetReuseFence() {
   NOTREACHED();
 }
 
 bool DXVAPictureBuffer::CopyOutputSampleDataToPictureBuffer(
     DXVAVideoDecodeAccelerator* decoder,
@@ skipping 16 matching lines @@
 bool DXVAPictureBuffer::CopySurfaceComplete(IDirect3DSurface9* src_surface,
                                             IDirect3DSurface9* dest_surface) {
   NOTREACHED();
   return false;
 }
 
 DXVAPictureBuffer::DXVAPictureBuffer(const PictureBuffer& buffer)
     : picture_buffer_(buffer) {}
 
 bool DXVAPictureBuffer::BindSampleToTexture(
+    DXVAVideoDecodeAccelerator* decoder,
     base::win::ScopedComPtr<IMFSample> sample) {
   NOTREACHED();
   return false;
 }
 
 bool PbufferPictureBuffer::Initialize(const DXVAVideoDecodeAccelerator& decoder,
                                       EGLConfig egl_config) {
   RETURN_ON_FAILURE(!picture_buffer_.service_texture_ids().empty(),
                     "No service texture ids provided", false);
 
@@ skipping 194 matching lines @@
 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glBindTexture(GL_TEXTURE_2D, current_texture);
   return true;
 }
 
 bool PbufferPictureBuffer::AllowOverlay() const {
   return false;
 }
 
+bool PbufferPictureBuffer::CanBindSamples() const {
+  return false;
+}
+
 PbufferPictureBuffer::PbufferPictureBuffer(const PictureBuffer& buffer)
     : DXVAPictureBuffer(buffer),
       decoding_surface_(NULL),
       texture_share_handle_(nullptr),
       keyed_mutex_value_(0),
       use_rgb_(true) {}
 
 PbufferPictureBuffer::~PbufferPictureBuffer() {
   // decoding_surface_ will be deleted by gl_image_.
 }
@@ skipping 79 matching lines @@
   }
   if (current_d3d_sample_) {
     dx11_decoding_texture_.Reset();
     current_d3d_sample_.Reset();
   }
   state_ = UNUSED;
   return true;
 }
 
 bool EGLStreamPictureBuffer::BindSampleToTexture(
+    DXVAVideoDecodeAccelerator* decoder,
     base::win::ScopedComPtr<IMFSample> sample) {
   DCHECK_EQ(BOUND, state_);
   state_ = IN_CLIENT;
 
   current_d3d_sample_ = sample;
   EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
 
   base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
   HRESULT hr =
       current_d3d_sample_->GetBufferByIndex(0, output_buffer.GetAddressOf());
@@ skipping 24 matching lines @@
   DCHECK(gl_image_dxgi);
 
   gl_image_dxgi->SetTexture(dx11_decoding_texture_, subresource);
   return true;
 }
 
 bool EGLStreamPictureBuffer::AllowOverlay() const {
   return true;
 }
 
+bool EGLStreamPictureBuffer::CanBindSamples() const {
+  return true;
+}
+
+EGLStreamDelayedCopyPictureBuffer::EGLStreamDelayedCopyPictureBuffer(
+    const PictureBuffer& buffer)
+    : DXVAPictureBuffer(buffer), stream_(nullptr) {}
+
+EGLStreamDelayedCopyPictureBuffer::~EGLStreamDelayedCopyPictureBuffer() {
+  // stream_ will be deleted by gl_image_.
+}
+
+bool EGLStreamDelayedCopyPictureBuffer::Initialize(
+    const DXVAVideoDecodeAccelerator& decoder) {
+  RETURN_ON_FAILURE(picture_buffer_.service_texture_ids().size() >= 2,
+                    "Not enough texture ids provided", false);
+
+  EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
+  const EGLint stream_attributes[] = {
+      EGL_CONSUMER_LATENCY_USEC_KHR,
+      0,
+      EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR,
+      0,
+      EGL_NONE,
+  };
+  stream_ = eglCreateStreamKHR(egl_display, stream_attributes);
+  RETURN_ON_FAILURE(!!stream_, "Could not create stream", false);
+  gl::ScopedActiveTexture texture0(GL_TEXTURE0);
+  gl::ScopedTextureBinder texture0_binder(
+      GL_TEXTURE_EXTERNAL_OES, picture_buffer_.service_texture_ids()[0]);
+  gl::ScopedActiveTexture texture1(GL_TEXTURE1);
+  gl::ScopedTextureBinder texture1_binder(
+      GL_TEXTURE_EXTERNAL_OES, picture_buffer_.service_texture_ids()[1]);
+
+  EGLAttrib consumer_attributes[] = {
+      EGL_COLOR_BUFFER_TYPE,
+      EGL_YUV_BUFFER_EXT,
+      EGL_YUV_NUMBER_OF_PLANES_EXT,
+      2,
+      EGL_YUV_PLANE0_TEXTURE_UNIT_NV,
+      0,
+      EGL_YUV_PLANE1_TEXTURE_UNIT_NV,
+      1,
+      EGL_NONE,
+  };
+  EGLBoolean result = eglStreamConsumerGLTextureExternalAttribsNV(
+      egl_display, stream_, consumer_attributes);
+  RETURN_ON_FAILURE(result, "Could not set stream consumer", false);
+
+  EGLAttrib producer_attributes[] = {
+      EGL_NONE,
+  };
+
+  result = eglCreateStreamProducerD3DTextureNV12ANGLE(egl_display, stream_,
+                                                      producer_attributes);
+  RETURN_ON_FAILURE(result, "Could not create stream producer", false);
+  scoped_refptr<gl::CopyingGLImageDXGI> copying_image_ =
+      make_scoped_refptr(new gl::CopyingGLImageDXGI(
+          base::win::ScopedComPtr<ID3D11Device>(decoder.D3D11Device()), size(),
+          stream_));
+  gl_image_ = copying_image_;
+  return copying_image_->Initialize();
+}
+
+bool EGLStreamDelayedCopyPictureBuffer::ReusePictureBuffer() {
+  DCHECK_NE(UNUSED, state_);
+
+  static_cast<gl::CopyingGLImageDXGI*>(gl_image_.get())->UnbindFromTexture();
+  if (current_d3d_sample_) {
+    dx11_decoding_texture_.Reset();
+    current_d3d_sample_.Reset();
+  }
+  state_ = UNUSED;
+  return true;
+}
+
+bool EGLStreamDelayedCopyPictureBuffer::BindSampleToTexture(
+    DXVAVideoDecodeAccelerator* decoder,
+    base::win::ScopedComPtr<IMFSample> sample) {
+  DCHECK_EQ(BOUND, state_);
+  state_ = IN_CLIENT;
+
+  current_d3d_sample_ = sample;
+
+  base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
+  HRESULT hr =
+      current_d3d_sample_->GetBufferByIndex(0, output_buffer.GetAddressOf());
+  RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from output sample", false);
+
+  base::win::ScopedComPtr<IMFDXGIBuffer> dxgi_buffer;
+  hr = output_buffer.CopyTo(dxgi_buffer.GetAddressOf());
+  RETURN_ON_HR_FAILURE(hr, "Failed to get DXGIBuffer from output sample",
+                       false);
+  hr = dxgi_buffer->GetResource(
+      IID_PPV_ARGS(dx11_decoding_texture_.GetAddressOf()));
+  RETURN_ON_HR_FAILURE(hr, "Failed to get texture from output sample", false);
+  UINT subresource;
+  dxgi_buffer->GetSubresourceIndex(&subresource);
+  if (!decoder->InitializeID3D11VideoProcessor(size().width(), size().height(),
+                                               color_space_))
+    return false;
+
+  DCHECK(decoder->d3d11_processor_);
+  DCHECK(decoder->enumerator_);
+
+  gl::GLImageDXGI* gl_image_dxgi =
+      gl::GLImageDXGI::FromGLImage(gl_image_.get());
+  DCHECK(gl_image_dxgi);
+
+  gl_image_dxgi->SetTexture(dx11_decoding_texture_, subresource);
+  return static_cast<gl::CopyingGLImageDXGI*>(gl_image_dxgi)
+      ->InitializeVideoProcessor(decoder->d3d11_processor_,
+                                 decoder->enumerator_);
+}
+
+bool EGLStreamDelayedCopyPictureBuffer::AllowOverlay() const {
+  return true;
+}
+
+bool EGLStreamDelayedCopyPictureBuffer::CanBindSamples() const {
+  return true;
+}
+
 EGLStreamCopyPictureBuffer::EGLStreamCopyPictureBuffer(
     const PictureBuffer& buffer)
     : DXVAPictureBuffer(buffer), stream_(nullptr) {}
 
 EGLStreamCopyPictureBuffer::~EGLStreamCopyPictureBuffer() {
   // stream_ will be deleted by gl_image_.
 }
 
 bool EGLStreamCopyPictureBuffer::Initialize(
     const DXVAVideoDecodeAccelerator& decoder) {
@@ skipping 147 matching lines @@
     EGLBoolean result = eglStreamConsumerReleaseKHR(egl_display, stream_);
     RETURN_ON_FAILURE(result, "Could not release stream", false);
   }
   return true;
 }
 
 bool EGLStreamCopyPictureBuffer::AllowOverlay() const {
   return true;
 }
 
+bool EGLStreamCopyPictureBuffer::CanBindSamples() const {
+  return false;
+}
+
 }  // namespace media