DXVA: remove path that reads back decoded frames to system memory.

content/common/gpu/media/dxva_video_decode_accelerator.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.
 
 #include "content/common/gpu/media/dxva_video_decode_accelerator.h"
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
 #endif   // !defined(OS_WIN)
 
 #include <ks.h>
 #include <codecapi.h>
-#include <d3dx9tex.h>
 #include <mfapi.h>
 #include <mferror.h>
 #include <wmcodecdsp.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_handle.h"
@@ skipping 127 matching lines @@
   base::SharedMemory shm(bitstream_buffer.handle(), true);
   RETURN_ON_FAILURE(shm.Map(bitstream_buffer.size()),
                     "Failed in base::SharedMemory::Map", NULL);
 
   return CreateInputSample(reinterpret_cast<const uint8*>(shm.memory()),
                            bitstream_buffer.size(),
                            stream_size,
                            alignment);
 }
 
-// Helper function to read the bitmap from the D3D surface passed in.
-static bool GetBitmapFromSurface(IDirect3DDevice9Ex* device,
-                                 IDirect3DSurface9* surface,
-                                 scoped_array<char>* bits) {
-  // TODO(ananta)
-  // The code below may not be necessary once we have an ANGLE extension which
-  // allows us to pass the Direct 3D surface directly for rendering.
-
-  // The decoded bits in the source direct 3d surface are in the YUV
-  // format. Angle does not support that. As a workaround we create an
-  // offscreen surface in the RGB format and copy the source surface
-  // to this surface.
-  D3DSURFACE_DESC surface_desc;
-  HRESULT hr = surface->GetDesc(&surface_desc);
-  RETURN_ON_HR_FAILURE(hr, "Failed to get surface description", false);
-
-  base::win::ScopedComPtr<IDirect3DSurface9> dest_surface;
-  hr = device->CreateOffscreenPlainSurface(surface_desc.Width,
-                                           surface_desc.Height,
-                                           D3DFMT_A8R8G8B8,
-                                           D3DPOOL_DEFAULT,
-                                           dest_surface.Receive(),
-                                           NULL);
-  RETURN_ON_HR_FAILURE(hr, "Failed to create offscreen surface", false);
-
-  hr = D3DXLoadSurfaceFromSurface(dest_surface, NULL, NULL, surface, NULL,
-                                  NULL, D3DX_DEFAULT, 0);
-  RETURN_ON_HR_FAILURE(hr, "D3DXLoadSurfaceFromSurface failed", false);
-
-  // Get the currently loaded bitmap from the DC.
-  HDC hdc = NULL;
-  hr = dest_surface->GetDC(&hdc);
-  RETURN_ON_HR_FAILURE(hr, "Failed to get HDC from surface", false);
-
-  HBITMAP bitmap =
-      reinterpret_cast<HBITMAP>(GetCurrentObject(hdc, OBJ_BITMAP));
-  if (!bitmap) {
-    NOTREACHED() << "Failed to get bitmap from DC";
-    dest_surface->ReleaseDC(hdc);
-    return false;
-  }
-
-  BITMAP bitmap_basic_info = {0};
-  if (!GetObject(bitmap, sizeof(BITMAP), &bitmap_basic_info)) {
-    NOTREACHED() << "Failed to read bitmap info";
-    dest_surface->ReleaseDC(hdc);
-    return false;
-  }
-  BITMAPINFO bitmap_info = {0};
-  bitmap_info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-  bitmap_info.bmiHeader.biWidth = bitmap_basic_info.bmWidth;
-  bitmap_info.bmiHeader.biHeight = bitmap_basic_info.bmHeight;
-  bitmap_info.bmiHeader.biPlanes = 1;
-  bitmap_info.bmiHeader.biBitCount = bitmap_basic_info.bmBitsPixel;
-  bitmap_info.bmiHeader.biCompression = BI_RGB;
-  bitmap_info.bmiHeader.biSizeImage = 0;
-  bitmap_info.bmiHeader.biClrUsed = 0;
-
-  int ret = GetDIBits(hdc, bitmap, 0, 0, NULL, &bitmap_info, DIB_RGB_COLORS);
-  if (!ret || bitmap_info.bmiHeader.biSizeImage <= 0) {
-    NOTREACHED() << "Failed to read bitmap size";
-    dest_surface->ReleaseDC(hdc);
-    return false;
-  }
-
-  bits->reset(new char[bitmap_info.bmiHeader.biSizeImage]);
-  ret = GetDIBits(hdc, bitmap, 0, bitmap_basic_info.bmHeight, bits->get(),
-                  &bitmap_info, DIB_RGB_COLORS);
-  if (!ret) {
-    NOTREACHED() << "Failed to retrieve bitmap bits.";
-  }
-  dest_surface->ReleaseDC(hdc);
-  return !!ret;
-}
-
 // Maintains information about a DXVA picture buffer, i.e. whether it is
 // available for rendering, the texture information, etc.
 struct DXVAVideoDecodeAccelerator::DXVAPictureBuffer {
  public:
   static linked_ptr<DXVAPictureBuffer> Create(
       const media::PictureBuffer& buffer, EGLConfig egl_config);
   ~DXVAPictureBuffer();
 
   void ReusePictureBuffer();
   // Copies the output sample data to the picture buffer provided by the
@@ skipping 118 matching lines @@
     NOTREACHED() << "Decode surface of different dimension than texture";
     return false;
   }
 
   hr = d3d9_->CheckDeviceFormatConversion(D3DADAPTER_DEFAULT,
                                           D3DDEVTYPE_HAL,
                                           surface_desc.Format,
                                           D3DFMT_X8R8G8B8);
   bool device_supports_format_conversion = (hr == S_OK);
 
+  RETURN_ON_FAILURE(device_supports_format_conversion,
+                    "Device does not support format converision",
+                    false);
+
   // This function currently executes in the context of IPC handlers in the
   // GPU process which ensures that there is always an OpenGL context.
   GLint current_texture = 0;
   glGetIntegerv(GL_TEXTURE_BINDING_2D, &current_texture);
 
   glBindTexture(GL_TEXTURE_2D, picture_buffer_.texture_id());
 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 
-  if (device_supports_format_conversion) {
-    base::win::ScopedComPtr<IDirect3DSurface9> d3d_surface;
-    HRESULT hr = decoding_texture_->GetSurfaceLevel(0, d3d_surface.Receive());
-    RETURN_ON_HR_FAILURE(hr, "Failed to get surface from texture", false);
+  base::win::ScopedComPtr<IDirect3DSurface9> d3d_surface;
+  hr = decoding_texture_->GetSurfaceLevel(0, d3d_surface.Receive());
+  RETURN_ON_HR_FAILURE(hr, "Failed to get surface from texture", false);
 
-    hr = device_->StretchRect(dest_surface,
-                              NULL,
-                              d3d_surface,
-                              NULL,
-                              D3DTEXF_NONE);
-    RETURN_ON_HR_FAILURE(hr, "Colorspace conversion via StretchRect failed",
-                         false);
-    // Ideally, this should be done immediately before the draw call that uses
-    // the texture. Flush it once here though.
-    hr = query_->Issue(D3DISSUE_END);
-    RETURN_ON_HR_FAILURE(hr, "Failed to issue END", false);
-    do {
-      hr = query_->GetData(NULL, 0, D3DGETDATA_FLUSH);
-      if (hr == S_FALSE)
-        Sleep(1);  // Poor-man's Yield().
-    } while (hr == S_FALSE);
-    eglBindTexImage(
-        static_cast<EGLDisplay*>(eglGetDisplay(EGL_DEFAULT_DISPLAY)),
-        decoding_surface_,
-        EGL_BACK_BUFFER);
-  } else {
-    scoped_array<char> bits;
-    RETURN_ON_FAILURE(GetBitmapFromSurface(DXVAVideoDecodeAccelerator::device_,
-                                           dest_surface, &bits),
-                      "Failed to get bitmap from surface for rendering",
-                      false);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, surface_desc.Width,
-                 surface_desc.Height, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE,
-                 reinterpret_cast<GLvoid*>(bits.get()));
-  }
+  hr = device_->StretchRect(dest_surface,
+                            NULL,
+                            d3d_surface,
+                            NULL,
+                            D3DTEXF_NONE);
+  RETURN_ON_HR_FAILURE(hr, "Colorspace conversion via StretchRect failed",
+                        false);
+
+  // Ideally, this should be done immediately before the draw call that uses
+  // the texture. Flush it once here though.
+  hr = query_->Issue(D3DISSUE_END);
+  RETURN_ON_HR_FAILURE(hr, "Failed to issue END", false);
+  do {
+    hr = query_->GetData(NULL, 0, D3DGETDATA_FLUSH);
+    if (hr == S_FALSE)
+      Sleep(1);  // Poor-man's Yield().
+  } while (hr == S_FALSE);
+  eglBindTexImage(
+      static_cast<EGLDisplay*>(eglGetDisplay(EGL_DEFAULT_DISPLAY)),
+      decoding_surface_,
+      EGL_BACK_BUFFER);
+
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glBindTexture(GL_TEXTURE_2D, current_texture);
   return true;
 }
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::PendingSampleInfo(
     int32 buffer_id, IMFSample* sample)
     : input_buffer_id(buffer_id) {
   output_sample.Attach(sample);
 }
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::~PendingSampleInfo() {}
 
 // static
 void DXVAVideoDecodeAccelerator::PreSandboxInitialization() {
   // Should be called only once during program startup.
   DCHECK(!pre_sandbox_init_done_);
 
   static wchar_t* decoding_dlls[] = {
     L"d3d9.dll",
-    L"d3dx9_43.dll",
     L"dxva2.dll",
     L"mf.dll",
     L"mfplat.dll",
     L"msmpeg2vdec.dll",
   };
 
   for (int i = 0; i < arraysize(decoding_dlls); ++i) {
     if (!::LoadLibrary(decoding_dlls[i])) {
       DLOG(ERROR) << "Failed to load decoder dll: " << decoding_dlls[i]
                   << ", Error: " << ::GetLastError();
@@ skipping 689 matching lines @@
       return;
   }
 
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
       &DXVAVideoDecodeAccelerator::NotifyFlushDone, base::AsWeakPtr(this)));
 
   state_ = kNormal;
 }
 
 }  // namespace content