Remove dependency on Skia from chromoting client.

remoting/codec/video_encoder_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/codec/video_encoder_vp8.h"
 
 #include "base/logging.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
 #include "media/base/yuv_convert.h"
 #include "remoting/base/util.h"
 #include "remoting/proto/video.pb.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_region.h"
 
 extern "C" {
 #define VPX_CODEC_DISABLE_COMPAT 1
 #include "third_party/libvpx/source/libvpx/vpx/vpx_encoder.h"
 #include "third_party/libvpx/source/libvpx/vpx/vp8cx.h"
 }
 
 namespace {
 
 // Defines the dimension of a macro block. This is used to compute the active
@@ skipping 113 matching lines @@
     return false;
 
   // Use the lowest level of noise sensitivity so as to spend less time
   // on motion estimation and inter-prediction mode.
   if (vpx_codec_control(codec_.get(), VP8E_SET_NOISE_SENSITIVITY, 0))
     return false;
   return true;
 }
 
 void VideoEncoderVp8::PrepareImage(const webrtc::DesktopFrame& frame,
-                                   SkRegion* updated_region) {
+                                   webrtc::DesktopRegion* updated_region) {
   if (frame.updated_region().is_empty()) {
-    updated_region->setEmpty();
+    updated_region->Clear();
     return;
   }
 
   // Align the region to macroblocks, to avoid encoding artefacts.
   // This also ensures that all rectangles have even-aligned top-left, which
   // is required for ConvertRGBToYUVWithRect() to work.
-  std::vector<SkIRect> aligned_rects;
+  std::vector<webrtc::DesktopRect> aligned_rects;
   for (webrtc::DesktopRegion::Iterator r(frame.updated_region());
        !r.IsAtEnd(); r.Advance()) {
     const webrtc::DesktopRect& rect = r.rect();
-    aligned_rects.push_back(AlignRect(
-      SkIRect::MakeLTRB(rect.left(), rect.top(), rect.right(), rect.bottom())));
+    aligned_rects.push_back(AlignRect(webrtc::DesktopRect::MakeLTRB(
+        rect.left(), rect.top(), rect.right(), rect.bottom())));
   }
   DCHECK(!aligned_rects.empty());
-  updated_region->setRects(&aligned_rects[0], aligned_rects.size());
+  updated_region->Clear();
+  updated_region->AddRects(&aligned_rects[0], aligned_rects.size());
 
   // Clip back to the screen dimensions, in case they're not macroblock aligned.
   // The conversion routines don't require even width & height, so this is safe
   // even if the source dimensions are not even.
-  updated_region->op(SkIRect::MakeWH(image_->w, image_->h),
-                     SkRegion::kIntersect_Op);
+  updated_region->IntersectWith(
+      webrtc::DesktopRect::MakeWH(image_->w, image_->h));
 
   // Convert the updated region to YUV ready for encoding.
   const uint8* rgb_data = frame.data();
   const int rgb_stride = frame.stride();
   const int y_stride = image_->stride[0];
   DCHECK_EQ(image_->stride[1], image_->stride[2]);
   const int uv_stride = image_->stride[1];
   uint8* y_data = image_->planes[0];
   uint8* u_data = image_->planes[1];
   uint8* v_data = image_->planes[2];
-  for (SkRegion::Iterator r(*updated_region); !r.done(); r.next()) {
-    const SkIRect& rect = r.rect();
+  for (webrtc::DesktopRegion::Iterator r(*updated_region); !r.IsAtEnd();
+       r.Advance()) {
+    const webrtc::DesktopRect& rect = r.rect();
     ConvertRGB32ToYUVWithRect(
         rgb_data, y_data, u_data, v_data,
-        rect.x(), rect.y(), rect.width(), rect.height(),
+        rect.left(), rect.top(), rect.width(), rect.height(),
         rgb_stride, y_stride, uv_stride);
   }
 }
 
-void VideoEncoderVp8::PrepareActiveMap(const SkRegion& updated_region) {
+void VideoEncoderVp8::PrepareActiveMap(
+    const webrtc::DesktopRegion& updated_region) {
   // Clear active map first.
   memset(active_map_.get(), 0, active_map_width_ * active_map_height_);
 
   // Mark updated areas active.
-  for (SkRegion::Iterator r(updated_region); !r.done(); r.next()) {
-    const SkIRect& rect = r.rect();
+  for (webrtc::DesktopRegion::Iterator r(updated_region); !r.IsAtEnd();
+       r.Advance()) {
+    const webrtc::DesktopRect& rect = r.rect();
     int left = rect.left() / kMacroBlockSize;
     int right = (rect.right() - 1) / kMacroBlockSize;
     int top = rect.top() / kMacroBlockSize;
     int bottom = (rect.bottom() - 1) / kMacroBlockSize;
     DCHECK_LT(right, active_map_width_);
     DCHECK_LT(bottom, active_map_height_);
 
     uint8* map = active_map_.get() + top * active_map_width_;
     for (int y = top; y <= bottom; ++y) {
       for (int x = left; x <= right; ++x)
@@ skipping 12 matching lines @@
 
   if (!initialized_ ||
       !frame.size().equals(webrtc::DesktopSize(image_->w, image_->h))) {
     bool ret = Init(frame.size());
     // TODO(hclam): Handle error better.
     CHECK(ret) << "Initialization of encoder failed";
     initialized_ = ret;
   }
 
   // Convert the updated capture data ready for encode.
-  SkRegion updated_region;
+  webrtc::DesktopRegion updated_region;
   PrepareImage(frame, &updated_region);
 
   // Update active map based on updated region.
   PrepareActiveMap(updated_region);
 
   // Apply active map to the encoder.
   vpx_active_map_t act_map;
   act_map.rows = active_map_height_;
   act_map.cols = active_map_width_;
   act_map.active_map = active_map_.get();
@@ skipping 15 matching lines @@
 
   // Read the encoded data.
   vpx_codec_iter_t iter = NULL;
   bool got_data = false;
 
   // TODO(hclam): Make sure we get exactly one frame from the packet.
   // TODO(hclam): We should provide the output buffer to avoid one copy.
   scoped_ptr<VideoPacket> packet(new VideoPacket());
 
   while (!got_data) {
-    const vpx_codec_cx_pkt_t* vpx_packet = vpx_codec_get_cx_data(codec_.get(),
-                                                                 &iter);
+    const vpx_codec_cx_pkt_t* vpx_packet =
+        vpx_codec_get_cx_data(codec_.get(), &iter);
     if (!vpx_packet)
       continue;
 
     switch (vpx_packet->kind) {
       case VPX_CODEC_CX_FRAME_PKT:
         got_data = true;
         // TODO(sergeyu): Split each frame into multiple partitions.
         packet->set_data(vpx_packet->data.frame.buf, vpx_packet->data.frame.sz);
         break;
       default:
         break;
     }
   }
 
   // Construct the VideoPacket message.
   packet->mutable_format()->set_encoding(VideoPacketFormat::ENCODING_VP8);
   packet->mutable_format()->set_screen_width(frame.size().width());
   packet->mutable_format()->set_screen_height(frame.size().height());
   packet->set_capture_time_ms(frame.capture_time_ms());
   packet->set_encode_time_ms(
       (base::Time::Now() - encode_start_time).InMillisecondsRoundedUp());
   if (!frame.dpi().is_zero()) {
     packet->mutable_format()->set_x_dpi(frame.dpi().x());
     packet->mutable_format()->set_y_dpi(frame.dpi().y());
   }
-  for (SkRegion::Iterator r(updated_region); !r.done(); r.next()) {
+  for (webrtc::DesktopRegion::Iterator r(updated_region); !r.IsAtEnd();
+       r.Advance()) {
     Rect* rect = packet->add_dirty_rects();
-    rect->set_x(r.rect().x());
-    rect->set_y(r.rect().y());
+    rect->set_x(r.rect().left());
+    rect->set_y(r.rect().top());
     rect->set_width(r.rect().width());
     rect->set_height(r.rect().height());
   }
 
   return packet.Pass();
 }
 
 }  // namespace remoting