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 <math.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) {
+      output_size_(SkISize::Make(0, 0)) {
 }
 
 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()));
   }
 
-  if (!DoScaling())
-    ConvertRects(rects, &updated_rects_);
-  else
-    ScaleAndConvertRects(rects, &updated_rects_);
+  // 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());
+  }
+
+  RefreshRects(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::SetOutputSize(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;
+  DCHECK(last_image_);
+  return !output_size_.equals(last_image_->d_w, last_image_->d_h);
 }
 
 void DecoderVp8::ConvertRects(const RectVector& input_rects,
                               RectVector* output_rects) {
   if (!last_image_)
     return;
 
   // The conversion routine we use is optimized for even widths & heights.
   int image_width = RoundToTwosMultiple(last_image_->d_w);
   int image_height = RoundToTwosMultiple(last_image_->d_h);
@@ skipping 29 matching lines @@
 
     output_rects->push_back(dest_rect);
   }
 }
 
 void DecoderVp8::ScaleAndConvertRects(const RectVector& input_rects,
                                       RectVector* output_rects) {
   if (!last_image_)
     return;
 
-  int input_width = last_image_->d_w;
-  int input_height = last_image_->d_h;
-
-  uint8* output_rgb_buf = frame_->data(media::VideoFrame::kRGBPlane);
-  const int output_stride = frame_->stride(media::VideoFrame::kRGBPlane);
-
-  // TODO(wez): Resize |frame_| to our desired output dimensions when scaling.
-  int output_width = ceil(input_width * horizontal_scale_ratio_);
-  int output_height = ceil(input_height * vertical_scale_ratio_);
+  DCHECK(output_size_.width() <= static_cast<int>(frame_->width()));
+  DCHECK(output_size_.height() <= static_cast<int>(frame_->height()));
 
   output_rects->clear();
 
   // Clip based on both the output dimensions and Pepper clip rect.
   SkIRect clip_rect = clip_rect_;
-  if (!clip_rect.intersect(SkIRect::MakeWH(output_width, output_height)))
+  if (!clip_rect.intersect(output_size_))

[Sergey Ulanov, 2011/12/21 02:38:19]

Does this compile given that |output_size_| is a not a rect? Should be written
as intersect(SkIRect::MakeWH(output_size_))?

     return;
 
+  SkISize image_size(last_image_->d_w, last_image_->d_h);
+  uint8* output_rgb_buf = frame_->data(media::VideoFrame::kRGBPlane);
+  const int output_stride = frame_->stride(media::VideoFrame::kRGBPlane);
+
   output_rects->reserve(input_rects.size());
 
   for (size_t i = 0; i < input_rects.size(); ++i) {
     // Determine the scaled area affected by this rectangle changing.
-    SkIRect output_rect = ScaleRect(input_rects[i],
-                                    horizontal_scale_ratio_,
-                                    vertical_scale_ratio_);
+    SkIRect output_rect = ScaleRect(dest_rect, image_size, output_size_);
     if (!output_rect.intersect(clip_rect))
       continue;
 
     // The scaler will not read outside the input dimensions.
     ScaleYUVToRGB32WithRect(last_image_->planes[0],
                             last_image_->planes[1],
                             last_image_->planes[2],
                             output_rgb_buf,
                             input_rects[i],
                             output_rect,
                             last_image_->stride[0],
                             last_image_->stride[1],
                             output_stride);
     output_rects->push_back(output_rect);
   }
 }
 
 }  // namespace remoting