Improving the decoder pipeline.

remoting/client/rectangle_update_decoder.cc

 // Copyright (c) 2012 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 "remoting/client/rectangle_update_decoder.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
+#include "ppapi/cpp/image_data.h"
 #include "remoting/base/decoder.h"
 #include "remoting/base/decoder_row_based.h"
 #include "remoting/base/decoder_vp8.h"
 #include "remoting/base/util.h"
 #include "remoting/client/frame_consumer.h"
 #include "remoting/protocol/session_config.h"
 
+using base::Passed;
 using remoting::protocol::ChannelConfig;
 using remoting::protocol::SessionConfig;
 
 namespace remoting {
 
 RectangleUpdateDecoder::RectangleUpdateDecoder(
     base::MessageLoopProxy* message_loop, FrameConsumer* consumer)
     : message_loop_(message_loop),
       consumer_(consumer),
       screen_size_(SkISize::Make(0, 0)),
-      clip_rect_(SkIRect::MakeEmpty()),
-      decoder_needs_reset_(false) {
+      view_size_(SkISize::Make(0, 0)),
+      clip_area_(SkIRect::MakeEmpty()) {
 }
 
 RectangleUpdateDecoder::~RectangleUpdateDecoder() {
 }
 
 void RectangleUpdateDecoder::Initialize(const SessionConfig& config) {
   // Initialize decoder based on the selected codec.
   ChannelConfig::Codec codec = config.video_config().codec;
   if (codec == ChannelConfig::CODEC_VERBATIM) {
     decoder_.reset(DecoderRowBased::CreateVerbatimDecoder());
   } else if (codec == ChannelConfig::CODEC_ZIP) {
     decoder_.reset(DecoderRowBased::CreateZlibDecoder());
   } else if (codec == ChannelConfig::CODEC_VP8) {
     decoder_.reset(new DecoderVp8());
   } else {
     NOTREACHED() << "Invalid Encoding found: " << codec;
   }
 }
 
 void RectangleUpdateDecoder::DecodePacket(const VideoPacket* packet,
                                           const base::Closure& done) {
   if (!message_loop_->BelongsToCurrentThread()) {
     message_loop_->PostTask(
         FROM_HERE, base::Bind(&RectangleUpdateDecoder::DecodePacket,
                               this, packet, done));
     return;
   }
-  AllocateFrame(packet, done);
-}
 
-void RectangleUpdateDecoder::AllocateFrame(const VideoPacket* packet,
-                                           const base::Closure& done) {
-  if (!message_loop_->BelongsToCurrentThread()) {
-    message_loop_->PostTask(
-        FROM_HERE, base::Bind(&RectangleUpdateDecoder::AllocateFrame,
-                              this, packet, done));
-    return;
-  }
   base::ScopedClosureRunner done_runner(done);
+  bool decoder_needs_reset = false;
 
   // If the packet includes a screen size, store it.
   if (packet->format().has_screen_width() &&
       packet->format().has_screen_height()) {
-    screen_size_.set(packet->format().screen_width(),
-                     packet->format().screen_height());
+    SkISize screen_size = SkISize::Make(packet->format().screen_width(),
+                                        packet->format().screen_height());
+    if (screen_size_ != screen_size) {
+      screen_size_ = screen_size;
+      decoder_needs_reset = true;
+    }
   }
 
   // If we've never seen a screen size, ignore the packet.
   if (screen_size_.isZero()) {
     return;
   }
 
-  // Ensure the output frame is the right size.
-  SkISize frame_size = SkISize::Make(0, 0);
-  if (frame_)
-    frame_size.set(frame_->width(), frame_->height());
-
-  // Allocate a new frame, if necessary.
-  if ((!frame_) || (screen_size_ != frame_size)) {
-    if (frame_) {
-      consumer_->ReleaseFrame(frame_);
-      frame_ = NULL;
-    }
-
-    consumer_->AllocateFrame(
-        media::VideoFrame::RGB32, screen_size_, &frame_,
-        base::Bind(&RectangleUpdateDecoder::ProcessPacketData,
-                   this, packet, done_runner.Release()));
-    decoder_needs_reset_ = true;
-    return;
-  }
-  ProcessPacketData(packet, done_runner.Release());
-}
-
-void RectangleUpdateDecoder::ProcessPacketData(
-    const VideoPacket* packet, const base::Closure& done) {
-  if (!message_loop_->BelongsToCurrentThread()) {
-    message_loop_->PostTask(
-        FROM_HERE, base::Bind(&RectangleUpdateDecoder::ProcessPacketData,
-                              this, packet, done));
-    return;
-  }
-  base::ScopedClosureRunner done_runner(done);
-
-  if (decoder_needs_reset_) {
-    decoder_->Reset();
-    decoder_->Initialize(frame_);
-    decoder_needs_reset_ = false;
+  if (decoder_needs_reset) {
+    decoder_->Initialize(screen_size_);
+    consumer_->SetScreenSize(screen_size_);
   }
 
   if (!decoder_->IsReadyForData()) {
     // TODO(ajwong): This whole thing should move into an invalid state.
     LOG(ERROR) << "Decoder is unable to process data. Dropping packet.";
     return;
   }
 
   if (decoder_->DecodePacket(packet) == Decoder::DECODE_DONE)
-    SubmitToConsumer();
+    DoPaint();
 }
 
-void RectangleUpdateDecoder::SetOutputSize(const SkISize& size) {
+void RectangleUpdateDecoder::DoPaint() {
+  if (buffers_.empty())
+    return;
+
+  // Draw the invalidated region to the buffer.
+  pp::ImageData* buffer = buffers_.front();
+  SkRegion output_region;
+  decoder_->RenderFrame(view_size_, clip_area_,
+                        reinterpret_cast<uint8*>(buffer->data()),
+                        buffer->stride(),
+                        &output_region);
+
+  // Notify the consumer that painting is done.
+  if (!output_region.isEmpty()) {
+    buffers_.pop();
+    consumer_->PaintBuffer(view_size_, clip_area_, buffer, output_region);
+  }
+}
+
+void RectangleUpdateDecoder::DrainQueue(const base::Closure& done) {
   if (!message_loop_->BelongsToCurrentThread()) {
     message_loop_->PostTask(
-        FROM_HERE, base::Bind(&RectangleUpdateDecoder::SetOutputSize,
-                              this, size));
+        FROM_HERE, base::Bind(&RectangleUpdateDecoder::DrainQueue, this, done));
     return;
   }
 
-  // TODO(wez): Refresh the frame only if the ratio has changed.
-  if (frame_) {
-    SkIRect frame_rect = SkIRect::MakeWH(frame_->width(), frame_->height());
-    refresh_region_.op(frame_rect, SkRegion::kUnion_Op);
+  while (!buffers_.empty()) {
+    consumer_->ReturnBuffer(buffers_.front());
+    buffers_.pop();
   }
 
-  // TODO(hclam): If the scale ratio has changed we should reallocate a
-  // VideoFrame of different size. However if the scale ratio is always
-  // smaller than 1.0 we can use the same video frame.
-  if (decoder_.get()) {
-    decoder_->SetOutputSize(size);
-    RefreshFullFrame();
-  }
+  if (!done.is_null())
+    done.Run();
 }
 
-void RectangleUpdateDecoder::UpdateClipRect(const SkIRect& new_clip_rect) {
+void RectangleUpdateDecoder::EnqueueBuffer(pp::ImageData* buffer) {
   if (!message_loop_->BelongsToCurrentThread()) {
     message_loop_->PostTask(
-        FROM_HERE, base::Bind(&RectangleUpdateDecoder::UpdateClipRect,
-                              this, new_clip_rect));
+        FROM_HERE, base::Bind(&RectangleUpdateDecoder::EnqueueBuffer,
+                              this, buffer));
     return;
   }
 
-  if (new_clip_rect == clip_rect_ || !decoder_.get())
-    return;
+  DCHECK(clip_area_.width() <= buffer->size().width() &&
+         clip_area_.height() <= buffer->size().height());
 
-  // TODO(wez): Only refresh newly-exposed portions of the frame.
-  if (frame_) {
-    SkIRect frame_rect = SkIRect::MakeWH(frame_->width(), frame_->height());
-    refresh_region_.op(frame_rect, SkRegion::kUnion_Op);
-  }
-
-  clip_rect_ = new_clip_rect;
-  decoder_->SetClipRect(new_clip_rect);
-
-  // TODO(wez): Defer refresh so that multiple events can be batched.
-  DoRefresh();
+  buffers_.push(buffer);
+  DoPaint();
 }
 
-void RectangleUpdateDecoder::RefreshFullFrame() {
+void RectangleUpdateDecoder::Invalidate(const SkRegion& region) {
   if (!message_loop_->BelongsToCurrentThread()) {
     message_loop_->PostTask(
-        FROM_HERE, base::Bind(&RectangleUpdateDecoder::RefreshFullFrame, this));
-    return;
-  }
-
-  // If a video frame or the decoder is not allocated yet then don't
-  // save the refresh rectangle to avoid wasted computation.
-  if (!frame_ || !decoder_.get())
-    return;
-
-  SkIRect frame_rect = SkIRect::MakeWH(frame_->width(), frame_->height());
-  refresh_region_.op(frame_rect, SkRegion::kUnion_Op);
-
-  DoRefresh();
-}
-
-void RectangleUpdateDecoder::SubmitToConsumer() {
-  // A frame is not allocated yet, we can reach here because of a refresh
-  // request.
-  if (!frame_)
-    return;
-
-  SkRegion* dirty_region = new SkRegion;
-  decoder_->GetUpdatedRegion(dirty_region);
-
-  consumer_->OnPartialFrameOutput(frame_, dirty_region, base::Bind(
-      &RectangleUpdateDecoder::OnFrameConsumed, this, dirty_region));
-}
-
-void RectangleUpdateDecoder::DoRefresh() {
-  DCHECK(message_loop_->BelongsToCurrentThread());
-
-  if (refresh_region_.isEmpty())
-    return;
-
-  decoder_->RefreshRegion(refresh_region_);
-  refresh_region_.setEmpty();
-  SubmitToConsumer();
-}
-
-void RectangleUpdateDecoder::OnFrameConsumed(SkRegion* region) {
-  if (!message_loop_->BelongsToCurrentThread()) {
-    message_loop_->PostTask(
-        FROM_HERE, base::Bind(&RectangleUpdateDecoder::OnFrameConsumed,
+        FROM_HERE, base::Bind(&RectangleUpdateDecoder::Invalidate,
                               this, region));
     return;
   }
 
-  delete region;
+  if (decoder_.get()) {
+    decoder_->Invalidate(view_size_, region);
+    DoPaint();
+  }
+}
 
-  DoRefresh();
+void RectangleUpdateDecoder::SetView(const SkISize& view_size,
+                                     const SkIRect& clip_area) {
+  if (!message_loop_->BelongsToCurrentThread()) {
+    message_loop_->PostTask(
+        FROM_HERE, base::Bind(&RectangleUpdateDecoder::SetView,
+                              this, view_size, clip_area));
+    return;
+  }
+
+  // The whole frame needs to be repainted if the scaling factor has changed.
+  // Otherwise the newly exposed parts of the frame will be automatically
+  // updated because they haven't been validated by RenderFrame() yet.
+  if (view_size_ != view_size && decoder_.get()) {
+    SkRegion region;
+    region.op(SkIRect::MakeSize(view_size), SkRegion::kUnion_Op);
+    decoder_->Invalidate(view_size, region);
+  }
+
+  if (view_size_ != view_size ||
+      clip_area_ != clip_area) {
+    view_size_ = view_size;
+    clip_area_ = clip_area;
+
+    // Return buffers to the consumer for reuse/reallocation.
+    while (!buffers_.empty()) {
+      consumer_->ReturnBuffer(buffers_.front());
+      buffers_.pop();
+    }
+  }
 }
 
 }  // namespace remoting