Video decode in hardware on ARM platform.

content/common/gpu/media/omx_video_decode_accelerator.cc

 // 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.
 
 #include "content/common/gpu/media/omx_video_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "content/common/gpu/gpu_channel.h"
-#include "content/common/gpu/media/gles2_texture_to_egl_image_translator.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/video/picture.h"
 
+#if (defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL))

[Ami GONE FROM CHROMIUM, 2012/02/18 00:00:25]

No other configuration builds this .cc file so IMO this guard is unnecessary.

+#include "ui/gfx/gl/gl_surface_egl.h"
+#endif
+
 // Helper typedef for input buffers.  This is used as the pAppPrivate field of
 // OMX_BUFFERHEADERTYPEs of input buffers, to point to the data associated with
 // them.
 typedef std::pair<scoped_ptr<base::SharedMemory>, int32> SharedMemoryAndId;
 
 enum { kNumPictureBuffers = 4 };
 
 // Open the libnvomx here for now.
 void* omx_handle = dlopen("libnvomx.so", RTLD_NOW);
 
@@ skipping 75 matching lines @@
     : message_loop_(MessageLoop::current()),
       component_handle_(NULL),
       client_state_(OMX_StateMax),
       current_state_change_(NO_TRANSITION),
       input_buffer_count_(0),
       input_buffer_size_(0),
       input_port_(0),
       input_buffers_at_component_(0),
       output_port_(0),
       output_buffers_at_component_(0),
+      width_(-1),
+      height_(-1),
       client_(client),
       profile_(OMX_VIDEO_AVCProfileMax),
-      component_name_is_nvidia_h264ext_(false) {
+      component_name_is_nvidia_h264ext_(false),
+      component_name_is_sec_h264ext_(false) {
   RETURN_ON_FAILURE(AreOMXFunctionPointersInitialized(),
                     "Failed to load openmax library", PLATFORM_FAILURE,);
   RETURN_ON_OMX_FAILURE(omx_init(), "Failed to init OpenMAX core",
                         PLATFORM_FAILURE,);
 }
 
 OmxVideoDecodeAccelerator::~OmxVideoDecodeAccelerator() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK(free_input_buffers_.empty());
   DCHECK_EQ(0, input_buffers_at_component_);
@@ skipping 67 matching lines @@
       this, &omx_accelerator_callbacks);
   RETURN_ON_OMX_FAILURE(result,
                         "Failed to OMX_GetHandle on: " << component.get(),
                         PLATFORM_FAILURE, false);
   client_state_ = OMX_StateLoaded;
 
   component_name_is_nvidia_h264ext_ = !strcmp(
       reinterpret_cast<char *>(component.get()),
       "OMX.Nvidia.h264ext.decode");
 
+  component_name_is_sec_h264ext_ = !strcmp(
+      reinterpret_cast<char *>(component.get()),
+      "OMX.SEC.AVC.Decoder");
+
   // Get the port information. This will obtain information about the number of
   // ports and index of the first port.
   OMX_PORT_PARAM_TYPE port_param;
   InitParam(*this, &port_param);
   result = OMX_GetParameter(component_handle_, OMX_IndexParamVideoInit,
                             &port_param);
   RETURN_ON_FAILURE(result == OMX_ErrorNone && port_param.nPorts == 2,
                     "Failed to get Port Param: " << result << ", "
                     << port_param.nPorts,
                     PLATFORM_FAILURE, false);
@@ skipping 125 matching lines @@
 
 void OmxVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& buffers) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   RETURN_ON_FAILURE(CanFillBuffer(), "Can't fill buffer", ILLEGAL_STATE,);
 
   DCHECK_EQ(output_buffers_at_component_, 0);
   DCHECK_EQ(fake_output_buffers_.size(), 0U);
   DCHECK_EQ(pictures_.size(), 0U);
 
-  static Gles2TextureToEglImageTranslator texture2eglImage_translator;
+  Display* x_display = NULL;
+  if (component_name_is_sec_h264ext_)
+    x_display = gfx::GLSurfaceEGL::GetNativeDisplay();
+
+  texture2eglImage_translator_ =

[Ami GONE FROM CHROMIUM, 2012/02/18 00:00:25]

This is leaking a translator per call to AssignPictureBuffers.
I think you want to make the class member a
scoped_ptr<Gles2TextureToEglImageTranslator> instead of a raw pointer.
Also, instead of creating a translator per call to AssignPictureBuffers, you can
create it once in CreateComponent(), which will allow you to remove the
component_name_is_sec_h264ext_ member (in favor of a variable local to the
CreateComponent method).

+    new Gles2TextureToEglImageTranslator(x_display);
   for (size_t i = 0; i < buffers.size(); ++i) {
-    EGLImageKHR egl_image = texture2eglImage_translator.TranslateToEglImage(
-        egl_display_, egl_context_, buffers[i].texture_id());
+    EGLImageKHR egl_image = texture2eglImage_translator_->TranslateToEglImage(
+                                   egl_display_, egl_context_,
+                                   buffers[i].texture_id(), width_, height_);
     CHECK(pictures_.insert(std::make_pair(
         buffers[i].id(), OutputPicture(buffers[i], NULL, egl_image))).second);
   }
 
   if (pictures_.size() < kNumPictureBuffers)
     return;  // get all the buffers first.
   DCHECK_EQ(pictures_.size(), kNumPictureBuffers);
 
   // These do their own RETURN_ON_FAILURE dances.
   if (!AllocateOutputBuffers())
@@ skipping 328 matching lines @@
     free_input_buffers_.pop();
     result = OMX_FreeBuffer(component_handle_, input_port_, omx_buffer);
     RETURN_ON_OMX_FAILURE(result, "OMX_FreeBuffer", PLATFORM_FAILURE,);
   }
 }
 
 void OmxVideoDecodeAccelerator::FreeOutputBuffers() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   // Calls to OMX to free buffers.
   OMX_ERRORTYPE result;
-  static Gles2TextureToEglImageTranslator texture2eglImage_translator;
   for (OutputPictureById::iterator it = pictures_.begin();
        it != pictures_.end(); ++it) {
     OMX_BUFFERHEADERTYPE* omx_buffer = it->second.omx_buffer_header;
     DCHECK(omx_buffer);
     delete reinterpret_cast<media::Picture*>(omx_buffer->pAppPrivate);
     result = OMX_FreeBuffer(component_handle_, output_port_, omx_buffer);
     RETURN_ON_OMX_FAILURE(result, "OMX_FreeBuffer", PLATFORM_FAILURE,);
-    texture2eglImage_translator.DestroyEglImage(egl_display_,
-                                                it->second.egl_image);
+    texture2eglImage_translator_->DestroyEglImage(egl_display_,
+                                                  it->second.egl_image);
     if (client_)
       client_->DismissPictureBuffer(it->first);
   }
   pictures_.clear();
 }
 
 void OmxVideoDecodeAccelerator::OnOutputPortDisabled() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   OMX_PARAM_PORTDEFINITIONTYPE port_format;
   InitParam(*this, &port_format);
   port_format.nPortIndex = output_port_;
   OMX_ERRORTYPE result = OMX_GetParameter(
       component_handle_, OMX_IndexParamPortDefinition, &port_format);
   RETURN_ON_OMX_FAILURE(result, "OMX_GetParameter", PLATFORM_FAILURE,);
   DCHECK_EQ(port_format.nBufferCountMin, kNumPictureBuffers);
 
   // TODO(fischman): to support mid-stream resize, need to free/dismiss any
   // |pictures_| we already have.  Make sure that the shutdown-path agrees with
   // this (there's already freeing logic there, which should not be duplicated).
 
   // Request picture buffers to be handed to the component.
   // ProvidePictureBuffers() will trigger AssignPictureBuffers, which ultimately
   // assigns the textures to the component and re-enables the port.
   const OMX_VIDEO_PORTDEFINITIONTYPE& vformat = port_format.format.video;
+  width_ = vformat.nFrameWidth;
+  height_ = vformat.nFrameHeight;
+
   if (client_) {
     client_->ProvidePictureBuffers(
         kNumPictureBuffers,
         gfx::Size(vformat.nFrameWidth, vformat.nFrameHeight));
   }
 }
 
 void OmxVideoDecodeAccelerator::OnOutputPortEnabled() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
@@ skipping 290 matching lines @@
 
 bool OmxVideoDecodeAccelerator::SendCommandToPort(
     OMX_COMMANDTYPE cmd, int port_index) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   OMX_ERRORTYPE result = OMX_SendCommand(component_handle_,
                                          cmd, port_index, 0);
   RETURN_ON_OMX_FAILURE(result, "SendCommand() failed" << cmd,
                         PLATFORM_FAILURE, false);
   return true;
 }