Replace RectVectors with SkRegions in Decoder.

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 74 matching lines @@
 
   // Gets the decoded data.
   vpx_codec_iter_t iter = NULL;
   vpx_image_t* image = vpx_codec_get_frame(codec_, &iter);
   if (!image) {
     LOG(INFO) << "No video frame decoded";
     return DECODE_ERROR;
   }
   last_image_ = image;
 
-  RectVector rects;
+  std::vector<SkIRect> 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()));
   }
 
-  RefreshRects(rects);
+  SkRegion region;
+  region.setRects(&rects[0], rects.size());
+
+  RefreshRegion(region);
   return DECODE_DONE;
 }
 
-void DecoderVp8::GetUpdatedRects(RectVector* rects) {
-  rects->swap(updated_rects_);
+void DecoderVp8::GetUpdatedRegion(SkRegion* region) {
+  region->swap(updated_region_);
 }
 
 void DecoderVp8::Reset() {
   frame_ = NULL;
   state_ = kUninitialized;
 }
 
 bool DecoderVp8::IsReadyForData() {
   return state_ == kReady;
 }
 
 VideoPacketFormat::Encoding DecoderVp8::Encoding() {
   return VideoPacketFormat::ENCODING_VP8;
 }
 
 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) {
+void DecoderVp8::RefreshRegion(const SkRegion& region) {
   // 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_.set(frame_->width(), output_size_.height());
   if (output_size_.height() > static_cast<int>(frame_->height()))
     output_size_.set(output_size_.width(), frame_->height());
 
   if (!DoScaling())
-    ConvertRects(rects, &updated_rects_);
+    ConvertRegion(region, &updated_region_);

[Sergey Ulanov, 2012/01/23 19:59:54]

nit: add { }

[Wez, 2012/01/23 21:37:23]

Done.

   else
-    ScaleAndConvertRects(rects, &updated_rects_);
+    ScaleAndConvertRegion(region, &updated_region_);
 }
 
 bool DecoderVp8::DoScaling() const {
   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) {
+void DecoderVp8::ConvertRegion(const SkRegion& input_region,
+                               SkRegion* output_region) {
   if (!last_image_)
     return;
 
-  output_rects->clear();
+  output_region->setEmpty();
 
   // Clip based on both the output dimensions and Pepper clip rect.
   // ConvertYUVToRGB32WithRect() requires even X and Y coordinates, so we align
   // |clip_rect| to prevent clipping from breaking alignment.  We then clamp it
   // to the image dimensions, which may lead to odd width & height, which we
   // can cope with.
   SkIRect clip_rect = AlignRect(clip_rect_);
   if (!clip_rect.intersect(SkIRect::MakeWH(last_image_->d_w, last_image_->d_h)))
     return;
 
   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) {
+  for (SkRegion::Iterator i(input_region); !i.done(); i.next()) {
     // Align the rectangle so the top-left coordinates are even, for
     // ConvertYUVToRGB32WithRect().
-    SkIRect dest_rect(AlignRect(input_rects[i]));
+    SkIRect dest_rect(AlignRect(i.rect()));
 
     // Clip the rectangle, preserving alignment since |clip_rect| is aligned.
     if (!dest_rect.intersect(clip_rect))
       continue;
 
     ConvertYUVToRGB32WithRect(last_image_->planes[0],
                               last_image_->planes[1],
                               last_image_->planes[2],
                               output_rgb_buf,
                               dest_rect,
                               last_image_->stride[0],
                               last_image_->stride[1],
                               output_stride);
 
-    output_rects->push_back(dest_rect);
+    output_region->op(dest_rect, SkRegion::kUnion_Op);

[Sergey Ulanov, 2012/01/23 19:59:54]

Comments about SkRegion::setRects() say that it may be faster than union of all
rects. I don't know if it is really the case, but if we don't use setRects()
here, then there is no reason to use it in DecoderVp8::DecodePacket()

[Wez, 2012/01/23 21:37:23]

To use setRects() here, we'd need to create a vector(SkIRect), push the rects
onto it, and then setRects() into the region.  Since SkRegion doesn't provide a
qay to query the rectangle count, we can't reserve() capacity in the vector. 
And although setRects() _could_ optimize things, it actually doesn't.  So I've
reverted to using op(kUnion_Op) elsewhere.

   }
 }
 
-void DecoderVp8::ScaleAndConvertRects(const RectVector& input_rects,
-                                      RectVector* output_rects) {
+void DecoderVp8::ScaleAndConvertRegion(const SkRegion& input_region,
+                                       SkRegion* output_region) {
   if (!last_image_)
     return;
 
   DCHECK(output_size_.width() <= static_cast<int>(frame_->width()));
   DCHECK(output_size_.height() <= static_cast<int>(frame_->height()));
 
-  output_rects->clear();
+  output_region->setEmpty();
 
   // Clip based on both the output dimensions and Pepper clip rect.
   SkIRect clip_rect = clip_rect_;
   if (!clip_rect.intersect(SkIRect::MakeSize(output_size_)))
     return;
 
   SkISize image_size = SkISize::Make(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) {
+  for (SkRegion::Iterator i(input_region); !i.done(); i.next()) {
     // Determine the scaled area affected by this rectangle changing.
-    SkIRect output_rect = ScaleRect(input_rects[i], image_size, output_size_);
+    SkIRect output_rect = ScaleRect(i.rect(), image_size, output_size_);
     if (!output_rect.intersect(clip_rect))
       continue;
 
     // The scaler will not to read outside the input dimensions.
     media::ScaleYUVToRGB32WithRect(last_image_->planes[0],
                                    last_image_->planes[1],
                                    last_image_->planes[2],
                                    output_rgb_buf,
                                    image_size.width(),
                                    image_size.height(),
                                    output_size_.width(),
                                    output_size_.height(),
                                    output_rect.x(),
                                    output_rect.y(),
                                    output_rect.right(),
                                    output_rect.bottom(),
                                    last_image_->stride[0],
                                    last_image_->stride[1],
                                    output_stride);
-    output_rects->push_back(output_rect);
+    output_region->op(output_rect, SkRegion::kUnion_Op);

[Sergey Ulanov, 2012/01/23 19:59:54]

same here

   }
 }
 
 }  // namespace remoting