Replace the use of an int32* with a proper struct for decoder configuration.

content/common/gpu/media/omx_video_decode_accelerator.cc

 // 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.
 
 #include "content/common/gpu/media/omx_video_decode_accelerator.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
@@ skipping 30 matching lines @@
 OMXDeinit omx_deinit =
     reinterpret_cast<OMXDeinit>(dlsym(omx_handle, "OMX_Deinit"));
 
 static bool AreOMXFunctionPointersInitialized() {
   return (omx_init && omx_gethandle && omx_get_components_of_role &&
           omx_free_handle && omx_deinit);
 }
 
 // Maps the media::H264Profile members to the OMX_VIDEO_AVCPROFILETYPE members.
 static OMX_U32 MapH264ProfileToOMXAVCProfile(uint32 profile) {
+  typedef media::VideoDecodeAccelerator::Config Config;
   switch (profile) {
-    case media::H264PROFILE_NONE:
+    case Config::H264PROFILE_NONE:
       return OMX_VIDEO_AVCProfileMax;
-    case media::H264PROFILE_BASELINE:
+    case Config::H264PROFILE_BASELINE:
       return OMX_VIDEO_AVCProfileBaseline;
-    case media::H264PROFILE_MAIN:
+    case Config::H264PROFILE_MAIN:
       return OMX_VIDEO_AVCProfileMain;
-    case media::H264PROFILE_EXTENDED:
+    case Config::H264PROFILE_EXTENDED:
       return OMX_VIDEO_AVCProfileExtended;
-    case media::H264PROFILE_HIGH:
+    case Config::H264PROFILE_HIGH:
       return OMX_VIDEO_AVCProfileHigh;
-    case media::H264PROFILE_HIGH10PROFILE:
+    case Config::H264PROFILE_HIGH10PROFILE:
       return OMX_VIDEO_AVCProfileHigh10;
-    case media::H264PROFILE_HIGH422PROFILE:
+    case Config::H264PROFILE_HIGH422PROFILE:
       return OMX_VIDEO_AVCProfileHigh422;
-    case media::H264PROFILE_HIGH444PREDICTIVEPROFILE:
+    case Config::H264PROFILE_HIGH444PREDICTIVEPROFILE:
       return OMX_VIDEO_AVCProfileHigh444;
     // Below enums don't have equivalent enum in Openmax.
-    case media::H264PROFILE_SCALABLEBASELINE:
-    case media::H264PROFILE_SCALABLEHIGH:
-    case media::H264PROFILE_STEREOHIGH:
-    case media::H264PROFILE_MULTIVIEWHIGH:
+    case Config::H264PROFILE_SCALABLEBASELINE:
+    case Config::H264PROFILE_SCALABLEHIGH:
+    case Config::H264PROFILE_STEREOHIGH:
+    case Config::H264PROFILE_MULTIVIEWHIGH:
       // Nvidia OMX video decoder requires the same resources (as that of the
       // High profile) in every profile higher to the Main profile.
       return OMX_VIDEO_AVCProfileHigh444;
   }
   NOTREACHED();
   return OMX_VIDEO_AVCProfileMax;
 }
 
 // Helper macros for dealing with failure.  If |result| evaluates false, emit
 // |log| to ERROR, register |error| with the decoder, and return |ret_val|
@@ skipping 43 matching lines @@
   DCHECK(pictures_.empty());
 }
 
 void OmxVideoDecodeAccelerator::SetEglState(
     EGLDisplay egl_display, EGLContext egl_context) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   egl_display_ = egl_display;
   egl_context_ = egl_context;
 }
 
-bool OmxVideoDecodeAccelerator::VerifyConfigs(
-    const std::vector<int32>& configs) {
-  size_t cur;
-  for (cur = 0; cur + 1 < configs.size(); cur++) {
-    uint32 n = configs[cur++];
-    uint32 v = configs[cur];
-    if ((n == media::VIDEOATTRIBUTEKEY_BITSTREAMFORMAT_FOURCC &&
-         v == media::VIDEOCODECFOURCC_H264) ||
-        (n == media::VIDEOATTRIBUTEKEY_BITSTREAMFORMAT_BITRATE &&
-         v < 14000000 /* Baseline supports up to 14Mbps. */) ||
-        (n == media::VIDEOATTRIBUTEKEY_BITSTREAMFORMAT_WIDTH &&
-         v <= 1920 /* Baseline supports upto 1080p. */) ||
-        (n == media::VIDEOATTRIBUTEKEY_BITSTREAMFORMAT_HEIGHT &&
-         v <= 1080 /* Baseline supports up to 1080p. */) ||
-        (n == media::VIDEOATTRIBUTEKEY_BITSTREAMFORMAT_H264_LEVEL ||
-         n == media::VIDEOATTRIBUTEKEY_BITSTREAMFORMAT_H264_PAYLOADFORMAT ||
-         n == media::VIDEOATTRIBUTEKEY_BITSTREAMFORMAT_H264_FEATURE_FMO ||
-         n == media::VIDEOATTRIBUTEKEY_BITSTREAMFORMAT_H264_FEATURE_ASO ||
-         n == media::VIDEOATTRIBUTEKEY_BITSTREAMFORMAT_H264_FEATURE_INTERLACE ||
-         n == media::VIDEOATTRIBUTEKEY_BITSTREAMFORMAT_H264_FEATURE_CABAC ||
-         /* TODO(fischman) Shorten the enum name. */
-         n == media::VIDEOATTRIBUTEKEY_BITSTREAMFORMAT_H264_FEATURE_WEIGHTEDPREDICTION)
-         ||
-        (n == media::VIDEOATTRIBUTEKEY_BITSTREAMFORMAT_H264_PROFILE &&
-        (v == media::H264PROFILE_BASELINE || v == media::H264PROFILE_MAIN ||
-         v == media::H264PROFILE_HIGH)) ||
-        (n == media::VIDEOATTRIBUTEKEY_VIDEOCOLORFORMAT &&
-         v == media::VIDEOCOLORFORMAT_RGBA)) {
-      if (n == media::VIDEOATTRIBUTEKEY_BITSTREAMFORMAT_H264_PROFILE) {
-        profile_ = v;
-      }
-      continue;
-    }
-    return false;
-  }
-  return cur == configs.size();
-}
-
 // This is to initialize the OMX data structures to default values.
 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(const std::vector<int32>& config) {
+bool OmxVideoDecodeAccelerator::Initialize(const Config& config) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
-  RETURN_ON_FAILURE(VerifyConfigs(config), "Invalid config", INVALID_ARGUMENT,
-                    false);
+
+  if (config.format == Config::H264)
+    profile_ = config.h264_profile;
+  RETURN_ON_FAILURE(config.format == Config::H264, "Only h264 supported",
+                    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;
 
@@ skipping 871 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;
 }