Detect configuration changes in H.264 video streams in the DXVA decoder

content/common/gpu/media/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 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>
 #include <stdint.h>
@@ skipping 26 matching lines @@
 namespace gfx {
 class GLContext;
 }
 
 typedef HRESULT (WINAPI* CreateDXGIDeviceManager)(
     UINT* reset_token,
     IMFDXGIDeviceManager** device_manager);
 
 namespace content {
 
+// Provides functionality to detect H.264 stream configuration changes.
+// 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_;
+  }
+
+ 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_;
+  bool config_changed_;
+
+  DISALLOW_COPY_AND_ASSIGN(H264ConfigChangeDetector);
+};
+
+
 // 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.
@@ skipping 115 matching lines @@
   // Helper for handling the Decode operation.
   void DecodeInternal(const base::win::ScopedComPtr<IMFSample>& input_sample);
 
   // Handles mid stream resolution changes.
   void HandleResolutionChanged(int width, int height);
 
   struct DXVAPictureBuffer;
   typedef std::map<int32_t, linked_ptr<DXVAPictureBuffer>> OutputBuffers;
 
   // Tells the client to dismiss the stale picture buffers passed in.
-  void DismissStaleBuffers();
+  void DismissStaleBuffers(bool force);
 
   // Called after the client indicates we can recycle a stale picture buffer.
   void DeferredDismissStaleBuffer(int32_t picture_buffer_id);
 
   // Sets the state of the decoder. Called from the main thread and the decoder
   // thread. The state is changed on the main thread.
   void SetState(State state);
 
   // Gets the state of the decoder. Can be called from the main thread and
   // the decoder thread. Thread safe.
   State GetState();
 
-  // Worker function for the Decoder Reset functionality. Executes on the
-  // decoder thread and queues tasks on the main thread as needed.
-  void ResetHelper();
-
   // Starts the thread used for decoding.
   void StartDecoderThread();
 
   // 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.
@@ skipping 48 matching lines @@
   // the |output_type| parameter. The GUID can be MFVideoFormat_RGB32,
   // MFVideoFormat_ARGB32, MFVideoFormat_NV12, etc.
   // Additionally if the |width| and |height| parameters are non zero, then
   // this function also sets the MF_MT_FRAME_SIZE attribute on the type.
   // Returns true on success.
   bool SetTransformOutputType(IMFTransform* transform,
                               const GUID& output_type,
                               int width,
                               int height);
 
+  // Checks if the resolution, bitrate etc of the stream changed. We do this
+  // by keeping track of the SPS/PPS frames and if they change we assume
+  // that the configuration changed.
+  // Returns S_OK or S_FALSE on succcess.
+  // The |config_changed| parameter is set to true if we detect a change in the
+  // stream.
+  HRESULT CheckConfigChanged(IMFSample* sample, bool* config_changed);
+
+  // Called when we detect a stream configuration change. We reinitialize the
+  // decoder here.
+  void ConfigChanged(const Config& config,
+                     const base::win::ScopedComPtr<IMFSample>& input_sample);
+
   // 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> d3d9_device_ex_;
   base::win::ScopedComPtr<IDirect3DDeviceManager9> device_manager_;
   base::win::ScopedComPtr<IDirect3DQuery9> query_;
@@ skipping 119 matching lines @@
 
   // Enables experimental hardware acceleration for VP8/VP9 video decoding.
   const bool enable_accelerated_vpx_decode_;
 
   // WeakPtrFactory for posting tasks back to |this|.
   base::WeakPtrFactory<DXVAVideoDecodeAccelerator> weak_this_factory_;
 
   // Function pointer for the MFCreateDXGIDeviceManager API.
   static CreateDXGIDeviceManager create_dxgi_device_manager_;
 
+  // The media foundation H.264 decoder has problems handling changes like
+  // resolution change, bitrate change etc. If we reinitialize the decoder
+  // when these changes occur then, the decoder works fine. The
+  // H264ConfigChangeDetector class provides functionality to check if the
+  // stream configuration changed.
+  H264ConfigChangeDetector config_change_detector_;
+
+  // Contains the initialization parameters for the video.
+  Config config_;
+
   DISALLOW_COPY_AND_ASSIGN(DXVAVideoDecodeAccelerator);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_DXVA_VIDEO_DECODE_ACCELERATOR_H_