Attach color space information to hardware decoded NV12 video frames.

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 18 matching lines @@
 #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 "gpu/command_buffer/service/gpu_preferences.h"
 #include "media/filters/h264_parser.h"
 #include "media/gpu/gpu_video_decode_accelerator_helpers.h"
 #include "media/gpu/media_gpu_export.h"
 #include "media/video/video_decode_accelerator.h"
+#include "ui/gfx/color_space.h"
 
 interface IMFSample;
 interface IDirect3DSurface9;
 
 namespace gl {
 class GLContext;
 }
 
 namespace gpu {
 class GpuDriverBugWorkarounds;
@@ skipping 17 matching lines @@
  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_;
   int last_pps_id_;
   std::vector<uint8_t> last_pps_;
   // Set to true if we detect a stream configuration change.
   bool config_changed_;
@@ skipping 103 matching lines @@
 
   // Registers the output media type for the decoder.
   bool SetDecoderOutputMediaType(const GUID& subtype);
 
   // Passes a command message to the decoder. This includes commands like
   // start of stream, end of stream, flush, drain the decoder, etc.
   bool SendMFTMessage(MFT_MESSAGE_TYPE msg, int32_t param);
 
   // The bulk of the decoding happens here. This function handles errors,
   // format changes and processes decoded output.
-  void DoDecode();
+  void DoDecode(const gfx::ColorSpace& color_space);
 
   // Invoked when we have a valid decoded output sample. Retrieves the D3D
   // surface and maintains a copy of it which is passed eventually to the
   // client when we have a picture buffer to copy the surface contents to.
-  bool ProcessOutputSample(IMFSample* sample);
+  bool ProcessOutputSample(IMFSample* sample,
+                           const gfx::ColorSpace& color_space);
 
   // Processes pending output samples by copying them to available picture
   // slots.
   void ProcessPendingSamples();
 
   // Helper function to notify the accelerator client about the error.
   void StopOnError(VideoDecodeAccelerator::Error error);
 
   // Transitions the decoder to the uninitialized state. The decoder will stop
   // accepting requests in this state.
   void Invalidate();
 
   // Notifies the client that the input buffer identifed by input_buffer_id has
   // been processed.
   void NotifyInputBufferRead(int input_buffer_id);
 
   // Notifies the client that the decoder was flushed.
   void NotifyFlushDone();
 
   // Notifies the client that the decoder was reset.
   void NotifyResetDone();
 
   // Requests picture buffers from the client.
   void RequestPictureBuffers(int width, int height);
 
   // Notifies the client about the availability of a picture.
-  void NotifyPictureReady(int picture_buffer_id, int input_buffer_id);
+  void NotifyPictureReady(int picture_buffer_id,
+                          int input_buffer_id,
+                          const gfx::ColorSpace& color_space);
 
   // Sends pending input buffer processed acks to the client if we don't have
   // output samples waiting to be processed.
   void NotifyInputBuffersDropped();
 
   // Decodes pending input buffers.
   void DecodePendingInputBuffers();
 
   // Helper for handling the Flush operation.
   void FlushInternal();
@@ skipping 145 matching lines @@
   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.
   struct PendingSampleInfo {
-    PendingSampleInfo(int32_t buffer_id, IMFSample* sample);
+    PendingSampleInfo(int32_t buffer_id,
+                      IMFSample* sample,
+                      const gfx::ColorSpace& color_space);
     PendingSampleInfo(const PendingSampleInfo& other);
     ~PendingSampleInfo();
 
     int32_t input_buffer_id;
 
     // The target picture buffer id where the frame would be copied to.
     // Defaults to -1.
     int picture_buffer_id;
 
+    // The color space of this picture.
+    gfx::ColorSpace color_space;
+
     base::win::ScopedComPtr<IMFSample> output_sample;
   };
 
   typedef std::list<PendingSampleInfo> PendingOutputSamples;
 
   // List of decoded output samples. Protected by |decoder_lock_|.
   PendingOutputSamples pending_output_samples_;
 
   // This map maintains the picture buffers passed the client for decoding.
   // The key is the picture buffer id.
@@ skipping 96 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_