Enable Android H264 High profile decoder

webrtc/sdk/android/src/jni/androidmediaencoder_jni.cc

 /*
  *  Copyright 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 65 matching lines @@
 #define ALOGV(...)
 #endif
 #define ALOGD LOG_TAG(rtc::LS_INFO, TAG_ENCODER)
 #define ALOGW LOG_TAG(rtc::LS_WARNING, TAG_ENCODER)
 #define ALOGE LOG_TAG(rtc::LS_ERROR, TAG_ENCODER)
 
 namespace {
 // Maximum time limit between incoming frames before requesting a key frame.
 const size_t kFrameDiffThresholdMs = 350;
 const int kMinKeyFrameInterval = 6;
+const char kH264HighProfileFieldTrial[] = "WebRTC-H264HighProfile";
 }  // namespace
 
 // MediaCodecVideoEncoder is a webrtc::VideoEncoder implementation that uses
 // Android's MediaCodec SDK API behind the scenes to implement (hopefully)
 // HW-backed video encode.  This C++ class is implemented as a very thin shim,
 // delegating all of the interesting work to org.webrtc.MediaCodecVideoEncoder.
 // MediaCodecVideoEncoder is created, operated, and destroyed on a single
 // thread, currently the libjingle Worker thread.
 class MediaCodecVideoEncoder : public webrtc::VideoEncoder,
                                public rtc::MessageHandler {
@@ skipping 1090 matching lines @@
 
 const char* MediaCodecVideoEncoder::ImplementationName() const {
   return "MediaCodec";
 }
 
 MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory()
     : egl_context_(nullptr) {
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
   jclass j_encoder_class = FindClass(jni, "org/webrtc/MediaCodecVideoEncoder");
+  jclass j_decoder_class = FindClass(jni, "org/webrtc/MediaCodecVideoDecoder");
   supported_codecs_.clear();
 
   bool is_vp8_hw_supported = jni->CallStaticBooleanMethod(
       j_encoder_class,
       GetStaticMethodID(jni, j_encoder_class, "isVp8HwSupported", "()Z"));
   CHECK_EXCEPTION(jni);
   if (is_vp8_hw_supported) {
     ALOGD << "VP8 HW Encoder supported.";
     supported_codecs_.push_back(cricket::VideoCodec("VP8"));
   }
 
   bool is_vp9_hw_supported = jni->CallStaticBooleanMethod(
       j_encoder_class,
       GetStaticMethodID(jni, j_encoder_class, "isVp9HwSupported", "()Z"));
   CHECK_EXCEPTION(jni);
   if (is_vp9_hw_supported) {
     ALOGD << "VP9 HW Encoder supported.";
     supported_codecs_.push_back(cricket::VideoCodec("VP9"));
   }
 
+  // Check if high profile is supported by decoder. If yes, encoder can always
+  // fall back to baseline profile as a subset as high profile.
+  bool is_h264_high_profile_hw_supported = false;
+  if (webrtc::field_trial::FindFullName(kH264HighProfileFieldTrial) ==
+      "Enabled") {
+    is_h264_high_profile_hw_supported = jni->CallStaticBooleanMethod(
+        j_decoder_class,
+        GetStaticMethodID(jni, j_decoder_class, "isH264HighProfileHwSupported",
+                          "()Z"));
+    CHECK_EXCEPTION(jni);
+  }
+  if (is_h264_high_profile_hw_supported) {
+    ALOGD << "H.264 High Profile HW Encoder supported.";
+    // TODO(magjed): Enumerate actual level instead of using hardcoded level
+    // 3.1. Level 3.1 is 1280x720@30fps which is enough for now.
+    cricket::VideoCodec constrained_high(cricket::kH264CodecName);
+    const webrtc::H264::ProfileLevelId constrained_high_profile(
+        webrtc::H264::kProfileConstrainedHigh, webrtc::H264::kLevel3_1);
+    constrained_high.SetParam(
+        cricket::kH264FmtpProfileLevelId,
+        *webrtc::H264::ProfileLevelIdToString(constrained_high_profile));
+    constrained_high.SetParam(cricket::kH264FmtpLevelAsymmetryAllowed, "1");
+    constrained_high.SetParam(cricket::kH264FmtpPacketizationMode, "1");
+    supported_codecs_.push_back(constrained_high);
+  }
+
   bool is_h264_hw_supported = jni->CallStaticBooleanMethod(
       j_encoder_class,
       GetStaticMethodID(jni, j_encoder_class, "isH264HwSupported", "()Z"));
   CHECK_EXCEPTION(jni);
   if (is_h264_hw_supported) {
     ALOGD << "H.264 HW Encoder supported.";
     // TODO(magjed): Push Constrained High profile as well when negotiation is
     // ready, http://crbug/webrtc/6337. We can negotiate Constrained High
     // profile as long as we have decode support for it and still send Baseline
     // since Baseline is a subset of the High profile.
     cricket::VideoCodec constrained_baseline(cricket::kH264CodecName);
-    // TODO(magjed): Enumerate actual level instead of using hardcoded level
-    // 3.1. Level 3.1 is 1280x720@30fps which is enough for now.
     const webrtc::H264::ProfileLevelId constrained_baseline_profile(
         webrtc::H264::kProfileConstrainedBaseline, webrtc::H264::kLevel3_1);
     constrained_baseline.SetParam(
         cricket::kH264FmtpProfileLevelId,
         *webrtc::H264::ProfileLevelIdToString(constrained_baseline_profile));
     constrained_baseline.SetParam(cricket::kH264FmtpLevelAsymmetryAllowed, "1");
     constrained_baseline.SetParam(cricket::kH264FmtpPacketizationMode, "1");
     supported_codecs_.push_back(constrained_baseline);
   }
 }
@@ skipping 40 matching lines @@
   return supported_codecs_;
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni