Renamed Encoder -> VideoEncoder.

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 "media/base/yuv_convert.h"
 #include "remoting/base/capture_data.h"
 #include "remoting/base/util.h"
 #include "remoting/proto/video.pb.h"
 
 extern "C" {
 #define VPX_CODEC_DISABLE_COMPAT 1
 #include "third_party/libvpx/libvpx.h"
 }
 
 namespace {
 
 // Defines the dimension of a macro block. This is used to compute the active
 // map for the encoder.
 const int kMacroBlockSize = 16;
 
 }  // namespace remoting
 
 namespace remoting {
 
-EncoderVp8::EncoderVp8()
+VideoEncoderVp8::VideoEncoderVp8()
     : initialized_(false),
       codec_(NULL),
       image_(NULL),
       active_map_width_(0),
       active_map_height_(0),
       last_timestamp_(0) {
 }
 
-EncoderVp8::~EncoderVp8() {
+VideoEncoderVp8::~VideoEncoderVp8() {
   Destroy();
 }
 
-void EncoderVp8::Destroy() {
+void VideoEncoderVp8::Destroy() {
   if (initialized_) {
     vpx_codec_err_t ret = vpx_codec_destroy(codec_.get());
     DCHECK(ret == VPX_CODEC_OK) << "Failed to destroy codec";
     initialized_ = false;
   }
 }
 
-bool EncoderVp8::Init(const SkISize& size) {
+bool VideoEncoderVp8::Init(const SkISize& 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 EncoderVp8::PrepareImage(scoped_refptr<CaptureData> capture_data,
-                              SkRegion* updated_region) {
+void VideoEncoderVp8::PrepareImage(scoped_refptr<CaptureData> capture_data,
+                                   SkRegion* updated_region) {
   // Perform RGB->YUV conversion.
   CHECK_EQ(capture_data->pixel_format(), media::VideoFrame::RGB32)
     << "Only RGB32 is supported";
 
   const SkRegion& region = capture_data->dirty_region();
   if (region.isEmpty()) {
     updated_region->setEmpty();
     return;
   }
 
@@ skipping 24 matching lines @@
   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,
         rect.x(), rect.y(), rect.width(), rect.height(),
         rgb_stride, y_stride, uv_stride);
   }
 }
 
-void EncoderVp8::PrepareActiveMap(const SkRegion& updated_region) {
+void VideoEncoderVp8::PrepareActiveMap(const SkRegion& 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();
     int left = rect.left() / kMacroBlockSize;
     int right = (rect.right() - 1) / kMacroBlockSize;
     int top = rect.top() / kMacroBlockSize;
     int bottom = (rect.bottom() - 1) / kMacroBlockSize;
     CHECK(right < active_map_width_);
     CHECK(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)
         map[x] = 1;
       map += active_map_width_;
     }
   }
 }
 
-void EncoderVp8::Encode(scoped_refptr<CaptureData> capture_data,
-                        bool key_frame,
-                        const DataAvailableCallback& data_available_callback) {
+void VideoEncoderVp8::Encode(
+    scoped_refptr<CaptureData> capture_data,
+    bool key_frame,
+    const DataAvailableCallback& data_available_callback) {
   DCHECK_LE(32, capture_data->size().width());
   DCHECK_LE(32, capture_data->size().height());
 
   if (!initialized_ ||
       (capture_data->size() != SkISize::Make(image_->w, image_->h))) {
     bool ret = Init(capture_data->size());
     // TODO(hclam): Handle error better.
     CHECK(ret) << "Initialization of encoder failed";
     initialized_ = ret;
   }
@@ skipping 69 matching lines @@
     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