Use webrtc::DesktopCapturer for screen capturer implementation.

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.h"
 #include "media/base/yuv_convert.h"
-#include "media/video/capture/screen/screen_capture_data.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"
 
 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 18 matching lines @@
 }
 
 void VideoEncoderVp8::Destroy() {
   if (initialized_) {
     vpx_codec_err_t ret = vpx_codec_destroy(codec_.get());
     DCHECK_EQ(ret, VPX_CODEC_OK) << "Failed to destroy codec";
     initialized_ = false;
   }
 }
 
-bool VideoEncoderVp8::Init(const SkISize& size) {
+bool VideoEncoderVp8::Init(const webrtc::DesktopSize& size) {
   Destroy();
   codec_.reset(new vpx_codec_ctx_t());
   image_.reset(new vpx_image_t());
   memset(image_.get(), 0, sizeof(vpx_image_t));
 
   image_->fmt = VPX_IMG_FMT_YV12;
 
   // libvpx seems to require both to be assigned.
   image_->d_w = size.width();
   image_->w = size.width();
@@ skipping 76 matching lines @@
   if (vpx_codec_control(codec_.get(), VP8E_SET_CPUUSED, 16))
     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(
-    scoped_refptr<media::ScreenCaptureData> capture_data,
-    SkRegion* updated_region) {
-  const SkRegion& region = capture_data->dirty_region();
-  if (region.isEmpty()) {
+void VideoEncoderVp8::PrepareImage(const webrtc::DesktopFrame* frame,
+                                   SkRegion* updated_region) {
+  if (frame->updated_region().is_empty()) {
     updated_region->setEmpty();
     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;
-  for (SkRegion::Iterator r(region); !r.done(); r.next()) {
-    aligned_rects.push_back(AlignRect(r.rect()));
+  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())));
   }
   DCHECK(!aligned_rects.empty());
   updated_region->setRects(&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);
 
   // Convert the updated region to YUV ready for encoding.
-  const uint8* rgb_data = capture_data->data();
-  const int rgb_stride = capture_data->stride();
+  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();
     ConvertRGB32ToYUVWithRect(
         rgb_data, y_data, u_data, v_data,
@@ skipping 19 matching lines @@
     uint8* map = active_map_.get() + top * active_map_width_;
     for (int y = top; y <= bottom; ++y) {
       for (int x = left; x <= right; ++x)
         map[x] = 1;
       map += active_map_width_;
     }
   }
 }
 
 void VideoEncoderVp8::Encode(
-    scoped_refptr<media::ScreenCaptureData> capture_data,
-    bool key_frame,
+    const webrtc::DesktopFrame* frame,
     const DataAvailableCallback& data_available_callback) {
-  DCHECK_LE(32, capture_data->size().width());
-  DCHECK_LE(32, capture_data->size().height());
+  DCHECK_LE(32, frame->size().width());
+  DCHECK_LE(32, frame->size().height());
 
   base::Time encode_start_time = base::Time::Now();
 
   if (!initialized_ ||
-      (capture_data->size() != SkISize::Make(image_->w, image_->h))) {
-    bool ret = Init(capture_data->size());
+      !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;
-  PrepareImage(capture_data, &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();
   if (vpx_codec_control(codec_.get(), VP8E_SET_ACTIVEMAP, &act_map)) {
@@ skipping 34 matching lines @@
         break;
       default:
         break;
     }
   }
 
   // Construct the VideoPacket message.
   packet->mutable_format()->set_encoding(VideoPacketFormat::ENCODING_VP8);
   packet->set_flags(VideoPacket::FIRST_PACKET | VideoPacket::LAST_PACKET |
                      VideoPacket::LAST_PARTITION);
-  packet->mutable_format()->set_screen_width(capture_data->size().width());
-  packet->mutable_format()->set_screen_height(capture_data->size().height());
-  packet->set_capture_time_ms(capture_data->capture_time_ms());
+  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());
-  packet->set_client_sequence_number(capture_data->client_sequence_number());
-  SkIPoint dpi(capture_data->dpi());
-  if (dpi.x())
-    packet->mutable_format()->set_x_dpi(dpi.x());
-  if (dpi.y())
-    packet->mutable_format()->set_y_dpi(dpi.y());
+  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()) {
     Rect* rect = packet->add_dirty_rects();
     rect->set_x(r.rect().x());
     rect->set_y(r.rect().y());
     rect->set_width(r.rect().width());
     rect->set_height(r.rect().height());
   }
 
   data_available_callback.Run(packet.Pass());
 }
 
 }  // namespace remoting