Prepare iOS H264 HW encoder for High Profile

webrtc/sdk/objc/Framework/Classes/h264_video_toolbox_encoder.mm

 /*
  *  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.
  *
  */
 
 #include "webrtc/sdk/objc/Framework/Classes/h264_video_toolbox_encoder.h"
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #if defined(WEBRTC_IOS)
 #import "WebRTC/UIDevice+RTCDevice.h"
 #include "RTCUIApplication.h"
 #endif
 #include "libyuv/convert_from.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/common_video/h264/profile_level_id.h"
 #include "webrtc/common_video/include/corevideo_frame_buffer.h"
 #include "webrtc/sdk/objc/Framework/Classes/h264_video_toolbox_nalu.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace internal {
 
 // The ratio between kVTCompressionPropertyKey_DataRateLimits and
 // kVTCompressionPropertyKey_AverageBitRate. The data rate limit is set higher
 // than the average bit rate to avoid undershooting the target.
 const float kLimitToAverageBitRateFactor = 1.5f;
@@ skipping 182 matching lines @@
                                  CMSampleBufferRef sample_buffer) {
   std::unique_ptr<FrameEncodeParams> encode_params(
       reinterpret_cast<FrameEncodeParams*>(params));
   encode_params->encoder->OnEncodedFrame(
       status, info_flags, sample_buffer, encode_params->codec_specific_info,
       encode_params->width, encode_params->height,
       encode_params->render_time_ms, encode_params->timestamp,
       encode_params->rotation);
 }
 
+// Extract VideoToolbox profile out of the cricket::VideoCodec. If there is no
+// specific VideoToolbox profile for the specified level, AutoLevel will be
+// returned. The user must initialize the encoder with a resolution and
+// framerate conforming to the selected H264 level regardless.
+CFStringRef ExtractProfile(const cricket::VideoCodec& codec) {
+  const rtc::Optional<webrtc::H264::ProfileLevelId> profile_level_id =
+      webrtc::H264::ParseSdpProfileLevelId(codec.params);
+  RTC_DCHECK(profile_level_id);
+  switch (profile_level_id->profile) {
+    case webrtc::H264::kProfileConstrainedBaseline:
+    case webrtc::H264::kProfileBaseline:
+      switch (profile_level_id->level) {
+        case webrtc::H264::kLevel4:
+          return kVTProfileLevel_H264_Baseline_4_0;
+        case webrtc::H264::kLevel4_2:
+          return kVTProfileLevel_H264_Baseline_4_2;
+        case webrtc::H264::kLevel5:
+          return kVTProfileLevel_H264_Baseline_5_0;
+        case webrtc::H264::kLevel5_1:
+          return kVTProfileLevel_H264_Baseline_5_1;
+        case webrtc::H264::kLevel5_2:
+          return kVTProfileLevel_H264_Baseline_5_2;
+        default:

[tkchin_webrtc, 2016/11/14 18:27:27]

usually in iOS code we use compiler error to catch when new enum values are
added instead of using default
if that's easy to do here (e.g. webrtc has autolevel enum) that would be good,
but not high pri

[magjed_webrtc, 2016/11/15 17:14:24]

Cool, didn't know the compiler would help finding missing enums. Done.

+          return kVTProfileLevel_H264_Baseline_AutoLevel;
+      }
+
+    case webrtc::H264::kProfileMain:
+      switch (profile_level_id->level) {
+        case webrtc::H264::kLevel4_2:
+          return kVTProfileLevel_H264_Main_4_2;
+        case webrtc::H264::kLevel5_1:
+          return kVTProfileLevel_H264_Main_5_1;
+        case webrtc::H264::kLevel5_2:
+          return kVTProfileLevel_H264_Main_5_2;
+        default:
+          return kVTProfileLevel_H264_Main_AutoLevel;
+      }
+
+    case webrtc::H264::kProfileConstrainedHigh:
+    case webrtc::H264::kProfileHigh:
+      switch (profile_level_id->level) {
+        case webrtc::H264::kLevel3:
+          return kVTProfileLevel_H264_High_3_0;
+        case webrtc::H264::kLevel3_1:
+          return kVTProfileLevel_H264_High_3_1;
+        case webrtc::H264::kLevel3_2:
+          return kVTProfileLevel_H264_High_3_2;
+        case webrtc::H264::kLevel4:
+          return kVTProfileLevel_H264_High_4_0;
+        case webrtc::H264::kLevel4_1:
+          return kVTProfileLevel_H264_High_4_1;
+        case webrtc::H264::kLevel4_2:
+          return kVTProfileLevel_H264_High_4_2;
+        case webrtc::H264::kLevel5_1:
+          return kVTProfileLevel_H264_High_5_1;
+        case webrtc::H264::kLevel5_2:
+          return kVTProfileLevel_H264_High_5_2;
+        default:
+          return kVTProfileLevel_H264_High_AutoLevel;
+      }
+  }
+}
+
 }  // namespace internal
 
 namespace webrtc {
 
 // .5 is set as a mininum to prevent overcompensating for large temporary
 // overshoots. We don't want to degrade video quality too badly.
 // .95 is set to prevent oscillations. When a lower bitrate is set on the
 // encoder than previously set, its output seems to have a brief period of
 // drastically reduced bitrate, so we want to avoid that. In steady state
 // conditions, 0.95 seems to give us better overall bitrate over long periods
 // of time.
-H264VideoToolboxEncoder::H264VideoToolboxEncoder()
+H264VideoToolboxEncoder::H264VideoToolboxEncoder(
+    const cricket::VideoCodec& codec)
     : callback_(nullptr),
       compression_session_(nullptr),
-      bitrate_adjuster_(Clock::GetRealTimeClock(), .5, .95) {
-}
+      bitrate_adjuster_(Clock::GetRealTimeClock(), .5, .95),
+      profile_(internal::ExtractProfile(codec)) {}
 
 H264VideoToolboxEncoder::~H264VideoToolboxEncoder() {
   DestroyCompressionSession();
 }
 
 int H264VideoToolboxEncoder::InitEncode(const VideoCodec* codec_settings,
                                         int number_of_cores,
                                         size_t max_payload_size) {
   RTC_DCHECK(codec_settings);
   RTC_DCHECK_EQ(codec_settings->codecType, kVideoCodecH264);
@@ skipping 236 matching lines @@
   ConfigureCompressionSession();
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 void H264VideoToolboxEncoder::ConfigureCompressionSession() {
   RTC_DCHECK(compression_session_);
   internal::SetVTSessionProperty(compression_session_,
                                  kVTCompressionPropertyKey_RealTime, true);
   internal::SetVTSessionProperty(compression_session_,
                                  kVTCompressionPropertyKey_ProfileLevel,
-                                 kVTProfileLevel_H264_Baseline_AutoLevel);
+                                 profile_);
   internal::SetVTSessionProperty(compression_session_,
                                  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,
@@ skipping 141 matching lines @@
   EncodedImageCallback::Result result =
       callback_->OnEncodedImage(frame, &codec_specific_info, header.get());
   if (result.error != EncodedImageCallback::Result::OK) {
     LOG(LS_ERROR) << "Encode callback failed: " << result.error;
     return;
   }
   bitrate_adjuster_.Update(frame._size);
 }
 
 }  // namespace webrtc