MediaRecorder: produce keyframes more often

content/renderer/media/video_track_recorder.cc

 // Copyright 2015 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 "content/renderer/media/video_track_recorder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 308 matching lines @@
   // frame rate or to e.g. microseconds.
   codec_config_.g_timebase.num = 1;
   codec_config_.g_timebase.den = base::Time::kMicrosecondsPerSecond;
 
   // Let the encoder decide where to place the Keyframes, between min and max.
   // In VPX_KF_AUTO mode libvpx will sometimes emit keyframes regardless of min/
   // max distance out of necessity.
   // Note that due to http://crbug.com/440223, it might be necessary to force a
   // key frame after 10,000frames since decoding fails after 30,000 non-key
   // frames.
+  // Forcing a keyframe in regular intervals also allows seeking in the
+  // resulting recording with decent performance.
   codec_config_.kf_mode = VPX_KF_AUTO;
   codec_config_.kf_min_dist = 0;
-  codec_config_.kf_max_dist = 30000;
+  codec_config_.kf_max_dist = 100;

[miu, 2016/03/11 20:04:36]

It seems that your goal is to generate a key frame once every 3 seconds of
video.  Adjusting this here will only work if the actual frame rate is near 30
FPS.

Instead of making this change here, I'd suggest adding some simple logic to
EncodeOnEncodingThread() to force a KF after 3 seconds have elapsed on the video
timeline.  Something like:

  // Force a key frame for every three seconds of video.  This is to allow video
players to efficiently seek around in the video stream.
  bool force_key_frame = false;
  if (last_key_frame_at_timestamp_.is_null() ||
      ((video_frame->timestamp() - last_key_frame_at_timestamp_) >
base::TimeDelta::FromSeconds(3)) {
    force_key_frame = true;
  }

  ...

  const vpx_codec_err_t ret = vpx_codec_encode(
      encoder_.get(), &vpx_image, 0  /* pts */, duration.InMicroseconds(),
      force_key_frame ? VPX_EFLAG_FORCE_KF : kNoFlags, VPX_DL_REALTIME);

  ...

  while ((pkt = vpx_codec_get_cx_data(...)) {
    ...
  }

  if (keyframe)
    last_key_frame_at_timestamp_ = video_frame->timestamp();

[thembrown, 2016/03/11 20:32:51]

My goal was mainly to introduce a upper bound for the number of frames that need
to be decoded when seeking. So it'd have to decode at most 100 frames (~ 3sec @
30fps, or 20 sec @ 5fps). For that purpose I don't see the advantage of
producing keyframes in a fixed time-interval instead, as the presentation
timestamps should not have any impact on decoding performance. A fixed
time-interval between keyframes would work too, but might produce more keyframes
than necessary at low frame rates.
What do you think?
(Firefox produces keyframes at fixed time-intervals IIRC.)

[miu, 2016/03/12 02:01:28]

SGTM.

 
   // Do not saturate CPU utilization just for encoding. On a lower-end system
   // with only 1 or 2 cores, use only one thread for encoding. On systems with
   // more cores, allow half of the cores to be used for encoding.
   codec_config_.g_threads =
       std::min(8, (base::SysInfo::NumberOfProcessors() + 1) / 2);
 
   // Number of frames to consume before producing output.
   codec_config_.g_lag_in_frames = 0;
 
@@ skipping 71 matching lines @@
   encoder_->set_paused(false);
 }
 
 void VideoTrackRecorder::OnVideoFrameForTesting(
     const scoped_refptr<media::VideoFrame>& frame,
     base::TimeTicks timestamp) {
   encoder_->StartFrameEncode(frame, timestamp);
 }
 
 }  // namespace content