media: Inform VideoBlit/MFTransform of video color information

media/gpu/dxva_video_decode_accelerator_win.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 MEDIA_GPU_DXVA_VIDEO_DECODE_ACCELERATOR_WIN_H_
 #define MEDIA_GPU_DXVA_VIDEO_DECODE_ACCELERATOR_WIN_H_
 
 #include <d3d11.h>
 #include <d3d9.h>
 #include <initguid.h>
@@ skipping 53 matching lines @@
 // TODO(ananta)
 // Move this to a common place so that all VDA's can use this.
 class H264ConfigChangeDetector {
  public:
   H264ConfigChangeDetector();
   ~H264ConfigChangeDetector();
 
   // Detects stream configuration changes.
   // Returns false on failure.
   bool DetectConfig(const uint8_t* stream, unsigned int size);
-
   bool config_changed() const { return config_changed_; }
 
   gfx::ColorSpace current_color_space() const;
 
  private:
   // These fields are used to track the SPS/PPS in the H.264 bitstream and
   // are eventually compared against the SPS/PPS in the bitstream to detect
   // a change.
   int last_sps_id_;
   std::vector<uint8_t> last_sps_;
@@ skipping 76 matching lines @@
   // some second generation Intel GPU drivers crash if we create a video
   // device with a resolution higher then 1920 x 1088. This function
   // checks if the GPU is in this list and if yes returns true.
   static bool IsLegacyGPU(ID3D11Device* device);
 
   // 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();
 
+  // TODO(hubbe): COMMENT
+  bool CreateVideoProcessor();
+
   // 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(VideoCodecProfile profile);
 
   // Validates whether the decoder supports hardware video acceleration.
   bool CheckDecoderDxvaSupport();
@@ skipping 93 matching lines @@
   // Returns if we have output samples waiting to be processed. We only
   // allow one output sample to be present in the output queue at any given
   // time.
   bool OutputSamplesPresent();
 
   // Copies the source surface |src_surface| to the destination |dest_surface|.
   // The copying is done on the decoder thread.
   void CopySurface(IDirect3DSurface9* src_surface,
                    IDirect3DSurface9* dest_surface,
                    int picture_buffer_id,
-                   int input_buffer_id);
+                   int input_buffer_id,
+                   const gfx::ColorSpace& color_space);
 
   // 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);
 
   void BindPictureBufferToSample(base::win::ScopedComPtr<IMFSample> sample,
                                  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.
   void CopyTexture(ID3D11Texture2D* src_texture,
                    ID3D11Texture2D* dest_texture,
                    base::win::ScopedComPtr<IDXGIKeyedMutex> dest_keyed_mutex,
                    uint64_t keyed_mutex_value,
                    int picture_buffer_id,
-                   int input_buffer_id);
+                   int input_buffer_id,
+                   const gfx::ColorSpace& color_space);
 
   // Copies the |video_frame| to the destination |dest_texture|.
   void CopyTextureOnDecoderThread(
       ID3D11Texture2D* dest_texture,
       base::win::ScopedComPtr<IDXGIKeyedMutex> dest_keyed_mutex,
       uint64_t keyed_mutex_value,
       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);
 
   // Polls to wait for GPU commands to be finished on the picture buffer
   // before reusing it.
   void WaitForOutputBuffer(int32_t picture_buffer_id, int count);
 
   // Initializes the DX11 Video format converter media types.
   // Returns true on success.
-  bool InitializeDX11VideoFormatConverterMediaType(int width, int height);
+  bool InitializeDX11VideoFormatConverterMediaType(
+      int width,
+      int height,
+      const gfx::ColorSpace& color_space);
 
   // 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);
 
   // Sets the output type on the |transform| to the GUID identified by the
   // the |output_type| parameter. The GUID can be MFVideoFormat_RGB32,
@@ skipping 29 matching lines @@
   base::win::ScopedComPtr<IDirect3DDeviceManager9> device_manager_;
   base::win::ScopedComPtr<IDirect3DQuery9> query_;
 
   base::win::ScopedComPtr<ID3D11Device> d3d11_device_;
   base::win::ScopedComPtr<ID3D11Device> angle_device_;
   base::win::ScopedComPtr<IMFDXGIDeviceManager> d3d11_device_manager_;
   base::win::ScopedComPtr<ID3D10Multithread> multi_threaded_;
   base::win::ScopedComPtr<ID3D11DeviceContext> d3d11_device_context_;
   base::win::ScopedComPtr<ID3D11Query> d3d11_query_;
 
+  base::win::ScopedComPtr<IDirectXVideoProcessorService>
+      video_processor_service_;
+  base::win::ScopedComPtr<IDirectXVideoProcessor> processor_;
+  DXVA2_ProcAmpValues default_procamp_values_;
+
   // 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_t dev_manager_reset_token_;
 
   // Reset token for the DX11 device manager.
   uint32_t dx11_dev_manager_reset_token_;
 
@@ skipping 91 matching lines @@
   bool pending_flush_;
 
   // Use CODECAPI_AVLowLatencyMode.
   bool enable_low_latency_;
 
   bool share_nv12_textures_;
 
   // Copy NV12 texture to another NV12 texture.
   bool copy_nv12_textures_;
 
+  // When converting YUV to RGB, make sure we tell the blitter about the input
+  // color space so that it can convert it correctly.
+  bool use_color_info_ = true;
+
   // Defaults to false. Indicates if we should use D3D or DX11 interfaces for
   // H/W decoding.
   bool use_dx11_;
 
   // True when using Microsoft's VP9 HMFT for decoding.
   bool using_ms_vp9_mft_ = false;
 
   // True if we should use DXGI keyed mutexes to synchronize between the two
   // contexts.
   bool use_keyed_mutex_;
@@ skipping 26 matching lines @@
 
   // Function pointer for the MFCreateDXGIDeviceManager API.
   static CreateDXGIDeviceManager create_dxgi_device_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(DXVAVideoDecodeAccelerator);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_DXVA_VIDEO_DECODE_ACCELERATOR_WIN_H_