Pepper: Expose visible_rect to PPB_VideoDecoder.GetPicture.

ppapi/examples/video_decode/video_decode.cc

 // Copyright (c) 2014 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 <stdio.h>
 #include <string.h>
 
 #include <iostream>
 #include <queue>
 #include <sstream>
@@ skipping 36 matching lines @@
   ~Shader() {}
 
   GLuint program;
   GLint texcoord_scale_location;
 };
 
 class Decoder;
 class MyInstance;
 
 struct PendingPicture {
-  PendingPicture(Decoder* decoder, const PP_VideoPicture& picture)
-      : decoder(decoder), picture(picture) {}
+  PendingPicture(Decoder* decoder,
+                 const PP_VideoPicture& picture,
+                 const PP_Rect& visible_rect)
+      : decoder(decoder), picture(picture), visible_rect(visible_rect) {}
   ~PendingPicture() {}
 
   Decoder* decoder;
   PP_VideoPicture picture;
+  PP_Rect visible_rect;
 };
 
 class MyInstance : public pp::Instance, public pp::Graphics3DClient {
  public:
   MyInstance(PP_Instance instance, pp::Module* module);
   virtual ~MyInstance();
 
   // pp::Instance implementation.
   virtual void DidChangeView(const pp::Rect& position,
                              const pp::Rect& clip_ignored);
   virtual bool HandleInputEvent(const pp::InputEvent& event);
 
   // pp::Graphics3DClient implementation.
   virtual void Graphics3DContextLost() {
     // TODO(vrk/fischman): Properly reset after a lost graphics context.  In
     // particular need to delete context_ and re-create textures.
     // Probably have to recreate the decoder from scratch, because old textures
     // can still be outstanding in the decoder!
     assert(false && "Unexpectedly lost graphics context");
   }
 
-  void PaintPicture(Decoder* decoder, const PP_VideoPicture& picture);
+  void PaintPicture(Decoder* decoder,
+                    const PP_VideoPicture& picture,
+                    const PP_Rect& visible_rect);
 
  private:
   // Log an error to the developer console and stderr by creating a temporary
   // object of this type and streaming to it.  Example usage:
   // LogError(this).s() << "Hello world: " << 42;
   class LogError {
    public:
     LogError(MyInstance* instance) : instance_(instance) {}
     ~LogError() {
       const std::string& msg = stream_.str();
@@ skipping 78 matching lines @@
   void DecodeDone(int32_t result);
   void PictureReady(int32_t result, PP_VideoPicture picture);
   void FlushDone(int32_t result);
   void ResetDone(int32_t result);
 
   MyInstance* instance_;
   int id_;
 
   pp::VideoDecoder* decoder_;
   pp::CompletionCallbackFactory<Decoder> callback_factory_;
+  PP_Rect picture_visible_rect_;
 
   size_t encoded_data_next_pos_to_decode_;
   int next_picture_id_;
   bool flushing_;
   bool resetting_;
 
   const PPB_Core* core_if_;
   static const int kMaxDecodeDelay = 128;
   PP_TimeTicks decode_time_[kMaxDecodeDelay];
   PP_TimeTicks total_latency_;
@@ skipping 77 matching lines @@
 }
 
 void Decoder::Start() {
   assert(decoder_);
 
   encoded_data_next_pos_to_decode_ = 0;
 
   // Register callback to get the first picture. We call GetPicture again in
   // PictureReady to continuously receive pictures as they're decoded.
   decoder_->GetPicture(
+      &picture_visible_rect_,
       callback_factory_.NewCallbackWithOutput(&Decoder::PictureReady));
 
   // Start the decode loop.
   DecodeNextFrame();
 }
 
 void Decoder::Reset() {
   assert(decoder_);
   assert(!resetting_);
   resetting_ = true;
@@ skipping 46 matching lines @@
   // Break out of the get picture loop on abort.
   if (result == PP_ERROR_ABORTED)
     return;
   assert(result == PP_OK);
 
   num_pictures_++;
   PP_TimeTicks latency = core_if_->GetTimeTicks() -
                          decode_time_[picture.decode_id % kMaxDecodeDelay];
   total_latency_ += latency;
 
+  PP_Rect visible_rect = picture_visible_rect_;
   decoder_->GetPicture(
+      &picture_visible_rect_,
       callback_factory_.NewCallbackWithOutput(&Decoder::PictureReady));
-  instance_->PaintPicture(this, picture);
+  instance_->PaintPicture(this, picture, visible_rect);
 }
 
 void Decoder::FlushDone(int32_t result) {
   assert(decoder_);
   assert(result == PP_OK || result == PP_ERROR_ABORTED);
   assert(flushing_);
   flushing_ = false;
 }
 
 void Decoder::ResetDone(int32_t result) {
@@ skipping 81 matching lines @@
 }
 
 void MyInstance::InitializeDecoders() {
   assert(video_decoders_.empty());
   // Create two decoders with ids 0 and 1.
   video_decoders_.push_back(new Decoder(this, 0, *context_));
   video_decoders_.push_back(new Decoder(this, 1, *context_));
 }
 
 void MyInstance::PaintPicture(Decoder* decoder,
-                              const PP_VideoPicture& picture) {
+                              const PP_VideoPicture& picture,
+                              const PP_Rect& visible_rect) {
   if (first_frame_delivered_ticks_ == -1)
     assert((first_frame_delivered_ticks_ = core_if_->GetTimeTicks()) != -1);
 
-  pending_pictures_.push(PendingPicture(decoder, picture));
+  pending_pictures_.push(PendingPicture(decoder, picture, visible_rect));
   if (!is_painting_)
     PaintNextPicture();
 }
 
 void MyInstance::PaintNextPicture() {
   assert(!is_painting_);
   is_painting_ = true;
 
   const PendingPicture& next = pending_pictures_.front();
   Decoder* decoder = next.decoder;
@@ skipping 262 matching lines @@
 };
 
 }  // anonymous namespace
 
 namespace pp {
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new MyModule();
 }
 }  // namespace pp