Add support for VP8 decode to OmxVideoDecodeAccelerator, for HW that supports it.

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 94 matching lines @@
       init_begun_(false),
       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),
       client_(client),
-      profile_(OMX_VIDEO_AVCProfileMax),
+      codec_(UNKNOWN),
+      h264_profile_(OMX_VIDEO_AVCProfileMax),
       component_name_is_nvidia_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());
@@ skipping 13 matching lines @@
 template <typename T>
 static void InitParam(const OmxVideoDecodeAccelerator& dec, T* param) {
   memset(param, 0, sizeof(T));
   param->nVersion.nVersion = 0x00000101;
   param->nSize = sizeof(T);
 }
 
 bool OmxVideoDecodeAccelerator::Initialize(media::VideoCodecProfile profile) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
-  RETURN_ON_FAILURE((profile >= media::H264PROFILE_MIN &&
-                     profile <= media::H264PROFILE_MAX),
-                    "Only h264 supported", INVALID_ARGUMENT, false);
-  profile_ = MapH264ProfileToOMXAVCProfile(profile);
-  RETURN_ON_FAILURE(profile_ != OMX_VIDEO_AVCProfileMax,
-                    "Unexpected profile", INVALID_ARGUMENT, false);
+  if (profile >= media::H264PROFILE_MIN && profile <= media::H264PROFILE_MAX) {
+    codec_ = H264;
+    h264_profile_ = MapH264ProfileToOMXAVCProfile(profile);
+    RETURN_ON_FAILURE(h264_profile_ != OMX_VIDEO_AVCProfileMax,
+                      "Unexpected profile", INVALID_ARGUMENT, false);
+  } else if (profile == media::VP8PROFILE_MAIN) {
+    codec_ = VP8;
+  } else {
+    RETURN_ON_FAILURE(false, "Unsupported profile: " << profile,
+                      INVALID_ARGUMENT, false);
+  }
 
   if (!CreateComponent())  // Does its own RETURN_ON_FAILURE dances.
     return false;
 
   DCHECK_EQ(current_state_change_, NO_TRANSITION);
   current_state_change_ = INITIALIZING;
   BeginTransitionToState(OMX_StateIdle);
 
   if (!AllocateInputBuffers())  // Does its own RETURN_ON_FAILURE dances.
     return false;
   if (!AllocateFakeOutputBuffers())  // Does its own RETURN_ON_FAILURE dances.
     return false;
 
   init_begun_ = true;
   return true;
 }
 
 bool OmxVideoDecodeAccelerator::CreateComponent() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   OMX_CALLBACKTYPE omx_accelerator_callbacks = {
     &OmxVideoDecodeAccelerator::EventHandler,
     &OmxVideoDecodeAccelerator::EmptyBufferCallback,
     &OmxVideoDecodeAccelerator::FillBufferCallback
   };
 
   // TODO(vhiremath@nvidia.com) Get this role_name from the configs
-  // For now hard coding to avc.
-  OMX_STRING role_name = const_cast<OMX_STRING>("video_decoder.avc");
+  // For now hard-coding.
+  OMX_STRING role_name = codec_ == H264 ?
+      const_cast<OMX_STRING>("video_decoder.avc") :
+      const_cast<OMX_STRING>("video_decoder.vpx");
   // Get the first component for this role and set the role on it.
   OMX_U32 num_components = 1;
-  scoped_array<OMX_U8> component(new OMX_U8[OMX_MAX_STRINGNAME_SIZE]);
+  std::string component(OMX_MAX_STRINGNAME_SIZE, '\0');
+  char* component_as_array = string_as_array(&component);
   OMX_ERRORTYPE result = omx_get_components_of_role(
-      role_name, &num_components, reinterpret_cast<OMX_U8**>(&component));
-  RETURN_ON_OMX_FAILURE(result, "Unsupport role: " << role_name,
+      role_name, &num_components,
+      reinterpret_cast<OMX_U8**>(&component_as_array));
+  RETURN_ON_OMX_FAILURE(result, "Unsupported role: " << role_name,
                         PLATFORM_FAILURE, false);
   RETURN_ON_FAILURE(num_components == 1, "No components for: " << role_name,
                     PLATFORM_FAILURE, false);
+  component_name_is_nvidia_h264ext_ = component == "OMX.Nvidia.h264ext.decode";
 
   // Get the handle to the component.
   result = omx_gethandle(
-      &component_handle_, reinterpret_cast<OMX_STRING>(component.get()),
+      &component_handle_,
+      reinterpret_cast<OMX_STRING>(string_as_array(&component)),
       this, &omx_accelerator_callbacks);
   RETURN_ON_OMX_FAILURE(result,
-                        "Failed to OMX_GetHandle on: " << component.get(),
+                        "Failed to OMX_GetHandle on: " << component,
                         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);
+  texture_to_egl_image_translator_.reset(new Gles2TextureToEglImageTranslator(
+      StartsWithASCII(component, "OMX.SEC.", true)));
 
   // 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,
@@ skipping 269 matching lines @@
     OMX_INDEXTYPE extension_index;
     OMX_ERRORTYPE result = OMX_GetExtensionIndex(
         component_handle_,
         const_cast<char*>("OMX.Nvidia.index.config.checkresources"),
         &extension_index);
     RETURN_ON_OMX_FAILURE(result,
                           "Failed to get the extension",
                           PLATFORM_FAILURE,);
     OMX_VIDEO_PARAM_PROFILELEVELTYPE video_profile_level;
     InitParam(*this, &video_profile_level);
-    video_profile_level.eProfile = profile_;
+    DCHECK_EQ(codec_, H264);
+    video_profile_level.eProfile = h264_profile_;
     result = OMX_SetConfig(component_handle_, extension_index,
                            &video_profile_level);
     RETURN_ON_OMX_FAILURE(result,
                           "Resource Allocation failed",
                           PLATFORM_FAILURE,);
   }
   BeginTransitionToState(OMX_StateExecuting);
 }
 
 void OmxVideoDecodeAccelerator::OnReachedExecutingInInitializing() {
@@ skipping 546 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;
 }