Refactoring of the client-side input pipeline and scaling dimension management.

remoting/base/decoder_vp8.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 "remoting/base/decoder_vp8.h"
 
 #include "base/logging.h"
 #include "media/base/media.h"
 #include "media/base/yuv_convert.h"
 #include "remoting/base/util.h"
 
 extern "C" {
 #define VPX_CODEC_DISABLE_COMPAT 1
 #include "third_party/libvpx/libvpx.h"
 }
 
 namespace remoting {
 
 DecoderVp8::DecoderVp8()
     : state_(kUninitialized),
       codec_(NULL),
       last_image_(NULL),
-      clip_rect_(SkIRect::MakeEmpty()),
-      horizontal_scale_ratio_(1.0),
-      vertical_scale_ratio_(1.0) {
+      clip_rect_(SkIRect::MakeEmpty()) {
+  output_size_.setEmpty();

[Sergey Ulanov, 2011/12/20 00:05:35]

Can we initialize output_size_ in the same way clip_rect_ is initialized?

[Wez, 2011/12/20 07:14:14]

Done.

 }
 
 DecoderVp8::~DecoderVp8() {
   if (codec_) {
     vpx_codec_err_t ret = vpx_codec_destroy(codec_);
     CHECK(ret == VPX_CODEC_OK) << "Failed to destroy codec";
   }
   delete codec_;
 }
 
@@ skipping 58 matching lines @@
   RectVector rects;
   rects.reserve(packet->dirty_rects_size());
   for (int i = 0; i < packet->dirty_rects_size(); ++i) {
     Rect remoting_rect = packet->dirty_rects(i);
     rects.push_back(SkIRect::MakeXYWH(remoting_rect.x(),
                                       remoting_rect.y(),
                                       remoting_rect.width(),
                                       remoting_rect.height()));
   }
 
+  // TODO(wez): Fix the rest of the decode pipeline not to assume the frame
+  // size is the host dimensions, since it's not when scaling.  If the host
+  // gets smaller, then the output size will be too big and we'll overrun the
+  // frame, so currently we render 1:1 in that case; the app will see the
+  // host size change and resize us if need be.
+  if ((output_size_.width() > static_cast<int>(frame_->width())) ||
+      (output_size_.height() > static_cast<int>(frame_->height()))) {
+    output_size_.set(frame_->width(), frame_->height());
+  }
+
   if (!DoScaling())
     ConvertRects(rects, &updated_rects_);
   else
     ScaleAndConvertRects(rects, &updated_rects_);
   return DECODE_DONE;
 }
 
 void DecoderVp8::GetUpdatedRects(RectVector* rects) {
   rects->swap(updated_rects_);
 }
 
 void DecoderVp8::Reset() {
   frame_ = NULL;
   state_ = kUninitialized;
 }
 
 bool DecoderVp8::IsReadyForData() {
   return state_ == kReady;
 }
 
 VideoPacketFormat::Encoding DecoderVp8::Encoding() {
   return VideoPacketFormat::ENCODING_VP8;
 }
 
-void DecoderVp8::SetScaleRatios(double horizontal_ratio,
-                                double vertical_ratio) {
-  // TODO(hclam): Ratio greater than 1.0 is not supported. This is
-  // because we need to reallocate the backing video frame and this
-  // is not implemented yet.
-  if (horizontal_ratio > 1.0 || horizontal_ratio <= 0.0 ||
-      vertical_ratio > 1.0 || vertical_ratio <= 0.0) {
-    return;
-  }
-
-  horizontal_scale_ratio_ = horizontal_ratio;
-  vertical_scale_ratio_ = vertical_ratio;
+void DecoderVp8::SetOutputDimensions(const SkISize& size) {
+  output_size_ = size;
 }
 
 void DecoderVp8::SetClipRect(const SkIRect& clip_rect) {
   clip_rect_ = clip_rect;
 }
 
 void DecoderVp8::RefreshRects(const RectVector& rects) {
   if (!DoScaling())
     ConvertRects(rects, &updated_rects_);
   else
     ScaleAndConvertRects(rects, &updated_rects_);
 }
 
 bool DecoderVp8::DoScaling() const {
-  return horizontal_scale_ratio_ != 1.0 || vertical_scale_ratio_ != 1.0;
+  return last_image_ &&
+      !output_size_.equals(last_image_->d_w, last_image_->d_h);

[Jamie, 2011/12/20 00:51:57]

This will change the behaviour if DoScaling is ever called after
SetOutputDimentions but before last_image is set. Are you sure that doesn't
matter?

[Wez, 2011/12/20 07:14:14]

DoScaling() determines whether we use the ConvertRects() or
ScaleAndConvertRects() method, so it shouldn't actually ever be called when
|last_image_| is NULL.  I've changed the code to DCHECK |last_image_|.

 }
 
 void DecoderVp8::ConvertRects(const RectVector& rects,
                               RectVector* output_rects) {
   if (!last_image_)
     return;
 
   uint8* data_start = frame_->data(media::VideoFrame::kRGBPlane);
   const int stride = frame_->stride(media::VideoFrame::kRGBPlane);
 
@@ skipping 33 matching lines @@
   if (!last_image_)
     return;
 
   uint8* data_start = frame_->data(media::VideoFrame::kRGBPlane);
   const int stride = frame_->stride(media::VideoFrame::kRGBPlane);
 
   output_rects->clear();
   output_rects->reserve(rects.size());
   for (size_t i = 0; i < rects.size(); ++i) {
     // Round down the image width and height.
-    int image_width = RoundToTwosMultiple(last_image_->d_w);
-    int image_height = RoundToTwosMultiple(last_image_->d_h);
+    SkISize image_size;
+    image_size.set(RoundToTwosMultiple(last_image_->d_w),
+                   RoundToTwosMultiple(last_image_->d_h));
 
     // Clip by the rounded down dimension of the image for safety.
     SkIRect dest_rect = rects[i];
-    if (!dest_rect.intersect(SkIRect::MakeWH(image_width, image_height)))
+    if (!dest_rect.intersect(SkIRect::MakeSize(image_size)))
       continue;
 
     // Align the rectangle to avoid artifacts in color space conversion.
     dest_rect = AlignRect(dest_rect);
 
-    SkIRect scaled_rect = ScaleRect(dest_rect,
-                                    horizontal_scale_ratio_,
-                                    vertical_scale_ratio_);
+    SkIRect scaled_rect = ScaleRect(dest_rect, image_size, output_size_);
 
     ScaleYUVToRGB32WithRect(last_image_->planes[0],
                             last_image_->planes[1],
                             last_image_->planes[2],
                             data_start,
                             dest_rect,
                             scaled_rect,
                             last_image_->stride[0],
                             last_image_->stride[1],
                             stride);
     output_rects->push_back(scaled_rect);
   }
 }
 
 }  // namespace remoting