<video> decode in hardware!

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/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 32 matching lines @@
     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 h264-related Profile enum values to OMX_VIDEO_AVCPROFILETYPE values.
 static OMX_U32 MapH264ProfileToOMXAVCProfile(uint32 profile) {
   switch (profile) {
-    case media::VideoDecodeAccelerator::H264PROFILE_BASELINE:
+    case media::H264PROFILE_BASELINE:
       return OMX_VIDEO_AVCProfileBaseline;
-    case media::VideoDecodeAccelerator::H264PROFILE_MAIN:
+    case media::H264PROFILE_MAIN:
       return OMX_VIDEO_AVCProfileMain;
-    case media::VideoDecodeAccelerator::H264PROFILE_EXTENDED:
+    case media::H264PROFILE_EXTENDED:
       return OMX_VIDEO_AVCProfileExtended;
-    case media::VideoDecodeAccelerator::H264PROFILE_HIGH:
+    case media::H264PROFILE_HIGH:
       return OMX_VIDEO_AVCProfileHigh;
-    case media::VideoDecodeAccelerator::H264PROFILE_HIGH10PROFILE:
+    case media::H264PROFILE_HIGH10PROFILE:
       return OMX_VIDEO_AVCProfileHigh10;
-    case media::VideoDecodeAccelerator::H264PROFILE_HIGH422PROFILE:
+    case media::H264PROFILE_HIGH422PROFILE:
       return OMX_VIDEO_AVCProfileHigh422;
-    case media::VideoDecodeAccelerator::H264PROFILE_HIGH444PREDICTIVEPROFILE:
+    case media::H264PROFILE_HIGH444PREDICTIVEPROFILE:
       return OMX_VIDEO_AVCProfileHigh444;
     // Below enums don't have equivalent enum in Openmax.
-    case media::VideoDecodeAccelerator::H264PROFILE_SCALABLEBASELINE:
-    case media::VideoDecodeAccelerator::H264PROFILE_SCALABLEHIGH:
-    case media::VideoDecodeAccelerator::H264PROFILE_STEREOHIGH:
-    case media::VideoDecodeAccelerator::H264PROFILE_MULTIVIEWHIGH:
+    case media::H264PROFILE_SCALABLEBASELINE:
+    case media::H264PROFILE_SCALABLEHIGH:
+    case media::H264PROFILE_STEREOHIGH:
+    case media::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;
     default:
       NOTREACHED();
       return OMX_VIDEO_AVCProfileMax;
   }
 }
 
 // Helper macros for dealing with failure.  If |result| evaluates false, emit
@@ skipping 55 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(Profile profile) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
-  RETURN_ON_FAILURE(profile >= H264PROFILE_MIN && profile <= H264PROFILE_MAX,
+  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 (!CreateComponent())  // Does its own RETURN_ON_FAILURE dances.
     return false;
 
   DCHECK_EQ(current_state_change_, NO_TRANSITION);
   current_state_change_ = INITIALIZING;
@@ skipping 603 matching lines @@
       reinterpret_cast<media::Picture*>(buffer->pAppPrivate);
   int picture_buffer_id = picture ? picture->picture_buffer_id() : -1;
   TRACE_EVENT2("Video Decoder", "OVDA::FillBufferDoneTask",
                "Buffer id", buffer->nTimeStamp,
                "Picture id", picture_buffer_id);
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK_GT(output_buffers_at_component_, 0);
   --output_buffers_at_component_;
 
   if (fake_output_buffers_.size() && fake_output_buffers_.count(buffer)) {
-    DCHECK_EQ(fake_output_buffers_.erase(buffer), 1U);
+    size_t erased = fake_output_buffers_.erase(buffer);
+    DCHECK_EQ(erased, 1U);
     OMX_ERRORTYPE result =
         OMX_FreeBuffer(component_handle_, output_port_, buffer);
     RETURN_ON_OMX_FAILURE(result, "OMX_FreeBuffer failed", PLATFORM_FAILURE,);
     return;
   }
   DCHECK(!fake_output_buffers_.size());
 
   if (buffer->nFlags & OMX_BUFFERFLAG_EOS) {
     // Avoid sending the (fake) EOS buffer to the client.
     return;
@@ skipping 243 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;
 }