Add WebrtcVideoEncoder 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 258 matching lines @@
     lossless_color_ = want_lossless;
     // TODO(wez): Switch to ConfigureCodec() path once libvpx supports it.
     // See https://code.google.com/p/webm/issues/detail?id=913.
     // if (codec_)
     //  Configure(webrtc::DesktopSize(codec_->config.enc->g_w,
     //                                codec_->config.enc->g_h));
     codec_.reset();
   }
 }
 
-void WebrtcVideoEncoderVpx::UpdateTargetBitrate(int new_bitrate_kbps) {
-  target_bitrate_kbps_ = new_bitrate_kbps;
-  // Configuration not initialized.
-  if (config_.g_timebase.den == 0)
-    return;
-
-  if (config_.rc_target_bitrate == static_cast<unsigned int>(new_bitrate_kbps))
-    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";
-}
-
-std::unique_ptr<VideoPacket> WebrtcVideoEncoderVpx::Encode(
+std::unique_ptr<WebrtcVideoEncoder::EncodedFrame> WebrtcVideoEncoderVpx::Encode(
     const webrtc::DesktopFrame& frame,
-    uint32_t flags) {
+    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_)
+  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);
+
   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);
 
     // Update active map based on updated region.
     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";
     }
   }
 
-  // Frame rate is adapted based on how well the encoder meets the target
-  // bandwidth requirement. We specify a target rate of 1 / 15 fps here.
-  // TODO(isheriff): Investigate if it makes sense to increase the target FPS.
   vpx_codec_err_t ret = vpx_codec_encode(
-      codec_.get(), image_.get(), 0, 66666,
-      (flags & REQUEST_KEY_FRAME) ? VPX_EFLAG_FORCE_KF : 0, VPX_DL_REALTIME);
+      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;
 
-  // TODO(hclam): Make sure we get exactly one frame from the packet.
-  // TODO(hclam): We should provide the output buffer to avoid one copy.
-  std::unique_ptr<VideoPacket> packet(
-      helper_.CreateVideoPacketWithUpdatedRegion(frame, updated_region));
-  packet->mutable_format()->set_encoding(VideoPacketFormat::ENCODING_VP8);
+  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;
-        packet->set_data(vpx_packet->data.frame.buf, vpx_packet->data.frame.sz);
-        packet->set_key_frame(vpx_packet->data.frame.flags & VPX_FRAME_IS_KEY);
+        // 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),
                  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 packet;
+  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;
 }
@@ skipping 49 matching lines @@
   }
 
   // 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;
+
+  // Configuration not initialized.
+  if (config_.g_timebase.den == 0)
+    return;
+
+  if (config_.rc_target_bitrate == static_cast<unsigned int>(new_bitrate_kbps))
+    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_) {
@@ skipping 111 matching lines @@
             kMacroBlockSize * (y + 1)));
       }
       x0 = x1 + 1;
     }
   }
   updated_region->IntersectWith(
       webrtc::DesktopRect::MakeWH(image_->w, image_->h));
 }
 
 }  // namespace remoting