Support H.264 high profile encoding on Exynos devices.

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 256 matching lines @@
                                    // |input_frame_infos_|.
   webrtc::VideoRotation output_rotation_;  // Last output frame rotation from
                                            // |input_frame_infos_|.
 
   // Frame size in bytes fed to MediaCodec.
   int yuv_size_;
   // True only when between a callback_->OnEncodedImage() call return a positive
   // value and the next Encode() call being ignored.
   bool drop_next_input_frame_;
   bool scale_;
+  webrtc::H264::Profile profile_;
   // Global references; must be deleted in Release().
   std::vector<jobject> input_buffers_;
   webrtc::H264BitstreamParser h264_bitstream_parser_;
 
   // VP9 variables to populate codec specific structure.
   webrtc::GofInfoVP9 gof_;  // Contains each frame's temporal information for
                             // non-flexible VP9 mode.
   size_t gof_idx_;
 
   // EGL context - owned by factory, should not be allocated/destroyed
@@ skipping 41 matching lines @@
                                      "<init>",
                                      "()V"))),
       inited_(false),
       use_surface_(false),
       egl_context_(egl_context),
       sw_fallback_required_(false) {
   encoder_queue_checker_.Detach();
 
   jclass j_output_buffer_info_class =
       FindClass(jni, "org/webrtc/MediaCodecVideoEncoder$OutputBufferInfo");
-  j_init_encode_method_ = GetMethodID(
-      jni,
-      *j_media_codec_video_encoder_class_,
-      "initEncode",
-      "(Lorg/webrtc/MediaCodecVideoEncoder$VideoCodecType;"
-      "IIIILorg/webrtc/EglBase14$Context;)Z");
+  j_init_encode_method_ =
+      GetMethodID(jni, *j_media_codec_video_encoder_class_, "initEncode",
+                  "(Lorg/webrtc/MediaCodecVideoEncoder$VideoCodecType;"
+                  "IIIIILorg/webrtc/EglBase14$Context;)Z");
   j_get_input_buffers_method_ = GetMethodID(
       jni,
       *j_media_codec_video_encoder_class_,
       "getInputBuffers",
       "()[Ljava/nio/ByteBuffer;");
   j_dequeue_input_buffer_method_ = GetMethodID(
       jni, *j_media_codec_video_encoder_class_, "dequeueInputBuffer", "()I");
   j_encode_buffer_method_ = GetMethodID(
       jni, *j_media_codec_video_encoder_class_, "encodeBuffer", "(ZIIJ)Z");
   j_encode_texture_method_ = GetMethodID(
@@ skipping 58 matching lines @@
     scale_ = codec_settings->VP8().automaticResizeOn;
   } else if (codec_type == kVideoCodecVP9) {
     scale_ = codec_settings->VP9().automaticResizeOn;
   } else {
     scale_ = true;
   }
 
   ALOGD << "InitEncode request: " << init_width << " x " << init_height;
   ALOGD << "Encoder automatic resize " << (scale_ ? "enabled" : "disabled");
 
+  // Check allowed H.264 profile
+  profile_ = webrtc::H264::Profile::kProfileBaseline;
+  if (codec_type == kVideoCodecH264) {
+    const rtc::Optional<webrtc::H264::ProfileLevelId> profile_level_id =
+        webrtc::H264::ParseSdpProfileLevelId(codec_.params);
+    RTC_DCHECK(profile_level_id);
+    profile_ = profile_level_id->profile;
+    ALOGD << "H.264 profile: " << profile_;
+  }
+
   return InitEncodeInternal(
       init_width, init_height, codec_settings->startBitrate,
       codec_settings->maxFramerate, codec_settings->expect_encode_from_texture);
 }
 
 int32_t MediaCodecVideoEncoder::SetChannelParameters(uint32_t /* packet_loss */,
                                                      int64_t /* rtt */) {
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
@@ skipping 92 matching lines @@
   if (sw_fallback_required_) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
   RTC_CHECK(!use_surface || egl_context_ != nullptr) << "EGL context not set.";
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
 
   const VideoCodecType codec_type = GetCodecType();
   ALOGD << "InitEncodeInternal Type: " << static_cast<int>(codec_type) << ", "
         << width << " x " << height << ". Bitrate: " << kbps
-        << " kbps. Fps: " << fps;
+        << " kbps. Fps: " << fps << ". Profile: " << profile_ << ".";
   if (kbps == 0) {
     kbps = last_set_bitrate_kbps_;
   }
   if (fps == 0) {
     fps = MAX_VIDEO_FPS;
   }
 
   width_ = width;
   height_ = height;
   last_set_bitrate_kbps_ = kbps;
@@ skipping 18 matching lines @@
   use_surface_ = use_surface;
   gof_.SetGofInfoVP9(webrtc::TemporalStructureMode::kTemporalStructureMode1);
   gof_idx_ = 0;
   last_frame_received_ms_ = -1;
   frames_received_since_last_key_ = kMinKeyFrameInterval;
 
   // We enforce no extra stride/padding in the format creation step.
   jobject j_video_codec_enum = JavaEnumFromIndexAndClassName(
       jni, "MediaCodecVideoEncoder$VideoCodecType", codec_type);
   const bool encode_status = jni->CallBooleanMethod(
-      *j_media_codec_video_encoder_, j_init_encode_method_,
-      j_video_codec_enum, width, height, kbps, fps,
+      *j_media_codec_video_encoder_, j_init_encode_method_, j_video_codec_enum,
+      profile_, width, height, kbps, fps,
       (use_surface ? egl_context_ : nullptr));
   if (!encode_status) {
     ALOGE << "Failed to configure encoder.";
     ProcessHWError(false /* reset_if_fallback_unavailable */);
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   if (CheckException(jni)) {
     ALOGE << "Exception in init encode.";
     ProcessHWError(false /* reset_if_fallback_unavailable */);
     return WEBRTC_VIDEO_CODEC_ERROR;
@@ skipping 660 matching lines @@
   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"));
+    supported_codecs_.push_back(cricket::VideoCodec(cricket::kVp8CodecName));
   }
 
   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"));
+    supported_codecs_.push_back(cricket::VideoCodec(cricket::kVp9CodecName));
   }
   supported_codecs_with_h264_hp_ = supported_codecs_;
 
   // 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 = jni->CallStaticBooleanMethod(
       j_decoder_class,
       GetStaticMethodID(jni, j_decoder_class, "isH264HighProfileHwSupported",
                         "()Z"));
   CHECK_EXCEPTION(jni);
@@ skipping 81 matching lines @@
   }
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni