Enable fire-and-forget Destroy of HW video decoder, and misc other improvements.

content/common/gpu/media/omx_video_decode_accelerator.h

 // Copyright (c) 2011 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_OMX_VIDEO_DECODE_ACCELERATOR_H_
 #define CONTENT_COMMON_GPU_MEDIA_OMX_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <dlfcn.h>
 #include <map>
 #include <queue>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/compiler_specific.h"
 #include "base/logging.h"
+#include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/shared_memory.h"
 #include "media/video/video_decode_accelerator.h"
 #include "third_party/angle/include/EGL/egl.h"
 #include "third_party/angle/include/EGL/eglext.h"
 #include "third_party/openmax/il/OMX_Component.h"
 #include "third_party/openmax/il/OMX_Core.h"
 #include "third_party/openmax/il/OMX_Video.h"
 
 // Class to wrap OpenMAX IL accelerator behind VideoDecodeAccelerator interface.
 // The implementation assumes an OpenMAX IL 1.1.2 implementation conforming to
 // http://www.khronos.org/registry/omxil/specs/OpenMAX_IL_1_1_2_Specification.pdf
 //
 // This class lives on a single thread and DCHECKs that it is never accessed
 // from any other.  OMX callbacks are trampolined from the OMX component's
-// thread to maintain this invariant.
+// thread to maintain this invariant.  The only exception to thread-unsafety is
+// that references can be added from any thread (practically used only by the
+// OMX thread).
 class OmxVideoDecodeAccelerator : public media::VideoDecodeAccelerator {
  public:
   // Does not take ownership of |client| which must outlive |*this|.
   OmxVideoDecodeAccelerator(media::VideoDecodeAccelerator::Client* client);
-  virtual ~OmxVideoDecodeAccelerator();
 
   // media::VideoDecodeAccelerator implementation.
   bool Initialize(const std::vector<uint32>& config) OVERRIDE;
   void Decode(const media::BitstreamBuffer& bitstream_buffer) OVERRIDE;
   virtual void AssignGLESBuffers(
       const std::vector<media::GLESBuffer>& buffers) OVERRIDE;
   void ReusePictureBuffer(int32 picture_buffer_id) OVERRIDE;
   void Flush() OVERRIDE;
   void Reset() OVERRIDE;
   void Destroy() OVERRIDE;
 
   void SetEglState(EGLDisplay egl_display, EGLContext egl_context);
 
  private:
+  virtual ~OmxVideoDecodeAccelerator();
+
   // Because OMX state-transitions are described solely by the "state reached"
   // (3.1.2.9.1, table 3-7 of the spec), we track what transition was requested
   // using this enum.  Note that it is an error to request a transition while
   // |*this| is in any state other than NO_TRANSITION.
   enum CurrentStateChange {
     NO_TRANSITION,  // Not in the middle of a transition.
     INITIALIZING,
     FLUSHING,
     RESETTING,
     DESTROYING,
@@ skipping 13 matching lines @@
   typedef std::map<int32, OutputPicture> OutputPictureById;
 
   // Verify that |config| is compatible with this class and hardware.
   bool VerifyConfigs(const std::vector<uint32>& configs);
 
   MessageLoop* message_loop_;
   OMX_HANDLETYPE component_handle_;
 
   // Create the Component for OMX. Handles all OMX initialization.
   bool CreateComponent();
-  void ShutdownComponent();
   // Buffer allocation/free methods for input and output buffers.
   bool AllocateInputBuffers();
   bool AllocateOutputBuffers();
   void FreeInputBuffers();
   void FreeOutputBuffers();
 
   // Methods to handle OMX state transitions.  See section 3.1.1.2 of the spec.
   // Request transitioning OMX component to some other state.
   void BeginTransitionToState(OMX_STATETYPE new_state);
   // The callback received when the OMX component has transitioned.
   void DispatchStateReached(OMX_STATETYPE reached);
   // Callbacks handling transitioning to specific states during state changes.
   // These follow a convention of OnReached<STATE>In<CurrentStateChange>(),
   // requiring that each pair of <reached-state>/CurrentStateChange is unique
   // (i.e. the source state is uniquely defined by the pair).
   void OnReachedIdleInInitializing();
   void OnReachedExecutingInInitializing();
   void OnReachedPauseInFlushing();
   void OnReachedExecutingInFlushing();
   void OnReachedPauseInResetting();
   void OnReachedExecutingInResetting();
   void OnReachedIdleInDestroying();
   void OnReachedLoadedInDestroying();
   void OnReachedEOSInFlushing();
   void OnReachedInvalidInErroring();
+  void ShutdownComponent();
+  void BusyLoopInDestroying();
 
   // Port-flushing helpers.
   void FlushIOPorts();
   void InputPortFlushDone();
   void OutputPortFlushDone();
 
   // Stop the component when any error is detected.
   void StopOnError(media::VideoDecodeAccelerator::Error error);
 
   // Determine whether we can issue fill buffer to the decoder based on the
@@ skipping 73 matching lines @@
                                     OMX_PTR event_data);
   static OMX_ERRORTYPE EmptyBufferCallback(OMX_HANDLETYPE component,
                                            OMX_PTR priv_data,
                                            OMX_BUFFERHEADERTYPE* buffer);
   static OMX_ERRORTYPE FillBufferCallback(OMX_HANDLETYPE component,
                                           OMX_PTR priv_data,
                                           OMX_BUFFERHEADERTYPE* buffer);
 };
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_OMX_VIDEO_DECODE_ACCELERATOR_H_