Supply empty frames until codec is done with top-off.

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/logging.h"
 #include "base/sys_info.h"
 #include "remoting/base/util.h"
@@ skipping 248 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)
-        return nullptr;
-      topoff_frame_count_--;
-    } else {
-      topoff_frame_count_ = 2;
-    }
-  }
+  // If there is nothing to encode, and nothing to top-off, then return nothing.
+  if (frame.updated_region().is_empty() && !encode_unchanged_frame_)
+    return nullptr;
 
   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.
   webrtc::DesktopRegion updated_region;
   PrepareImage(frame, &updated_region);
 
   // Update active map based on updated region.
   SetActiveMapFromRegion(updated_region);
 
   // Apply active map to the encoder.
   vpx_active_map_t act_map;
-  act_map.rows = active_map_height_;
-  act_map.cols = active_map_width_;
+  act_map.rows = active_map_size_.height();
+  act_map.cols = active_map_size_.width();
   act_map.active_map = active_map_.get();
   if (vpx_codec_control(codec_.get(), VP8E_SET_ACTIVEMAP, &act_map)) {
     LOG(ERROR) << "Unable to apply active map";
   }
 
   // Do the actual encoding.
   int timestamp = (encode_start_time - timestamp_base_).InMilliseconds();
   vpx_codec_err_t ret = vpx_codec_encode(
       codec_.get(), image_.get(), timestamp, 1, 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 (use_vp9_ && !lossless_encode_) {
     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";
     UpdateRegionFromActiveMap(&updated_region);
+
+    // If the encoder output no changes then there's nothing left to top-off.
+    encode_unchanged_frame_ = !updated_region.is_empty();
   }
 
   // Read the encoded data.
   vpx_codec_iter_t iter = NULL;
   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.
   scoped_ptr<VideoPacket> packet(
       helper_.CreateVideoPacketWithUpdatedRegion(frame, updated_region));
@@ skipping 15 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) {
+VideoEncoderVpx::VideoEncoderVpx(bool use_vp9)
+    : use_vp9_(use_vp9), encode_unchanged_frame_(false) {
 }
 
 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_);
 
   // Initialize active map.
-  active_map_width_ = (size.width() + kMacroBlockSize - 1) / kMacroBlockSize;
-  active_map_height_ = (size.height() + kMacroBlockSize - 1) / kMacroBlockSize;
-  active_map_.reset(new uint8[active_map_width_ * active_map_height_]);
+  active_map_size_ = webrtc::DesktopSize(
+      (size.width() + kMacroBlockSize - 1) / kMacroBlockSize,
+      (size.height() + kMacroBlockSize - 1) / kMacroBlockSize);
+  active_map_.reset(
+      new uint8[active_map_size_.width() * active_map_size_.height()]);
 
   // 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();
     }
   }
@@ skipping 114 matching lines @@
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 void VideoEncoderVpx::SetActiveMapFromRegion(
     const webrtc::DesktopRegion& updated_region) {
   // Clear active map first.
-  memset(active_map_.get(), 0, active_map_width_ * active_map_height_);
+  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_width_);
-    DCHECK_LT(bottom, active_map_height_);
+    DCHECK_LT(right, active_map_size_.width());
+    DCHECK_LT(bottom, active_map_size_.height());
 
-    uint8* map = active_map_.get() + top * active_map_width_;
+    uint8* map = active_map_.get() + top * active_map_size_.width();
     for (int y = top; y <= bottom; ++y) {
       for (int x = left; x <= right; ++x)
         map[x] = 1;
-      map += active_map_width_;
+      map += active_map_size_.width();
     }
   }
 }
 
 void VideoEncoderVpx::UpdateRegionFromActiveMap(
     webrtc::DesktopRegion* updated_region) {
   const uint8* map = active_map_.get();
-  for (int y = 0; y < active_map_height_; ++y) {
-    for (int x0 = 0; x0 < active_map_width_;) {
+  for (int y = 0; y < active_map_size_.height(); ++y) {
+    for (int x0 = 0; x0 < active_map_size_.width();) {
       int x1 = x0;
-      for (; x1 < active_map_width_; ++x1) {
-        if (map[y * active_map_width_ + x1] == 0)
+      for (; x1 < active_map_size_.width(); ++x1) {
+        if (map[y * active_map_size_.width() + x1] == 0)
           break;
       }
       if (x1 > x0) {
         updated_region->AddRect(webrtc::DesktopRect::MakeLTRB(
             kMacroBlockSize * x0, kMacroBlockSize * y, kMacroBlockSize * x1,
             kMacroBlockSize * (y + 1)));
       }
       x0 = x1 + 1;
     }
   }
   updated_region->IntersectWith(
       webrtc::DesktopRect::MakeWH(image_->w, image_->h));
 }
 
 }  // namespace remoting