Support H.264 video decoding on Windows 8+ using DX11

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 <dxgi1_2.h>
 #include <mfapi.h>
 #include <mferror.h>
 #include <wmcodecdsp.h>
 
 #include "base/base_paths_win.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_version_info.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/trace_event/trace_event.h"
 #include "base/win/windows_version.h"
 #include "media/video/video_decode_accelerator.h"
 #include "ui/gl/gl_bindings.h"
+#include "ui/gl/gl_context.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/gl_switches.h"
 
 namespace {
 
 // Path is appended on to the PROGRAM_FILES base path.
 const wchar_t kVPXDecoderDLLPath[] = L"Intel\\Media SDK\\";
 
 const wchar_t kVP8DecoderDLLName[] =
 #if defined(ARCH_CPU_X86)
@@ skipping 34 matching lines @@
   { 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
 };
 
 const CLSID MEDIASUBTYPE_VP90 = {
   0x30395056,
   0x0000,
   0x0010,
   { 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
 };
 
+// The CLSID of the video processor media foundation transform which we use for
+// texture color conversion in DX11.
+DEFINE_GUID(CLSID_VideoProcessorMFT,
+            0x88753b26, 0x5b24, 0x49bd, 0xb2, 0xe7, 0xc, 0x44, 0x5c, 0x78,
+            0xc9, 0x82);
+
+// MF_XVP_PLAYBACK_MODE
+// Data type: UINT32 (treat as BOOL)
+// If this attribute is TRUE, the video processor will run in playback mode
+// where it allows callers to allocate output samples and allows last frame
+// regeneration (repaint).
+DEFINE_GUID(MF_XVP_PLAYBACK_MODE, 0x3c5d293f, 0xad67, 0x4e29, 0xaf, 0x12,
+            0xcf, 0x3e, 0x23, 0x8a, 0xcc, 0xe9);
 }
 
 namespace content {
 
+CreateDXGIDeviceManager DXVAVideoDecodeAccelerator::create_dxgi_device_manager_
+    = NULL;
+
 #define RETURN_ON_FAILURE(result, log, ret)  \
   do {                                       \
     if (!(result)) {                         \
       DLOG(ERROR) << log;                    \
       return ret;                            \
     }                                        \
   } while (0)
 
 #define RETURN_ON_HR_FAILURE(result, log, ret)                    \
   RETURN_ON_FAILURE(SUCCEEDED(result),                            \
@@ skipping 51 matching lines @@
   } else {
     hr = MFCreateAlignedMemoryBuffer(buffer_length,
                                      align - 1,
                                      buffer.Receive());
   }
   RETURN_ON_HR_FAILURE(hr, "Failed to create memory buffer for sample", NULL);
 
   hr = sample->AddBuffer(buffer.get());
   RETURN_ON_HR_FAILURE(hr, "Failed to add buffer to sample", NULL);
 
+  buffer->SetCurrentLength(0);
   return sample.Detach();
 }
 
 // Creates a Media Foundation sample with one buffer containing a copy of the
 // given Annex B stream data.
 // If duration and sample time are not known, provide 0.
 // |min_size| specifies the minimum size of the buffer (might be required by
 // the decoder for input). If no alignment is required, provide 0.
 static IMFSample* CreateInputSample(const uint8* stream, int size,
                                     int min_size, int alignment) {
@@ skipping 51 matching lines @@
       EGLConfig egl_config);
   ~DXVAPictureBuffer();
 
   void ReusePictureBuffer();
   // Copies the output sample data to the picture buffer provided by the
   // client.
   // The dest_surface parameter contains the decoded bits.
   bool CopyOutputSampleDataToPictureBuffer(
       DXVAVideoDecodeAccelerator* decoder,
       IDirect3DSurface9* dest_surface,
+      ID3D11Texture2D* dx11_texture,
       int input_buffer_id);
 
   bool available() const {
     return available_;
   }
 
   void set_available(bool available) {
     available_ = available;
   }
 
@@ skipping 10 matching lines @@
   void CopySurfaceComplete(IDirect3DSurface9* src_surface,
                            IDirect3DSurface9* dest_surface);
 
  private:
   explicit DXVAPictureBuffer(const media::PictureBuffer& buffer);
 
   bool available_;
   media::PictureBuffer picture_buffer_;
   EGLSurface decoding_surface_;
   base::win::ScopedComPtr<IDirect3DTexture9> decoding_texture_;
+  base::win::ScopedComPtr<ID3D11Texture2D> dx11_decoding_texture_;
 
   // The following |IDirect3DSurface9| interface pointers are used to hold
   // references on the surfaces during the course of a StretchRect operation
   // to copy the source surface to the target. The references are released
   // when the StretchRect operation i.e. the copy completes.
   base::win::ScopedComPtr<IDirect3DSurface9> decoder_surface_;
   base::win::ScopedComPtr<IDirect3DSurface9> target_surface_;
 
+  // This ID3D11Texture2D interface pointer is used to hold a reference to the
+  // decoder texture during the course of a copy operation. This reference is
+  // released when the copy completes.
+  base::win::ScopedComPtr<ID3D11Texture2D> decoder_dx11_texture_;
+
   // Set to true if RGB is supported by the texture.
   // Defaults to true.
   bool use_rgb_;
 
   DISALLOW_COPY_AND_ASSIGN(DXVAPictureBuffer);
 };
 
 // static
 linked_ptr<DXVAVideoDecodeAccelerator::DXVAPictureBuffer>
 DXVAVideoDecodeAccelerator::DXVAPictureBuffer::Create(
@@ skipping 28 matching lines @@
   EGLBoolean ret = eglQuerySurfacePointerANGLE(
       egl_display,
       picture_buffer->decoding_surface_,
       EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE,
       &share_handle);
 
   RETURN_ON_FAILURE(share_handle && ret == EGL_TRUE,
                     "Failed to query ANGLE surface pointer",
                     linked_ptr<DXVAPictureBuffer>(NULL));
 
-  // TODO(dshwang): after moving to D3D11, use RGBA surface. crbug.com/438691
-  HRESULT hr = decoder.device_->CreateTexture(
-      buffer.size().width(),
-      buffer.size().height(),
-      1,
-      D3DUSAGE_RENDERTARGET,
-      use_rgb ? D3DFMT_X8R8G8B8 : D3DFMT_A8R8G8B8,
-      D3DPOOL_DEFAULT,
-      picture_buffer->decoding_texture_.Receive(),
-      &share_handle);
-
+  HRESULT hr = E_FAIL;
+  if (decoder.d3d11_device_) {
+    base::win::ScopedComPtr<ID3D11Resource> resource;
+    hr = decoder.d3d11_device_->OpenSharedResource(
+        share_handle,
+        __uuidof(ID3D11Resource),
+        reinterpret_cast<void**>(resource.Receive()));
+    RETURN_ON_HR_FAILURE(hr, "Failed to open shared resource",
+                         linked_ptr<DXVAPictureBuffer>(NULL));
+    hr = picture_buffer->dx11_decoding_texture_.QueryFrom(resource.get());
+  } else {
+    hr = decoder.d3d9_device_ex_->CreateTexture(
+        buffer.size().width(),
+        buffer.size().height(),
+        1,
+        D3DUSAGE_RENDERTARGET,
+        use_rgb ? D3DFMT_X8R8G8B8 : D3DFMT_A8R8G8B8,
+        D3DPOOL_DEFAULT,
+        picture_buffer->decoding_texture_.Receive(),
+        &share_handle);
+  }
   RETURN_ON_HR_FAILURE(hr, "Failed to create texture",
                        linked_ptr<DXVAPictureBuffer>(NULL));
   picture_buffer->use_rgb_ = !!use_rgb;
   return picture_buffer;
 }
 
 DXVAVideoDecodeAccelerator::DXVAPictureBuffer::DXVAPictureBuffer(
     const media::PictureBuffer& buffer)
     : available_(true),
       picture_buffer_(buffer),
@@ skipping 19 matching lines @@
 
 void DXVAVideoDecodeAccelerator::DXVAPictureBuffer::ReusePictureBuffer() {
   DCHECK(decoding_surface_);
   EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
   eglReleaseTexImage(
     egl_display,
     decoding_surface_,
     EGL_BACK_BUFFER);
   decoder_surface_.Release();
   target_surface_.Release();
+  decoder_dx11_texture_.Release();
   set_available(true);
 }
 
 bool DXVAVideoDecodeAccelerator::DXVAPictureBuffer::
     CopyOutputSampleDataToPictureBuffer(
         DXVAVideoDecodeAccelerator* decoder,
         IDirect3DSurface9* dest_surface,
+        ID3D11Texture2D* dx11_texture,
         int input_buffer_id) {
-  DCHECK(dest_surface);
-
+  DCHECK(dest_surface || dx11_texture);
+  if (dx11_texture) {
+    // Grab a reference on the decoder texture. This reference will be released
+    // when we receive a notification that the copy was completed or when the
+    // DXVAPictureBuffer instance is destroyed.
+    decoder_dx11_texture_ = dx11_texture;
+    decoder->CopyTexture(dx11_texture, dx11_decoding_texture_.get(), NULL,
+                         id(), input_buffer_id);
+    return true;
+  }
   D3DSURFACE_DESC surface_desc;
   HRESULT hr = dest_surface->GetDesc(&surface_desc);
   RETURN_ON_HR_FAILURE(hr, "Failed to get surface description", false);
 
   D3DSURFACE_DESC texture_desc;
   decoding_texture_->GetLevelDesc(0, &texture_desc);
 
   if (texture_desc.Width != surface_desc.Width ||
       texture_desc.Height != surface_desc.Height) {
     NOTREACHED() << "Decode surface of different dimension than texture";
@@ skipping 29 matching lines @@
     IDirect3DSurface9* dest_surface) {
   DCHECK(!available());
 
   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_LINEAR);
 
-  DCHECK_EQ(src_surface, decoder_surface_.get());
-  DCHECK_EQ(dest_surface, target_surface_.get());
-
-  decoder_surface_.Release();
-  target_surface_.Release();
+  if (src_surface && dest_surface) {
+    DCHECK_EQ(src_surface, decoder_surface_.get());
+    DCHECK_EQ(dest_surface, target_surface_.get());
+    decoder_surface_.Release();
+    target_surface_.Release();
+  } else {
+    DCHECK(decoder_dx11_texture_.get());
+    decoder_dx11_texture_.Release();
+  }
 
   EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
   eglBindTexImage(
       egl_display,
       decoding_surface_,
       EGL_BACK_BUFFER);
 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glBindTexture(GL_TEXTURE_2D, current_texture);
 }
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::PendingSampleInfo(
     int32 buffer_id, IMFSample* sample)
     : input_buffer_id(buffer_id),
       picture_buffer_id(-1) {
   output_sample.Attach(sample);
 }
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::~PendingSampleInfo() {}
 
-// static
-bool DXVAVideoDecodeAccelerator::CreateD3DDevManager() {
-  TRACE_EVENT0("gpu", "DXVAVideoDecodeAccelerator_CreateD3DDevManager");
-
-  HRESULT hr = Direct3DCreate9Ex(D3D_SDK_VERSION, d3d9_.Receive());
-  RETURN_ON_HR_FAILURE(hr, "Direct3DCreate9Ex failed", false);
-
-  D3DPRESENT_PARAMETERS present_params = {0};
-  present_params.BackBufferWidth = 1;
-  present_params.BackBufferHeight = 1;
-  present_params.BackBufferFormat = D3DFMT_UNKNOWN;
-  present_params.BackBufferCount = 1;
-  present_params.SwapEffect = D3DSWAPEFFECT_DISCARD;
-  present_params.hDeviceWindow = ::GetShellWindow();
-  present_params.Windowed = TRUE;
-  present_params.Flags = D3DPRESENTFLAG_VIDEO;
-  present_params.FullScreen_RefreshRateInHz = 0;
-  present_params.PresentationInterval = 0;
-
-  hr = d3d9_->CreateDeviceEx(D3DADAPTER_DEFAULT,
-                             D3DDEVTYPE_HAL,
-                             ::GetShellWindow(),
-                             D3DCREATE_FPU_PRESERVE |
-                             D3DCREATE_SOFTWARE_VERTEXPROCESSING |
-                             D3DCREATE_DISABLE_PSGP_THREADING |
-                             D3DCREATE_MULTITHREADED,
-                             &present_params,
-                             NULL,
-                             device_.Receive());
-  RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device", false);
-
-  hr = DXVA2CreateDirect3DDeviceManager9(&dev_manager_reset_token_,
-                                         device_manager_.Receive());
-  RETURN_ON_HR_FAILURE(hr, "DXVA2CreateDirect3DDeviceManager9 failed", false);
-
-  hr = device_manager_->ResetDevice(device_.get(), dev_manager_reset_token_);
-  RETURN_ON_HR_FAILURE(hr, "Failed to reset device", false);
-
-  hr = device_->CreateQuery(D3DQUERYTYPE_EVENT, query_.Receive());
-  RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device query", false);
-  // Ensure query_ API works (to avoid an infinite loop later in
-  // CopyOutputSampleDataToPictureBuffer).
-  hr = query_->Issue(D3DISSUE_END);
-  RETURN_ON_HR_FAILURE(hr, "Failed to issue END test query", false);
-  return true;
-}
-
 DXVAVideoDecodeAccelerator::DXVAVideoDecodeAccelerator(
-    const base::Callback<bool(void)>& make_context_current)
+    const base::Callback<bool(void)>& make_context_current,
+    gfx::GLContext* gl_context)
     : client_(NULL),
       dev_manager_reset_token_(0),
+      dx11_dev_manager_reset_token_(0),
       egl_config_(NULL),
       state_(kUninitialized),
       pictures_requested_(false),
       inputs_before_decode_(0),
       sent_drain_message_(false),
       make_context_current_(make_context_current),
       codec_(media::kUnknownVideoCodec),
       decoder_thread_("DXVAVideoDecoderThread"),
       weak_this_factory_(this),
       weak_ptr_(weak_this_factory_.GetWeakPtr()),
-      pending_flush_(false) {
+      pending_flush_(false),
+      use_dx11_(false),
+      dx11_video_format_converter_media_type_needs_init_(true),
+      gl_context_(gl_context) {
   memset(&input_stream_info_, 0, sizeof(input_stream_info_));
   memset(&output_stream_info_, 0, sizeof(output_stream_info_));
 }
 
 DXVAVideoDecodeAccelerator::~DXVAVideoDecodeAccelerator() {
   client_ = NULL;
 }
 
 bool DXVAVideoDecodeAccelerator::Initialize(media::VideoCodecProfile profile,
                                            Client* client) {
   client_ = client;
 
   main_thread_task_runner_ = base::MessageLoop::current()->task_runner();
 
-  // Not all versions of Windows 7 and later include Media Foundation DLLs.
-  // Instead of crashing while delay loading the DLL when calling MFStartup()
-  // below, probe whether we can successfully load the DLL now.
-  //
-  // See http://crbug.com/339678 for details.
-  HMODULE mfplat_dll = ::LoadLibrary(L"MFPlat.dll");
-  RETURN_ON_FAILURE(mfplat_dll, "MFPlat.dll is required for decoding", false);
-
   if (profile != media::H264PROFILE_BASELINE &&
       profile != media::H264PROFILE_MAIN &&
       profile != media::H264PROFILE_HIGH &&
       profile != media::VP8PROFILE_ANY &&
       profile != media::VP9PROFILE_ANY) {
     RETURN_AND_NOTIFY_ON_FAILURE(false,
         "Unsupported h.264, vp8, or vp9 profile", PLATFORM_FAILURE, false);
   }
 
+  // Not all versions of Windows 7 and later include Media Foundation DLLs.
+  // Instead of crashing while delay loading the DLL when calling MFStartup()
+  // below, probe whether we can successfully load the DLL now.
+  // See http://crbug.com/339678 for details.
+  HMODULE dxgi_manager_dll = NULL;
+  if ((dxgi_manager_dll = ::GetModuleHandle(L"MFPlat.dll")) == NULL) {
+    HMODULE mfplat_dll = ::LoadLibrary(L"MFPlat.dll");
+    RETURN_ON_FAILURE(mfplat_dll, "MFPlat.dll is required for decoding",
+                      false);
+    // On Windows 8+ mfplat.dll provides the MFCreateDXGIDeviceManager API.
+    // On Windows 7 mshtmlmedia.dll provides it.
+    dxgi_manager_dll = mfplat_dll;
+  }
+
+  // TODO(ananta)
+  // The code below works, as in we can create the DX11 device manager for
+  // Windows 7. However the IMFTransform we use for texture conversion and
+  // copy does not exist on Windows 7. Look into an alternate approach
+  // and enable the code below.
+#if defined ENABLE_DX11_FOR_WIN7
+  if ((base::win::GetVersion() == base::win::VERSION_WIN7) &&
+       ((dxgi_manager_dll = ::GetModuleHandle(L"mshtmlmedia.dll")) == NULL)) {
+    HMODULE mshtml_media_dll = ::LoadLibrary(L"mshtmlmedia.dll");
+    if (mshtml_media_dll)
+      dxgi_manager_dll = mshtml_media_dll;
+  }
+#endif
+  // If we don't find the MFCreateDXGIDeviceManager API we fallback to D3D9
+  // decoding.
+  if (dxgi_manager_dll && !create_dxgi_device_manager_) {
+    create_dxgi_device_manager_ = reinterpret_cast<CreateDXGIDeviceManager>(
+            ::GetProcAddress(dxgi_manager_dll, "MFCreateDXGIDeviceManager"));
+  }
+
   RETURN_AND_NOTIFY_ON_FAILURE(
       gfx::g_driver_egl.ext.b_EGL_ANGLE_surface_d3d_texture_2d_share_handle,
       "EGL_ANGLE_surface_d3d_texture_2d_share_handle unavailable",
       PLATFORM_FAILURE,
       false);
 
   State state = GetState();
   RETURN_AND_NOTIFY_ON_FAILURE((state == kUninitialized),
       "Initialize: invalid state: " << state, ILLEGAL_STATE, false);
 
   HRESULT hr = MFStartup(MF_VERSION, MFSTARTUP_FULL);
   RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "MFStartup failed.", PLATFORM_FAILURE,
       false);
 
-  RETURN_AND_NOTIFY_ON_FAILURE(CreateD3DDevManager(),
-                               "Failed to initialize D3D device and manager",
-                               PLATFORM_FAILURE,
-                               false);
-
   RETURN_AND_NOTIFY_ON_FAILURE(InitDecoder(profile),
       "Failed to initialize decoder", PLATFORM_FAILURE, false);
 
   RETURN_AND_NOTIFY_ON_FAILURE(GetStreamsInfoAndBufferReqs(),
       "Failed to get input/output stream info.", PLATFORM_FAILURE, false);
 
   RETURN_AND_NOTIFY_ON_FAILURE(
       SendMFTMessage(MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0),
       "Send MFT_MESSAGE_NOTIFY_BEGIN_STREAMING notification failed",
       PLATFORM_FAILURE, false);
 
   RETURN_AND_NOTIFY_ON_FAILURE(
       SendMFTMessage(MFT_MESSAGE_NOTIFY_START_OF_STREAM, 0),
       "Send MFT_MESSAGE_NOTIFY_START_OF_STREAM notification failed",
       PLATFORM_FAILURE, false);
 
   SetState(kNormal);
 
   StartDecoderThread();
   return true;
 }
 
+bool DXVAVideoDecodeAccelerator::CreateD3DDevManager() {
+  TRACE_EVENT0("gpu", "DXVAVideoDecodeAccelerator_CreateD3DDevManager");
+
+  HRESULT hr = Direct3DCreate9Ex(D3D_SDK_VERSION, d3d9_.Receive());
+  RETURN_ON_HR_FAILURE(hr, "Direct3DCreate9Ex failed", false);
+
+  D3DPRESENT_PARAMETERS present_params = {0};
+  present_params.BackBufferWidth = 1;
+  present_params.BackBufferHeight = 1;
+  present_params.BackBufferFormat = D3DFMT_UNKNOWN;
+  present_params.BackBufferCount = 1;
+  present_params.SwapEffect = D3DSWAPEFFECT_DISCARD;
+  present_params.hDeviceWindow = ::GetShellWindow();
+  present_params.Windowed = TRUE;
+  present_params.Flags = D3DPRESENTFLAG_VIDEO;
+  present_params.FullScreen_RefreshRateInHz = 0;
+  present_params.PresentationInterval = 0;
+
+  hr = d3d9_->CreateDeviceEx(D3DADAPTER_DEFAULT,
+                             D3DDEVTYPE_HAL,
+                             ::GetShellWindow(),
+                             D3DCREATE_FPU_PRESERVE |
+                             D3DCREATE_SOFTWARE_VERTEXPROCESSING |
+                             D3DCREATE_DISABLE_PSGP_THREADING |
+                             D3DCREATE_MULTITHREADED,
+                             &present_params,
+                             NULL,
+                             d3d9_device_ex_.Receive());
+  RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device", false);
+
+  hr = DXVA2CreateDirect3DDeviceManager9(&dev_manager_reset_token_,
+                                         device_manager_.Receive());
+  RETURN_ON_HR_FAILURE(hr, "DXVA2CreateDirect3DDeviceManager9 failed", false);
+
+  hr = device_manager_->ResetDevice(d3d9_device_ex_.get(),
+                                    dev_manager_reset_token_);
+  RETURN_ON_HR_FAILURE(hr, "Failed to reset device", false);
+
+  hr = d3d9_device_ex_->CreateQuery(D3DQUERYTYPE_EVENT, query_.Receive());
+  RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device query", false);
+  // Ensure query_ API works (to avoid an infinite loop later in
+  // CopyOutputSampleDataToPictureBuffer).
+  hr = query_->Issue(D3DISSUE_END);
+  RETURN_ON_HR_FAILURE(hr, "Failed to issue END test query", false);
+  return true;
+}
+
+bool DXVAVideoDecodeAccelerator::CreateDX11DevManager() {
+  HRESULT hr = create_dxgi_device_manager_(&dx11_dev_manager_reset_token_,
+                                           d3d11_device_manager_.Receive());
+  RETURN_ON_HR_FAILURE(hr, "MFCreateDXGIDeviceManager failed", false);
+
+  // This array defines the set of DirectX hardware feature levels we support.
+  // The ordering MUST be preserved. All applications are assumed to support
+  // 9.1 unless otherwise stated by the application, which is not our case.
+  D3D_FEATURE_LEVEL feature_levels[] = {
+    D3D_FEATURE_LEVEL_11_1,
+    D3D_FEATURE_LEVEL_11_0,
+    D3D_FEATURE_LEVEL_10_1,
+    D3D_FEATURE_LEVEL_10_0,
+    D3D_FEATURE_LEVEL_9_3,
+    D3D_FEATURE_LEVEL_9_2,
+    D3D_FEATURE_LEVEL_9_1 };
+
+  D3D_FEATURE_LEVEL feature_level_out = D3D_FEATURE_LEVEL_11_0;
+  hr = D3D11CreateDevice(NULL,
+                         D3D_DRIVER_TYPE_HARDWARE,
+                         NULL,
+                         D3D11_CREATE_DEVICE_VIDEO_SUPPORT,
+                         feature_levels,
+                         arraysize(feature_levels),
+                         D3D11_SDK_VERSION,
+                         d3d11_device_.Receive(),
+                         &feature_level_out,
+                         d3d11_device_context_.Receive());
+  RETURN_ON_HR_FAILURE(hr, "Failed to create DX11 device", false);
+
+  hr = d3d11_device_manager_->ResetDevice(d3d11_device_.get(),
+                                          dx11_dev_manager_reset_token_);
+  RETURN_ON_HR_FAILURE(hr, "Failed to reset device", false);
+
+  hr = ::CoCreateInstance(
+      CLSID_VideoProcessorMFT,
+      NULL,
+      CLSCTX_INPROC_SERVER,
+      IID_IMFTransform,
+      reinterpret_cast<void**>(video_format_converter_mft_.Receive()));
+  if (FAILED(hr)) {
+    // TODO(ananta)

[DaleCurtis, 2015/02/26 22:32:22]

Do you want to alias GetLastError() on the stack ahead of time to debug these?

[ananta, 2015/02/26 23:32:57]

Yes. Done.

+    // Remove this CHECK when the change to use DX11 for H/W decoding
+    // stablizes.
+    CHECK(false);
+  }
+  RETURN_ON_HR_FAILURE(hr, "Failed to create video format converter", false);
+  return true;
+}
+
 void DXVAVideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   State state = GetState();
   RETURN_AND_NOTIFY_ON_FAILURE((state == kNormal || state == kStopped ||
                                 state == kFlushing),
            "Invalid state: " << state, ILLEGAL_STATE,);
 
   base::win::ScopedComPtr<IMFSample> sample;
@@ skipping 29 matching lines @@
        ++buffer_index) {
     linked_ptr<DXVAPictureBuffer> picture_buffer =
         DXVAPictureBuffer::Create(*this, buffers[buffer_index], egl_config_);
     RETURN_AND_NOTIFY_ON_FAILURE(picture_buffer.get(),
         "Failed to allocate picture buffer", PLATFORM_FAILURE,);
 
     bool inserted = output_picture_buffers_.insert(std::make_pair(
         buffers[buffer_index].id(), picture_buffer)).second;
     DCHECK(inserted);
   }
+
   ProcessPendingSamples();
   if (pending_flush_) {
     decoder_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DXVAVideoDecodeAccelerator::FlushInternal,
                    base::Unretained(this)));
   }
 }
 
 void DXVAVideoDecodeAccelerator::ReusePictureBuffer(
@@ skipping 188 matching lines @@
   RETURN_ON_HR_FAILURE(hr, "DllGetClassObject for decoder failed", false);
 
   hr = factory->CreateInstance(NULL,
                                __uuidof(IMFTransform),
                                reinterpret_cast<void**>(decoder_.Receive()));
   RETURN_ON_HR_FAILURE(hr, "Failed to create decoder instance", false);
 
   RETURN_ON_FAILURE(CheckDecoderDxvaSupport(),
                     "Failed to check decoder DXVA support", false);
 
+  ULONG_PTR device_manager_to_use = NULL;
+  if (use_dx11_) {
+    CHECK(create_dxgi_device_manager_);
+    RETURN_AND_NOTIFY_ON_FAILURE(CreateDX11DevManager(),
+                                 "Failed to initialize DX11 device and manager",
+                                 PLATFORM_FAILURE,
+                                 false);
+    device_manager_to_use = reinterpret_cast<ULONG_PTR>(
+        d3d11_device_manager_.get());
+  } else {
+    RETURN_AND_NOTIFY_ON_FAILURE(CreateD3DDevManager(),
+                                 "Failed to initialize D3D device and manager",
+                                 PLATFORM_FAILURE,
+                                 false);
+    device_manager_to_use = reinterpret_cast<ULONG_PTR>(device_manager_.get());
+  }
+
   hr = decoder_->ProcessMessage(
             MFT_MESSAGE_SET_D3D_MANAGER,
-            reinterpret_cast<ULONG_PTR>(device_manager_.get()));
-  RETURN_ON_HR_FAILURE(hr, "Failed to pass D3D manager to decoder", false);
+            device_manager_to_use);
+  if (use_dx11_) {
+    RETURN_ON_HR_FAILURE(hr, "Failed to pass DX11 manager to decoder", false);
+  } else {
+    RETURN_ON_HR_FAILURE(hr, "Failed to pass D3D manager to decoder", false);
+  }
 
   EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
 
   EGLint config_attribs[] = {
     EGL_BUFFER_SIZE, 32,
     EGL_RED_SIZE, 8,
     EGL_GREEN_SIZE, 8,
     EGL_BLUE_SIZE, 8,
     EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
     EGL_ALPHA_SIZE, 0,
@@ skipping 26 matching lines @@
     hr = attributes->SetUINT32(CODECAPI_AVDecVideoAcceleration_H264, TRUE);
     RETURN_ON_HR_FAILURE(hr, "Failed to enable DXVA H/W decoding", false);
   }
 
   hr = attributes->SetUINT32(CODECAPI_AVLowLatencyMode, TRUE);
   if (SUCCEEDED(hr)) {
     DVLOG(1) << "Successfully set Low latency mode on decoder.";
   } else {
     DVLOG(1) << "Failed to set Low latency mode on decoder. Error: " << hr;
   }
+
+  // The decoder should use DX11 iff
+  // 1. The underlying H/W decoder supports it.
+  // 2. We have a pointer to the MFCreateDXGIDeviceManager function needed for
+  //    this. This should always be true for Windows 8+.
+  // 3. ANGLE is using DX11.
+  DCHECK(gl_context_);
+  if (create_dxgi_device_manager_ &&
+      (gl_context_->GetGLRenderer().find("Direct3D11") !=
+           std::string::npos)) {
+    UINT32 dx11_aware = 0;
+    hr = attributes->GetUINT32(MF_SA_D3D11_AWARE, &dx11_aware);

[DaleCurtis, 2015/02/26 22:32:22]

Remove hr= if you're not going to use it?

[ananta, 2015/02/26 23:32:57]

Done.

+    use_dx11_ = !!dx11_aware;
+  }
   return true;
 }
 
 bool DXVAVideoDecodeAccelerator::SetDecoderMediaTypes() {
   RETURN_ON_FAILURE(SetDecoderInputMediaType(),
                     "Failed to set decoder input media type", false);
   return SetDecoderOutputMediaType(MFVideoFormat_NV12);
 }
 
 bool DXVAVideoDecodeAccelerator::SetDecoderInputMediaType() {
@@ skipping 144 matching lines @@
 
   inputs_before_decode_ = 0;
 
   RETURN_AND_NOTIFY_ON_FAILURE(ProcessOutputSample(output_data_buffer.pSample),
       "Failed to process output sample.", PLATFORM_FAILURE,);
 }
 
 bool DXVAVideoDecodeAccelerator::ProcessOutputSample(IMFSample* sample) {
   RETURN_ON_FAILURE(sample, "Decode succeeded with NULL output sample", false);
 
-  base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
-  HRESULT hr = sample->GetBufferByIndex(0, output_buffer.Receive());
-  RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from output sample", false);
-
-  base::win::ScopedComPtr<IDirect3DSurface9> surface;
-  hr = MFGetService(output_buffer.get(), MR_BUFFER_SERVICE,
-                    IID_PPV_ARGS(surface.Receive()));
-  RETURN_ON_HR_FAILURE(hr, "Failed to get D3D surface from output sample",
-                       false);
-
   LONGLONG input_buffer_id = 0;
   RETURN_ON_HR_FAILURE(sample->GetSampleTime(&input_buffer_id),
                        "Failed to get input buffer id associated with sample",
                        false);
 
   {
     base::AutoLock lock(decoder_lock_);
     DCHECK(pending_output_samples_.empty());
     pending_output_samples_.push_back(
         PendingSampleInfo(input_buffer_id, sample));
   }
 
   if (pictures_requested_) {
     DVLOG(1) << "Waiting for picture slots from the client.";
     main_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DXVAVideoDecodeAccelerator::ProcessPendingSamples,
                    weak_this_factory_.GetWeakPtr()));
     return true;
   }
 
-  // We only read the surface description, which contains its width/height when
-  // we need the picture buffers from the client. Once we have those, then they
-  // are reused.
-  D3DSURFACE_DESC surface_desc;
-  hr = surface->GetDesc(&surface_desc);
-  RETURN_ON_HR_FAILURE(hr, "Failed to get surface description", false);
+  int width = 0;
+  int height = 0;
+  if (!GetVideoFrameDimensions(sample, &width, &height)) {
+    RETURN_ON_FAILURE(false, "Failed to get D3D surface from output sample",
+                      false);
+  }
 
   // Go ahead and request picture buffers.
   main_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::RequestPictureBuffers,
                  weak_this_factory_.GetWeakPtr(),
-                 surface_desc.Width,
-                 surface_desc.Height));
+                 width,
+                 height));
 
   pictures_requested_ = true;
   return true;
 }
 
 void DXVAVideoDecodeAccelerator::ProcessPendingSamples() {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   if (!output_picture_buffers_.size())
     return;
@@ skipping 11 matching lines @@
       PendingSampleInfo* pending_sample = NULL;
       {
         base::AutoLock lock(decoder_lock_);
 
         PendingSampleInfo& sample_info = pending_output_samples_.front();
         if (sample_info.picture_buffer_id != -1)
           continue;
         pending_sample = &sample_info;
       }
 
+      int width = 0;
+      int height = 0;
+      if (!GetVideoFrameDimensions(pending_sample->output_sample.get(),
+          &width, &height)) {
+        RETURN_AND_NOTIFY_ON_FAILURE(false,
+            "Failed to get D3D surface from output sample", PLATFORM_FAILURE,);
+      }
+
+      if (width != index->second->size().width() ||
+          height != index->second->size().height()) {
+        HandleResolutionChanged(width, height);
+        return;
+      }
+
       base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
       HRESULT hr = pending_sample->output_sample->GetBufferByIndex(
           0, output_buffer.Receive());
-      RETURN_AND_NOTIFY_ON_HR_FAILURE(
-          hr, "Failed to get buffer from output sample", PLATFORM_FAILURE,);
+      RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
+          "Failed to get buffer from output sample", PLATFORM_FAILURE,);
 
       base::win::ScopedComPtr<IDirect3DSurface9> surface;
-      hr = MFGetService(output_buffer.get(), MR_BUFFER_SERVICE,
-                        IID_PPV_ARGS(surface.Receive()));
-      RETURN_AND_NOTIFY_ON_HR_FAILURE(
-          hr, "Failed to get D3D surface from output sample",
-          PLATFORM_FAILURE,);
+      base::win::ScopedComPtr<ID3D11Texture2D> d3d11_texture;
 
-      D3DSURFACE_DESC surface_desc;
-      hr = surface->GetDesc(&surface_desc);
-      RETURN_AND_NOTIFY_ON_HR_FAILURE(
-          hr, "Failed to get surface description", PLATFORM_FAILURE,);
-
-      if (surface_desc.Width !=
-              static_cast<uint32>(index->second->size().width()) ||
-          surface_desc.Height !=
-              static_cast<uint32>(index->second->size().height())) {
-        HandleResolutionChanged(surface_desc.Width, surface_desc.Height);
-        return;
+      if (use_dx11_) {
+        base::win::ScopedComPtr<IMFDXGIBuffer> dxgi_buffer;
+        hr = dxgi_buffer.QueryFrom(output_buffer.get());
+        RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
+            "Failed to get DXGIBuffer from output sample", PLATFORM_FAILURE,);
+        hr = dxgi_buffer->GetResource(
+            __uuidof(ID3D11Texture2D),
+            reinterpret_cast<void**>(d3d11_texture.Receive()));
+      } else {
+        hr = MFGetService(output_buffer.get(), MR_BUFFER_SERVICE,
+                          IID_PPV_ARGS(surface.Receive()));
       }
+      RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
+          "Failed to get surface from output sample", PLATFORM_FAILURE,);
 
       pending_sample->picture_buffer_id = index->second->id();
 
       RETURN_AND_NOTIFY_ON_FAILURE(
           index->second->CopyOutputSampleDataToPictureBuffer(
               this,
               surface.get(),
+              d3d11_texture.get(),
               pending_sample->input_buffer_id),
-          "Failed to copy output sample", PLATFORM_FAILURE, );
+          "Failed to copy output sample", PLATFORM_FAILURE,);
 
       index->second->set_available(false);
     }
   }
 }
 
 void DXVAVideoDecodeAccelerator::StopOnError(
   media::VideoDecodeAccelerator::Error error) {
   if (!main_thread_task_runner_->BelongsToCurrentThread()) {
     main_thread_task_runner_->PostTask(
@@ skipping 16 matching lines @@
 void DXVAVideoDecodeAccelerator::Invalidate() {
   if (GetState() == kUninitialized)
     return;
   decoder_thread_.Stop();
   weak_this_factory_.InvalidateWeakPtrs();
   output_picture_buffers_.clear();
   stale_output_picture_buffers_.clear();
   pending_output_samples_.clear();
   pending_input_buffers_.clear();
   decoder_.Release();
+  if (video_format_converter_mft_.get()) {
+    video_format_converter_mft_->ProcessMessage(
+        MFT_MESSAGE_NOTIFY_END_STREAMING, 0);
+    video_format_converter_mft_.Release();
+  }
   MFShutdown();
+  dx11_video_format_converter_media_type_needs_init_ = true;
   SetState(kUninitialized);
 }
 
 void DXVAVideoDecodeAccelerator::NotifyInputBufferRead(int input_buffer_id) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   if (client_)
     client_->NotifyEndOfBitstreamBuffer(input_buffer_id);
 }
 
 void DXVAVideoDecodeAccelerator::NotifyFlushDone() {
@@ skipping 204 matching lines @@
   // http://code.google.com/p/chromium/issues/detail?id=150925
   main_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::NotifyInputBufferRead,
                  weak_this_factory_.GetWeakPtr(),
                  input_buffer_id));
 }
 
 void DXVAVideoDecodeAccelerator::HandleResolutionChanged(int width,
                                                          int height) {
+  dx11_video_format_converter_media_type_needs_init_ = true;
+
   main_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::DismissStaleBuffers,
                  weak_this_factory_.GetWeakPtr()));
 
   main_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::RequestPictureBuffers,
                  weak_this_factory_.GetWeakPtr(),
                  width,
@@ skipping 73 matching lines @@
         FROM_HERE,
         base::Bind(&DXVAVideoDecodeAccelerator::CopySurface,
                    base::Unretained(this),
                    src_surface,
                    dest_surface,
                    picture_buffer_id,
                    input_buffer_id));
     return;
   }
 
-  HRESULT hr = device_->StretchRect(src_surface, NULL, dest_surface,
-                                    NULL, D3DTEXF_NONE);
+  HRESULT hr = d3d9_device_ex_->StretchRect(src_surface, NULL, dest_surface,
+                                            NULL, D3DTEXF_NONE);
   RETURN_ON_HR_FAILURE(hr, "Colorspace conversion via StretchRect failed",);
 
   // 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",);
 
   // Flush the decoder device to ensure that the decoded frame is copied to the
   // target surface.
   decoder_thread_task_runner_->PostDelayedTask(
@@ skipping 50 matching lines @@
         base::Bind(&DXVAVideoDecodeAccelerator::FlushInternal,
                    base::Unretained(this)));
     return;
   }
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
+void DXVAVideoDecodeAccelerator::CopyTexture(ID3D11Texture2D* src_texture,
+                                             ID3D11Texture2D* dest_texture,
+                                             IMFSample* video_frame,
+                                             int picture_buffer_id,
+                                             int input_buffer_id) {
+  HRESULT hr = E_FAIL;
+
+  DCHECK(use_dx11_);
+
+  if (!decoder_thread_task_runner_->BelongsToCurrentThread()) {
+    // The media foundation H.264 decoder outputs YUV12 textures which we
+    // cannot copy into ANGLE as they expect ARGB textures. In D3D land
+    // the StretchRect API in the IDirect3DDevice9Ex interface did the color
+    // space conversion for us. Sadly in DX11 land the API does not provide
+    // a straightforward way to do this.
+    // We use the video processor MFT.
+    // https://msdn.microsoft.com/en-us/library/hh162913(v=vs.85).aspx
+    // This object implements a media foundation transform (IMFTransform)
+    // which follows the same contract as the decoder. The color space
+    // conversion as per msdn is done in the GPU.
+
+    D3D11_TEXTURE2D_DESC source_desc;
+    src_texture->GetDesc(&source_desc);
+
+    // Set up the input and output types for the video processor MFT.
+    if (!InitializeDX11VideoFormatConverterMediaType(source_desc.Width,
+                                                     source_desc.Height)) {
+      // TODO(ananta)
+      // Remove this CHECK when the change to use DX11 for H/W decoding
+      // stablizes.
+      CHECK(false);

[DaleCurtis, 2015/02/26 22:32:22]

Ditto for GetLastError alias.

[ananta, 2015/02/26 23:32:57]

Added the alias to the InitializeDX11VideoFormatConverterMediaType and removed
the check here.

+      RETURN_AND_NOTIFY_ON_FAILURE(
+          false, "Failed to initialize media types for convesion.",
+          PLATFORM_FAILURE,);
+    }
+
+    // The input to the video processor is the output sample.
+    base::win::ScopedComPtr<IMFSample> input_sample_for_conversion;
+    {
+      base::AutoLock lock(decoder_lock_);
+      PendingSampleInfo& sample_info = pending_output_samples_.front();
+      input_sample_for_conversion = sample_info.output_sample;
+    }
+
+    decoder_thread_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&DXVAVideoDecodeAccelerator::CopyTexture,
+                    base::Unretained(this),
+                    src_texture,
+                    dest_texture,
+                    input_sample_for_conversion.Detach(),
+                    picture_buffer_id,
+                    input_buffer_id));
+    return;
+  }
+
+  DCHECK(video_frame);
+
+  base::win::ScopedComPtr<IMFSample> input_sample;
+  input_sample.Attach(video_frame);
+
+  DCHECK(video_format_converter_mft_.get());
+
+  hr = video_format_converter_mft_->ProcessInput(0, video_frame, 0);
+  if (FAILED(hr)) {
+    DCHECK(false);
+    RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
+        "Failed to convert output sample format.", PLATFORM_FAILURE,);
+  }
+
+  // The video processor MFT requires output samples to be allocated by the
+  // caller. We create a sample with a buffer backed with the ID3D11Texture2D
+  // interface exposed by ANGLE. This works nicely as this ensures that the
+  // video processor coverts the color space of the output frame and copies

[DaleCurtis, 2015/02/26 22:32:22]

Neat, is this more efficient than our existing copy?

[ananta, 2015/02/26 23:32:57]

The existing copy in D3D9 occurs in the GPU process. It is still a copy across
devices with any locking etc being performed by the API.

The video processor route in DX11 occurs in the GPU process and does any locking
etc if needed.

On a related note this will all go away once ANGLE folks land the extension to
allow a caller to retrieve the ANGLE device object. We can avoid creating a
device in the decoder then.

+  // the result into the ANGLE texture.
+  base::win::ScopedComPtr<IMFSample> output_sample;
+  hr = MFCreateSample(output_sample.Receive());
+  if (FAILED(hr)) {
+    RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
+        "Failed to create output sample.", PLATFORM_FAILURE,);
+  }
+
+  base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
+  hr = MFCreateDXGISurfaceBuffer(
+      __uuidof(ID3D11Texture2D), dest_texture, 0, FALSE,
+      output_buffer.Receive());
+  if (FAILED(hr)) {
+    // TODO(ananta)
+    // Remove this CHECK when the change to use DX11 for H/W decoding
+    // stablizes.
+    CHECK(false);
+    RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
+        "Failed to create output sample.", PLATFORM_FAILURE,);
+  }
+
+  output_sample->AddBuffer(output_buffer.get());
+
+  DWORD status = 0;
+  MFT_OUTPUT_DATA_BUFFER format_converter_output = {};
+  format_converter_output.pSample = output_sample.get();
+  hr = video_format_converter_mft_->ProcessOutput(

[DaleCurtis, 2015/02/26 22:32:22]

Does this complete immediately? Unlike StretchRect...

[ananta, 2015/02/26 23:32:57]

Yes. This transform internally retrieves the bits from the videoframe via the
Lock operation on the frames buffer and then converts the frame from NV12 to
whatever we want. When ProcessOutput returns we have the converted bits. We thus
don't need to call Flush and wait for the command set to complete.

+        0,  // No flags
+        1,  // # of out streams to pull from
+        &format_converter_output,
+        &status);
+  if (FAILED(hr)) {
+    // TODO(ananta)
+    // Remove this CHECK when the change to use DX11 for H/W decoding
+    // stablizes.
+    CHECK(false);
+    RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
+        "Failed to convert output sample format.", PLATFORM_FAILURE,);
+  }
+
+  main_thread_task_runner_->PostTask(
+    FROM_HERE,
+    base::Bind(&DXVAVideoDecodeAccelerator::CopySurfaceComplete,
+               weak_this_factory_.GetWeakPtr(),
+               reinterpret_cast<IDirect3DSurface9*>(NULL),
+               reinterpret_cast<IDirect3DSurface9*>(NULL),
+               picture_buffer_id,
+               input_buffer_id));
+}
+
 void DXVAVideoDecodeAccelerator::FlushDecoder(
     int iterations,
     IDirect3DSurface9* src_surface,
     IDirect3DSurface9* dest_surface,
     int picture_buffer_id,
     int input_buffer_id) {
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   // The DXVA decoder has its own device which it uses for decoding. ANGLE
   // has its own device which we don't have access to.
@@ skipping 21 matching lines @@
   main_thread_task_runner_->PostTask(
     FROM_HERE,
     base::Bind(&DXVAVideoDecodeAccelerator::CopySurfaceComplete,
                weak_this_factory_.GetWeakPtr(),
                src_surface,
                dest_surface,
                picture_buffer_id,
                input_buffer_id));
 }
 
+bool DXVAVideoDecodeAccelerator::InitializeDX11VideoFormatConverterMediaType(
+    int width, int height) {
+  if (!dx11_video_format_converter_media_type_needs_init_)
+    return true;
+
+  CHECK(video_format_converter_mft_.get());
+
+  HRESULT hr = video_format_converter_mft_->ProcessMessage(
+      MFT_MESSAGE_SET_D3D_MANAGER,
+      reinterpret_cast<ULONG_PTR>(d3d11_device_manager_.get()));
+  if (FAILED(hr)) {
+    // TODO(ananta)
+    // Remove this CHECK when the change to use DX11 for H/W decoding
+    // stablizes.
+    CHECK(false);
+  }
+  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
+      "Failed to initialize video format converter", PLATFORM_FAILURE, false);
+
+  video_format_converter_mft_->ProcessMessage(
+      MFT_MESSAGE_NOTIFY_END_STREAMING, 0);
+
+  base::win::ScopedComPtr<IMFMediaType> media_type;
+  hr = MFCreateMediaType(media_type.Receive());
+  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "MFCreateMediaType failed",
+      PLATFORM_FAILURE, false);
+
+  hr = media_type->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
+  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to set major input type",
+      PLATFORM_FAILURE, false);
+
+  hr = media_type->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_NV12);
+  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to set input sub type",
+      PLATFORM_FAILURE, false);
+
+  hr = media_type->SetUINT32(MF_MT_ALL_SAMPLES_INDEPENDENT, TRUE);
+  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
+      "Failed to set attributes on media type", PLATFORM_FAILURE, false);
+
+  hr = media_type->SetUINT32(MF_MT_INTERLACE_MODE,
+                             MFVideoInterlace_Progressive);
+  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
+      "Failed to set attributes on media type", PLATFORM_FAILURE, false);
+
+  base::win::ScopedComPtr<IMFAttributes> converter_attributes;
+  hr = video_format_converter_mft_->GetAttributes(
+      converter_attributes.Receive());
+  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to get converter attributes",
+      PLATFORM_FAILURE, false);
+
+  hr = converter_attributes->SetUINT32(MF_XVP_PLAYBACK_MODE, TRUE);
+  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to set converter attributes",
+      PLATFORM_FAILURE, false);
+
+  hr = converter_attributes->SetUINT32(MF_LOW_LATENCY, FALSE);
+  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to set converter attributes",
+      PLATFORM_FAILURE, false);
+
+  hr = MFSetAttributeSize(media_type.get(), MF_MT_FRAME_SIZE, width, height);
+  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to set media type attributes",
+      PLATFORM_FAILURE, false);
+
+  hr = video_format_converter_mft_->SetInputType(0, media_type.get(), 0);
+  if (FAILED(hr)) {
+    // TODO(ananta)
+    // Remove this CHECK when the change to use DX11 for H/W decoding
+    // stablizes.
+    CHECK(false);
+  }
+  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to set converter input type",
+      PLATFORM_FAILURE, false);
+
+  base::win::ScopedComPtr<IMFMediaType> out_media_type;
+
+  for (uint32 i = 0;
+        SUCCEEDED(video_format_converter_mft_->GetOutputAvailableType(0, i,
+                                                  out_media_type.Receive()));
+        ++i) {
+    GUID out_subtype = {0};
+    hr = out_media_type->GetGUID(MF_MT_SUBTYPE, &out_subtype);
+    RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to get output major type",
+      PLATFORM_FAILURE, false);
+
+    if (out_subtype == MFVideoFormat_ARGB32) {
+      hr = out_media_type->SetUINT32(MF_MT_ALL_SAMPLES_INDEPENDENT, TRUE);
+      RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
+          "Failed to set attributes on media type", PLATFORM_FAILURE, false);
+
+      hr = out_media_type->SetUINT32(MF_MT_INTERLACE_MODE,
+                                     MFVideoInterlace_Progressive);
+      RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
+          "Failed to set attributes on media type", PLATFORM_FAILURE, false);
+
+      hr = MFSetAttributeSize(out_media_type.get(), MF_MT_FRAME_SIZE, width,
+                              height);
+      RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
+          "Failed to set media type attributes", PLATFORM_FAILURE, false);
+
+      hr = video_format_converter_mft_->SetOutputType(
+          0, out_media_type.get(), 0);  // No flags
+      if (FAILED(hr)) {
+        // TODO(ananta)
+        // Remove this CHECK when the change to use DX11 for H/W decoding
+        // stablizes.
+        CHECK(false);
+      }
+      RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
+          "Failed to set converter output type", PLATFORM_FAILURE, false);
+
+      hr = video_format_converter_mft_->ProcessMessage(
+          MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0);
+      if (FAILED(hr)) {
+        // TODO(ananta)
+        // Remove this CHECK when the change to use DX11 for H/W decoding
+        // stablizes.
+        RETURN_AND_NOTIFY_ON_FAILURE(
+            false, "Failed to initialize video converter.", PLATFORM_FAILURE,
+            false);
+      }
+      dx11_video_format_converter_media_type_needs_init_ = false;
+      return true;
+    }
+    out_media_type.Release();
+  }
+  return false;
+}
+
+bool DXVAVideoDecodeAccelerator::GetVideoFrameDimensions(
+    IMFSample* sample,
+    int* width,
+    int* height) {
+  base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
+  HRESULT hr = sample->GetBufferByIndex(0, output_buffer.Receive());
+  RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from output sample", false);
+
+  if (use_dx11_) {
+    base::win::ScopedComPtr<IMFDXGIBuffer> dxgi_buffer;
+    base::win::ScopedComPtr<ID3D11Texture2D> d3d11_texture;
+    hr = dxgi_buffer.QueryFrom(output_buffer.get());
+    RETURN_ON_HR_FAILURE(hr, "Failed to get DXGIBuffer from output sample",
+                         false);
+    hr = dxgi_buffer->GetResource(
+        __uuidof(ID3D11Texture2D),
+        reinterpret_cast<void**>(d3d11_texture.Receive()));
+    RETURN_ON_HR_FAILURE(hr, "Failed to get D3D11Texture from output buffer",
+                         false);
+    D3D11_TEXTURE2D_DESC d3d11_texture_desc;
+    d3d11_texture->GetDesc(&d3d11_texture_desc);
+    *width = d3d11_texture_desc.Width;
+    *height = d3d11_texture_desc.Height;
+  } else {
+    base::win::ScopedComPtr<IDirect3DSurface9> surface;
+    hr = MFGetService(output_buffer.get(), MR_BUFFER_SERVICE,
+                      IID_PPV_ARGS(surface.Receive()));
+    RETURN_ON_HR_FAILURE(hr, "Failed to get D3D surface from output sample",
+                         false);
+    D3DSURFACE_DESC surface_desc;
+    hr = surface->GetDesc(&surface_desc);
+    RETURN_ON_HR_FAILURE(hr, "Failed to get surface description", false);
+    *width = surface_desc.Width;
+    *height = surface_desc.Height;
+  }
+  return true;
+}
+
 }  // namespace content