Reduce VT keyframe frequency.

webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  *
  */
@@ skipping 447 matching lines @@
                                  kVTCompressionPropertyKey_AllowFrameReordering,
                                  false);
   SetEncoderBitrateBps(target_bitrate_bps_);
   // TODO(tkchin): Look at entropy mode and colorspace matrices.
   // TODO(tkchin): Investigate to see if there's any way to make this work.
   // May need it to interop with Android. Currently this call just fails.
   // On inspecting encoder output on iOS8, this value is set to 6.
   // internal::SetVTSessionProperty(compression_session_,
   //     kVTCompressionPropertyKey_MaxFrameDelayCount,
   //     1);
-  // TODO(tkchin): See if enforcing keyframe frequency is beneficial in any
-  // way.
-  // internal::SetVTSessionProperty(
-  //     compression_session_,
-  //     kVTCompressionPropertyKey_MaxKeyFrameInterval, 240);
-  // internal::SetVTSessionProperty(
-  //     compression_session_,
-  //     kVTCompressionPropertyKey_MaxKeyFrameIntervalDuration, 240);
+
+  // Set a relatively large value for keyframe emission (7200 frames or
+  // 4 minutes).
+  internal::SetVTSessionProperty(
+      compression_session_,
+      kVTCompressionPropertyKey_MaxKeyFrameInterval, 7200);

[mflodman, 2016/06/02 05:09:35]

Good to have the same on both intervals, in case of 30 fps that is of course.

+  internal::SetVTSessionProperty(
+      compression_session_,
+      kVTCompressionPropertyKey_MaxKeyFrameIntervalDuration, 240);
 }
 
 void H264VideoToolboxEncoder::DestroyCompressionSession() {
   if (compression_session_) {
     VTCompressionSessionInvalidate(compression_session_);
     CFRelease(compression_session_);
     compression_session_ = nullptr;
   }
 }
 
 const char* H264VideoToolboxEncoder::ImplementationName() const {
   return "VideoToolbox";
 }
 
 void H264VideoToolboxEncoder::SetBitrateBps(uint32_t bitrate_bps) {
   if (encoder_bitrate_bps_ != bitrate_bps) {
     SetEncoderBitrateBps(bitrate_bps);
   }
 }
 
 void H264VideoToolboxEncoder::SetEncoderBitrateBps(uint32_t bitrate_bps) {
   if (compression_session_) {
     internal::SetVTSessionProperty(compression_session_,
                                    kVTCompressionPropertyKey_AverageBitRate,
                                    bitrate_bps);
+
+    // TODO(tkchin): Add a helper method to set array value.
+    int64_t bytes_per_second_value = bitrate_bps / 8;
+    CFNumberRef bytes_per_second =
+        CFNumberCreate(kCFAllocatorDefault,
+                       kCFNumberSInt64Type,
+                       &bytes_per_second_value);
+    int64_t one_second_value = 1;
+    CFNumberRef one_second =
+        CFNumberCreate(kCFAllocatorDefault,
+                       kCFNumberSInt64Type,
+                       &one_second_value);
+    const void* nums[2] = { bytes_per_second, one_second };
+    CFArrayRef data_rate_limits =
+        CFArrayCreate(nullptr, nums, 2, &kCFTypeArrayCallBacks);
+    OSStatus status =
+        VTSessionSetProperty(compression_session_,
+                             kVTCompressionPropertyKey_DataRateLimits,

[mflodman, 2016/06/02 05:09:35]

I didn't see any good documentation around this, but this might solve a few of
the issues we've been seeing. So seems like a great change!

+                             data_rate_limits);
+    if (bytes_per_second) {
+      CFRelease(bytes_per_second);
+    }
+    if (one_second) {
+      CFRelease(one_second);
+    }
+    if (data_rate_limits) {
+      CFRelease(data_rate_limits);
+    }
+    if (status != noErr) {
+      LOG(LS_ERROR) << "Failed to set data rate limit";
+    }
+
     encoder_bitrate_bps_ = bitrate_bps;
   }
 }
 
 void H264VideoToolboxEncoder::OnEncodedFrame(
     OSStatus status,
     VTEncodeInfoFlags info_flags,
     CMSampleBufferRef sample_buffer,
     CodecSpecificInfo codec_specific_info,
     int32_t width,
@@ skipping 15 matching lines @@
   bool is_keyframe = false;
   CFArrayRef attachments =
       CMSampleBufferGetSampleAttachmentsArray(sample_buffer, 0);
   if (attachments != nullptr && CFArrayGetCount(attachments)) {
     CFDictionaryRef attachment =
         static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(attachments, 0));
     is_keyframe =
         !CFDictionaryContainsKey(attachment, kCMSampleAttachmentKey_NotSync);
   }
 
+  if (is_keyframe) {
+    LOG(LS_INFO) << "Generated keyframe";
+  }
+
   // Convert the sample buffer into a buffer suitable for RTP packetization.
   // TODO(tkchin): Allocate buffers through a pool.
   std::unique_ptr<rtc::Buffer> buffer(new rtc::Buffer());
   std::unique_ptr<webrtc::RTPFragmentationHeader> header;
   {
     webrtc::RTPFragmentationHeader* header_raw;
     bool result = H264CMSampleBufferToAnnexBBuffer(sample_buffer, is_keyframe,
                                                    buffer.get(), &header_raw);
     header.reset(header_raw);
     if (!result) {
@@ skipping 21 matching lines @@
   if (result != 0) {
     LOG(LS_ERROR) << "Encode callback failed: " << result;
     return;
   }
   bitrate_adjuster_.Update(frame._size);
 }
 
 }  // namespace webrtc
 
 #endif  // defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED)