Allow the Chromoting client plugin to support up-scaling, albeit slowly.

remoting/base/decoder_vp8.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/base/decoder_vp8.h"
 
 #include <math.h>
 
 #include "base/logging.h"
 #include "media/base/media.h"
@@ skipping 101 matching lines @@
   DCHECK_EQ(kReady, state_);
   DCHECK(!view_size.isEmpty());
 
   for (SkRegion::Iterator i(region); !i.done(); i.next()) {
     SkIRect rect = i.rect();
     rect = ScaleRect(rect, view_size, screen_size_);
     updated_region_.op(rect, SkRegion::kUnion_Op);
   }
 }
 
+static int CalculateYOffset(int x, int y, int stride) {

[alexeypa (please no reviews), 2012/06/14 17:00:16]

CalculateYOffset and CalculateUVOffset are defined in remoting/base/util.cc

[Wez, 2012/06/18 21:51:34]

I've made them visible and used them.

(The intent is to fold this logic into an API in base and simplify DecoderVP8
again)

+  DCHECK(((x & 1) == 0) && ((y & 1) == 0));

[Sergey Ulanov, 2012/06/14 18:04:03]

nit: would be more readable as x % 2 == 0 && y % 2 == 0

[Wez, 2012/06/18 21:51:34]

This is how they're implemented in remoting/base/util.cc. Using % 2 assumes that
the compiler will optimize the check to & 1, otherwise performance will be a
problem.

[Sergey Ulanov, 2012/06/18 22:29:50]

All compilers we compile this code with should be smart enough to optimize it
for this case. If you don't assume that the compiler is smart then /2 should be
replaced with >>1 in line 129 as will as in many other places.

+  return stride * y + x;
+}
+
+static int CalculateUVOffset(int x, int y, int stride) {
+  DCHECK(((x & 1) == 0) && ((y & 1) == 0));
+  return stride * y / 2 + x / 2;
+}
+
 void DecoderVp8::RenderFrame(const SkISize& view_size,
                              const SkIRect& clip_area,
                              uint8* image_buffer,
                              int image_stride,
                              SkRegion* output_region) {
   DCHECK_EQ(kReady, state_);
   DCHECK(!view_size.isEmpty());
 
   // Early-return and do nothing if we haven't yet decoded any frames.
   if (!last_image_)
     return;
 
   SkIRect source_clip = SkIRect::MakeWH(last_image_->d_w, last_image_->d_h);
 
-  // ScaleYUVToRGB32WithRect doesn't support up-scaling, and our web-app never
-  // intentionally up-scales, so if we see up-scaling (e.g. during host resize
-  // or if the user applies page zoom) just don't render anything.
-  // TODO(wez): Remove this hack when ScaleYUVToRGB32WithRect can up-scale.
-  if (source_clip.width() < view_size.width() ||

[alexeypa (please no reviews), 2012/06/14 17:00:16]

It is the only place where this check is done? I remember there were a couple of
places.

[Wez, 2012/06/18 21:51:34]

This should be the only place.

-      source_clip.height() < view_size.height()) {
+  // ScaleYUVToRGB32WithRect does not currently support up-scaling.  We won't
+  // be asked to up-scale except during resizes or if page zoom is >100%, so
+  // we work-around the limitation by using the slower ScaleYUVToRGB32.
+  // TODO(wez): Remove this hack if/when ScaleYUVToRGB32WithRect can up-scale.
+  if (!updated_region_.isEmpty() &&
+      (source_clip.width() < view_size.width() ||
+       source_clip.height() < view_size.height())) {
+    // We're scaling only |clip_area| into the |image_buffer|, so we need to
+    // work out which source rectangle that corresponds to.
+    SkIRect source_rect = ScaleRect(clip_area, view_size, screen_size_);

[Jamie, 2012/06/14 01:14:29]

It's not obvious to me that ScaleRect will return even coordinates as required
by the DCHECKs.

[Wez, 2012/06/18 21:51:34]

It won't - fixed!

+    int y_offset = CalculateYOffset(source_rect.x(),
+                                    source_rect.y(),
+                                    last_image_->stride[0]);
+    int uv_offset = CalculateUVOffset(source_rect.x(),
+                                      source_rect.y(),
+                                      last_image_->stride[1]);
+    ScaleYUVToRGB32(last_image_->planes[0] + y_offset,
+                    last_image_->planes[1] + uv_offset,
+                    last_image_->planes[2] + uv_offset,
+                    image_buffer,
+                    source_rect.width(),
+                    source_rect.height(),
+                    clip_area.width(),
+                    clip_area.height(),
+                    last_image_->stride[0],
+                    last_image_->stride[1],
+                    image_stride,
+                    media::YV12,
+                    media::ROTATE_0,
+                    media::FILTER_BILINEAR);
+
+    output_region->op(clip_area, SkRegion::kUnion_Op);
+    updated_region_.op(source_rect, SkRegion::kDifference_Op);
     return;
   }
 
   for (SkRegion::Iterator i(updated_region_); !i.done(); i.next()) {
     // Determine the scaled area affected by this rectangle changing.
     SkIRect rect = i.rect();
     if (!rect.intersect(source_clip))
       continue;
     rect = ScaleRect(rect, screen_size_, view_size);
     if (!rect.intersect(clip_area))
@@ skipping 13 matching lines @@
                                   rect);
 
     output_region->op(rect, SkRegion::kUnion_Op);
   }
 
   updated_region_.op(ScaleRect(clip_area, view_size, screen_size_),
                      SkRegion::kDifference_Op);
 }
 
 }  // namespace remoting