Clean up video frame sizes, types in Video Decode API

content/common/gpu/media/omx_video_decode_accelerator_unittest.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.
 //
 // The bulk of this file is support code; sorry about that.  Here's an overview
 // to hopefully help readers of this code:
 // - RenderingHelper is charged with interacting with X11, EGL, and GLES2.
 // - ClientState is an enum for the state of the decode client used by the test.
 // - ClientStateNotification is a barrier abstraction that allows the test code
 //   to be written sequentially and wait for the decode client to see certain
@@ skipping 393 matching lines @@
                         std::string* encoded_data,
                         int num_NALUs_per_decode,
                         int delete_decoder_state);
   virtual ~EglRenderingVDAClient();
   void CreateDecoder();
 
   // VideoDecodeAccelerator::Client implementation.
   // The heart of the Client.
   virtual void ProvidePictureBuffers(
       uint32 requested_num_of_buffers,
-      const gfx::Size& dimensions,
-      VideoDecodeAccelerator::MemoryType type);
+      const gfx::Size& dimensions);
   virtual void DismissPictureBuffer(int32 picture_buffer_id);
   virtual void PictureReady(const media::Picture& picture);
   // Simple state changes.
   virtual void NotifyInitializeDone();
   virtual void NotifyEndOfStream();
   virtual void NotifyEndOfBitstreamBuffer(int32 bitstream_buffer_id);
   virtual void NotifyFlushDone();
   virtual void NotifyResetDone();
   virtual void NotifyError(VideoDecodeAccelerator::Error error);
 
   // Simple getters for inspecting the state of the Client.
   ClientState state() { return state_; }
   VideoDecodeAccelerator::Error error() { return error_; }
   int num_done_bitstream_buffers() { return num_done_bitstream_buffers_; }
   int num_decoded_frames() { return num_decoded_frames_; }
   EGLDisplay egl_display() { return rendering_helper_->egl_display(); }
   EGLContext egl_context() { return rendering_helper_->egl_context(); }
   double frames_per_second();
   bool decoder_deleted() { return !decoder_; }
 
  private:
-  typedef std::map<int, media::GLESBuffer*> PictureBufferById;
+  typedef std::map<int, media::PictureBuffer*> PictureBufferById;
 
   void SetState(ClientState new_state);
 
   // Delete the associated OMX decoder helper.
   void DeleteDecoder();
 
   // Compute & return in |*end_pos| the end position for the next batch of NALUs
   // to ship to the decoder (based on |start_pos| & |num_NALUs_per_decode_|).
   void GetRangeForNextNALUs(size_t start_pos, size_t* end_pos);
 
@@ skipping 57 matching lines @@
     media::VIDEOATTRIBUTEKEY_VIDEOCOLORFORMAT, media::VIDEOCOLORFORMAT_RGBA,
   };
   std::vector<uint32> config(
       config_array, config_array + arraysize(config_array));
   CHECK(decoder_->Initialize(config));
 }
 
 
 void EglRenderingVDAClient::ProvidePictureBuffers(
     uint32 requested_num_of_buffers,
-    const gfx::Size& dimensions,
-    VideoDecodeAccelerator::MemoryType type) {
+    const gfx::Size& dimensions) {
   if (decoder_deleted())
     return;
-  CHECK_EQ(type, VideoDecodeAccelerator::PICTUREBUFFER_MEMORYTYPE_GL_TEXTURE);
-  std::vector<media::GLESBuffer> buffers;
+  std::vector<media::PictureBuffer> buffers;
   CHECK_EQ(dimensions.width(), kFrameWidth);
   CHECK_EQ(dimensions.height(), kFrameHeight);
 
   for (uint32 i = 0; i < requested_num_of_buffers; ++i) {
     uint32 id = picture_buffers_by_id_.size();
     GLuint texture_id;
     base::WaitableEvent done(false, false);
     rendering_helper_->CreateTexture(rendering_window_id_, &texture_id, &done);
     done.Wait();
-    media::GLESBuffer* buffer =
-        new media::GLESBuffer(id, dimensions, texture_id);
+    media::PictureBuffer* buffer =
+        new media::PictureBuffer(id, dimensions, texture_id);
     CHECK(picture_buffers_by_id_.insert(std::make_pair(id, buffer)).second);
     buffers.push_back(*buffer);
   }
-  decoder_->AssignGLESBuffers(buffers);
+  decoder_->AssignPictureBuffers(buffers);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
   CHECK_EQ(static_cast<int>(eglGetError()), EGL_SUCCESS);
 }
 
 void EglRenderingVDAClient::DismissPictureBuffer(int32 picture_buffer_id) {
   PictureBufferById::iterator it =
       picture_buffers_by_id_.find(picture_buffer_id);
   DCHECK(it != picture_buffers_by_id_.end());
   rendering_helper_->DeleteTexture(it->second->texture_id());
   delete it->second;
   picture_buffers_by_id_.erase(it);
 }
 
 void EglRenderingVDAClient::PictureReady(const media::Picture& picture) {
   // We shouldn't be getting pictures delivered after Reset has completed.
   DCHECK_LT(state_, CS_RESET);
 
   if (decoder_deleted())
     return;
   last_frame_delivered_ticks_ = base::TimeTicks::Now();
 
   // Because we feed the decoder a limited number of NALUs at a time, we can be
   // sure that the bitstream buffer from which a frame comes has a limited
   // range.  Assert that.
   CHECK_GE((picture.bitstream_buffer_id() + 1) * num_NALUs_per_decode_,
            num_decoded_frames_);
   CHECK_LE(picture.bitstream_buffer_id(), next_bitstream_buffer_id_);
   ++num_decoded_frames_;
 
-  media::GLESBuffer* gles_buffer =
+  media::PictureBuffer* picture_buffer =
       picture_buffers_by_id_[picture.picture_buffer_id()];
-  CHECK(gles_buffer);
-  rendering_helper_->RenderTexture(gles_buffer->texture_id());
+  CHECK(picture_buffer);
+  rendering_helper_->RenderTexture(picture_buffer->texture_id());
 
   decoder_->ReusePictureBuffer(picture.picture_buffer_id());
 }
 
 void EglRenderingVDAClient::NotifyInitializeDone() {
   SetState(CS_INITIALIZED);
   initialize_done_ticks_ = base::TimeTicks::Now();
   DecodeNextNALUs();
 }
 
@@ skipping 283 matching lines @@
         MakeTuple(1, kMaxSupportedNumConcurrentDecoders + 0, CS_RESET),
         MakeTuple(1, kMaxSupportedNumConcurrentDecoders + 1, CS_RESET)));
 
 // TODO(fischman, vrk): add more tests!  In particular:
 // - Test life-cycle: Seek/Stop/Pause/Play/RePlay for a single decoder.
 // - Test alternate configurations
 // - Test failure conditions.
 // - Test frame size changes mid-stream
 
 }  // namespace