Clean up video frame sizes, types in Video Decode API

ppapi/examples/gles2/gles2.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 <string.h>
 
 #include <iostream>
 #include <list>
 #include <map>
 #include <set>
@@ skipping 40 matching lines @@
   virtual void Graphics3DContextLost() {
     // TODO(vrk/fischman): Properly reset after a lost graphics context.  In
     // particular need to delete context_ & surface_ and re-create textures.
     // Probably have to recreate the decoder from scratch, because old textures
     // can still be outstanding in the decoder!
     assert(!"Unexpectedly lost graphics context");
   }
 
   // pp::VideoDecoderClient_Dev implementation.
   virtual void ProvidePictureBuffers(
-      uint32_t req_num_of_bufs, PP_Size dimensions,
-      PP_PictureBufferType_Dev type);
+      uint32_t req_num_of_bufs, PP_Size dimensions);
   virtual void DismissPictureBuffer(int32_t picture_buffer_id);
   virtual void PictureReady(const PP_Picture_Dev& picture);
   virtual void EndOfStream();
   virtual void NotifyError(PP_VideoDecodeError_Dev error);
 
  private:
   enum { kNumConcurrentDecodes = 7 };
 
   // Initialize Video Decoder.
   void InitializeDecoder();
 
   // Callbacks passed into pp:VideoDecoder_Dev functions.
   void DecoderInitDone(int32_t result);
   void DecoderBitstreamDone(int32_t result, int bitstream_buffer_id);
   void DecoderFlushDone(int32_t result);
 
   // Decode helpers.
   void DecodeNextNALUs();
   void DecodeNextNALU();
   void GetNextNALUBoundary(size_t start_pos, size_t* end_pos);
-  void Render(const PP_GLESBuffer_Dev& buffer);
+  void Render(const PP_PictureBuffer_Dev& buffer);
 
   // GL-related functions.
   void InitGL();
   GLuint CreateTexture(int32_t width, int32_t height);
   void CreateGLObjects();
   void CreateShader(GLuint program, GLenum type, const char* source, int size);
   void DeleteTexture(GLuint id);
   void PaintFinished(int32_t result, int picture_buffer_id);
 
   pp::Size position_size_;
   int next_picture_buffer_id_;
   int next_bitstream_buffer_id_;
   bool is_painting_;
   pp::CompletionCallbackFactory<GLES2DemoInstance> callback_factory_;
   size_t encoded_data_next_pos_to_decode_;
   std::set<int> bitstream_ids_at_decoder_;
   // When decode outpaces render, we queue up decoded pictures for later
   // painting.
   std::list<PP_Picture_Dev> pictures_pending_paint_;
   int num_frames_rendered_;
 
   // Map of texture buffers indexed by buffer id.
-  typedef std::map<int, PP_GLESBuffer_Dev> PictureBufferMap;
+  typedef std::map<int, PP_PictureBuffer_Dev> PictureBufferMap;
   PictureBufferMap buffers_by_id_;
   // Map of bitstream buffers indexed by id.
   typedef std::map<int, pp::Buffer_Dev*> BitstreamBufferMap;
   BitstreamBufferMap bitstream_buffers_by_id_;
   PP_TimeTicks first_frame_delivered_ticks_;
   PP_TimeTicks last_swap_request_ticks_;
   PP_TimeTicks swap_ticks_;
 
   // Unowned pointers.
   const struct PPB_Core* core_if_;
@@ skipping 127 matching lines @@
 
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(
           &GLES2DemoInstance::DecoderBitstreamDone, id);
   assert(bitstream_ids_at_decoder_.insert(id).second);
   video_decoder_->Decode(bitstream_buffer, cb);
   encoded_data_next_pos_to_decode_ = end_pos;
 }
 
 void GLES2DemoInstance::ProvidePictureBuffers(
-    uint32_t req_num_of_bufs, PP_Size dimensions,
-    PP_PictureBufferType_Dev type) {
-  std::vector<PP_GLESBuffer_Dev> buffers;
+    uint32_t req_num_of_bufs, PP_Size dimensions) {
+  std::vector<PP_PictureBuffer_Dev> buffers;
   for (uint32_t i = 0; i < req_num_of_bufs; i++) {
-    PP_GLESBuffer_Dev buffer;
+    PP_PictureBuffer_Dev buffer;
     buffer.texture_id = CreateTexture(dimensions.width, dimensions.height);
     int id = ++next_picture_buffer_id_;
-    buffer.info.id= id;
+    buffer.id = id;
     buffers.push_back(buffer);
     assert(buffers_by_id_.insert(std::make_pair(id, buffer)).second);
   }
-  video_decoder_->AssignGLESBuffers(buffers);
+  video_decoder_->AssignPictureBuffers(buffers);
 }
 
 void GLES2DemoInstance::DismissPictureBuffer(int32_t picture_buffer_id) {
   PictureBufferMap::iterator it = buffers_by_id_.find(picture_buffer_id);
   assert(it != buffers_by_id_.end());
   DeleteTexture(it->second.texture_id);
   buffers_by_id_.erase(it);
 }
 
 void GLES2DemoInstance::PictureReady(const PP_Picture_Dev& picture) {
@@ skipping 49 matching lines @@
   gles2_if_->Clear(context_->pp_resource(), GL_COLOR_BUFFER_BIT);
   gles2_if_->Viewport(context_->pp_resource(), 0, 0,
                       position_size_.width(), position_size_.height());
 
   assert(BindGraphics(*surface_));
   assertNoGLError();
 
   CreateGLObjects();
 }
 
-void GLES2DemoInstance::Render(const PP_GLESBuffer_Dev& buffer) {
+void GLES2DemoInstance::Render(const PP_PictureBuffer_Dev& buffer) {
   assert(!is_painting_);
   is_painting_ = true;
   gles2_if_->ActiveTexture(context_->pp_resource(), GL_TEXTURE0);
   gles2_if_->BindTexture(
       context_->pp_resource(), GL_TEXTURE_2D, buffer.texture_id);
   gles2_if_->DrawArrays(context_->pp_resource(), GL_TRIANGLE_STRIP, 0, 4);
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(
-          &GLES2DemoInstance::PaintFinished, buffer.info.id);
+          &GLES2DemoInstance::PaintFinished, buffer.id);
   last_swap_request_ticks_ = core_if_->GetTimeTicks();
   assert(surface_->SwapBuffers(cb) == PP_OK_COMPLETIONPENDING);
 }
 
 void GLES2DemoInstance::PaintFinished(int32_t result, int picture_buffer_id) {
   swap_ticks_ += core_if_->GetTimeTicks() - last_swap_request_ticks_;
   is_painting_ = false;
   ++num_frames_rendered_;
   if (num_frames_rendered_ % 50 == 0) {
     double elapsed = core_if_->GetTimeTicks() - first_frame_delivered_ticks_;
@@ skipping 117 matching lines @@
   gles2_if_->DeleteShader(context_->pp_resource(), shader);
 }
 }  // anonymous namespace
 
 namespace pp {
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new GLES2DemoModule();
 }
 }  // namespace pp