Clean up video frame sizes, types in Video Decode API

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/stl_util-inl.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"
@@ skipping 304 matching lines @@
   omx_buffer->nTimeStamp = bitstream_buffer.id();
 
   // Give this buffer to OMX.
   OMX_ERRORTYPE result = OMX_EmptyThisBuffer(component_handle_, omx_buffer);
   RETURN_ON_OMX_FAILURE(result, "OMX_EmptyThisBuffer() failed",
                         VIDEODECODERERROR_INVALIDINPUT,);
 
   input_buffers_at_component_++;
 }
 
-void OmxVideoDecodeAccelerator::AssignGLESBuffers(
-    const std::vector<media::GLESBuffer>& buffers) {
+void OmxVideoDecodeAccelerator::AssignPictureBuffers(
+    const std::vector<media::PictureBuffer>& buffers) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   RETURN_ON_FAILURE(CanFillBuffer(), "Can't fill buffer",
                     VIDEODECODERERROR_UNSUPPORTED,);
 
   CHECK_EQ(output_buffers_at_component_, 0);
   CHECK_EQ(fake_output_buffers_.size(), 0U);
   CHECK_EQ(pictures_.size(), 0U);
 
   static Gles2TextureToEglImageTranslator texture2eglImage_translator;
   for (size_t i = 0; i < buffers.size(); ++i) {
@@ skipping 275 matching lines @@
     buffer->nFlags = 0;
     free_input_buffers_.push(buffer);
   }
   return true;
 }
 
 bool OmxVideoDecodeAccelerator::AllocateOutputBuffers() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   DCHECK(!pictures_.empty());
-  gfx::Size decoded_pixel_size(pictures_.begin()->second.gles_buffer.size());
-  gfx::Size visible_pixel_size(pictures_.begin()->second.gles_buffer.size());
   for (OutputPictureById::iterator it = pictures_.begin();
        it != pictures_.end(); ++it) {
-    media::GLESBuffer& gles_buffer = it->second.gles_buffer;
+    media::PictureBuffer& picture_buffer = it->second.picture_buffer;
     OMX_BUFFERHEADERTYPE** omx_buffer = &it->second.omx_buffer_header;
     DCHECK(!*omx_buffer);
     OMX_ERRORTYPE result = OMX_UseEGLImage(
-        component_handle_, omx_buffer, output_port_, &gles_buffer,
+        component_handle_, omx_buffer, output_port_, &picture_buffer,
         it->second.egl_image);
     RETURN_ON_OMX_FAILURE(result, "OMX_UseEGLImage",
                           VIDEODECODERERROR_MEMFAILURE, false);
     // Here we set a garbage bitstream buffer id, and then overwrite it before
     // passing to PictureReady.
     int garbage_bitstream_buffer_id = -1;
     (*omx_buffer)->pAppPrivate =
-        new media::Picture(gles_buffer.id(), garbage_bitstream_buffer_id,
-                           decoded_pixel_size, visible_pixel_size);
+        new media::Picture(picture_buffer.id(), garbage_bitstream_buffer_id);
   }
   return true;
 }
 
 void OmxVideoDecodeAccelerator::FreeInputBuffers() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   // Calls to OMX to free buffers.
   OMX_ERRORTYPE result;
   OMX_BUFFERHEADERTYPE* omx_buffer;
   while (!free_input_buffers_.empty()) {
@@ skipping 35 matching lines @@
       component_handle_, OMX_IndexParamPortDefinition, &port_format);
   RETURN_ON_OMX_FAILURE(result, "OMX_GetParameter",
                         VIDEODECODERERROR_UNSUPPORTED,);
   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 AssignGLESBuffers, which ultimately
+  // 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;
   if (client_) {
     client_->ProvidePictureBuffers(
         kNumPictureBuffers,
-        gfx::Size(vformat.nFrameWidth, vformat.nFrameHeight),
-        PICTUREBUFFER_MEMORYTYPE_GL_TEXTURE);
+        gfx::Size(vformat.nFrameWidth, vformat.nFrameHeight));
   }
 }
 
 void OmxVideoDecodeAccelerator::OnOutputPortEnabled() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   if (!CanFillBuffer()) {
     StopOnError(VIDEODECODERERROR_UNSUPPORTED);  // Should be STATE_ERROR.
     return;
   }
@@ skipping 273 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,
                         VIDEODECODERERROR_INVALIDINPUT, false);
   return true;
 }