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/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 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,
-      NON_EXPORTED_BASE(public base::NonThreadSafe) {
+    : 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.
     kFlushingPendingInputBuffers, // pending flush request for unprocessed
                                   // input buffers.
   };
@@ skipping 11 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;
+
   // 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 70 matching lines @@
 
   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. 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() const;
+
+  // 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();
+
   // 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 43 matching lines @@
   // 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|.

[DaleCurtis, 2014/12/04 19:21:34]

move the WeakPtr members to the end of the variable definitions, they should
always be destructed first except in rare cases.

[ananta, 2014/12/04 19:48:55]

Done.

   base::WeakPtrFactory<DXVAVideoDecodeAccelerator> weak_this_factory_;
 
+  // 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_;
+
   // 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::SingleThreadTaskRunner> decoder_thread_task_runner_;
+
+  // Task runner to be used for posting tasks to the main thread.
+  scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
+
+  // Used to synchronize access between the decoder thread and the main thread.
+  // Currently only used to synchronize access to the pending output samples
+  // queue.
+  base::Lock decoder_lock_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_DXVA_VIDEO_DECODE_ACCELERATOR_H_