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

content/common/gpu/media/dxva_video_decode_accelerator.h

 // 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.
 
 #ifndef CONTENT_COMMON_GPU_MEDIA_DXVA_VIDEO_DECODE_ACCELERATOR_H_
 #define CONTENT_COMMON_GPU_MEDIA_DXVA_VIDEO_DECODE_ACCELERATOR_H_
 
+#include <d3d11.h>
 #include <d3d9.h>
 // Work around bug in this header by disabling the relevant warning for it.
 // https://connect.microsoft.com/VisualStudio/feedback/details/911260/dxva2api-h-in-win8-sdk-triggers-c4201-with-w4
 #pragma warning(push)
 #pragma warning(disable:4201)
 #include <dxva2api.h>
 #pragma warning(pop)
 #include <list>
 #include <map>
 #include <mfidl.h>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/threading/thread.h"
 #include "base/win/scoped_comptr.h"
 #include "content/common/content_export.h"
 #include "media/video/video_decode_accelerator.h"
 
 interface IMFSample;
 interface IDirect3DSurface9;
 
+namespace gfx {
+class GLContext;
+}
+
+typedef HRESULT (WINAPI* CreateDXGIDeviceManager)(
+    UINT* reset_token,
+    IMFDXGIDeviceManager** device_manager);
+
 namespace content {
 
 // Class to provide a DXVA 2.0 based accelerator using the Microsoft Media
 // foundation APIs via the VideoDecodeAccelerator interface.
 // This class lives on a single thread and DCHECKs that it is never accessed
 // from any other.
 class CONTENT_EXPORT DXVAVideoDecodeAccelerator
     : public media::VideoDecodeAccelerator {
  public:
   enum State {
     kUninitialized,               // un-initialized.
     kNormal,                      // normal playing state.
     kResetting,                   // upon received Reset(), before ResetDone()
     kStopped,                     // upon output EOS received.
     kFlushing,                    // upon flush request received.
   };
 
   // Does not take ownership of |client| which must outlive |*this|.
   explicit DXVAVideoDecodeAccelerator(
-      const base::Callback<bool(void)>& make_context_current);
+      const base::Callback<bool(void)>& make_context_current,
+      gfx::GLContext* gl_context);
   ~DXVAVideoDecodeAccelerator() override;
 
   // media::VideoDecodeAccelerator implementation.
   bool Initialize(media::VideoCodecProfile profile,
                   Client* client) override;
   void Decode(const media::BitstreamBuffer& bitstream_buffer) override;
   void AssignPictureBuffers(
       const std::vector<media::PictureBuffer>& buffers) override;
   void ReusePictureBuffer(int32 picture_buffer_id) override;
   void Flush() override;
   void Reset() override;
   void Destroy() override;
   bool CanDecodeOnIOThread() override;
   GLenum GetSurfaceInternalFormat() const override;
 
  private:
   typedef void* EGLConfig;
   typedef void* EGLSurface;
 
   // Creates and initializes an instance of the D3D device and the
   // corresponding device manager. The device manager instance is eventually
   // passed to the IMFTransform interface implemented by the decoder.
   bool CreateD3DDevManager();
 
+  // Creates and initializes an instance of the DX11 device and the
+  // corresponding device manager. The device manager instance is eventually
+  // passed to the IMFTransform interface implemented by the decoder.
+  bool CreateDX11DevManager();
+
   // Creates, initializes and sets the media codec types for the decoder.
   bool InitDecoder(media::VideoCodecProfile profile);
 
   // Validates whether the decoder supports hardware video acceleration.
   bool CheckDecoderDxvaSupport();
 
   // Returns information about the input and output streams. This includes
   // alignment information, decoder support flags, minimum sample size, etc.
   bool GetStreamsInfoAndBufferReqs();
 
@@ skipping 101 matching lines @@
                    int picture_buffer_id,
                    int input_buffer_id);
 
   // This is a notification that the source surface |src_surface| was copied to
   // the destination |dest_surface|. Received on the main thread.
   void CopySurfaceComplete(IDirect3DSurface9* src_surface,
                            IDirect3DSurface9* dest_surface,
                            int picture_buffer_id,
                            int input_buffer_id);
 
+  // Copies the source texture |src_texture| to the destination |dest_texture|.
+  // The copying is done on the decoder thread. The |video_frame| parameter
+  // is the sample containing the frame to be copied.
+  void CopyTexture(ID3D11Texture2D* src_texture,
+                   ID3D11Texture2D* dest_texture,
+                   IMFSample* video_frame,
+                   int picture_buffer_id,
+                   int input_buffer_id);
+
   // Flushes the decoder device to ensure that the decoded surface is copied
   // to the target surface. |iterations| helps to maintain an upper limit on
   // the number of times we try to complete the flush operation.
   void FlushDecoder(int iterations,
                     IDirect3DSurface9* src_surface,
                     IDirect3DSurface9* dest_surface,
                     int picture_buffer_id,
                     int input_buffer_id);
 
+  // Initializes the DX11 Video format converter media types.
+  // Returns true on success.
+  bool InitializeDX11VideoFormatConverterMediaType(int width, int height);
+
+  // Returns the output video frame dimensions (width, height).
+  // |sample| :- This is the output sample containing the video frame.
+  // |width| :- The width is returned here.
+  // |height| :- The height is returned here.
+  // Returns true on success.
+  bool GetVideoFrameDimensions(IMFSample* sample, int* width, int* height);
+
   // To expose client callbacks from VideoDecodeAccelerator.
   media::VideoDecodeAccelerator::Client* client_;
 
   base::win::ScopedComPtr<IMFTransform> decoder_;
+  base::win::ScopedComPtr<IMFTransform> video_format_converter_mft_;
 
   base::win::ScopedComPtr<IDirect3D9Ex> d3d9_;
-  base::win::ScopedComPtr<IDirect3DDevice9Ex> device_;
+  base::win::ScopedComPtr<IDirect3DDevice9Ex> d3d9_device_ex_;
   base::win::ScopedComPtr<IDirect3DDeviceManager9> device_manager_;
   base::win::ScopedComPtr<IDirect3DQuery9> query_;
+
+  base::win::ScopedComPtr<ID3D11DeviceContext> d3d11_device_context_;
+  base::win::ScopedComPtr<ID3D11Device > d3d11_device_;
+  base::win::ScopedComPtr<IMFDXGIDeviceManager> d3d11_device_manager_;
+  base::win::ScopedComPtr<ID3D11Query> d3d11_query_;
+
   // Ideally the reset token would be a stack variable which is used while
   // creating the device manager. However it seems that the device manager
   // holds onto the token and attempts to access it if the underlying device
   // changes.
   // TODO(ananta): This needs to be verified.
   uint32 dev_manager_reset_token_;
 
+  // Reset token for the DX11 device manager.
+  uint32 dx11_dev_manager_reset_token_;
+
+  uint32 dx11_dev_manager_reset_token_format_conversion_;
+
   // The EGL config to use for decoded frames.
   EGLConfig egl_config_;
 
   // Current state of the decoder.
   volatile State state_;
 
   MFT_INPUT_STREAM_INFO input_stream_info_;
   MFT_OUTPUT_STREAM_INFO output_stream_info_;
 
   // Contains information about a decoded sample.
@@ skipping 65 matching lines @@
 
   // Disallow rebinding WeakReference ownership to a different thread by
   // keeping a persistent reference. This avoids problems with the
   // thread safety of reaching into this class from multiple threads to
   // attain a WeakPtr.
   const base::WeakPtr<DXVAVideoDecodeAccelerator> weak_ptr_;
 
   // Set to true if we are in the context of a Flush operation. Used to prevent
   // multiple flush done notifications being sent out.
   bool pending_flush_;
+
+  // Defaults to false. Indicates if we should use D3D or DX11 interfaces for
+  // H/W decoding.
+  bool use_dx11_;
+
+  // Set to true if the DX11 video format converter input media types need to
+  // be initialized. Defaults to true.
+  bool dx11_video_format_converter_media_type_needs_init_;
+
+  // The GLContext to be used by the decoder.
+  scoped_refptr<gfx::GLContext> gl_context_;
+
+  // Function pointer for the MFCreateDXGIDeviceManager API.
+  static CreateDXGIDeviceManager create_dxgi_device_manager_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_DXVA_VIDEO_DECODE_ACCELERATOR_H_