Move the DXVA decoder off the GPU thread.

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 <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/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 content {
 
 // Class to provide a DXVA 2.0 based accelerator using the Microsoft Media
@@ skipping 27 matching lines @@
       const std::vector<media::PictureBuffer>& buffers) override;
   virtual void ReusePictureBuffer(int32 picture_buffer_id) override;
   virtual void Flush() override;
   virtual void Reset() override;
   virtual void Destroy() override;
   virtual bool CanDecodeOnIOThread() override;
 
  private:
   typedef void* EGLConfig;
   typedef void* EGLSurface;
+  // List of input samples waiting to be processed.
+  typedef std::list<base::win::ScopedComPtr<IMFSample>> PendingInputs;
+  PendingInputs pending_input_buffers_;

[DaleCurtis, 2014/12/03 01:04:33]

This should be declared below and the typedef with the Notify method.

+
   // 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, 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();
@@ skipping 47 matching lines @@
   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(const media::Picture& picture);
 
   // Sends pending input buffer processed acks to the client if we don't have
   // output samples waiting to be processed.
-  void NotifyInputBuffersDropped();
+  void NotifyInputBuffersDropped(const PendingInputs& input_buffers);
 
   // Decodes pending input buffers.
   void DecodePendingInputBuffers();
 
   // Helper for handling the Flush operation.
   void FlushInternal();
 
   // 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, linked_ptr<DXVAPictureBuffer> > OutputBuffers;
 
   // Tells the client to dismiss the stale picture buffers passed in.
   void DismissStaleBuffers();
 
   // Called after the client indicates we can recycle a stale picture buffer.
   void DeferredDismissStaleBuffer(int32 picture_buffer_id);
 
+  // Sets the state of the decoder. Can be called from the main thread and
+  // the decoder thread. Threadsafe.

[DaleCurtis, 2014/12/03 01:04:33]

"thread-safe" or "thread safe" -- up to you.

[ananta, 2014/12/03 04:08:02]

Reworded

+  void SetState(State state);
+
+  // Gets the state of the decoder. Can be called from the main thread and
+  // the decoder thread. Threadsafe.
+  State GetState() const;
+
+  // Worker function for the Decoder Reset functionality. Executes on the
+  // decoder thread and queues tasks on the main thread as needed.
+  void ResetHelper();
+
   // To expose client callbacks from VideoDecodeAccelerator.
   media::VideoDecodeAccelerator::Client* client_;
 
   base::win::ScopedComPtr<IMFTransform> decoder_;
 
   base::win::ScopedComPtr<IDirect3D9Ex> d3d9_;
   base::win::ScopedComPtr<IDirect3DDevice9Ex> device_;
   base::win::ScopedComPtr<IDirect3DDeviceManager9> device_manager_;
   base::win::ScopedComPtr<IDirect3DQuery9> query_;
   // Ideally the reset token would be a stack variable which is used while
@@ skipping 36 matching lines @@
   // become available.
   OutputBuffers stale_output_picture_buffers_;
 
   // Set to true if we requested picture slots from the client.
   bool pictures_requested_;
 
   // Counter which holds the number of input packets before a successful
   // decode.
   int inputs_before_decode_;
 
-  // List of input samples waiting to be processed.
-  typedef std::list<base::win::ScopedComPtr<IMFSample>> PendingInputs;
-  PendingInputs pending_input_buffers_;
-
   // Callback to set the correct gl context.
   base::Callback<bool(void)> make_context_current_;
 
   // WeakPtrFactory for posting tasks back to |this|.
   base::WeakPtrFactory<DXVAVideoDecodeAccelerator> weak_this_factory_;
 
   // Which codec we are decoding with hardware acceleration.
   media::VideoCodec codec_;
+  // Thread on which the decoder operations like passing input frames,
+  // getting output frames are performed. One instance of this thread
+  // is created per decoder instance.
+  base::Thread decoder_thread_;
+
+  // Task runner to be used for posting tasks to the decoder thread.
+  scoped_refptr<base::TaskRunner> decoder_thread_task_runner_;
+
+  // Task runner to be used for posting tasks to the main thread.
+  scoped_refptr<base::TaskRunner> main_thread_task_runner_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_DXVA_VIDEO_DECODE_ACCELERATOR_H_