Enable fire-and-forget Destroy of HW video decoder, and misc other improvements.

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(
-      pp::VideoDecoder_Dev decoder, uint32_t req_num_of_bufs,
-      PP_Size dimensions, PP_PictureBufferType_Dev type);
-  virtual void DismissPictureBuffer(
-      pp::VideoDecoder_Dev decoder, int32_t picture_buffer_id);
-  virtual void PictureReady(
-      pp::VideoDecoder_Dev decoder, const PP_Picture_Dev& picture);
-  virtual void EndOfStream(pp::VideoDecoder_Dev decoder);
-  virtual void NotifyError(
-      pp::VideoDecoder_Dev decoder, PP_VideoDecodeError_Dev error);
+      uint32_t req_num_of_bufs, PP_Size dimensions,
+      PP_PictureBufferType_Dev type);
+  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);
-  void DecoderAbortDone(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);
 
   // GL-related functions.
   void InitGL();
   GLuint CreateTexture(int32_t width, int32_t height);
@@ skipping 47 matching lines @@
       context_(NULL),
       surface_(NULL),
       video_decoder_(NULL) {
   assert((core_if_ = static_cast<const struct PPB_Core*>(
       module->GetBrowserInterface(PPB_CORE_INTERFACE))));
   assert((gles2_if_ = static_cast<const struct PPB_OpenGLES2_Dev*>(
       module->GetBrowserInterface(PPB_OPENGLES2_DEV_INTERFACE))));
 }
 
 GLES2DemoInstance::~GLES2DemoInstance() {
-  delete video_decoder_;
+  delete video_decoder_;  // May be NULL, which is fine.
   delete surface_;
   delete context_;
 }
 
 void GLES2DemoInstance::DidChangeView(
     const pp::Rect& position, const pp::Rect& clip_ignored) {
   if (position.width() == 0 || position.height() == 0)
     return;
   if (position_size_.width()) {
     assert(position.size() == position_size_);
@@ skipping 27 matching lines @@
       bitstream_buffers_by_id_.find(bitstream_buffer_id);
   assert(it != bitstream_buffers_by_id_.end());
   delete it->second;
   DecodeNextNALUs();
 }
 
 void GLES2DemoInstance::DecoderFlushDone(int32_t result) {
   // Check that each bitstream buffer ID we handed to the decoder got handed
   // back to us.
   assert(bitstream_ids_at_decoder_.empty());
-}
-
-void GLES2DemoInstance::DecoderAbortDone(int32_t result) {
+  delete video_decoder_;
+  video_decoder_ = NULL;
 }
 
 static bool LookingAtNAL(const unsigned char* encoded, size_t pos) {
   return pos + 3 < kDataLen &&
       encoded[pos] == 0 && encoded[pos + 1] == 0 &&
       encoded[pos + 2] == 0 && encoded[pos + 3] == 1;
 }
 
 void GLES2DemoInstance::GetNextNALUBoundary(
     size_t start_pos, size_t* end_pos) {
@@ skipping 39 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(
-    pp::VideoDecoder_Dev decoder, uint32_t req_num_of_bufs, PP_Size dimensions,
+    uint32_t req_num_of_bufs, PP_Size dimensions,
     PP_PictureBufferType_Dev type) {
   std::vector<PP_GLESBuffer_Dev> buffers;
   for (uint32_t i = 0; i < req_num_of_bufs; i++) {
     PP_GLESBuffer_Dev buffer;
     buffer.texture_id = CreateTexture(dimensions.width, dimensions.height);
     int id = ++next_picture_buffer_id_;
     buffer.info.id= id;
     buffers.push_back(buffer);
     assert(buffers_by_id_.insert(std::make_pair(id, buffer)).second);
   }
   video_decoder_->AssignGLESBuffers(buffers);
 }
 
-void GLES2DemoInstance::DismissPictureBuffer(
-    pp::VideoDecoder_Dev decoder, int32_t picture_buffer_id) {
+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(
-    pp::VideoDecoder_Dev decoder, const PP_Picture_Dev& picture) {
+void GLES2DemoInstance::PictureReady(const PP_Picture_Dev& picture) {
   if (first_frame_delivered_ticks_ == -1)
     assert((first_frame_delivered_ticks_ = core_if_->GetTimeTicks()) != -1);
   if (is_painting_) {
     pictures_pending_paint_.push_back(picture);
     return;
   }
   PictureBufferMap::iterator it =
       buffers_by_id_.find(picture.picture_buffer_id);
   assert(it != buffers_by_id_.end());
   Render(it->second);
 }
 
-void GLES2DemoInstance::EndOfStream(pp::VideoDecoder_Dev decoder) {
+void GLES2DemoInstance::EndOfStream() {
 }
 
-void GLES2DemoInstance::NotifyError(
-    pp::VideoDecoder_Dev decoder, PP_VideoDecodeError_Dev error) {
+void GLES2DemoInstance::NotifyError(PP_VideoDecodeError_Dev error) {
 }
 
 // This object is the global object representing this plugin library as long
 // as it is loaded.
 class GLES2DemoModule : public pp::Module {
  public:
   GLES2DemoModule() : pp::Module() {}
   virtual ~GLES2DemoModule() {}
 
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
@@ skipping 49 matching lines @@
   is_painting_ = false;
   ++num_frames_rendered_;
   if (num_frames_rendered_ % 50 == 0) {
     double elapsed = core_if_->GetTimeTicks() - first_frame_delivered_ticks_;
     double fps = (elapsed > 0) ? num_frames_rendered_ / elapsed : 1000;
     double ms_per_swap = (swap_ticks_ * 1e3) / num_frames_rendered_;
     std::cerr << "Rendered frames: " << num_frames_rendered_ << ", fps: "
               << fps << ", with average ms/swap of: " << ms_per_swap
               << std::endl;
   }
-  video_decoder_->ReusePictureBuffer(picture_buffer_id);
+  if (video_decoder_)
+    video_decoder_->ReusePictureBuffer(picture_buffer_id);
   while (!pictures_pending_paint_.empty() && !is_painting_) {
     PP_Picture_Dev picture = pictures_pending_paint_.front();
     pictures_pending_paint_.pop_front();
-    PictureReady(*video_decoder_, picture);
+    PictureReady(picture);
   }
 }
 
 GLuint GLES2DemoInstance::CreateTexture(int32_t width, int32_t height) {
   GLuint texture_id;
   gles2_if_->GenTextures(context_->pp_resource(), 1, &texture_id);
   assertNoGLError();
   // Assign parameters.
   gles2_if_->ActiveTexture(context_->pp_resource(), GL_TEXTURE0);
   gles2_if_->BindTexture(
@@ skipping 95 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