Extend VideoControl to allow clients to request lossless modes.

remoting/codec/video_encoder_vpx.cc

 // Copyright 2013 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_vpx.h"
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/logging.h"
 #include "base/sys_info.h"
 #include "remoting/base/util.h"
 #include "remoting/proto/video.pb.h"
 #include "third_party/libyuv/include/libyuv/convert_from_argb.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 remoting {
 
 namespace {
 
+// Name of command-line flag to enable VP9 to use I444 by default.
+const char kEnableI444SwitchName[] = "enable-i444";
+
 // Number of bytes in an RGBx pixel.
 const int kBytesPerRgbPixel = 4;
 
 // Defines the dimension of a macro block. This is used to compute the active
 // map for the encoder.
 const int kMacroBlockSize = 16;
 
 // Magic encoder profile numbers for I420 and I444 input formats.
 const int kVp9I420ProfileNumber = 0;
 const int kVp9I444ProfileNumber = 1;
@@ skipping 53 matching lines @@
     return ScopedVpxCodec();
 
   // 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 ScopedVpxCodec();
 
   return codec.Pass();
 }
 
-ScopedVpxCodec CreateVP9Codec(bool use_i444, const webrtc::DesktopSize& size) {
+ScopedVpxCodec CreateVP9Codec(const webrtc::DesktopSize& size,
+                              bool use_i444,

[Jamie, 2014/05/29 22:19:41]

Is i444 the same as lossless colour? Since that's what you've called it in the
public method, it would be better to be consistent here if it's the same thing.

[Wez, 2014/05/29 22:39:26]

Done.

+                              bool lossless_encode) {
   ScopedVpxCodec codec(new vpx_codec_ctx_t);
 
   // Configure the encoder.
   vpx_codec_enc_cfg_t config;
   const vpx_codec_iface_t* algo = vpx_codec_vp9_cx();
   CHECK(algo);
   vpx_codec_err_t ret = vpx_codec_enc_config_default(algo, &config, 0);
   if (ret != VPX_CODEC_OK)
     return ScopedVpxCodec();
 
   SetCommonCodecParameters(size, &config);
 
   // Configure VP9 for I420 or I444 source frames.
   config.g_profile = use_i444 ? kVp9I444ProfileNumber : kVp9I420ProfileNumber;
 
-  // Disable quantization entirely, putting the encoder in "lossless" mode.
-  config.rc_min_quantizer = 0;
-  config.rc_max_quantizer = 0;
+  if (lossless_encode) {
+    // Disable quantization entirely, putting the encoder in "lossless" mode.
+    config.rc_min_quantizer = 0;
+    config.rc_max_quantizer = 0;
+  } else {
+    // Lossy encode using the same settings as for VP8.
+    config.rc_min_quantizer = 20;
+    config.rc_max_quantizer = 30;
+  }
 
   if (vpx_codec_enc_init(codec.get(), algo, &config, 0))
     return ScopedVpxCodec();
 
   // VP9 encode doesn't yet support Realtime, so falls back to Good quality,
   // for which 4 is the lowest CPU usage.
   // Note that this is configured via the same parameter as for VP8.
   if (vpx_codec_control(codec.get(), VP8E_SET_CPUUSED, 4))
     return ScopedVpxCodec();
 
@@ skipping 66 matching lines @@
   image->stride[2] = uv_stride;
 
   *out_image = image.Pass();
   *out_image_buffer = image_buffer.Pass();
 }
 
 } // namespace
 
 // static
 scoped_ptr<VideoEncoderVpx> VideoEncoderVpx::CreateForVP8() {
-  return scoped_ptr<VideoEncoderVpx>(
-      new VideoEncoderVpx(base::Bind(&CreateVP8Codec),
-                          base::Bind(&CreateImage, false)));
+  return scoped_ptr<VideoEncoderVpx>(new VideoEncoderVpx(false));
 }
 
 // static
-scoped_ptr<VideoEncoderVpx> VideoEncoderVpx::CreateForVP9I420() {
-  return scoped_ptr<VideoEncoderVpx>(
-      new VideoEncoderVpx(base::Bind(&CreateVP9Codec, false),
-                          base::Bind(&CreateImage, false)));
-}
-
-// static
-scoped_ptr<VideoEncoderVpx> VideoEncoderVpx::CreateForVP9I444() {
-  return scoped_ptr<VideoEncoderVpx>(
-      new VideoEncoderVpx(base::Bind(&CreateVP9Codec, true),
-                          base::Bind(&CreateImage, true)));
+scoped_ptr<VideoEncoderVpx> VideoEncoderVpx::CreateForVP9() {
+  return scoped_ptr<VideoEncoderVpx>(new VideoEncoderVpx(true));
 }
 
 VideoEncoderVpx::~VideoEncoderVpx() {}
 
+void VideoEncoderVpx::SetLosslessEncode(bool want_lossless) {
+  if (use_vp9_ && (want_lossless != lossless_encode_)) {
+    lossless_encode_ = want_lossless;
+    codec_.reset(); // Force encoder re-initialization.
+  }
+}
+
+void VideoEncoderVpx::SetLosslessColor(bool want_lossless) {
+  if (use_vp9_ && (want_lossless != lossless_color_)) {
+    lossless_color_ = want_lossless;
+    codec_.reset(); // Force encoder re-initialization.
+  }
+}
+
 scoped_ptr<VideoPacket> VideoEncoderVpx::Encode(
     const webrtc::DesktopFrame& frame) {
   DCHECK_LE(32, frame.size().width());
   DCHECK_LE(32, frame.size().height());
 
   base::TimeTicks encode_start_time = base::TimeTicks::Now();
 
   if (!codec_ ||
       !frame.size().equals(webrtc::DesktopSize(image_->w, image_->h))) {
     bool ret = Initialize(frame.size());
@@ skipping 69 matching lines @@
     Rect* rect = packet->add_dirty_rects();
     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();
 }
 
-VideoEncoderVpx::VideoEncoderVpx(const CreateCodecCallback& create_codec,
-                                 const CreateImageCallback& create_image)
-    : create_codec_(create_codec),
-      create_image_(create_image),
+VideoEncoderVpx::VideoEncoderVpx(bool use_vp9)
+    : use_vp9_(use_vp9),
+      lossless_encode_(false),
+      lossless_color_(false),
       active_map_width_(0),
       active_map_height_(0) {
+  if (use_vp9_) {
+    // Use lossless encoding mode by default.
+    SetLosslessEncode(true);
+
+    // Use I444 colour space, by default, if specified on the command-line.
+    if (CommandLine::ForCurrentProcess()->HasSwitch(kEnableI444SwitchName)) {
+      SetLosslessColor(true);
+    }
+  }
 }
 
 bool VideoEncoderVpx::Initialize(const webrtc::DesktopSize& size) {
+  DCHECK(use_vp9_ || !lossless_color_);
+  DCHECK(use_vp9_ || !lossless_encode_);
+
   codec_.reset();
 
   // (Re)Create the VPX image structure and pixel buffer.
-  create_image_.Run(size, &image_, &image_buffer_);
+  CreateImage(lossless_color_, size, &image_, &image_buffer_);
 
   // Initialize active map.
   active_map_width_ = (image_->w + kMacroBlockSize - 1) / kMacroBlockSize;
   active_map_height_ = (image_->h + kMacroBlockSize - 1) / kMacroBlockSize;
   active_map_.reset(new uint8[active_map_width_ * active_map_height_]);
 
   // (Re)Initialize the codec.
-  codec_ = create_codec_.Run(size);
+  if (use_vp9_) {
+    codec_ = CreateVP9Codec(size, lossless_color_, lossless_encode_);
+  } else {
+    codec_ = CreateVP8Codec(size);
+  }
 
   return codec_;
 }
 
 void VideoEncoderVpx::PrepareImage(const webrtc::DesktopFrame& frame,
                                    webrtc::DesktopRegion* updated_region) {
   if (frame.updated_region().is_empty()) {
     updated_region->Clear();
     return;
   }
@@ skipping 83 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_;
     }
   }
 }
 
 }  // namespace remoting