Update VideoFramePump to pass un-changed frames to encoders.

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 55 matching lines @@
   // Configure VP9 for I420 or I444 source frames.
   config->g_profile =
       lossless_color ? kVp9I444ProfileNumber : kVp9I420ProfileNumber;
 
   if (lossless_encode) {
     // Disable quantization entirely, putting the encoder in "lossless" mode.
     config->rc_min_quantizer = 0;
     config->rc_max_quantizer = 0;
     config->rc_end_usage = VPX_VBR;
   } else {
-    config->rc_min_quantizer = 4;
+    // TODO(wez): Set quantization range to 4-40, once the libvpx encoder is
+    // updated not to output any bits if nothing needs topping-off.
+    config->rc_min_quantizer = 20;
     config->rc_max_quantizer = 30;
     config->rc_end_usage = VPX_CBR;
     // In the absence of a good bandwidth estimator set the target bitrate to a
     // conservative default.
     config->rc_target_bitrate = 500;
   }
 }
 
 void SetVp8CodecOptions(vpx_codec_ctx_t* codec) {
   // CPUUSED of 16 will have the smallest CPU load. This turns off sub-pixel
@@ skipping 144 matching lines @@
     //                                codec_->config.enc->g_h));
     codec_.reset();
   }
 }
 
 scoped_ptr<VideoPacket> VideoEncoderVpx::Encode(
     const webrtc::DesktopFrame& frame) {
   DCHECK_LE(32, frame.size().width());
   DCHECK_LE(32, frame.size().height());
 
+  if (!use_vp9_ || lossless_encode_) {
+    // Neither VP8 nor VP9-lossless support top-off, so ignore unchanged frames.
+    if (frame.updated_region().is_empty())
+      return nullptr;
+  } else {
+    // Let VP9-lossy mode top-off, by continuing to pass it unchanged frames
+    // for a short while.
+    if (frame.updated_region().is_empty()) {
+      if (topoff_frame_count_ > 0) {

[Sergey Ulanov, 2015/06/06 00:19:58]

nit: might be more readable if you handle the return case first:
  if (topoff_frame_count == 0)
    return nullptr;
  topoff_frame_count--;

[Sergey Ulanov, 2015/06/09 05:32:43]

not addressed in the last patch set.

[Wez, 2015/06/09 22:00:37]

Done.

+        topoff_frame_count_--;
+      } else {
+        return nullptr;
+      }
+    } else {
+      topoff_frame_count_ = 2;
+    }
+  }
+
   base::TimeTicks encode_start_time = base::TimeTicks::Now();
 
   // 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());
   }
 
   // Convert the updated capture data ready for encode.
@@ skipping 56 matching lines @@
   }
 
   // Note the time taken to encode the pixel data.
   packet->set_encode_time_ms(
       (base::TimeTicks::Now() - encode_start_time).InMillisecondsRoundedUp());
 
   return packet.Pass();
 }
 
 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 I444 colour space, by default, if specified on the command-line.
-    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-            kEnableI444SwitchName)) {
-      SetLosslessColor(true);
-    }
-  }
+    : use_vp9_(use_vp9) {
 }
 
 void VideoEncoderVpx::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_);
@@ skipping 174 matching lines @@
             kMacroBlockSize * (y + 1)));
       }
       x0 = x1 + 1;
     }
   }
   updated_region->IntersectWith(
       webrtc::DesktopRect::MakeWH(image_->w, image_->h));
 }
 
 }  // namespace remoting