Bindings for injectable Java video encoders.

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

Index: webrtc/sdk/android/src/jni/videoencoderfactorywrapper.cc
diff --git a/webrtc/sdk/android/src/jni/videoencoderfactorywrapper.cc b/webrtc/sdk/android/src/jni/videoencoderfactorywrapper.cc
new file mode 100644
index 0000000000000000000000000000000000000000..acb3c2a43e4085157675ffd714c4cf11ca2507cc
--- /dev/null
+++ b/webrtc/sdk/android/src/jni/videoencoderfactorywrapper.cc
@@ -0,0 +1,99 @@
+/*
+ *  Copyright 2017 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/android/src/jni/videoencoderfactorywrapper.h"
+
+#include "webrtc/api/video_codecs/video_encoder.h"
+#include "webrtc/common_types.h"
+#include "webrtc/rtc_base/logging.h"
+#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
+#include "webrtc/sdk/android/src/jni/videoencoderwrapper.h"
+
+namespace webrtc_jni {
+
+VideoEncoderFactoryWrapper::VideoEncoderFactoryWrapper(JNIEnv* jni,
+                                                       jobject encoder_factory)
+    : video_codec_info_class_(jni, FindClass(jni, "org/webrtc/VideoCodecInfo")),
+      hash_map_class_(jni, jni->FindClass("java/util/HashMap")),
+      encoder_factory_(jni, encoder_factory) {
+  jclass encoder_factory_class = jni->GetObjectClass(*encoder_factory_);
+  create_encoder_method_ = jni->GetMethodID(
+      encoder_factory_class, "createEncoder",
+      "(Lorg/webrtc/VideoCodecInfo;)Lorg/webrtc/VideoEncoder;");
+  get_supported_codecs_method_ =
+      jni->GetMethodID(encoder_factory_class, "getSupportedCodecs",
+                       "()[Lorg/webrtc/VideoCodecInfo;");
+
+  video_codec_info_constructor_ =
+      jni->GetMethodID(*video_codec_info_class_, "<init>",
+                       "(ILjava/lang/String;Ljava/util/Map;)V");
+  payload_field_ = jni->GetFieldID(*video_codec_info_class_, "payload", "I");
+  name_field_ =
+      jni->GetFieldID(*video_codec_info_class_, "name", "Ljava/lang/String;");
+
+  hash_map_constructor_ = jni->GetMethodID(*hash_map_class_, "<init>", "()V");
+  put_method_ = jni->GetMethodID(
+      *hash_map_class_, "put",
+      "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+
+  supported_codecs_ = GetSupportedCodecs(jni);
+}
+
+webrtc::VideoEncoder* VideoEncoderFactoryWrapper::CreateVideoEncoder(
+    const cricket::VideoCodec& codec) {
+  JNIEnv* jni = AttachCurrentThreadIfNeeded();
+  ScopedLocalRefFrame local_ref_frame(jni);
+  jobject j_codec_info = ToJavaCodecInfo(jni, codec);
+  jobject encoder = jni->CallObjectMethod(*encoder_factory_,
+                                          create_encoder_method_, j_codec_info);
+  return encoder != nullptr ? new VideoEncoderWrapper(jni, encoder) : nullptr;
+}
+
+jobject VideoEncoderFactoryWrapper::ToJavaCodecInfo(
+    JNIEnv* jni,
+    const cricket::VideoCodec& codec) {
+  jobject j_params = jni->NewObject(*hash_map_class_, hash_map_constructor_);
+  for (auto const& param : codec.params) {
+    jni->CallObjectMethod(j_params, put_method_,
+                          JavaStringFromStdString(jni, param.first),
+                          JavaStringFromStdString(jni, param.second));
+  }
+  return jni->NewObject(*video_codec_info_class_, video_codec_info_constructor_,
+                        codec.id, JavaStringFromStdString(jni, codec.name),
+                        j_params);
+}
+
+std::vector<cricket::VideoCodec> VideoEncoderFactoryWrapper::GetSupportedCodecs(
+    JNIEnv* jni) const {
+  const jobjectArray j_supported_codecs = static_cast<jobjectArray>(
+      jni->CallObjectMethod(*encoder_factory_, get_supported_codecs_method_));
+  const jsize supported_codecs_count = jni->GetArrayLength(j_supported_codecs);
+
+  std::vector<cricket::VideoCodec> supported_codecs;
+  supported_codecs.resize(supported_codecs_count);
+  for (jsize i = 0; i < supported_codecs_count; i++) {
+    jobject j_supported_codec =
+        jni->GetObjectArrayElement(j_supported_codecs, i);
+    int payload = jni->GetIntField(j_supported_codec, payload_field_);
+    jstring j_name = static_cast<jstring>(
+        jni->GetObjectField(j_supported_codec, name_field_));
+    supported_codecs[i] =
+        cricket::VideoCodec(payload, JavaToStdString(jni, j_name));
+    // TODO(sakal): Parse params

[magjed_webrtc, 2017/08/28 16:54:21]

Is this not needed?

[sakal, 2017/08/29 12:59:38]

Missed this, implemented it now.

+  }
+  return supported_codecs;
+}
+
+void VideoEncoderFactoryWrapper::DestroyVideoEncoder(
+    webrtc::VideoEncoder* encoder) {
+  delete encoder;
+}
+
+}  // namespace webrtc_jni