OmxVideoDecodeAcceleratorTest is born!

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_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/angle/include/EGL/egl.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.
   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;
 
+  void SetEglState(EGLDisplay egl_display, EGLContext egl_context);
+
  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.
@@ skipping 41 matching lines @@
   int input_port_;
   int input_buffers_at_component_;
 
   // Following are output port related variables.
   int output_buffer_count_;
   int output_buffer_size_;
   int output_port_;
   int output_buffers_at_component_;
 
   bool uses_egl_image_;
+  EGLDisplay egl_display_;
+  EGLContext egl_context_;

[vrk (LEFT CHROMIUM), 2011/06/03 07:55:24]

Someday, one context will not be good enough! Today though, it is. We should
also have some mechanism to handle lost contexts... maybe we should make crbugs
for these larger tasks to do?

[Ami GONE FROM CHROMIUM, 2011/06/03 17:43:59]

NOTE'd the former, TODO'd the latter.

+
   // 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::BaseBuffer*> assigned_picture_buffers_;
   typedef std::pair<int32, OMX_BUFFERHEADERTYPE*> OutputPicture;
   std::vector<OutputPicture> output_pictures_;
 
   // To expose client callbacks from VideoDecodeAccelerator.
+  // NOTE: all calls to this object *MUST* be executed in message_loop_.
   Client* client_;
 
   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
@@ skipping 27 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_OMX_VIDEO_DECODE_ACCELERATOR_H_