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"
@@ skipping 181 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");
 
+  bool component_name_is_sec_h264ext = !strcmp(
+      reinterpret_cast<char *>(component.get()),
+      "OMX.SEC.AVC.Decoder");
+  Gles2TextureToEglImageTranslator* texture_to_egl_image_translator =
+      new Gles2TextureToEglImageTranslator(component_name_is_sec_h264ext);
+  texture_to_egl_image_translator_.reset(texture_to_egl_image_translator);
+
   // 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;
   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 =
+        texture_to_egl_image_translator_->TranslateToEglImage(
+            egl_display_, egl_context_,
+            buffers[i].texture_id(),
+            last_requested_picture_buffer_dimensions_);
     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);
+    texture_to_egl_image_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;
+  last_requested_picture_buffer_dimensions_.SetSize(vformat.nFrameWidth,
+                                                    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;
 }