Add WebrtcCaptureScheduler interface.

remoting/codec/webrtc_video_encoder_vpx.cc

 // Copyright 2016 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/webrtc_video_encoder_vpx.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 26 matching lines @@
 // Magic encoder profile numbers for I420 and I444 input formats.
 const int kVp9I420ProfileNumber = 0;
 const int kVp9I444ProfileNumber = 1;
 
 // Magic encoder constants for adaptive quantization strategy.
 const int kVp9AqModeNone = 0;
 const int kVp9AqModeCyclicRefresh = 3;
 
 const int kDefaultTargetBitrateKbps = 1000;
 
-// Target quantizer at which stop the encoding top-off.
-const int kTargetQuantizerForVp8TopOff = 30;
-
 void SetCommonCodecParameters(vpx_codec_enc_cfg_t* config,
                               const webrtc::DesktopSize& size) {
   // Use millisecond granularity time base.
   config->g_timebase.num = 1;
   config->g_timebase.den = base::Time::kMicrosecondsPerSecond;
 
   config->g_w = size.width();
   config->g_h = size.height();
   config->g_pass = VPX_RC_ONE_PASS;
 
@@ skipping 215 matching lines @@
     codec_.reset();
   }
 }
 
 std::unique_ptr<WebrtcVideoEncoder::EncodedFrame> WebrtcVideoEncoderVpx::Encode(
     const webrtc::DesktopFrame& frame,
     const FrameParams& params) {
   DCHECK_LE(32, frame.size().width());
   DCHECK_LE(32, frame.size().height());
 
-  // Based on information fetching active map, we return here if there is
-  // nothing to top-off.
-  if (frame.updated_region().is_empty() && !encode_unchanged_frame_ &&
-      !params.key_frame) {
-    return nullptr;
-  }
-
   // Create or reconfigure the codec to match the size of |frame|.
   if (!codec_ ||
       (image_ &&
        !frame.size().equals(webrtc::DesktopSize(image_->w, image_->h)))) {
     Configure(frame.size());
   }
 
-  UpdateTargetBitrate(params.bitrate_kbps);
+  UpdateConfig(params);
 
   vpx_active_map_t act_map;
   act_map.rows = active_map_size_.height();
   act_map.cols = active_map_size_.width();
   act_map.active_map = active_map_.get();
 
   webrtc::DesktopRegion updated_region;
-  if (!frame.updated_region().is_empty()) {
-    // Convert the updated capture data ready for encode.
-    PrepareImage(frame, &updated_region);
+  // Convert the updated capture data ready for encode.
+  PrepareImage(frame, &updated_region);
 
-    // Update active map based on updated region.
-    SetActiveMapFromRegion(updated_region);
+  // Update active map based on updated region.
+  if (params.clear_active_map)
+    ClearActiveMap();
+  SetActiveMapFromRegion(updated_region);
 
-    // Apply active map to the encoder.
-
-    if (vpx_codec_control(codec_.get(), VP8E_SET_ACTIVEMAP, &act_map)) {
-      LOG(ERROR) << "Unable to apply active map";
-    }
+  // Apply active map to the encoder.
+  if (vpx_codec_control(codec_.get(), VP8E_SET_ACTIVEMAP, &act_map)) {
+    LOG(ERROR) << "Unable to apply active map";
   }
 
   vpx_codec_err_t ret = vpx_codec_encode(
       codec_.get(), image_.get(), 0, params.duration.InMicroseconds(),
       (params.key_frame) ? VPX_EFLAG_FORCE_KF : 0, VPX_DL_REALTIME);
   DCHECK_EQ(ret, VPX_CODEC_OK)
       << "Encoding error: " << vpx_codec_err_to_string(ret) << "\n"
       << "Details: " << vpx_codec_error(codec_.get()) << "\n"
       << vpx_codec_error_detail(codec_.get());
 
   if (!lossless_encode_) {
     // VP8 doesn't return active map, so we assume it's the same on the output
     // as on the input.
     if (use_vp9_) {
       ret = vpx_codec_control(codec_.get(), VP9E_GET_ACTIVEMAP, &act_map);
       DCHECK_EQ(ret, VPX_CODEC_OK)
           << "Failed to fetch active map: " << vpx_codec_err_to_string(ret)
           << "\n";
-
-      // If the encoder output no changes then there's nothing left to top-off.
-      encode_unchanged_frame_ = !updated_region.is_empty();
-    } else {
-      // Always set |encode_unchanged_frame_| when using VP8. It will be reset
-      // below once the target quantizer value is reached.
-      encode_unchanged_frame_ = true;
     }
 
     UpdateRegionFromActiveMap(&updated_region);
   }
 
   // Read the encoded data.
   vpx_codec_iter_t iter = nullptr;
   bool got_data = false;
 
   std::unique_ptr<EncodedFrame> encoded_frame(new EncodedFrame());
   encoded_frame->size = frame.size();
 
   while (!got_data) {
     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): Avoid copying the data here..
         encoded_frame->data.assign(
             reinterpret_cast<const char*>(vpx_packet->data.frame.buf),
             vpx_packet->data.frame.sz);
         encoded_frame->key_frame =
             vpx_packet->data.frame.flags & VPX_FRAME_IS_KEY;
-        int quantizer = -1;
         CHECK_EQ(vpx_codec_control(codec_.get(), VP8E_GET_LAST_QUANTIZER_64,
-                                   &quantizer),
+                                   &(encoded_frame->quantizer)),
                  VPX_CODEC_OK);
-        // VP8: Stop top-off as soon as the target quantizer value is reached.
-        if (!use_vp9_ && quantizer <= kTargetQuantizerForVp8TopOff)
-          encode_unchanged_frame_ = false;
         break;
       }
       default:
         break;
     }
   }
 
   return encoded_frame;
 }
 
 WebrtcVideoEncoderVpx::WebrtcVideoEncoderVpx(bool use_vp9)
     : use_vp9_(use_vp9),
-      target_bitrate_kbps_(kDefaultTargetBitrateKbps),
-      encode_unchanged_frame_(false),
       clock_(&default_tick_clock_) {
   // Indicates config is still uninitialized.
   config_.g_timebase.den = 0;
 }
 
 void WebrtcVideoEncoderVpx::Configure(const webrtc::DesktopSize& size) {
   DCHECK(use_vp9_ || !lossless_color_);
   DCHECK(use_vp9_ || !lossless_encode_);
 
   // Tear down |image_| if it no longer matches the size and color settings.
   // PrepareImage() will then create a new buffer of the required dimensions if
   // |image_| is not allocated.
   FreeImageIfMismatched(lossless_color_, size, &image_, &image_buffer_);
 
   // Initialize active map.
   active_map_size_ = webrtc::DesktopSize(
       (size.width() + kMacroBlockSize - 1) / kMacroBlockSize,
       (size.height() + kMacroBlockSize - 1) / kMacroBlockSize);
   active_map_.reset(
       new uint8_t[active_map_size_.width() * active_map_size_.height()]);
+  ClearActiveMap();
 
   // TODO(wez): Remove this hack once VPX can handle frame size reconfiguration.
   // See https://code.google.com/p/webm/issues/detail?id=912.
   if (codec_) {
     // If the frame size has changed then force re-creation of the codec.
     if (codec_->config.enc->g_w != static_cast<unsigned int>(size.width()) ||
         codec_->config.enc->g_h != static_cast<unsigned int>(size.height())) {
       codec_.reset();
     }
   }
 
   // Fetch a default configuration for the desired codec.
   const vpx_codec_iface_t* interface =
       use_vp9_ ? vpx_codec_vp9_cx() : vpx_codec_vp8_cx();
   vpx_codec_err_t ret = vpx_codec_enc_config_default(interface, &config_, 0);
   DCHECK_EQ(VPX_CODEC_OK, ret) << "Failed to fetch default configuration";
 
   // Customize the default configuration to our needs.
   if (use_vp9_) {
     SetVp9CodecParameters(&config_, size, lossless_color_, lossless_encode_);
   } else {
     SetVp8CodecParameters(&config_, size);
   }
-  config_.rc_target_bitrate = target_bitrate_kbps_;
+
+  config_.rc_target_bitrate = kDefaultTargetBitrateKbps;
 
   // Initialize or re-configure the codec with the custom configuration.
   if (!codec_) {
     codec_.reset(new vpx_codec_ctx_t);
     ret = vpx_codec_enc_init(codec_.get(), interface, &config_, 0);
     CHECK_EQ(VPX_CODEC_OK, ret) << "Failed to initialize codec";
   } else {
     ret = vpx_codec_enc_config_set(codec_.get(), &config_);
     CHECK_EQ(VPX_CODEC_OK, ret) << "Failed to reconfigure codec";
   }
 
   // Apply further customizations to the codec now it's initialized.
   if (use_vp9_) {
     SetVp9CodecOptions(codec_.get(), lossless_encode_);
   } else {
     SetVp8CodecOptions(codec_.get());
   }
 }
 
-void WebrtcVideoEncoderVpx::UpdateTargetBitrate(int new_bitrate_kbps) {
-  target_bitrate_kbps_ = new_bitrate_kbps;
-
+void WebrtcVideoEncoderVpx::UpdateConfig(const FrameParams& params) {
   // Configuration not initialized.
   if (config_.g_timebase.den == 0)
     return;
 
-  if (config_.rc_target_bitrate == static_cast<unsigned int>(new_bitrate_kbps))
+  bool changed = false;
+
+  if (params.bitrate_kbps >= 0 &&
+      config_.rc_target_bitrate !=
+          static_cast<unsigned int>(params.bitrate_kbps)) {
+    config_.rc_target_bitrate = params.bitrate_kbps;
+    changed = true;
+  }
+
+  if (params.vpx_min_quantizer >= 0 &&
+      config_.rc_min_quantizer !=
+          static_cast<unsigned int>(params.vpx_min_quantizer)) {
+    config_.rc_min_quantizer = params.vpx_min_quantizer;
+    changed = true;
+  }
+
+  if (params.vpx_max_quantizer >= 0 &&
+      config_.rc_max_quantizer !=
+          static_cast<unsigned int>(params.vpx_max_quantizer)) {
+    config_.rc_max_quantizer = params.vpx_max_quantizer;
+    changed = true;
+  }
+
+  if (!changed)
     return;
-  config_.rc_target_bitrate = new_bitrate_kbps;
 
   // Update encoder context.
   if (vpx_codec_enc_config_set(codec_.get(), &config_))
     NOTREACHED() << "Unable to set encoder config";
 
-  VLOG(1) << "New rc_target_bitrate: " << new_bitrate_kbps << " kbps";
 }
 
 void WebrtcVideoEncoderVpx::PrepareImage(
     const webrtc::DesktopFrame& frame,
     webrtc::DesktopRegion* updated_region) {
   if (frame.updated_region().is_empty()) {
     updated_region->Clear();
     return;
   }
 
   updated_region->Clear();
   if (image_) {
-    // Pad each rectangle to avoid the block-artefact filters in libvpx from
-    // introducing artefacts; VP9 includes up to 8px either side, and VP8 up to
+    // Pad each rectangle to avoid the block-artifact filters in libvpx from
+    // introducing artifacts; VP9 includes up to 8px either side, and VP8 up to
     // 3px, so unchanged pixels up to that far out may still be affected by the
     // changes in the updated region, and so must be listed in the active map.
     // After padding we align each rectangle to 16x16 active-map macroblocks.
     // This implicitly ensures all rects have even top-left coords, which is
     // is required by ConvertRGBToYUVWithRect().
     // TODO(wez): Do we still need 16x16 align, or is even alignment sufficient?
     int padding = use_vp9_ ? 8 : 3;
     for (webrtc::DesktopRegion::Iterator r(frame.updated_region());
          !r.IsAtEnd(); r.Advance()) {
       const webrtc::DesktopRect& rect = r.rect();
@@ skipping 50 matching lines @@
                            v_data + uv_offset, uv_stride, rect.width(),
                            rect.height());
       }
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
+void WebrtcVideoEncoderVpx::ClearActiveMap() {
+  // Clear active map first.

[Irfan, 2016/09/14 20:01:29]

DCHECK(active_map_) ?

[Sergey Ulanov, 2016/09/16 00:02:47]

Done.

+  memset(active_map_.get(), 0,
+         active_map_size_.width() * active_map_size_.height());
+}
+
 void WebrtcVideoEncoderVpx::SetActiveMapFromRegion(
     const webrtc::DesktopRegion& updated_region) {
-  // Clear active map first.
-  memset(active_map_.get(), 0,
-         active_map_size_.width() * active_map_size_.height());
-
   // Mark updated areas active.
   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_size_.width());
     DCHECK_LT(bottom, active_map_size_.height());
@@ skipping 23 matching lines @@
             kMacroBlockSize * (y + 1)));
       }
       x0 = x1 + 1;
     }
   }
   updated_region->IntersectWith(
       webrtc::DesktopRect::MakeWH(image_->w, image_->h));
 }
 
 }  // namespace remoting