Updated OMX decoder for recent PPAPI changes, and added to the build.

content/common/gpu/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_GPU_OMX_VIDEO_DECODE_ACCELERATOR_H_
-#define CONTENT_GPU_OMX_VIDEO_DECODE_ACCELERATOR_H_
+#ifndef CONTENT_COMMON_GPU_OMX_VIDEO_DECODE_ACCELERATOR_H_
+#define CONTENT_COMMON_GPU_OMX_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <dlfcn.h>
 #include <map>
 #include <queue>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/shared_memory.h"
 #include "media/video/video_decode_accelerator.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.
 class OmxVideoDecodeAccelerator : public media::VideoDecodeAccelerator {
  public:
   OmxVideoDecodeAccelerator(media::VideoDecodeAccelerator::Client* client,
                             MessageLoop* message_loop);
   virtual ~OmxVideoDecodeAccelerator();
 
   // media::VideoDecodeAccelerator implementation.
-  const std::vector<uint32>& GetConfig(
-      const std::vector<uint32>& prototype_config);
-  bool Initialize(const std::vector<uint32>& config);
-  bool Decode(const media::BitstreamBuffer& bitstream_buffer,
-              const media::VideoDecodeAcceleratorCallback& callback);
-  void AssignPictureBuffer(std::vector<PictureBuffer*> picture_buffers);
-  void ReusePictureBuffer(int32 picture_buffer_id);
-  bool Flush(const media::VideoDecodeAcceleratorCallback& callback);
-  bool Abort(const media::VideoDecodeAcceleratorCallback& callback);
+  void GetConfigs(const std::vector<uint32>& requested_configs,
+                  std::vector<uint32>* matched_configs) OVERRIDE;
+  bool Initialize(const std::vector<uint32>& config) OVERRIDE;
+  bool Decode(const media::BitstreamBuffer& bitstream_buffer) OVERRIDE;
+  virtual void AssignGLESBuffers(
+      const std::vector<media::GLESBuffer>& buffers) OVERRIDE;
+  virtual void AssignSysmemBuffers(
+      const std::vector<media::SysmemBuffer>& buffers) OVERRIDE;
+  void ReusePictureBuffer(int32 picture_buffer_id) OVERRIDE;
+  bool Flush() OVERRIDE;
+  bool Abort() OVERRIDE;
 
  private:
   MessageLoop* message_loop_;
   OMX_HANDLETYPE component_handle_;
 
+  // Common initialization code for Assign{GLES,Sysmem}Buffers.
+  void AssignBuffersHelper(const std::vector<media::BaseBuffer*>& buffers);
+
   // Create the Component for OMX. Handles all OMX initialization.
   bool CreateComponent();
   // Buffer allocation/free methods for input and output buffers.
   bool AllocateInputBuffers();
   bool AllocateOutputBuffers();
   void FreeInputBuffers();
   void FreeOutputBuffers();
 
   // Methods to handle OMX state transitions.
   bool TransitionToState(OMX_STATETYPE new_state);
@@ skipping 38 matching lines @@
   int output_buffer_count_;
   int output_buffer_size_;
   int output_port_;
   int output_buffers_at_component_;
 
   bool uses_egl_image_;
   // Free input OpenMAX buffers that can be used to take bitstream from demuxer.
   std::queue<OMX_BUFFERHEADERTYPE*> free_input_buffers_;
 
   // For output buffer recycling cases.
-  std::vector<media::VideoDecodeAccelerator::PictureBuffer*>
-      assigned_picture_buffers_;
-  typedef std::pair<PictureBuffer*,
-                    OMX_BUFFERHEADERTYPE*> OutputPicture;
+  std::vector<media::BaseBuffer*> assigned_picture_buffers_;
+  typedef std::pair<int32, OMX_BUFFERHEADERTYPE*> OutputPicture;
   std::vector<OutputPicture> output_pictures_;
 
   // To expose client callbacks from VideoDecodeAccelerator.
   Client* client_;
 
-  media::VideoDecodeAcceleratorCallback flush_done_callback_;
-  media::VideoDecodeAcceleratorCallback abort_done_callback_;
-
   std::vector<uint32> texture_ids_;
   std::vector<uint32> context_ids_;
   // Method to handle events
   void EventHandlerCompleteTask(OMX_EVENTTYPE event,
                                 OMX_U32 data1,
                                 OMX_U32 data2);
 
   // Method to receive buffers from component's input port
   void EmptyBufferDoneTask(OMX_BUFFERHEADERTYPE* buffer);
 
   // Method to receive buffers from component's output port
   void FillBufferDoneTask(OMX_BUFFERHEADERTYPE* buffer);
   typedef std::pair<OMX_BUFFERHEADERTYPE*, uint32> OMXbufferTexture;
-  // void pointer to hold EGLImage handle.
-  void* egl_image_;
 
-  typedef std::map<
-    OMX_BUFFERHEADERTYPE*,
-    std::pair<base::SharedMemory*,
-              media::VideoDecodeAcceleratorCallback> > OMXBufferCallbackMap;
-  OMXBufferCallbackMap omx_buff_cb_;
+  typedef std::map<OMX_BUFFERHEADERTYPE*,
+                   std::pair<base::SharedMemory*, int32> > OMXBufferIdMap;
+  OMXBufferIdMap omx_buff_ids_;
 
   // Method used the change the state of the port.
   void ChangePort(OMX_COMMANDTYPE cmd, int port_index);
 
   // Member function pointers to respond to events
   void (OmxVideoDecodeAccelerator::*on_port_disable_event_func_)(int port);
   void (OmxVideoDecodeAccelerator::*on_port_enable_event_func_)(int port);
   void (OmxVideoDecodeAccelerator::*on_state_event_func_)(OMX_STATETYPE state);
   void (OmxVideoDecodeAccelerator::*on_flush_event_func_)(int port);
   void (OmxVideoDecodeAccelerator::*on_buffer_flag_event_func_)();
 
   // Callback methods for the OMX component.
   // When these callbacks are received, the
   // call is delegated to the three internal methods above.
   static OMX_ERRORTYPE EventHandler(OMX_HANDLETYPE component,
                                     OMX_PTR priv_data,
                                     OMX_EVENTTYPE event,
                                     OMX_U32 data1, OMX_U32 data2,
                                     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_GPU_OMX_VIDEO_DECODE_ACCELERATOR_H_
+#endif  // CONTENT_COMMON_GPU_OMX_VIDEO_DECODE_ACCELERATOR_H_