Expose java to native conversion of bitrate limits in public API.

A downstream project needs this functionality.

Bug: none
Change-Id: I316ca5066383a7fe73e793b305c14b48f622b70e
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/172843
Reviewed-by: Sami Kalliomäki <sakal@webrtc.org>
Commit-Queue: Sergey Silkin <ssilkin@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31031}

4 files changed, 53 insertions, 32 deletions

diff --git a/sdk/android/native_api/codecs/wrapper.cc b/sdk/android/native_api/codecs/wrapper.cc
index 08cafd83b8..c3f2095335 100644
--- a/sdk/android/native_api/codecs/wrapper.cc
+++ b/sdk/android/native_api/codecs/wrapper.cc
@@ -16,6 +16,7 @@
 #include "sdk/android/src/jni/video_codec_info.h"
 #include "sdk/android/src/jni/video_decoder_factory_wrapper.h"
 #include "sdk/android/src/jni/video_encoder_factory_wrapper.h"
+#include "sdk/android/src/jni/video_encoder_wrapper.h"
 
 namespace webrtc {
 
@@ -38,4 +39,11 @@ std::unique_ptr<VideoEncoderFactory> JavaToNativeVideoEncoderFactory(
       jni, JavaParamRef<jobject>(encoder_factory));
 }
 
+std::vector<VideoEncoder::ResolutionBitrateLimits>
+JavaToNativeResolutionBitrateLimits(JNIEnv* jni,
+                                    const jobjectArray j_bitrate_limits_array) {
+  return jni::JavaToNativeResolutionBitrateLimits(
+      jni, JavaParamRef<jobjectArray>(j_bitrate_limits_array));
+}
+
 }  // namespace webrtc
diff --git a/sdk/android/native_api/codecs/wrapper.h b/sdk/android/native_api/codecs/wrapper.h
index b1ff24c679..2246fd76d2 100644
--- a/sdk/android/native_api/codecs/wrapper.h
+++ b/sdk/android/native_api/codecs/wrapper.h
@@ -13,9 +13,11 @@
 
 #include <jni.h>
 #include <memory>
+#include <vector>
 
 #include "api/video_codecs/sdp_video_format.h"
 #include "api/video_codecs/video_decoder_factory.h"
+#include "api/video_codecs/video_encoder.h"
 #include "api/video_codecs/video_encoder_factory.h"
 
 namespace webrtc {
@@ -35,6 +37,12 @@ std::unique_ptr<VideoEncoderFactory> JavaToNativeVideoEncoderFactory(
     JNIEnv* jni,
     jobject encoder_factory);
 
+// Creates an array of VideoEncoder::ResolutionBitrateLimits from Java array
+// of ResolutionBitrateLimits.
+std::vector<VideoEncoder::ResolutionBitrateLimits>
+JavaToNativeResolutionBitrateLimits(JNIEnv* jni,
+                                    const jobjectArray j_bitrate_limits_array);
+
 }  // namespace webrtc
 
 #endif  // SDK_ANDROID_NATIVE_API_CODECS_WRAPPER_H_
diff --git a/sdk/android/src/jni/video_encoder_wrapper.cc b/sdk/android/src/jni/video_encoder_wrapper.cc
index 446b12ce53..1b34e99dce 100644
--- a/sdk/android/src/jni/video_encoder_wrapper.cc
+++ b/sdk/android/src/jni/video_encoder_wrapper.cc
@@ -38,7 +38,8 @@ VideoEncoderWrapper::VideoEncoderWrapper(JNIEnv* jni,
 
   // Get bitrate limits in the constructor. This is a static property of the
   // encoder and is expected to be available before it is initialized.
-  encoder_info_.resolution_bitrate_limits = GetResolutionBitrateLimits(jni);
+  encoder_info_.resolution_bitrate_limits = JavaToNativeResolutionBitrateLimits(
+      jni, Java_VideoEncoder_getResolutionBitrateLimits(jni, encoder_));
 }
 VideoEncoderWrapper::~VideoEncoderWrapper() = default;
 
@@ -210,37 +211,6 @@ VideoEncoderWrapper::GetScalingSettingsInternal(JNIEnv* jni) const {
   }
 }
 
-std::vector<VideoEncoder::ResolutionBitrateLimits>
-VideoEncoderWrapper::GetResolutionBitrateLimits(JNIEnv* jni) const {
-  std::vector<VideoEncoder::ResolutionBitrateLimits> resolution_bitrate_limits;
-
-  ScopedJavaLocalRef<jobjectArray> j_bitrate_limits_array =
-      Java_VideoEncoder_getResolutionBitrateLimits(jni, encoder_);
-
-  const jsize num_thresholds =
-      jni->GetArrayLength(j_bitrate_limits_array.obj());
-  for (int i = 0; i < num_thresholds; ++i) {
-    ScopedJavaLocalRef<jobject> j_bitrate_limits = ScopedJavaLocalRef<jobject>(
-        jni, jni->GetObjectArrayElement(j_bitrate_limits_array.obj(), i));
-
-    jint frame_size_pixels =
-        Java_ResolutionBitrateLimits_getFrameSizePixels(jni, j_bitrate_limits);
-    jint min_start_bitrate_bps =
-        Java_ResolutionBitrateLimits_getMinStartBitrateBps(jni,
-                                                           j_bitrate_limits);
-    jint min_bitrate_bps =
-        Java_ResolutionBitrateLimits_getMinBitrateBps(jni, j_bitrate_limits);
-    jint max_bitrate_bps =
-        Java_ResolutionBitrateLimits_getMaxBitrateBps(jni, j_bitrate_limits);
-
-    resolution_bitrate_limits.push_back(VideoEncoder::ResolutionBitrateLimits(
-        frame_size_pixels, min_start_bitrate_bps, min_bitrate_bps,
-        max_bitrate_bps));
-  }
-
-  return resolution_bitrate_limits;
-}
-
 void VideoEncoderWrapper::OnEncodedFrame(
     JNIEnv* jni,
     const JavaRef<jobject>& j_encoded_image) {
@@ -455,5 +425,34 @@ bool IsHardwareVideoEncoder(JNIEnv* jni, const JavaRef<jobject>& j_encoder) {
   return Java_VideoEncoder_isHardwareEncoder(jni, j_encoder);
 }
 
+std::vector<VideoEncoder::ResolutionBitrateLimits>
+JavaToNativeResolutionBitrateLimits(
+    JNIEnv* jni,
+    const JavaRef<jobjectArray>& j_bitrate_limits_array) {
+  std::vector<VideoEncoder::ResolutionBitrateLimits> resolution_bitrate_limits;
+
+  const jsize array_length = jni->GetArrayLength(j_bitrate_limits_array.obj());
+  for (int i = 0; i < array_length; ++i) {
+    ScopedJavaLocalRef<jobject> j_bitrate_limits = ScopedJavaLocalRef<jobject>(
+        jni, jni->GetObjectArrayElement(j_bitrate_limits_array.obj(), i));
+
+    jint frame_size_pixels =
+        Java_ResolutionBitrateLimits_getFrameSizePixels(jni, j_bitrate_limits);
+    jint min_start_bitrate_bps =
+        Java_ResolutionBitrateLimits_getMinStartBitrateBps(jni,
+                                                           j_bitrate_limits);
+    jint min_bitrate_bps =
+        Java_ResolutionBitrateLimits_getMinBitrateBps(jni, j_bitrate_limits);
+    jint max_bitrate_bps =
+        Java_ResolutionBitrateLimits_getMaxBitrateBps(jni, j_bitrate_limits);
+
+    resolution_bitrate_limits.push_back(VideoEncoder::ResolutionBitrateLimits(
+        frame_size_pixels, min_start_bitrate_bps, min_bitrate_bps,
+        max_bitrate_bps));
+  }
+
+  return resolution_bitrate_limits;
+}
+
 }  // namespace jni
 }  // namespace webrtc
diff --git a/sdk/android/src/jni/video_encoder_wrapper.h b/sdk/android/src/jni/video_encoder_wrapper.h
index 52323bc8a6..0e9d37bf23 100644
--- a/sdk/android/src/jni/video_encoder_wrapper.h
+++ b/sdk/android/src/jni/video_encoder_wrapper.h
@@ -13,6 +13,7 @@
 
 #include <jni.h>
 #include <deque>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -108,6 +109,11 @@ std::unique_ptr<VideoEncoder> JavaToNativeVideoEncoder(
 
 bool IsHardwareVideoEncoder(JNIEnv* jni, const JavaRef<jobject>& j_encoder);
 
+std::vector<VideoEncoder::ResolutionBitrateLimits>
+JavaToNativeResolutionBitrateLimits(
+    JNIEnv* jni,
+    const JavaRef<jobjectArray>& j_bitrate_limits_array);
+
 }  // namespace jni
 }  // namespace webrtc