zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Android: Generate JNI code for remaining classes in sdk/android

Browse Source 
Bug: webrtc:8278
Change-Id: I20a4388ab347d8745d0edde808f7a0b610f077f9
Reviewed-on: https://webrtc-review.googlesource.com/31484
Commit-Queue: Magnus Jedvert <magjed@webrtc.org>
Reviewed-by: Sami Kalliomäki <sakal@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#21227}
This commit is contained in:
Magnus Jedvert
2017-12-12 12:52:54 +01:00
committed by Commit Bot
parent 1a8fffbb01
commit 9060eb1528
99 changed files with 1553 additions and 1659 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
sdk/android/src/jni/OWNERS
View File

@ -1,4 +1,4 @@
per-file androidhistogram_jni.cc=sakal@webrtc.org
per-file androidmetrics_jni.cc=sakal@webrtc.org
per-file androidhistogram.cc=sakal@webrtc.org
per-file androidmetrics.cc=sakal@webrtc.org
per-file androidvideotracksource.*=sakal@webrtc.org
per-file androidvideotracksource_jni.cc=sakal@webrtc.org
per-file androidvideotracksource.cc=sakal@webrtc.org

1
sdk/android/src/jni/androidhistogram_jni.cc → sdk/android/src/jni/androidhistogram.cc
View File

@ -11,7 +11,6 @@
#include <map>
#include <memory>
#include "sdk/android/src/jni/classreferenceholder.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "system_wrappers/include/metrics.h"

1
sdk/android/src/jni/androidmediacodeccommon.h
View File

@ -16,7 +16,6 @@
#include "rtc_base/logging.h"
#include "rtc_base/thread.h"
#include "sdk/android/src/jni/classreferenceholder.h"
#include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc {

22
sdk/android/src/jni/androidmediadecoder_jni.cc → sdk/android/src/jni/androidmediadecoder.cc
View File

@ -29,7 +29,7 @@
#include "rtc_base/timeutils.h"
#include "sdk/android/generated_video_jni/jni/MediaCodecVideoDecoder_jni.h"
#include "sdk/android/src/jni/androidmediacodeccommon.h"
#include "sdk/android/src/jni/surfacetexturehelper_jni.h"
#include "sdk/android/src/jni/surfacetexturehelper.h"
#include "sdk/android/src/jni/videoframe.h"
#include "third_party/libyuv/include/libyuv/convert.h"
#include "third_party/libyuv/include/libyuv/convert_from.h"
@ -209,9 +209,9 @@ int32_t MediaCodecVideoDecoder::InitDecodeOnCodecThread() {
CheckOnCodecThread();
JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni);
ALOGD << "InitDecodeOnCodecThread Type: " << (int)codecType_ << ". "
<< codec_.width << " x " << codec_.height << ". Fps: " <<
(int)codec_.maxFramerate;
ALOGD << "InitDecodeOnCodecThread Type: " << static_cast<int>(codecType_)
<< ". " << codec_.width << " x " << codec_.height
<< ". Fps: " << static_cast<int>(codec_.maxFramerate);
// Release previous codec first if it was allocated before.
int ret_val = ReleaseOnCodecThread();
@ -278,8 +278,8 @@ int32_t MediaCodecVideoDecoder::ResetDecodeOnCodecThread() {
CheckOnCodecThread();
JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni);
ALOGD << "ResetDecodeOnCodecThread Type: " << (int)codecType_ << ". "
<< codec_.width << " x " << codec_.height;
ALOGD << "ResetDecodeOnCodecThread Type: " << static_cast<int>(codecType_)
<< ". " << codec_.width << " x " << codec_.height;
ALOGD << " Frames received: " << frames_received_ <<
". Frames decoded: " << frames_decoded_;
@ -725,8 +725,8 @@ bool MediaCodecVideoDecoder::DeliverPendingOutputs(
". " << width << " x " << height <<
". Color: " << color_format <<
". TS: " << presentation_timestamps_ms <<
". DecTime: " << (int)decode_time_ms <<
". DelayTime: " << (int)frame_delayed_ms;
". DecTime: " << static_cast<int>(decode_time_ms) <<
". DelayTime: " << static_cast<int>(frame_delayed_ms);
}
// Calculate and print decoding statistics - every 3 seconds.
@ -843,18 +843,18 @@ void MediaCodecVideoDecoderFactory::SetEGLContext(
VideoDecoder* MediaCodecVideoDecoderFactory::CreateVideoDecoder(
VideoCodecType type) {
if (supported_codec_types_.empty()) {
ALOGW << "No HW video decoder for type " << (int)type;
ALOGW << "No HW video decoder for type " << static_cast<int>(type);
return nullptr;
}
for (VideoCodecType codec_type : supported_codec_types_) {
if (codec_type == type) {
ALOGD << "Create HW video decoder for type " << (int)type;
ALOGD << "Create HW video decoder for type " << static_cast<int>(type);
JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni);
return new MediaCodecVideoDecoder(jni, type, egl_context_);
}
}
ALOGW << "Can not find HW video decoder for type " << (int)type;
ALOGW << "Can not find HW video decoder for type " << static_cast<int>(type);
return nullptr;
}

10
sdk/android/src/jni/androidmediadecoder_jni.h
View File

@ -8,11 +8,13 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef SDK_ANDROID_SRC_JNI_ANDROIDMEDIADECODER_JNI_H_
#define SDK_ANDROID_SRC_JNI_ANDROIDMEDIADECODER_JNI_H_
#ifndef SDK_ANDROID_SRC_JNI_ANDROIDMEDIADECODER_H_
#define SDK_ANDROID_SRC_JNI_ANDROIDMEDIADECODER_H_
#include <vector>
#include "sdk/android/src/jni/jni_helpers.h"
#include "media/engine/webrtcvideodecoderfactory.h"
#include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc {
namespace jni {
@ -41,4 +43,4 @@ class MediaCodecVideoDecoderFactory
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_ANDROIDMEDIADECODER_JNI_H_
#endif // SDK_ANDROID_SRC_JNI_ANDROIDMEDIADECODER_H_

4
sdk/android/src/jni/androidmediaencoder_jni.cc → sdk/android/src/jni/androidmediaencoder.cc
View File

@ -76,7 +76,7 @@ __android_log_print(ANDROID_LOG_VERBOSE, TAG_ENCODER, __VA_ARGS__)
#define ALOGW RTC_LOG_TAG(rtc::LS_WARNING, TAG_ENCODER)
#define ALOGE RTC_LOG_TAG(rtc::LS_ERROR, TAG_ENCODER)
namespace {
namespace {
// Maximum time limit between incoming frames before requesting a key frame.
const size_t kFrameDiffThresholdMs = 350;
const int kMinKeyFrameInterval = 6;
@ -1346,7 +1346,7 @@ void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(VideoEncoder* encoder) {
}
JNI_FUNCTION_DECLARATION(void,
MediaCodecVideoEncoder_fillNativeBuffer,
MediaCodecVideoEncoder_fillInputBufferNative,
JNIEnv* jni,
jclass,
jlong native_encoder,

8
sdk/android/src/jni/androidmediaencoder_jni.h
View File

@ -8,13 +8,13 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef SDK_ANDROID_SRC_JNI_ANDROIDMEDIAENCODER_JNI_H_
#define SDK_ANDROID_SRC_JNI_ANDROIDMEDIAENCODER_JNI_H_
#ifndef SDK_ANDROID_SRC_JNI_ANDROIDMEDIAENCODER_H_
#define SDK_ANDROID_SRC_JNI_ANDROIDMEDIAENCODER_H_
#include <vector>
#include "sdk/android/src/jni/jni_helpers.h"
#include "media/engine/webrtcvideoencoderfactory.h"
#include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc {
namespace jni {
@ -44,4 +44,4 @@ class MediaCodecVideoEncoderFactory
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_ANDROIDMEDIAENCODER_JNI_H_
#endif // SDK_ANDROID_SRC_JNI_ANDROIDMEDIAENCODER_H_

1
sdk/android/src/jni/androidmetrics_jni.cc → sdk/android/src/jni/androidmetrics.cc
View File

@ -12,7 +12,6 @@
#include <memory>
#include "sdk/android/generated_metrics_jni/jni/Metrics_jni.h"
#include "sdk/android/src/jni/classreferenceholder.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "system_wrappers/include/metrics.h"
#include "system_wrappers/include/metrics_default.h"

2
sdk/android/src/jni/androidnetworkmonitor_jni.h
View File

@ -11,4 +11,4 @@
// TODO(deadbeef): Remove this file when clients are updated to new include
// path.
#include "sdk/android/src/jni/pc/androidnetworkmonitor_jni.h"
#include "sdk/android/src/jni/pc/androidnetworkmonitor.h"

114
sdk/android/src/jni/androidvideotracksource.cc
View File

@ -12,16 +12,28 @@
#include <utility>
#include "api/videosourceproxy.h"
#include "rtc_base/logging.h"
#include "sdk/android/src/jni/classreferenceholder.h"
namespace webrtc {
namespace jni {
namespace {
// MediaCodec wants resolution to be divisible by 2.
const int kRequiredResolutionAlignment = 2;
VideoRotation jintToVideoRotation(jint rotation) {
RTC_DCHECK(rotation == 0 || rotation == 90 || rotation == 180 ||
rotation == 270);
return static_cast<VideoRotation>(rotation);
}
namespace webrtc {
namespace jni {
AndroidVideoTrackSource* AndroidVideoTrackSourceFromJavaProxy(jlong j_proxy) {
auto proxy_source = reinterpret_cast<VideoTrackSourceProxy*>(j_proxy);
return reinterpret_cast<AndroidVideoTrackSource*>(proxy_source->internal());
}
} // namespace
AndroidVideoTrackSource::AndroidVideoTrackSource(
rtc::Thread* signaling_thread,
@ -198,5 +210,99 @@ void AndroidVideoTrackSource::OnOutputFormatRequest(int width,
video_adapter()->OnOutputFormatRequest(format);
}
} // namespace webrtc
JNI_FUNCTION_DECLARATION(
void,
AndroidVideoTrackSourceObserver_nativeOnByteBufferFrameCaptured,
JNIEnv* jni,
jclass,
jlong j_source,
jbyteArray j_frame,
jint length,
jint width,
jint height,
jint rotation,
jlong timestamp) {
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
jbyte* bytes = jni->GetByteArrayElements(j_frame, nullptr);
source->OnByteBufferFrameCaptured(bytes, length, width, height,
jintToVideoRotation(rotation), timestamp);
jni->ReleaseByteArrayElements(j_frame, bytes, JNI_ABORT);
}
JNI_FUNCTION_DECLARATION(
void,
AndroidVideoTrackSourceObserver_nativeOnTextureFrameCaptured,
JNIEnv* jni,
jclass,
jlong j_source,
jint j_width,
jint j_height,
jint j_oes_texture_id,
jfloatArray j_transform_matrix,
jint j_rotation,
jlong j_timestamp) {
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
source->OnTextureFrameCaptured(
j_width, j_height, jintToVideoRotation(j_rotation), j_timestamp,
NativeHandleImpl(jni, j_oes_texture_id, j_transform_matrix));
}
JNI_FUNCTION_DECLARATION(void,
AndroidVideoTrackSourceObserver_nativeOnFrameCaptured,
JNIEnv* jni,
jclass,
jlong j_source,
jint j_width,
jint j_height,
jint j_rotation,
jlong j_timestamp_ns,
jobject j_video_frame_buffer) {
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
source->OnFrameCaptured(jni, j_width, j_height, j_timestamp_ns,
jintToVideoRotation(j_rotation),
j_video_frame_buffer);
}
JNI_FUNCTION_DECLARATION(void,
AndroidVideoTrackSourceObserver_nativeCapturerStarted,
JNIEnv* jni,
jclass,
jlong j_source,
jboolean j_success) {
RTC_LOG(LS_INFO) << "AndroidVideoTrackSourceObserve_nativeCapturerStarted";
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
source->SetState(j_success ? AndroidVideoTrackSource::SourceState::kLive
: AndroidVideoTrackSource::SourceState::kEnded);
}
JNI_FUNCTION_DECLARATION(void,
AndroidVideoTrackSourceObserver_nativeCapturerStopped,
JNIEnv* jni,
jclass,
jlong j_source) {
RTC_LOG(LS_INFO) << "AndroidVideoTrackSourceObserve_nativeCapturerStopped";
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
source->SetState(AndroidVideoTrackSource::SourceState::kEnded);
}
JNI_FUNCTION_DECLARATION(void,
VideoSource_nativeAdaptOutputFormat,
JNIEnv* jni,
jclass,
jlong j_source,
jint j_width,
jint j_height,
jint j_fps) {
RTC_LOG(LS_INFO) << "VideoSource_nativeAdaptOutputFormat";
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
source->OnOutputFormatRequest(j_width, j_height, j_fps);
}
} // namespace jni
} // namespace webrtc

2
sdk/android/src/jni/androidvideotracksource.h
View File

@ -20,7 +20,7 @@
#include "rtc_base/checks.h"
#include "rtc_base/thread_checker.h"
#include "rtc_base/timestampaligner.h"
#include "sdk/android/src/jni/surfacetexturehelper_jni.h"
#include "sdk/android/src/jni/surfacetexturehelper.h"
#include "sdk/android/src/jni/videoframe.h"
namespace webrtc {

132
sdk/android/src/jni/androidvideotracksource_jni.cc
View File

@ -1,132 +0,0 @@
/*
* Copyright (c) 2016 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 "api/video/video_rotation.h"
#include "api/videosourceproxy.h"
#include "rtc_base/logging.h"
#include "sdk/android/src/jni/androidvideotracksource.h"
#include "sdk/android/src/jni/classreferenceholder.h"
namespace webrtc {
namespace {
static VideoRotation jintToVideoRotation(jint rotation) {
RTC_DCHECK(rotation == 0 || rotation == 90 || rotation == 180 ||
rotation == 270);
return static_cast<VideoRotation>(rotation);
}
} // namespace
namespace jni {
static AndroidVideoTrackSource* AndroidVideoTrackSourceFromJavaProxy(
jlong j_proxy) {
auto proxy_source = reinterpret_cast<VideoTrackSourceProxy*>(j_proxy);
return reinterpret_cast<AndroidVideoTrackSource*>(proxy_source->internal());
}
JNI_FUNCTION_DECLARATION(
void,
AndroidVideoTrackSourceObserver_nativeOnByteBufferFrameCaptured,
JNIEnv* jni,
jclass,
jlong j_source,
jbyteArray j_frame,
jint length,
jint width,
jint height,
jint rotation,
jlong timestamp) {
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
jbyte* bytes = jni->GetByteArrayElements(j_frame, nullptr);
source->OnByteBufferFrameCaptured(bytes, length, width, height,
jintToVideoRotation(rotation), timestamp);
jni->ReleaseByteArrayElements(j_frame, bytes, JNI_ABORT);
}
JNI_FUNCTION_DECLARATION(
void,
AndroidVideoTrackSourceObserver_nativeOnTextureFrameCaptured,
JNIEnv* jni,
jclass,
jlong j_source,
jint j_width,
jint j_height,
jint j_oes_texture_id,
jfloatArray j_transform_matrix,
jint j_rotation,
jlong j_timestamp) {
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
source->OnTextureFrameCaptured(
j_width, j_height, jintToVideoRotation(j_rotation), j_timestamp,
NativeHandleImpl(jni, j_oes_texture_id, j_transform_matrix));
}
JNI_FUNCTION_DECLARATION(void,
AndroidVideoTrackSourceObserver_nativeOnFrameCaptured,
JNIEnv* jni,
jclass,
jlong j_source,
jint j_width,
jint j_height,
jint j_rotation,
jlong j_timestamp_ns,
jobject j_video_frame_buffer) {
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
source->OnFrameCaptured(jni, j_width, j_height, j_timestamp_ns,
jintToVideoRotation(j_rotation),
j_video_frame_buffer);
}
JNI_FUNCTION_DECLARATION(void,
AndroidVideoTrackSourceObserver_nativeCapturerStarted,
JNIEnv* jni,
jclass,
jlong j_source,
jboolean j_success) {
RTC_LOG(LS_INFO) << "AndroidVideoTrackSourceObserve_nativeCapturerStarted";
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
source->SetState(j_success ? AndroidVideoTrackSource::SourceState::kLive
: AndroidVideoTrackSource::SourceState::kEnded);
}
JNI_FUNCTION_DECLARATION(void,
AndroidVideoTrackSourceObserver_nativeCapturerStopped,
JNIEnv* jni,
jclass,
jlong j_source) {
RTC_LOG(LS_INFO) << "AndroidVideoTrackSourceObserve_nativeCapturerStopped";
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
source->SetState(AndroidVideoTrackSource::SourceState::kEnded);
}
JNI_FUNCTION_DECLARATION(void,
VideoSource_nativeAdaptOutputFormat,
JNIEnv* jni,
jclass,
jlong j_source,
jint j_width,
jint j_height,
jint j_fps) {
RTC_LOG(LS_INFO) << "VideoSource_nativeAdaptOutputFormat";
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
source->OnOutputFormatRequest(j_width, j_height, j_fps);
}
} // namespace jni
} // namespace webrtc

140
sdk/android/src/jni/classreferenceholder.cc
View File

@ -1,140 +0,0 @@
/*
* 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.
*/
#include "sdk/android/src/jni/classreferenceholder.h"
#include "sdk/android/src/jni/class_loader.h"
#include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc {
namespace jni {
// ClassReferenceHolder holds global reference to Java classes in app/webrtc.
class ClassReferenceHolder {
public:
explicit ClassReferenceHolder(JNIEnv* jni);
~ClassReferenceHolder();
void FreeReferences(JNIEnv* jni);
jclass GetClass(const std::string& name);
private:
void LoadClass(JNIEnv* jni, const std::string& name);
std::map<std::string, jclass> classes_;
};
// Allocated in LoadGlobalClassReferenceHolder(),
// freed in FreeGlobalClassReferenceHolder().
static ClassReferenceHolder* g_class_reference_holder = nullptr;
void LoadGlobalClassReferenceHolder() {
JNIEnv* env = GetEnv();
RTC_CHECK(g_class_reference_holder == nullptr);
g_class_reference_holder = new ClassReferenceHolder(env);
// TODO(magjed): This is a weird place to call the other class loader from,
// but the only place that will keep backwards compatibility.
InitClassLoader(env);
}
void FreeGlobalClassReferenceHolder() {
g_class_reference_holder->FreeReferences(AttachCurrentThreadIfNeeded());
delete g_class_reference_holder;
g_class_reference_holder = nullptr;
}
ClassReferenceHolder::ClassReferenceHolder(JNIEnv* jni) {
LoadClass(jni, "android/graphics/SurfaceTexture");
LoadClass(jni, "java/lang/String");
LoadClass(jni, "java/nio/ByteBuffer");
LoadClass(jni, "java/util/ArrayList");
LoadClass(jni, "java/util/LinkedHashMap");
LoadClass(jni, "org/webrtc/Camera1Enumerator");
LoadClass(jni, "org/webrtc/Camera2Enumerator");
LoadClass(jni, "org/webrtc/CameraEnumerationAndroid");
LoadClass(jni, "org/webrtc/EglBase");
LoadClass(jni, "org/webrtc/EglBase$Context");
LoadClass(jni, "org/webrtc/EglBase14$Context");
LoadClass(jni, "org/webrtc/EncodedImage");
LoadClass(jni, "org/webrtc/EncodedImage$FrameType");
LoadClass(jni, "org/webrtc/MediaSource$State");
LoadClass(jni, "org/webrtc/NetworkMonitor");
LoadClass(jni, "org/webrtc/NetworkMonitorAutoDetect$ConnectionType");
LoadClass(jni, "org/webrtc/NetworkMonitorAutoDetect$IPAddress");
LoadClass(jni, "org/webrtc/NetworkMonitorAutoDetect$NetworkInformation");
LoadClass(jni, "org/webrtc/PeerConnection$BundlePolicy");
LoadClass(jni, "org/webrtc/PeerConnection$CandidateNetworkPolicy");
LoadClass(jni, "org/webrtc/PeerConnection$ContinualGatheringPolicy");
LoadClass(jni, "org/webrtc/PeerConnection$IceConnectionState");
LoadClass(jni, "org/webrtc/PeerConnection$IceGatheringState");
LoadClass(jni, "org/webrtc/PeerConnection$IceTransportsType");
LoadClass(jni, "org/webrtc/PeerConnection$KeyType");
LoadClass(jni, "org/webrtc/PeerConnection$RtcpMuxPolicy");
LoadClass(jni, "org/webrtc/PeerConnection$SignalingState");
LoadClass(jni, "org/webrtc/PeerConnection$TcpCandidatePolicy");
LoadClass(jni, "org/webrtc/PeerConnection$TlsCertPolicy");
LoadClass(jni, "org/webrtc/PeerConnectionFactory");
LoadClass(jni, "org/webrtc/RTCStats");
LoadClass(jni, "org/webrtc/RTCStatsReport");
LoadClass(jni, "org/webrtc/RtpReceiver");
LoadClass(jni, "org/webrtc/RtpSender");
LoadClass(jni, "org/webrtc/SessionDescription");
LoadClass(jni, "org/webrtc/SessionDescription$Type");
LoadClass(jni, "org/webrtc/StatsReport");
LoadClass(jni, "org/webrtc/StatsReport$Value");
LoadClass(jni, "org/webrtc/SurfaceTextureHelper");
LoadClass(jni, "org/webrtc/VideoCapturer");
LoadClass(jni, "org/webrtc/VideoCodecInfo");
LoadClass(jni, "org/webrtc/VideoCodecStatus");
LoadClass(jni, "org/webrtc/VideoFrame");
LoadClass(jni, "org/webrtc/VideoFrame$Buffer");
LoadClass(jni, "org/webrtc/VideoFrame$I420Buffer");
LoadClass(jni, "org/webrtc/VideoFrame$TextureBuffer");
LoadClass(jni, "org/webrtc/VideoRenderer$I420Frame");
LoadClass(jni, "org/webrtc/VideoSink");
LoadClass(jni, "org/webrtc/WrappedNativeI420Buffer");
}
ClassReferenceHolder::~ClassReferenceHolder() {
RTC_CHECK(classes_.empty()) << "Must call FreeReferences() before dtor!";
}
void ClassReferenceHolder::FreeReferences(JNIEnv* jni) {
for (std::map<std::string, jclass>::const_iterator it = classes_.begin();
it != classes_.end(); ++it) {
jni->DeleteGlobalRef(it->second);
}
classes_.clear();
}
jclass ClassReferenceHolder::GetClass(const std::string& name) {
std::map<std::string, jclass>::iterator it = classes_.find(name);
RTC_CHECK(it != classes_.end()) << "Unexpected GetClass() call for: " << name;
return it->second;
}
void ClassReferenceHolder::LoadClass(JNIEnv* jni, const std::string& name) {
jclass localRef = jni->FindClass(name.c_str());
CHECK_EXCEPTION(jni) << "error during FindClass: " << name;
RTC_CHECK(localRef) << name;
jclass globalRef = reinterpret_cast<jclass>(jni->NewGlobalRef(localRef));
CHECK_EXCEPTION(jni) << "error during NewGlobalRef: " << name;
RTC_CHECK(globalRef) << name;
bool inserted = classes_.insert(std::make_pair(name, globalRef)).second;
RTC_CHECK(inserted) << "Duplicate class name: " << name;
}
// Returns a global reference guaranteed to be valid for the lifetime of the
// process.
jclass FindClass(JNIEnv* jni, const char* name) {
return g_class_reference_holder->GetClass(name);
}
} // namespace jni
} // namespace webrtc

31
sdk/android/src/jni/classreferenceholder.h
View File

@ -8,35 +8,24 @@
* be found in the AUTHORS file in the root of the source tree.
*/
// Android's FindClass() is trickier than usual because the app-specific
// ClassLoader is not consulted when there is no app-specific frame on the
// stack. Consequently, we only look up all classes once in app/webrtc.
// http://developer.android.com/training/articles/perf-jni.html#faq_FindClass
#ifndef SDK_ANDROID_SRC_JNI_CLASSREFERENCEHOLDER_H_
#define SDK_ANDROID_SRC_JNI_CLASSREFERENCEHOLDER_H_
// TODO(magjed): Remove this whole file and replace with either generated JNI
// code or class_loader.h.
#include <jni.h>
#include <map>
#include <string>
// TODO(magjed): Update external clients to call webrtc::jni::InitClassLoader
// immediately instead.
#include "sdk/android/src/jni/class_loader.h"
#include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc {
namespace jni {
// LoadGlobalClassReferenceHolder must be called in JNI_OnLoad.
void LoadGlobalClassReferenceHolder();
// FreeGlobalClassReferenceHolder must be called in JNI_UnLoad.
void FreeGlobalClassReferenceHolder();
// Deprecated. Call webrtc::jni::InitClassLoader() immediately instead..
inline void LoadGlobalClassReferenceHolder() {
webrtc::jni::InitClassLoader(GetEnv());
}
// Deprecated. Most cases of finding classes should be done with generated JNI
// code, and the few remaining cases should use the function from
// class_loader.h.
// Returns a global reference guaranteed to be valid for the lifetime of the
// process.
jclass FindClass(JNIEnv* jni, const char* name);
// Deprecated. Do not call at all.
inline void FreeGlobalClassReferenceHolder() {}
} // namespace jni
} // namespace webrtc

12
sdk/android/src/jni/jni_generator_helper.cc
View File

@ -63,11 +63,13 @@ jmethodID MethodID::LazyGet(JNIEnv* env,
rtc::AtomicOps::AcquireLoadPtr(atomic_method_id);
if (value)
return reinterpret_cast<jmethodID>(value);
jmethodID id =
(type == MethodID::TYPE_STATIC)
? webrtc::jni::GetStaticMethodID(env, clazz, method_name,
jni_signature)
: webrtc::jni::GetMethodID(env, clazz, method_name, jni_signature);
jmethodID id = (type == MethodID::TYPE_STATIC)
? env->GetStaticMethodID(clazz, method_name, jni_signature)
: env->GetMethodID(clazz, method_name, jni_signature);
CHECK_EXCEPTION(env) << "error during GetMethodID: " << method_name << ", "
<< jni_signature;
RTC_CHECK(id) << method_name << ", " << jni_signature;
rtc::AtomicOps::CompareAndSwapPtr(
atomic_method_id, base::subtle::AtomicWord(nullptr),
reinterpret_cast<base::subtle::AtomicWord>(id));

8
sdk/android/src/jni/jni_generator_helper.h
View File

@ -16,7 +16,9 @@
#ifndef SDK_ANDROID_SRC_JNI_JNI_GENERATOR_HELPER_H_
#define SDK_ANDROID_SRC_JNI_JNI_GENERATOR_HELPER_H_
#include "sdk/android/src/jni/jni_helpers.h"
#include <jni.h>
#include "rtc_base/checks.h"
#define CHECK_CLAZZ(env, jcaller, clazz, ...) RTC_DCHECK(clazz);
#define CHECK_NATIVE_PTR(env, jcaller, native_ptr, method_name, ...) \
@ -26,6 +28,10 @@
#define JNI_REGISTRATION_EXPORT __attribute__((visibility("default")))
#define JNI_GENERATOR_EXPORT extern "C" JNIEXPORT JNICALL
#define CHECK_EXCEPTION(jni) \
RTC_CHECK(!jni->ExceptionCheck()) \
<< (jni->ExceptionDescribe(), jni->ExceptionClear(), "")
namespace jni_generator {
inline void CheckException(JNIEnv* env) {
CHECK_EXCEPTION(env);

155
sdk/android/src/jni/jni_helpers.cc
View File

@ -15,6 +15,7 @@
#include <unistd.h>
#include <vector>
#include "sdk/android/generated_base_jni/jni/JniHelper_jni.h"
#include "sdk/android/generated_external_classes_jni/jni/ArrayList_jni.h"
#include "sdk/android/generated_external_classes_jni/jni/Boolean_jni.h"
#include "sdk/android/generated_external_classes_jni/jni/Double_jni.h"
@ -25,8 +26,6 @@
#include "sdk/android/generated_external_classes_jni/jni/LinkedHashMap_jni.h"
#include "sdk/android/generated_external_classes_jni/jni/Long_jni.h"
#include "sdk/android/generated_external_classes_jni/jni/Map_jni.h"
#include "sdk/android/src/jni/class_loader.h"
#include "sdk/android/src/jni/classreferenceholder.h"
namespace webrtc {
namespace jni {
@ -151,117 +150,21 @@ jlong jlongFromPointer(void* ptr) {
return ret;
}
// JNIEnv-helper methods that RTC_CHECK success: no Java exception thrown and
// found object/class/method/field is non-null.
jmethodID GetMethodID(
JNIEnv* jni, jclass c, const std::string& name, const char* signature) {
jmethodID m = jni->GetMethodID(c, name.c_str(), signature);
CHECK_EXCEPTION(jni) << "error during GetMethodID: " << name << ", "
<< signature;
RTC_CHECK(m) << name << ", " << signature;
return m;
}
jmethodID GetStaticMethodID(
JNIEnv* jni, jclass c, const char* name, const char* signature) {
jmethodID m = jni->GetStaticMethodID(c, name, signature);
CHECK_EXCEPTION(jni) << "error during GetStaticMethodID: " << name << ", "
<< signature;
RTC_CHECK(m) << name << ", " << signature;
return m;
}
jfieldID GetFieldID(
JNIEnv* jni, jclass c, const char* name, const char* signature) {
jfieldID f = jni->GetFieldID(c, name, signature);
CHECK_EXCEPTION(jni) << "error during GetFieldID";
RTC_CHECK(f) << name << ", " << signature;
return f;
}
jfieldID GetStaticFieldID(JNIEnv* jni,
jclass c,
const char* name,
const char* signature) {
jfieldID f = jni->GetStaticFieldID(c, name, signature);
CHECK_EXCEPTION(jni) << "error during GetStaticFieldID";
RTC_CHECK(f) << name << ", " << signature;
return f;
}
jclass GetObjectClass(JNIEnv* jni, jobject object) {
jclass c = jni->GetObjectClass(object);
CHECK_EXCEPTION(jni) << "error during GetObjectClass";
RTC_CHECK(c) << "GetObjectClass returned NULL";
return c;
}
jobject GetObjectField(JNIEnv* jni, jobject object, jfieldID id) {
jobject o = jni->GetObjectField(object, id);
CHECK_EXCEPTION(jni) << "error during GetObjectField";
RTC_CHECK(!IsNull(jni, o)) << "GetObjectField returned NULL";
return o;
}
jobject GetStaticObjectField(JNIEnv* jni, jclass c, jfieldID id) {
jobject o = jni->GetStaticObjectField(c, id);
CHECK_EXCEPTION(jni) << "error during GetStaticObjectField";
RTC_CHECK(!IsNull(jni, o)) << "GetStaticObjectField returned NULL";
return o;
}
jobject GetNullableObjectField(JNIEnv* jni, jobject object, jfieldID id) {
jobject o = jni->GetObjectField(object, id);
CHECK_EXCEPTION(jni) << "error during GetObjectField";
return o;
}
jstring GetStringField(JNIEnv* jni, jobject object, jfieldID id) {
return static_cast<jstring>(GetObjectField(jni, object, id));
}
jlong GetLongField(JNIEnv* jni, jobject object, jfieldID id) {
jlong l = jni->GetLongField(object, id);
CHECK_EXCEPTION(jni) << "error during GetLongField";
return l;
}
jint GetIntField(JNIEnv* jni, jobject object, jfieldID id) {
jint i = jni->GetIntField(object, id);
CHECK_EXCEPTION(jni) << "error during GetIntField";
return i;
}
bool GetBooleanField(JNIEnv* jni, jobject object, jfieldID id) {
jboolean b = jni->GetBooleanField(object, id);
CHECK_EXCEPTION(jni) << "error during GetBooleanField";
return b;
}
bool IsNull(JNIEnv* jni, jobject obj) {
return jni->IsSameObject(obj, nullptr);
}
// Given a jstring, reinterprets it to a new native string.
std::string JavaToStdString(JNIEnv* jni, const jstring& j_string) {
// Invoke String.getBytes(String charsetName) method to convert |j_string|
// to a byte array.
const jclass string_class = GetObjectClass(jni, j_string);
const jmethodID get_bytes =
GetMethodID(jni, string_class, "getBytes", "(Ljava/lang/String;)[B");
const jbyteArray j_byte_array = (jbyteArray)jni->CallObjectMethod(
j_string, get_bytes, NativeToJavaString(jni, "ISO-8859-1"));
CHECK_EXCEPTION(jni) << "error during CallObjectMethod";
const jbyteArray j_byte_array = Java_JniHelper_getStringBytes(jni, j_string);
const size_t len = jni->GetArrayLength(j_byte_array);
CHECK_EXCEPTION(jni) << "error during GetArrayLength";
std::vector<char> buf(len);
std::string str(len, '\0');
jni->GetByteArrayRegion(j_byte_array, 0, len,
reinterpret_cast<jbyte*>(&buf[0]));
reinterpret_cast<jbyte*>(&str[0]));
CHECK_EXCEPTION(jni) << "error during GetByteArrayRegion";
return std::string(buf.begin(), buf.end());
return str;
}
// Given a list of jstrings, reinterprets it to a new vector of native strings.
@ -282,6 +185,10 @@ rtc::Optional<int32_t> JavaToNativeOptionalInt(JNIEnv* jni, jobject integer) {
return JNI_Integer::Java_Integer_intValue(jni, integer);
}
int64_t JavaToNativeLong(JNIEnv* env, jobject j_long) {
return JNI_Long::Java_Long_longValue(env, j_long);
}
jobject NativeToJavaBoolean(JNIEnv* env, bool b) {
return JNI_Boolean::Java_Boolean_ConstructorJLB_Z(env, b);
}
@ -309,29 +216,6 @@ jobject NativeToJavaInteger(JNIEnv* jni,
return optional_int ? NativeToJavaInteger(jni, *optional_int) : nullptr;
}
// Return the (singleton) Java Enum object corresponding to |index|;
static jobject JavaEnumFromIndex(JNIEnv* jni,
jclass state_class,
const std::string& state_class_name,
int index) {
jmethodID state_values_id = GetStaticMethodID(
jni, state_class, "values", ("()[L" + state_class_name + ";").c_str());
jobjectArray state_values = static_cast<jobjectArray>(
jni->CallStaticObjectMethod(state_class, state_values_id));
CHECK_EXCEPTION(jni) << "error during CallStaticObjectMethod";
jobject ret = jni->GetObjectArrayElement(state_values, index);
CHECK_EXCEPTION(jni) << "error during GetObjectArrayElement";
return ret;
}
jobject JavaEnumFromIndexAndClassName(JNIEnv* jni,
const std::string& state_class_fragment,
int index) {
const std::string state_class = "org/webrtc/" + state_class_fragment;
return JavaEnumFromIndex(jni, FindClass(jni, state_class.c_str()),
state_class, index);
}
std::string GetJavaEnumName(JNIEnv* jni, jobject j_enum) {
return JavaToStdString(jni, JNI_Enum::Java_Enum_name(jni, j_enum));
}
@ -339,20 +223,11 @@ std::string GetJavaEnumName(JNIEnv* jni, jobject j_enum) {
std::map<std::string, std::string> JavaToStdMapStrings(JNIEnv* jni,
jobject j_map) {
jobject j_entry_set = JNI_Map::Java_Map_entrySet(jni, j_map);
jclass entry_class = jni->FindClass("java/util/Map$Entry");
jmethodID get_key_method =
jni->GetMethodID(entry_class, "getKey", "()Ljava/lang/Object;");
jmethodID get_value_method =
jni->GetMethodID(entry_class, "getValue", "()Ljava/lang/Object;");
std::map<std::string, std::string> result;
for (jobject j_entry : Iterable(jni, j_entry_set)) {
jstring j_key =
static_cast<jstring>(jni->CallObjectMethod(j_entry, get_key_method));
jstring j_value =
static_cast<jstring>(jni->CallObjectMethod(j_entry, get_value_method));
result.insert(std::make_pair(JavaToStdString(jni, j_key),
JavaToStdString(jni, j_value)));
result.insert(std::make_pair(
JavaToStdString(jni, Java_JniHelper_getKey(jni, j_entry)),
JavaToStdString(jni, Java_JniHelper_getValue(jni, j_entry))));
}
return result;
@ -468,10 +343,10 @@ jobjectArray NativeToJavaLongArray(JNIEnv* env,
jobjectArray NativeToJavaStringArray(
JNIEnv* env,
const std::vector<std::string>& container) {
// TODO(magjed): Remove this class when we can generate it from String.class
// directly (the script currently chokes on that class).
return NativeToJavaObjectArray(
env, container, FindClass(env, "java/lang/String"), &NativeToJavaString);
env, container,
static_cast<jclass>(Java_JniHelper_getStringClass(env).obj()),
&NativeToJavaString);
}
JavaMapBuilder::JavaMapBuilder(JNIEnv* env)

46
sdk/android/src/jni/jni_helpers.h
View File

@ -33,12 +33,6 @@
RTC_CHECK(!jni->ExceptionCheck()) \
<< (jni->ExceptionDescribe(), jni->ExceptionClear(), "")
// Helper that calls ptr->Release() and aborts the process with a useful
// message if that didn't actually delete *ptr because of extra refcounts.
#define CHECK_RELEASE(ptr) \
RTC_CHECK((ptr)->Release() == rtc::RefCountReleaseStatus::kDroppedLastRef) \
<< "Unexpected refcount."
// Convenience macro defining JNI-accessible methods in the org.webrtc package.
// Eliminates unnecessary boilerplate and line-wraps, reducing visual clutter.
#define JNI_FUNCTION_DECLARATION(rettype, name, ...) \
@ -62,39 +56,6 @@ JNIEnv* AttachCurrentThreadIfNeeded();
// function expecting a 64-bit param) picks up garbage in the high 32 bits.
jlong jlongFromPointer(void* ptr);
// JNIEnv-helper methods that RTC_CHECK success: no Java exception thrown and
// found object/class/method/field is non-null.
jmethodID GetMethodID(
JNIEnv* jni, jclass c, const std::string& name, const char* signature);
jmethodID GetStaticMethodID(
JNIEnv* jni, jclass c, const char* name, const char* signature);
jfieldID GetFieldID(JNIEnv* jni, jclass c, const char* name,
const char* signature);
jfieldID GetStaticFieldID(JNIEnv* jni,
jclass c,
const char* name,
const char* signature);
jclass GetObjectClass(JNIEnv* jni, jobject object);
// Throws an exception if the object field is null.
jobject GetObjectField(JNIEnv* jni, jobject object, jfieldID id);
jobject GetStaticObjectField(JNIEnv* jni, jclass c, jfieldID id);
jobject GetNullableObjectField(JNIEnv* jni, jobject object, jfieldID id);
jstring GetStringField(JNIEnv* jni, jobject object, jfieldID id);
jlong GetLongField(JNIEnv* jni, jobject object, jfieldID id);
jint GetIntField(JNIEnv* jni, jobject object, jfieldID id);
bool GetBooleanField(JNIEnv* jni, jobject object, jfieldID id);
// Returns true if |obj| == null in Java.
bool IsNull(JNIEnv* jni, jobject obj);
@ -106,6 +67,7 @@ std::string JavaToStdString(JNIEnv* jni, const jstring& j_string);
std::vector<std::string> JavaToStdVectorStrings(JNIEnv* jni, jobject list);
rtc::Optional<int32_t> JavaToNativeOptionalInt(JNIEnv* jni, jobject integer);
int64_t JavaToNativeLong(JNIEnv* env, jobject j_long);
jobject NativeToJavaBoolean(JNIEnv* env, bool b);
jobject NativeToJavaInteger(JNIEnv* jni, int32_t i);
@ -116,12 +78,6 @@ jstring NativeToJavaString(JNIEnv* jni, const std::string& native);
jobject NativeToJavaInteger(JNIEnv* jni,
const rtc::Optional<int32_t>& optional_int);
// Return the (singleton) Java Enum object corresponding to |index|;
// |state_class_fragment| is something like "MediaSource$State".
jobject JavaEnumFromIndexAndClassName(JNIEnv* jni,
const std::string& state_class_fragment,
int index);
// Parses Map<String, String> to std::map<std::string, std::string>.
std::map<std::string, std::string> JavaToStdMapStrings(JNIEnv* jni,
jobject j_map);

0
sdk/android/src/jni/nv12buffer_jni.cc → sdk/android/src/jni/nv12buffer.cc
View File

0
sdk/android/src/jni/nv21buffer_jni.cc → sdk/android/src/jni/nv21buffer.cc
View File

2
sdk/android/src/jni/pc/androidnetworkmonitor_jni.cc → sdk/android/src/jni/pc/androidnetworkmonitor.cc
View File

@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "sdk/android/src/jni/pc/androidnetworkmonitor_jni.h"
#include "sdk/android/src/jni/pc/androidnetworkmonitor.h"
#include <dlfcn.h>
// This was added in Lollipop to dlfcn.h

6
sdk/android/src/jni/pc/androidnetworkmonitor_jni.h → sdk/android/src/jni/pc/androidnetworkmonitor.h
View File

@ -8,8 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef SDK_ANDROID_SRC_JNI_PC_ANDROIDNETWORKMONITOR_JNI_H_
#define SDK_ANDROID_SRC_JNI_PC_ANDROIDNETWORKMONITOR_JNI_H_
#ifndef SDK_ANDROID_SRC_JNI_PC_ANDROIDNETWORKMONITOR_H_
#define SDK_ANDROID_SRC_JNI_PC_ANDROIDNETWORKMONITOR_H_
#include <stdint.h>
#include <map>
@ -111,4 +111,4 @@ using webrtc::jni::AndroidNetworkMonitorFactory;
} // namespace webrtc_jni
#endif // SDK_ANDROID_SRC_JNI_PC_ANDROIDNETWORKMONITOR_JNI_H_
#endif // SDK_ANDROID_SRC_JNI_PC_ANDROIDNETWORKMONITOR_H_

2
sdk/android/src/jni/pc/audio_jni.cc → sdk/android/src/jni/pc/audio.cc
View File

@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "sdk/android/src/jni/pc/audio_jni.h"
#include "sdk/android/src/jni/pc/audio.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"

10
sdk/android/src/jni/pc/audio_jni.h → sdk/android/src/jni/pc/audio.h
View File

@ -8,13 +8,13 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef SDK_ANDROID_SRC_JNI_PC_AUDIO_JNI_H_
#define SDK_ANDROID_SRC_JNI_PC_AUDIO_JNI_H_
#ifndef SDK_ANDROID_SRC_JNI_PC_AUDIO_H_
#define SDK_ANDROID_SRC_JNI_PC_AUDIO_H_
// Adding 'nogncheck' to disable the gn include headers check.
// We don't want this target depend on audio related targets
#include "api/audio_codecs/audio_decoder_factory.h" // nogncheck
#include "api/audio_codecs/audio_encoder_factory.h" // nogncheck
#include "api/audio_codecs/audio_decoder_factory.h" // nogncheck
#include "api/audio_codecs/audio_encoder_factory.h" // nogncheck
#include "modules/audio_processing/include/audio_processing.h" // nogncheck
#include "rtc_base/scoped_ref_ptr.h"
@ -30,4 +30,4 @@ rtc::scoped_refptr<AudioProcessing> CreateAudioProcessing();
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_PC_AUDIO_JNI_H_
#endif // SDK_ANDROID_SRC_JNI_PC_AUDIO_H_

0
sdk/android/src/jni/pc/audiotrack_jni.cc → sdk/android/src/jni/pc/audiotrack.cc
View File

0
sdk/android/src/jni/pc/callsessionfilerotatinglogsink_jni.cc → sdk/android/src/jni/pc/callsessionfilerotatinglogsink.cc
View File

0
sdk/android/src/jni/pc/defaultaudioprocessingfactory_jni.cc → sdk/android/src/jni/pc/defaultaudioprocessingfactory.cc
View File

0
sdk/android/src/jni/pc/dtmfsender_jni.cc → sdk/android/src/jni/pc/dtmfsender.cc
View File

202
sdk/android/src/jni/pc/icecandidate.cc Normal file
View File

@ -0,0 +1,202 @@
/*
* 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 "sdk/android/src/jni/pc/icecandidate.h"
#include <string>
#include "pc/webrtcsdp.h"
#include "sdk/android/generated_peerconnection_jni/jni/IceCandidate_jni.h"
#include "sdk/android/src/jni/pc/mediastreamtrack.h"
namespace webrtc {
namespace jni {
namespace {
jobject CreateJavaIceCandidate(JNIEnv* env,
const std::string& sdp_mid,
int sdp_mline_index,
const std::string& sdp,
const std::string server_url) {
return Java_IceCandidate_Constructor(
env, NativeToJavaString(env, sdp_mid), sdp_mline_index,
NativeToJavaString(env, sdp), NativeToJavaString(env, server_url));
}
} // namespace
cricket::Candidate JavaToNativeCandidate(JNIEnv* jni, jobject j_candidate) {
std::string sdp_mid =
JavaToStdString(jni, Java_IceCandidate_getSdpMid(jni, j_candidate));
std::string sdp =
JavaToStdString(jni, Java_IceCandidate_getSdp(jni, j_candidate));
cricket::Candidate candidate;
if (!SdpDeserializeCandidate(sdp_mid, sdp, &candidate, NULL)) {
RTC_LOG(LS_ERROR) << "SdpDescrializeCandidate failed with sdp " << sdp;
}
return candidate;
}
jobject NativeToJavaCandidate(JNIEnv* env,
const cricket::Candidate& candidate) {
std::string sdp = SdpSerializeCandidate(candidate);
RTC_CHECK(!sdp.empty()) << "got an empty ICE candidate";
// sdp_mline_index is not used, pass an invalid value -1.
return CreateJavaIceCandidate(env, candidate.transport_name(),
-1 /* sdp_mline_index */, sdp,
"" /* server_url */);
}
jobject NativeToJavaIceCandidate(JNIEnv* env,
const IceCandidateInterface& candidate) {
std::string sdp;
RTC_CHECK(candidate.ToString(&sdp)) << "got so far: " << sdp;
return CreateJavaIceCandidate(env, candidate.sdp_mid(),
candidate.sdp_mline_index(), sdp,
candidate.candidate().url());
}
jobjectArray NativeToJavaCandidateArray(
JNIEnv* jni,
const std::vector<cricket::Candidate>& candidates) {
return NativeToJavaObjectArray(jni, candidates,
org_webrtc_IceCandidate_clazz(jni),
&NativeToJavaCandidate);
}
PeerConnectionInterface::IceTransportsType JavaToNativeIceTransportsType(
JNIEnv* jni,
jobject j_ice_transports_type) {
std::string enum_name = GetJavaEnumName(jni, j_ice_transports_type);
if (enum_name == "ALL")
return PeerConnectionInterface::kAll;
if (enum_name == "RELAY")
return PeerConnectionInterface::kRelay;
if (enum_name == "NOHOST")
return PeerConnectionInterface::kNoHost;
if (enum_name == "NONE")
return PeerConnectionInterface::kNone;
RTC_CHECK(false) << "Unexpected IceTransportsType enum_name " << enum_name;
return PeerConnectionInterface::kAll;
}
PeerConnectionInterface::BundlePolicy JavaToNativeBundlePolicy(
JNIEnv* jni,
jobject j_bundle_policy) {
std::string enum_name = GetJavaEnumName(jni, j_bundle_policy);
if (enum_name == "BALANCED")
return PeerConnectionInterface::kBundlePolicyBalanced;
if (enum_name == "MAXBUNDLE")
return PeerConnectionInterface::kBundlePolicyMaxBundle;
if (enum_name == "MAXCOMPAT")
return PeerConnectionInterface::kBundlePolicyMaxCompat;
RTC_CHECK(false) << "Unexpected BundlePolicy enum_name " << enum_name;
return PeerConnectionInterface::kBundlePolicyBalanced;
}
PeerConnectionInterface::RtcpMuxPolicy JavaToNativeRtcpMuxPolicy(
JNIEnv* jni,
jobject j_rtcp_mux_policy) {
std::string enum_name = GetJavaEnumName(jni, j_rtcp_mux_policy);
if (enum_name == "NEGOTIATE")
return PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
if (enum_name == "REQUIRE")
return PeerConnectionInterface::kRtcpMuxPolicyRequire;
RTC_CHECK(false) << "Unexpected RtcpMuxPolicy enum_name " << enum_name;
return PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
}
PeerConnectionInterface::TcpCandidatePolicy JavaToNativeTcpCandidatePolicy(
JNIEnv* jni,
jobject j_tcp_candidate_policy) {
std::string enum_name = GetJavaEnumName(jni, j_tcp_candidate_policy);
if (enum_name == "ENABLED")
return PeerConnectionInterface::kTcpCandidatePolicyEnabled;
if (enum_name == "DISABLED")
return PeerConnectionInterface::kTcpCandidatePolicyDisabled;
RTC_CHECK(false) << "Unexpected TcpCandidatePolicy enum_name " << enum_name;
return PeerConnectionInterface::kTcpCandidatePolicyEnabled;
}
PeerConnectionInterface::CandidateNetworkPolicy
JavaToNativeCandidateNetworkPolicy(JNIEnv* jni,
jobject j_candidate_network_policy) {
std::string enum_name = GetJavaEnumName(jni, j_candidate_network_policy);
if (enum_name == "ALL")
return PeerConnectionInterface::kCandidateNetworkPolicyAll;
if (enum_name == "LOW_COST")
return PeerConnectionInterface::kCandidateNetworkPolicyLowCost;
RTC_CHECK(false) << "Unexpected CandidateNetworkPolicy enum_name "
<< enum_name;
return PeerConnectionInterface::kCandidateNetworkPolicyAll;
}
rtc::KeyType JavaToNativeKeyType(JNIEnv* jni, jobject j_key_type) {
std::string enum_name = GetJavaEnumName(jni, j_key_type);
if (enum_name == "RSA")
return rtc::KT_RSA;
if (enum_name == "ECDSA")
return rtc::KT_ECDSA;
RTC_CHECK(false) << "Unexpected KeyType enum_name " << enum_name;
return rtc::KT_ECDSA;
}
PeerConnectionInterface::ContinualGatheringPolicy
JavaToNativeContinualGatheringPolicy(JNIEnv* jni, jobject j_gathering_policy) {
std::string enum_name = GetJavaEnumName(jni, j_gathering_policy);
if (enum_name == "GATHER_ONCE")
return PeerConnectionInterface::GATHER_ONCE;
if (enum_name == "GATHER_CONTINUALLY")
return PeerConnectionInterface::GATHER_CONTINUALLY;
RTC_CHECK(false) << "Unexpected ContinualGatheringPolicy enum name "
<< enum_name;
return PeerConnectionInterface::GATHER_ONCE;
}
PeerConnectionInterface::TlsCertPolicy JavaToNativeTlsCertPolicy(
JNIEnv* jni,
jobject j_ice_server_tls_cert_policy) {
std::string enum_name = GetJavaEnumName(jni, j_ice_server_tls_cert_policy);
if (enum_name == "TLS_CERT_POLICY_SECURE")
return PeerConnectionInterface::kTlsCertPolicySecure;
if (enum_name == "TLS_CERT_POLICY_INSECURE_NO_CHECK")
return PeerConnectionInterface::kTlsCertPolicyInsecureNoCheck;
RTC_CHECK(false) << "Unexpected TlsCertPolicy enum_name " << enum_name;
return PeerConnectionInterface::kTlsCertPolicySecure;
}
} // namespace jni
} // namespace webrtc

33
sdk/android/src/jni/pc/java_native_conversion.h → sdk/android/src/jni/pc/icecandidate.h
View File

@ -8,32 +8,22 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef SDK_ANDROID_SRC_JNI_PC_JAVA_NATIVE_CONVERSION_H_
#define SDK_ANDROID_SRC_JNI_PC_JAVA_NATIVE_CONVERSION_H_
#ifndef SDK_ANDROID_SRC_JNI_PC_ICECANDIDATE_H_
#define SDK_ANDROID_SRC_JNI_PC_ICECANDIDATE_H_
#include <vector>
#include "api/datachannelinterface.h"
#include "api/jsep.h"
#include "api/jsepicecandidate.h"
#include "api/mediastreaminterface.h"
#include "api/mediatypes.h"
#include "api/peerconnectioninterface.h"
#include "api/rtpparameters.h"
#include "rtc_base/sslidentity.h"
#include "sdk/android/src/jni/jni_helpers.h"
// This file contains helper methods for converting between simple C++ and Java
// PeerConnection-related structures. Similar to some methods in jni_helpers.h,
// but specifically for structures tied to the PeerConnection API.
namespace webrtc {
namespace jni {
cricket::MediaType JavaToNativeMediaType(JNIEnv* jni, jobject j_media_type);
jobject NativeToJavaMediaType(JNIEnv* jni, cricket::MediaType media_type);
cricket::Candidate JavaToNativeCandidate(JNIEnv* jni, jobject j_candidate);
jobject NativeToJavaCandidate(JNIEnv* env, const cricket::Candidate& candidate);
@ -45,16 +35,6 @@ jobjectArray NativeToJavaCandidateArray(
JNIEnv* jni,
const std::vector<cricket::Candidate>& candidates);
std::unique_ptr<SessionDescriptionInterface> JavaToNativeSessionDescription(
JNIEnv* jni,
jobject j_sdp);
jobject NativeToJavaSessionDescription(JNIEnv* jni,
const SessionDescriptionInterface* desc);
PeerConnectionFactoryInterface::Options
JavaToNativePeerConnectionFactoryOptions(JNIEnv* jni, jobject options);
/*****************************************************
* Below are all things that go into RTCConfiguration.
*****************************************************/
@ -87,14 +67,7 @@ PeerConnectionInterface::TlsCertPolicy JavaToNativeTlsCertPolicy(
JNIEnv* jni,
jobject j_ice_server_tls_cert_policy);
/*********************************************************
* RtpParameters, used for RtpSender and RtpReceiver APIs.
*********************************************************/
RtpParameters JavaToNativeRtpParameters(JNIEnv* jni, jobject j_parameters);
jobject NativeToJavaRtpParameters(JNIEnv* jni, const RtpParameters& parameters);
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_PC_JAVA_NATIVE_CONVERSION_H_
#endif // SDK_ANDROID_SRC_JNI_PC_ICECANDIDATE_H_

443
sdk/android/src/jni/pc/java_native_conversion.cc
View File

@ -1,443 +0,0 @@
/*
* 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 "sdk/android/src/jni/pc/java_native_conversion.h"
#include <string>
#include "pc/webrtcsdp.h"
#include "sdk/android/generated_peerconnection_jni/jni/IceCandidate_jni.h"
#include "sdk/android/generated_peerconnection_jni/jni/MediaStreamTrack_jni.h"
#include "sdk/android/src/jni/classreferenceholder.h"
namespace webrtc {
namespace jni {
namespace {
jobject CreateJavaIceCandidate(JNIEnv* env,
const std::string& sdp_mid,
int sdp_mline_index,
const std::string& sdp,
const std::string server_url) {
return Java_IceCandidate_Constructor(
env, NativeToJavaString(env, sdp_mid), sdp_mline_index,
NativeToJavaString(env, sdp), NativeToJavaString(env, server_url));
}
} // namespace
jobject NativeToJavaMediaType(JNIEnv* jni, cricket::MediaType media_type) {
return Java_MediaType_fromNativeIndex(jni, media_type);
}
cricket::MediaType JavaToNativeMediaType(JNIEnv* jni, jobject j_media_type) {
return static_cast<cricket::MediaType>(
Java_MediaType_getNative(jni, j_media_type));
}
cricket::Candidate JavaToNativeCandidate(JNIEnv* jni, jobject j_candidate) {
std::string sdp_mid =
JavaToStdString(jni, Java_IceCandidate_getSdpMid(jni, j_candidate));
std::string sdp =
JavaToStdString(jni, Java_IceCandidate_getSdp(jni, j_candidate));
cricket::Candidate candidate;
if (!SdpDeserializeCandidate(sdp_mid, sdp, &candidate, NULL)) {
RTC_LOG(LS_ERROR) << "SdpDescrializeCandidate failed with sdp " << sdp;
}
return candidate;
}
jobject NativeToJavaCandidate(JNIEnv* env,
const cricket::Candidate& candidate) {
std::string sdp = SdpSerializeCandidate(candidate);
RTC_CHECK(!sdp.empty()) << "got an empty ICE candidate";
// sdp_mline_index is not used, pass an invalid value -1.
return CreateJavaIceCandidate(env, candidate.transport_name(),
-1 /* sdp_mline_index */, sdp,
"" /* server_url */);
}
jobject NativeToJavaIceCandidate(JNIEnv* env,
const IceCandidateInterface& candidate) {
std::string sdp;
RTC_CHECK(candidate.ToString(&sdp)) << "got so far: " << sdp;
return CreateJavaIceCandidate(env, candidate.sdp_mid(),
candidate.sdp_mline_index(), sdp,
candidate.candidate().url());
}
jobjectArray NativeToJavaCandidateArray(
JNIEnv* jni,
const std::vector<cricket::Candidate>& candidates) {
return NativeToJavaObjectArray(jni, candidates,
org_webrtc_IceCandidate_clazz(jni),
&NativeToJavaCandidate);
}
std::unique_ptr<SessionDescriptionInterface> JavaToNativeSessionDescription(
JNIEnv* jni,
jobject j_sdp) {
jfieldID j_type_id = GetFieldID(jni, GetObjectClass(jni, j_sdp), "type",
"Lorg/webrtc/SessionDescription$Type;");
jobject j_type = GetObjectField(jni, j_sdp, j_type_id);
jmethodID j_canonical_form_id =
GetMethodID(jni, GetObjectClass(jni, j_type), "canonicalForm",
"()Ljava/lang/String;");
jstring j_type_string =
(jstring)jni->CallObjectMethod(j_type, j_canonical_form_id);
CHECK_EXCEPTION(jni) << "error during CallObjectMethod";
std::string std_type = JavaToStdString(jni, j_type_string);
rtc::Optional<SdpType> sdp_type_maybe = SdpTypeFromString(std_type);
if (!sdp_type_maybe) {
RTC_LOG(LS_ERROR) << "Unexpected SDP type: " << std_type;
return nullptr;
}
jfieldID j_description_id = GetFieldID(jni, GetObjectClass(jni, j_sdp),
"description", "Ljava/lang/String;");
jstring j_description = (jstring)GetObjectField(jni, j_sdp, j_description_id);
std::string std_description = JavaToStdString(jni, j_description);
return CreateSessionDescription(*sdp_type_maybe, std_description);
}
jobject NativeToJavaSessionDescription(
JNIEnv* jni,
const SessionDescriptionInterface* desc) {
std::string sdp;
RTC_CHECK(desc->ToString(&sdp)) << "got so far: " << sdp;
jstring j_description = NativeToJavaString(jni, sdp);
jclass j_type_class = FindClass(jni, "org/webrtc/SessionDescription$Type");
jmethodID j_type_from_canonical = GetStaticMethodID(
jni, j_type_class, "fromCanonicalForm",
"(Ljava/lang/String;)Lorg/webrtc/SessionDescription$Type;");
jstring j_type_string = NativeToJavaString(jni, desc->type());
jobject j_type = jni->CallStaticObjectMethod(
j_type_class, j_type_from_canonical, j_type_string);
CHECK_EXCEPTION(jni) << "error during CallObjectMethod";
jclass j_sdp_class = FindClass(jni, "org/webrtc/SessionDescription");
jmethodID j_sdp_ctor =
GetMethodID(jni, j_sdp_class, "<init>",
"(Lorg/webrtc/SessionDescription$Type;Ljava/lang/String;)V");
jobject j_sdp =
jni->NewObject(j_sdp_class, j_sdp_ctor, j_type, j_description);
CHECK_EXCEPTION(jni) << "error during NewObject";
return j_sdp;
}
PeerConnectionFactoryInterface::Options
JavaToNativePeerConnectionFactoryOptions(JNIEnv* jni, jobject options) {
jclass options_class = jni->GetObjectClass(options);
jfieldID network_ignore_mask_field =
jni->GetFieldID(options_class, "networkIgnoreMask", "I");
int network_ignore_mask =
jni->GetIntField(options, network_ignore_mask_field);
jfieldID disable_encryption_field =
jni->GetFieldID(options_class, "disableEncryption", "Z");
bool disable_encryption =
jni->GetBooleanField(options, disable_encryption_field);
jfieldID disable_network_monitor_field =
jni->GetFieldID(options_class, "disableNetworkMonitor", "Z");
bool disable_network_monitor =
jni->GetBooleanField(options, disable_network_monitor_field);
PeerConnectionFactoryInterface::Options native_options;
// This doesn't necessarily match the c++ version of this struct; feel free
// to add more parameters as necessary.
native_options.network_ignore_mask = network_ignore_mask;
native_options.disable_encryption = disable_encryption;
native_options.disable_network_monitor = disable_network_monitor;
return native_options;
}
PeerConnectionInterface::IceTransportsType JavaToNativeIceTransportsType(
JNIEnv* jni,
jobject j_ice_transports_type) {
std::string enum_name = GetJavaEnumName(jni, j_ice_transports_type);
if (enum_name == "ALL")
return PeerConnectionInterface::kAll;
if (enum_name == "RELAY")
return PeerConnectionInterface::kRelay;
if (enum_name == "NOHOST")
return PeerConnectionInterface::kNoHost;
if (enum_name == "NONE")
return PeerConnectionInterface::kNone;
RTC_CHECK(false) << "Unexpected IceTransportsType enum_name " << enum_name;
return PeerConnectionInterface::kAll;
}
PeerConnectionInterface::BundlePolicy JavaToNativeBundlePolicy(
JNIEnv* jni,
jobject j_bundle_policy) {
std::string enum_name = GetJavaEnumName(jni, j_bundle_policy);
if (enum_name == "BALANCED")
return PeerConnectionInterface::kBundlePolicyBalanced;
if (enum_name == "MAXBUNDLE")
return PeerConnectionInterface::kBundlePolicyMaxBundle;
if (enum_name == "MAXCOMPAT")
return PeerConnectionInterface::kBundlePolicyMaxCompat;
RTC_CHECK(false) << "Unexpected BundlePolicy enum_name " << enum_name;
return PeerConnectionInterface::kBundlePolicyBalanced;
}
PeerConnectionInterface::RtcpMuxPolicy JavaToNativeRtcpMuxPolicy(
JNIEnv* jni,
jobject j_rtcp_mux_policy) {
std::string enum_name = GetJavaEnumName(jni, j_rtcp_mux_policy);
if (enum_name == "NEGOTIATE")
return PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
if (enum_name == "REQUIRE")
return PeerConnectionInterface::kRtcpMuxPolicyRequire;
RTC_CHECK(false) << "Unexpected RtcpMuxPolicy enum_name " << enum_name;
return PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
}
PeerConnectionInterface::TcpCandidatePolicy JavaToNativeTcpCandidatePolicy(
JNIEnv* jni,
jobject j_tcp_candidate_policy) {
std::string enum_name = GetJavaEnumName(jni, j_tcp_candidate_policy);
if (enum_name == "ENABLED")
return PeerConnectionInterface::kTcpCandidatePolicyEnabled;
if (enum_name == "DISABLED")
return PeerConnectionInterface::kTcpCandidatePolicyDisabled;
RTC_CHECK(false) << "Unexpected TcpCandidatePolicy enum_name " << enum_name;
return PeerConnectionInterface::kTcpCandidatePolicyEnabled;
}
PeerConnectionInterface::CandidateNetworkPolicy
JavaToNativeCandidateNetworkPolicy(JNIEnv* jni,
jobject j_candidate_network_policy) {
std::string enum_name = GetJavaEnumName(jni, j_candidate_network_policy);
if (enum_name == "ALL")
return PeerConnectionInterface::kCandidateNetworkPolicyAll;
if (enum_name == "LOW_COST")
return PeerConnectionInterface::kCandidateNetworkPolicyLowCost;
RTC_CHECK(false) << "Unexpected CandidateNetworkPolicy enum_name "
<< enum_name;
return PeerConnectionInterface::kCandidateNetworkPolicyAll;
}
rtc::KeyType JavaToNativeKeyType(JNIEnv* jni, jobject j_key_type) {
std::string enum_name = GetJavaEnumName(jni, j_key_type);
if (enum_name == "RSA")
return rtc::KT_RSA;
if (enum_name == "ECDSA")
return rtc::KT_ECDSA;
RTC_CHECK(false) << "Unexpected KeyType enum_name " << enum_name;
return rtc::KT_ECDSA;
}
PeerConnectionInterface::ContinualGatheringPolicy
JavaToNativeContinualGatheringPolicy(JNIEnv* jni, jobject j_gathering_policy) {
std::string enum_name = GetJavaEnumName(jni, j_gathering_policy);
if (enum_name == "GATHER_ONCE")
return PeerConnectionInterface::GATHER_ONCE;
if (enum_name == "GATHER_CONTINUALLY")
return PeerConnectionInterface::GATHER_CONTINUALLY;
RTC_CHECK(false) << "Unexpected ContinualGatheringPolicy enum name "
<< enum_name;
return PeerConnectionInterface::GATHER_ONCE;
}
PeerConnectionInterface::TlsCertPolicy JavaToNativeTlsCertPolicy(
JNIEnv* jni,
jobject j_ice_server_tls_cert_policy) {
std::string enum_name = GetJavaEnumName(jni, j_ice_server_tls_cert_policy);
if (enum_name == "TLS_CERT_POLICY_SECURE")
return PeerConnectionInterface::kTlsCertPolicySecure;
if (enum_name == "TLS_CERT_POLICY_INSECURE_NO_CHECK")
return PeerConnectionInterface::kTlsCertPolicyInsecureNoCheck;
RTC_CHECK(false) << "Unexpected TlsCertPolicy enum_name " << enum_name;
return PeerConnectionInterface::kTlsCertPolicySecure;
}
RtpParameters JavaToNativeRtpParameters(JNIEnv* jni, jobject j_parameters) {
RtpParameters parameters;
jclass parameters_class = jni->FindClass("org/webrtc/RtpParameters");
jfieldID encodings_id =
GetFieldID(jni, parameters_class, "encodings", "Ljava/util/List;");
jfieldID codecs_id =
GetFieldID(jni, parameters_class, "codecs", "Ljava/util/List;");
// Convert encodings.
jobject j_encodings = GetObjectField(jni, j_parameters, encodings_id);
jclass j_encoding_parameters_class =
jni->FindClass("org/webrtc/RtpParameters$Encoding");
jfieldID active_id =
GetFieldID(jni, j_encoding_parameters_class, "active", "Z");
jfieldID bitrate_id = GetFieldID(jni, j_encoding_parameters_class,
"maxBitrateBps", "Ljava/lang/Integer;");
jfieldID ssrc_id =
GetFieldID(jni, j_encoding_parameters_class, "ssrc", "Ljava/lang/Long;");
jclass j_long_class = jni->FindClass("java/lang/Long");
jmethodID long_value_id = GetMethodID(jni, j_long_class, "longValue", "()J");
for (jobject j_encoding_parameters : Iterable(jni, j_encodings)) {
RtpEncodingParameters encoding;
encoding.active = GetBooleanField(jni, j_encoding_parameters, active_id);
jobject j_bitrate =
GetNullableObjectField(jni, j_encoding_parameters, bitrate_id);
encoding.max_bitrate_bps = JavaToNativeOptionalInt(jni, j_bitrate);
jobject j_ssrc =
GetNullableObjectField(jni, j_encoding_parameters, ssrc_id);
if (!IsNull(jni, j_ssrc)) {
jlong ssrc_value = jni->CallLongMethod(j_ssrc, long_value_id);
CHECK_EXCEPTION(jni) << "error during CallLongMethod";
encoding.ssrc = ssrc_value;
}
parameters.encodings.push_back(encoding);
}
// Convert codecs.
jobject j_codecs = GetObjectField(jni, j_parameters, codecs_id);
jclass codec_class = jni->FindClass("org/webrtc/RtpParameters$Codec");
jfieldID payload_type_id = GetFieldID(jni, codec_class, "payloadType", "I");
jfieldID name_id = GetFieldID(jni, codec_class, "name", "Ljava/lang/String;");
jfieldID kind_id = GetFieldID(jni, codec_class, "kind",
"Lorg/webrtc/MediaStreamTrack$MediaType;");
jfieldID clock_rate_id =
GetFieldID(jni, codec_class, "clockRate", "Ljava/lang/Integer;");
jfieldID num_channels_id =
GetFieldID(jni, codec_class, "numChannels", "Ljava/lang/Integer;");
for (jobject j_codec : Iterable(jni, j_codecs)) {
RtpCodecParameters codec;
codec.payload_type = GetIntField(jni, j_codec, payload_type_id);
codec.name = JavaToStdString(jni, GetStringField(jni, j_codec, name_id));
codec.kind =
JavaToNativeMediaType(jni, GetObjectField(jni, j_codec, kind_id));
jobject j_clock_rate = GetNullableObjectField(jni, j_codec, clock_rate_id);
codec.clock_rate = JavaToNativeOptionalInt(jni, j_clock_rate);
jobject j_num_channels =
GetNullableObjectField(jni, j_codec, num_channels_id);
codec.num_channels = JavaToNativeOptionalInt(jni, j_num_channels);
parameters.codecs.push_back(codec);
}
return parameters;
}
jobject NativeToJavaRtpParameters(JNIEnv* jni,
const RtpParameters& parameters) {
jclass parameters_class = jni->FindClass("org/webrtc/RtpParameters");
jmethodID parameters_ctor =
GetMethodID(jni, parameters_class, "<init>", "()V");
jobject j_parameters = jni->NewObject(parameters_class, parameters_ctor);
CHECK_EXCEPTION(jni) << "error during NewObject";
// Add encodings.
jclass encoding_class = jni->FindClass("org/webrtc/RtpParameters$Encoding");
jmethodID encoding_ctor = GetMethodID(jni, encoding_class, "<init>", "()V");
jfieldID encodings_id =
GetFieldID(jni, parameters_class, "encodings", "Ljava/util/List;");
jobject j_encodings = GetObjectField(jni, j_parameters, encodings_id);
jmethodID encodings_add = GetMethodID(jni, GetObjectClass(jni, j_encodings),
"add", "(Ljava/lang/Object;)Z");
jfieldID active_id = GetFieldID(jni, encoding_class, "active", "Z");
jfieldID bitrate_id =
GetFieldID(jni, encoding_class, "maxBitrateBps", "Ljava/lang/Integer;");
jfieldID ssrc_id =
GetFieldID(jni, encoding_class, "ssrc", "Ljava/lang/Long;");
jclass long_class = jni->FindClass("java/lang/Long");
jmethodID long_ctor = GetMethodID(jni, long_class, "<init>", "(J)V");
for (const RtpEncodingParameters& encoding : parameters.encodings) {
jobject j_encoding_parameters =
jni->NewObject(encoding_class, encoding_ctor);
CHECK_EXCEPTION(jni) << "error during NewObject";
jni->SetBooleanField(j_encoding_parameters, active_id, encoding.active);
CHECK_EXCEPTION(jni) << "error during SetBooleanField";
jni->SetObjectField(j_encoding_parameters, bitrate_id,
NativeToJavaInteger(jni, encoding.max_bitrate_bps));
if (encoding.ssrc) {
jobject j_ssrc_value = jni->NewObject(long_class, long_ctor,
static_cast<jlong>(*encoding.ssrc));
CHECK_EXCEPTION(jni) << "error during NewObject";
jni->SetObjectField(j_encoding_parameters, ssrc_id, j_ssrc_value);
CHECK_EXCEPTION(jni) << "error during SetObjectField";
}
jboolean added = jni->CallBooleanMethod(j_encodings, encodings_add,
j_encoding_parameters);
CHECK_EXCEPTION(jni) << "error during CallBooleanMethod";
RTC_CHECK(added);
}
// Add codecs.
jclass codec_class = jni->FindClass("org/webrtc/RtpParameters$Codec");
jmethodID codec_ctor = GetMethodID(jni, codec_class, "<init>", "()V");
jfieldID codecs_id =
GetFieldID(jni, parameters_class, "codecs", "Ljava/util/List;");
jobject j_codecs = GetObjectField(jni, j_parameters, codecs_id);
jmethodID codecs_add = GetMethodID(jni, GetObjectClass(jni, j_codecs), "add",
"(Ljava/lang/Object;)Z");
jfieldID payload_type_id = GetFieldID(jni, codec_class, "payloadType", "I");
jfieldID name_id = GetFieldID(jni, codec_class, "name", "Ljava/lang/String;");
jfieldID kind_id = GetFieldID(jni, codec_class, "kind",
"Lorg/webrtc/MediaStreamTrack$MediaType;");
jfieldID clock_rate_id =
GetFieldID(jni, codec_class, "clockRate", "Ljava/lang/Integer;");
jfieldID num_channels_id =
GetFieldID(jni, codec_class, "numChannels", "Ljava/lang/Integer;");
for (const RtpCodecParameters& codec : parameters.codecs) {
jobject j_codec = jni->NewObject(codec_class, codec_ctor);
CHECK_EXCEPTION(jni) << "error during NewObject";
jni->SetIntField(j_codec, payload_type_id, codec.payload_type);
CHECK_EXCEPTION(jni) << "error during SetIntField";
jni->SetObjectField(j_codec, name_id, NativeToJavaString(jni, codec.name));
CHECK_EXCEPTION(jni) << "error during SetObjectField";
jni->SetObjectField(j_codec, kind_id,
NativeToJavaMediaType(jni, codec.kind));
CHECK_EXCEPTION(jni) << "error during SetObjectField";
jni->SetObjectField(j_codec, clock_rate_id,
NativeToJavaInteger(jni, codec.clock_rate));
jni->SetObjectField(j_codec, num_channels_id,
NativeToJavaInteger(jni, codec.num_channels));
jboolean added = jni->CallBooleanMethod(j_codecs, codecs_add, j_codec);
CHECK_EXCEPTION(jni) << "error during CallBooleanMethod";
RTC_CHECK(added);
}
return j_parameters;
}
} // namespace jni
} // namespace webrtc

0
sdk/android/src/jni/pc/logging_jni.cc → sdk/android/src/jni/pc/logging.cc
View File

4
sdk/android/src/jni/pc/media_jni.cc → sdk/android/src/jni/pc/media.cc
View File

@ -7,7 +7,9 @@
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "sdk/android/src/jni/pc/media_jni.h"
#include "sdk/android/src/jni/pc/media.h"
#include <utility>
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h"

8
sdk/android/src/jni/pc/media_jni.h → sdk/android/src/jni/pc/media.h
View File

@ -8,8 +8,10 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef SDK_ANDROID_SRC_JNI_PC_MEDIA_JNI_H_
#define SDK_ANDROID_SRC_JNI_PC_MEDIA_JNI_H_
#ifndef SDK_ANDROID_SRC_JNI_PC_MEDIA_H_
#define SDK_ANDROID_SRC_JNI_PC_MEDIA_H_
#include <memory>
#include "rtc_base/scoped_ref_ptr.h"
@ -58,4 +60,4 @@ cricket::MediaEngineInterface* CreateMediaEngine(
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_PC_MEDIA_JNI_H_
#endif // SDK_ANDROID_SRC_JNI_PC_MEDIA_H_

2
sdk/android/src/jni/pc/mediaconstraints_jni.cc → sdk/android/src/jni/pc/mediaconstraints.cc
View File

@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "sdk/android/src/jni/pc/mediaconstraints_jni.h"
#include "sdk/android/src/jni/pc/mediaconstraints.h"
#include "rtc_base/ptr_util.h"
#include "sdk/android/generated_peerconnection_jni/jni/MediaConstraints_jni.h"

7
sdk/android/src/jni/pc/mediaconstraints_jni.h → sdk/android/src/jni/pc/mediaconstraints.h
View File

@ -8,10 +8,11 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef SDK_ANDROID_SRC_JNI_PC_MEDIACONSTRAINTS_JNI_H_
#define SDK_ANDROID_SRC_JNI_PC_MEDIACONSTRAINTS_JNI_H_
#ifndef SDK_ANDROID_SRC_JNI_PC_MEDIACONSTRAINTS_H_
#define SDK_ANDROID_SRC_JNI_PC_MEDIACONSTRAINTS_H_
#include <jni.h>
#include <memory>
#include "api/mediaconstraintsinterface.h"
@ -25,4 +26,4 @@ std::unique_ptr<MediaConstraintsInterface> JavaToNativeMediaConstraints(
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_PC_MEDIACONSTRAINTS_JNI_H_
#endif // SDK_ANDROID_SRC_JNI_PC_MEDIACONSTRAINTS_H_

8
sdk/android/src/jni/pc/mediasource_jni.cc → sdk/android/src/jni/pc/mediasource.cc
View File

@ -9,19 +9,19 @@
*/
#include "api/mediastreaminterface.h"
#include "sdk/android/generated_peerconnection_jni/jni/MediaSource_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc {
namespace jni {
JNI_FUNCTION_DECLARATION(jobject,
MediaSource_nativeState,
MediaSource_getNativeState,
JNIEnv* jni,
jclass,
jlong j_p) {
rtc::scoped_refptr<MediaSourceInterface> p(
reinterpret_cast<MediaSourceInterface*>(j_p));
return JavaEnumFromIndexAndClassName(jni, "MediaSource$State", p->state());
return Java_State_fromNativeIndex(
jni, reinterpret_cast<MediaSourceInterface*>(j_p)->state());
}
} // namespace jni

0
sdk/android/src/jni/pc/mediastream_jni.cc → sdk/android/src/jni/pc/mediastream.cc
View File

17
sdk/android/src/jni/pc/mediastreamtrack_jni.cc → sdk/android/src/jni/pc/mediastreamtrack.cc
View File

@ -8,12 +8,24 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "sdk/android/src/jni/pc/mediastreamtrack.h"
#include "api/mediastreaminterface.h"
#include "sdk/android/generated_peerconnection_jni/jni/MediaStreamTrack_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc {
namespace jni {
jobject NativeToJavaMediaType(JNIEnv* jni, cricket::MediaType media_type) {
return Java_MediaType_fromNativeIndex(jni, media_type);
}
cricket::MediaType JavaToNativeMediaType(JNIEnv* jni, jobject j_media_type) {
return static_cast<cricket::MediaType>(
Java_MediaType_getNative(jni, j_media_type));
}
JNI_FUNCTION_DECLARATION(jstring,
MediaStreamTrack_getNativeId,
JNIEnv* jni,
@ -45,9 +57,8 @@ JNI_FUNCTION_DECLARATION(jobject,
JNIEnv* jni,
jclass,
jlong j_p) {
return JavaEnumFromIndexAndClassName(
jni, "MediaStreamTrack$State",
reinterpret_cast<MediaStreamTrackInterface*>(j_p)->state());
return Java_State_fromNativeIndex(
jni, reinterpret_cast<MediaStreamTrackInterface*>(j_p)->state());
}
JNI_FUNCTION_DECLARATION(jboolean,

27
sdk/android/src/jni/pc/mediastreamtrack.h Normal file
View File

@ -0,0 +1,27 @@
/*
* 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.
*/
#ifndef SDK_ANDROID_SRC_JNI_PC_MEDIASTREAMTRACK_H_
#define SDK_ANDROID_SRC_JNI_PC_MEDIASTREAMTRACK_H_
#include <jni.h>
#include "api/mediatypes.h"
namespace webrtc {
namespace jni {
jobject NativeToJavaMediaType(JNIEnv* jni, cricket::MediaType media_type);
cricket::MediaType JavaToNativeMediaType(JNIEnv* jni, jobject j_media_type);
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_PC_MEDIASTREAMTRACK_H_

2
sdk/android/src/jni/pc/null_audio_jni.cc → sdk/android/src/jni/pc/null_audio.cc
View File

@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "sdk/android/src/jni/pc/audio_jni.h"
#include "sdk/android/src/jni/pc/audio.h"
namespace webrtc {
namespace jni {

2
sdk/android/src/jni/pc/null_media_jni.cc → sdk/android/src/jni/pc/null_media.cc
View File

@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "sdk/android/src/jni/pc/media_jni.h"
#include "sdk/android/src/jni/pc/media.h"
namespace webrtc {
namespace jni {

2
sdk/android/src/jni/pc/null_video_jni.cc → sdk/android/src/jni/pc/null_video.cc
View File

@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "sdk/android/src/jni/pc/video_jni.h"
#include "sdk/android/src/jni/pc/video.h"
namespace webrtc {
namespace jni {

35
sdk/android/src/jni/pc/ownedfactoryandthreads.cc
View File

@ -10,9 +10,8 @@
#include "sdk/android/src/jni/pc/ownedfactoryandthreads.h"
#include "rtc_base/logging.h"
#include "sdk/android/src/jni/classreferenceholder.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/pc/peerconnectionfactory.h"
namespace webrtc {
namespace jni {
@ -22,44 +21,20 @@ PeerConnectionFactoryInterface* factoryFromJava(jlong j_p) {
}
OwnedFactoryAndThreads::~OwnedFactoryAndThreads() {
CHECK_RELEASE(factory_);
factory_->Release();
if (network_monitor_factory_ != nullptr) {
rtc::NetworkMonitorFactory::ReleaseFactory(network_monitor_factory_);
}
}
void OwnedFactoryAndThreads::JavaCallbackOnFactoryThreads() {
JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni);
jclass j_factory_class = FindClass(jni, "org/webrtc/PeerConnectionFactory");
jmethodID m = nullptr;
if (network_thread_->IsCurrent()) {
RTC_LOG(LS_INFO) << "Network thread JavaCallback";
m = GetStaticMethodID(jni, j_factory_class, "onNetworkThreadReady", "()V");
}
if (worker_thread_->IsCurrent()) {
RTC_LOG(LS_INFO) << "Worker thread JavaCallback";
m = GetStaticMethodID(jni, j_factory_class, "onWorkerThreadReady", "()V");
}
if (signaling_thread_->IsCurrent()) {
RTC_LOG(LS_INFO) << "Signaling thread JavaCallback";
m = GetStaticMethodID(jni, j_factory_class, "onSignalingThreadReady",
"()V");
}
if (m != nullptr) {
jni->CallStaticVoidMethod(j_factory_class, m);
CHECK_EXCEPTION(jni) << "error during JavaCallback::CallStaticVoidMethod";
}
}
void OwnedFactoryAndThreads::InvokeJavaCallbacksOnFactoryThreads() {
RTC_LOG(LS_INFO) << "InvokeJavaCallbacksOnFactoryThreads.";
network_thread_->Invoke<void>(RTC_FROM_HERE,
[this] { JavaCallbackOnFactoryThreads(); });
&PeerConnectionFactoryNetworkThreadReady);
worker_thread_->Invoke<void>(RTC_FROM_HERE,
[this] { JavaCallbackOnFactoryThreads(); });
&PeerConnectionFactoryWorkerThreadReady);
signaling_thread_->Invoke<void>(RTC_FROM_HERE,
[this] { JavaCallbackOnFactoryThreads(); });
&PeerConnectionFactorySignalingThreadReady);
}
} // namespace jni

2
sdk/android/src/jni/pc/ownedfactoryandthreads.h
View File

@ -68,8 +68,6 @@ class OwnedFactoryAndThreads {
void InvokeJavaCallbacksOnFactoryThreads();
private:
void JavaCallbackOnFactoryThreads();
const std::unique_ptr<Thread> network_thread_;
const std::unique_ptr<Thread> worker_thread_;
const std::unique_ptr<Thread> signaling_thread_;

252
sdk/android/src/jni/pc/peerconnection.cc
View File

@ -42,27 +42,24 @@
#include "sdk/android/generated_peerconnection_jni/jni/MediaStream_jni.h"
#include "sdk/android/generated_peerconnection_jni/jni/PeerConnection_jni.h"
#include "sdk/android/generated_peerconnection_jni/jni/RtpSender_jni.h"
#include "sdk/android/src/jni/classreferenceholder.h"
#include "sdk/android/generated_peerconnection_jni/jni/TurnCustomizer_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/pc/datachannel.h"
#include "sdk/android/src/jni/pc/java_native_conversion.h"
#include "sdk/android/src/jni/pc/mediaconstraints_jni.h"
#include "sdk/android/src/jni/pc/icecandidate.h"
#include "sdk/android/src/jni/pc/mediaconstraints.h"
#include "sdk/android/src/jni/pc/rtcstatscollectorcallbackwrapper.h"
#include "sdk/android/src/jni/pc/sdpobserver_jni.h"
#include "sdk/android/src/jni/pc/statsobserver_jni.h"
#include "sdk/android/src/jni/pc/sdpobserver.h"
#include "sdk/android/src/jni/pc/sessiondescription.h"
#include "sdk/android/src/jni/pc/statsobserver.h"
namespace webrtc {
namespace jni {
namespace {
rtc::scoped_refptr<PeerConnectionInterface> ExtractNativePC(JNIEnv* jni,
jobject j_pc) {
jfieldID native_pc_id =
GetFieldID(jni, GetObjectClass(jni, j_pc), "nativePeerConnection", "J");
jlong j_p = GetLongField(jni, j_pc, native_pc_id);
return rtc::scoped_refptr<PeerConnectionInterface>(
reinterpret_cast<PeerConnectionInterface*>(j_p));
PeerConnectionInterface* ExtractNativePC(JNIEnv* jni, jobject j_pc) {
return reinterpret_cast<PeerConnectionInterface*>(
Java_PeerConnection_getNativePeerConnection(jni, j_pc));
}
jobject NativeToJavaRtpSender(JNIEnv* env,
@ -74,49 +71,23 @@ jobject NativeToJavaRtpSender(JNIEnv* env,
return Java_RtpSender_Constructor(env, jlongFromPointer(sender.release()));
}
// Convenience, used since callbacks occur on the signaling thread, which may
// be a non-Java thread.
JNIEnv* jni() {
return AttachCurrentThreadIfNeeded();
}
} // namespace
void JavaToNativeIceServers(JNIEnv* jni,
jobject j_ice_servers,
PeerConnectionInterface::IceServers* ice_servers) {
PeerConnectionInterface::IceServers JavaToNativeIceServers(
JNIEnv* jni,
jobject j_ice_servers) {
PeerConnectionInterface::IceServers ice_servers;
for (jobject j_ice_server : Iterable(jni, j_ice_servers)) {
jclass j_ice_server_class = GetObjectClass(jni, j_ice_server);
jfieldID j_ice_server_urls_id =
GetFieldID(jni, j_ice_server_class, "urls", "Ljava/util/List;");
jfieldID j_ice_server_username_id =
GetFieldID(jni, j_ice_server_class, "username", "Ljava/lang/String;");
jfieldID j_ice_server_password_id =
GetFieldID(jni, j_ice_server_class, "password", "Ljava/lang/String;");
jfieldID j_ice_server_tls_cert_policy_id =
GetFieldID(jni, j_ice_server_class, "tlsCertPolicy",
"Lorg/webrtc/PeerConnection$TlsCertPolicy;");
jobject j_ice_server_tls_cert_policy =
GetObjectField(jni, j_ice_server, j_ice_server_tls_cert_policy_id);
jfieldID j_ice_server_hostname_id =
GetFieldID(jni, j_ice_server_class, "hostname", "Ljava/lang/String;");
jfieldID j_ice_server_tls_alpn_protocols_id = GetFieldID(
jni, j_ice_server_class, "tlsAlpnProtocols", "Ljava/util/List;");
jfieldID j_ice_server_tls_elliptic_curves_id = GetFieldID(
jni, j_ice_server_class, "tlsEllipticCurves", "Ljava/util/List;");
jobject urls = GetObjectField(jni, j_ice_server, j_ice_server_urls_id);
jstring username = reinterpret_cast<jstring>(
GetObjectField(jni, j_ice_server, j_ice_server_username_id));
jstring password = reinterpret_cast<jstring>(
GetObjectField(jni, j_ice_server, j_ice_server_password_id));
Java_IceServer_getTlsCertPolicy(jni, j_ice_server);
jobject urls = Java_IceServer_getUrls(jni, j_ice_server);
jstring username = Java_IceServer_getUsername(jni, j_ice_server);
jstring password = Java_IceServer_getPassword(jni, j_ice_server);
PeerConnectionInterface::TlsCertPolicy tls_cert_policy =
JavaToNativeTlsCertPolicy(jni, j_ice_server_tls_cert_policy);
jstring hostname = reinterpret_cast<jstring>(
GetObjectField(jni, j_ice_server, j_ice_server_hostname_id));
jobject tls_alpn_protocols = GetNullableObjectField(
jni, j_ice_server, j_ice_server_tls_alpn_protocols_id);
jobject tls_elliptic_curves = GetNullableObjectField(
jni, j_ice_server, j_ice_server_tls_elliptic_curves_id);
jstring hostname = Java_IceServer_getHostname(jni, j_ice_server);
jobject tls_alpn_protocols =
Java_IceServer_getTlsAlpnProtocols(jni, j_ice_server);
jobject tls_elliptic_curves =
Java_IceServer_getTlsEllipticCurves(jni, j_ice_server);
PeerConnectionInterface::IceServer server;
server.urls = JavaToStdVectorStrings(jni, urls);
server.username = JavaToStdString(jni, username);
@ -126,102 +97,33 @@ void JavaToNativeIceServers(JNIEnv* jni,
server.tls_alpn_protocols = JavaToStdVectorStrings(jni, tls_alpn_protocols);
server.tls_elliptic_curves =
JavaToStdVectorStrings(jni, tls_elliptic_curves);
ice_servers->push_back(server);
ice_servers.push_back(server);
}
return ice_servers;
}
} // namespace
void JavaToNativeRTCConfiguration(
JNIEnv* jni,
jobject j_rtc_config,
PeerConnectionInterface::RTCConfiguration* rtc_config) {
jclass j_rtc_config_class = GetObjectClass(jni, j_rtc_config);
jfieldID j_ice_transports_type_id =
GetFieldID(jni, j_rtc_config_class, "iceTransportsType",
"Lorg/webrtc/PeerConnection$IceTransportsType;");
jobject j_ice_transports_type =
GetObjectField(jni, j_rtc_config, j_ice_transports_type_id);
jfieldID j_bundle_policy_id =
GetFieldID(jni, j_rtc_config_class, "bundlePolicy",
"Lorg/webrtc/PeerConnection$BundlePolicy;");
Java_RTCConfiguration_getIceTransportsType(jni, j_rtc_config);
jobject j_bundle_policy =
GetObjectField(jni, j_rtc_config, j_bundle_policy_id);
jfieldID j_rtcp_mux_policy_id =
GetFieldID(jni, j_rtc_config_class, "rtcpMuxPolicy",
"Lorg/webrtc/PeerConnection$RtcpMuxPolicy;");
Java_RTCConfiguration_getBundlePolicy(jni, j_rtc_config);
jobject j_rtcp_mux_policy =
GetObjectField(jni, j_rtc_config, j_rtcp_mux_policy_id);
jfieldID j_tcp_candidate_policy_id =
GetFieldID(jni, j_rtc_config_class, "tcpCandidatePolicy",
"Lorg/webrtc/PeerConnection$TcpCandidatePolicy;");
Java_RTCConfiguration_getRtcpMuxPolicy(jni, j_rtc_config);
jobject j_tcp_candidate_policy =
GetObjectField(jni, j_rtc_config, j_tcp_candidate_policy_id);
jfieldID j_candidate_network_policy_id =
GetFieldID(jni, j_rtc_config_class, "candidateNetworkPolicy",
"Lorg/webrtc/PeerConnection$CandidateNetworkPolicy;");
Java_RTCConfiguration_getTcpCandidatePolicy(jni, j_rtc_config);
jobject j_candidate_network_policy =
GetObjectField(jni, j_rtc_config, j_candidate_network_policy_id);
jfieldID j_ice_servers_id =
GetFieldID(jni, j_rtc_config_class, "iceServers", "Ljava/util/List;");
jobject j_ice_servers = GetObjectField(jni, j_rtc_config, j_ice_servers_id);
jfieldID j_audio_jitter_buffer_max_packets_id =
GetFieldID(jni, j_rtc_config_class, "audioJitterBufferMaxPackets", "I");
jfieldID j_audio_jitter_buffer_fast_accelerate_id = GetFieldID(
jni, j_rtc_config_class, "audioJitterBufferFastAccelerate", "Z");
jfieldID j_ice_connection_receiving_timeout_id =
GetFieldID(jni, j_rtc_config_class, "iceConnectionReceivingTimeout", "I");
jfieldID j_ice_backup_candidate_pair_ping_interval_id = GetFieldID(
jni, j_rtc_config_class, "iceBackupCandidatePairPingInterval", "I");
jfieldID j_continual_gathering_policy_id =
GetFieldID(jni, j_rtc_config_class, "continualGatheringPolicy",
"Lorg/webrtc/PeerConnection$ContinualGatheringPolicy;");
Java_RTCConfiguration_getCandidateNetworkPolicy(jni, j_rtc_config);
jobject j_ice_servers =
Java_RTCConfiguration_getIceServers(jni, j_rtc_config);
jobject j_continual_gathering_policy =
GetObjectField(jni, j_rtc_config, j_continual_gathering_policy_id);
jfieldID j_ice_candidate_pool_size_id =
GetFieldID(jni, j_rtc_config_class, "iceCandidatePoolSize", "I");
jfieldID j_presume_writable_when_fully_relayed_id = GetFieldID(
jni, j_rtc_config_class, "presumeWritableWhenFullyRelayed", "Z");
jfieldID j_prune_turn_ports_id =
GetFieldID(jni, j_rtc_config_class, "pruneTurnPorts", "Z");
jfieldID j_ice_check_min_interval_id = GetFieldID(
jni, j_rtc_config_class, "iceCheckMinInterval", "Ljava/lang/Integer;");
jfieldID j_disable_ipv6_on_wifi_id =
GetFieldID(jni, j_rtc_config_class, "disableIPv6OnWifi", "Z");
jfieldID j_max_ipv6_networks_id =
GetFieldID(jni, j_rtc_config_class, "maxIPv6Networks", "I");
jfieldID j_ice_regather_interval_range_id =
GetFieldID(jni, j_rtc_config_class, "iceRegatherIntervalRange",
"Lorg/webrtc/PeerConnection$IntervalRange;");
jclass j_interval_range_class =
jni->FindClass("org/webrtc/PeerConnection$IntervalRange");
jmethodID get_min_id =
GetMethodID(jni, j_interval_range_class, "getMin", "()I");
jmethodID get_max_id =
GetMethodID(jni, j_interval_range_class, "getMax", "()I");
jfieldID j_turn_customizer_type_id = GetFieldID(
jni, j_rtc_config_class, "turnCustomizer", "Lorg/webrtc/TurnCustomizer;");
Java_RTCConfiguration_getContinualGatheringPolicy(jni, j_rtc_config);
jobject j_turn_customizer =
GetNullableObjectField(jni, j_rtc_config, j_turn_customizer_type_id);
jclass j_turn_customizer_class = jni->FindClass("org/webrtc/TurnCustomizer");
jfieldID j_native_turn_customizer_id =
GetFieldID(jni, j_turn_customizer_class, "nativeTurnCustomizer", "J");
Java_RTCConfiguration_getTurnCustomizer(jni, j_rtc_config);
rtc_config->type = JavaToNativeIceTransportsType(jni, j_ice_transports_type);
rtc_config->bundle_policy = JavaToNativeBundlePolicy(jni, j_bundle_policy);
@ -231,51 +133,60 @@ void JavaToNativeRTCConfiguration(
JavaToNativeTcpCandidatePolicy(jni, j_tcp_candidate_policy);
rtc_config->candidate_network_policy =
JavaToNativeCandidateNetworkPolicy(jni, j_candidate_network_policy);
JavaToNativeIceServers(jni, j_ice_servers, &rtc_config->servers);
rtc_config->servers = JavaToNativeIceServers(jni, j_ice_servers);
rtc_config->audio_jitter_buffer_max_packets =
GetIntField(jni, j_rtc_config, j_audio_jitter_buffer_max_packets_id);
rtc_config->audio_jitter_buffer_fast_accelerate = GetBooleanField(
jni, j_rtc_config, j_audio_jitter_buffer_fast_accelerate_id);
Java_RTCConfiguration_getAudioJitterBufferMaxPackets(jni, j_rtc_config);
rtc_config->audio_jitter_buffer_fast_accelerate =
Java_RTCConfiguration_getAudioJitterBufferFastAccelerate(jni,
j_rtc_config);
rtc_config->ice_connection_receiving_timeout =
GetIntField(jni, j_rtc_config, j_ice_connection_receiving_timeout_id);
rtc_config->ice_backup_candidate_pair_ping_interval = GetIntField(
jni, j_rtc_config, j_ice_backup_candidate_pair_ping_interval_id);
Java_RTCConfiguration_getIceConnectionReceivingTimeout(jni, j_rtc_config);
rtc_config->ice_backup_candidate_pair_ping_interval =
Java_RTCConfiguration_getIceBackupCandidatePairPingInterval(jni,
j_rtc_config);
rtc_config->continual_gathering_policy =
JavaToNativeContinualGatheringPolicy(jni, j_continual_gathering_policy);
rtc_config->ice_candidate_pool_size =
GetIntField(jni, j_rtc_config, j_ice_candidate_pool_size_id);
Java_RTCConfiguration_getIceCandidatePoolSize(jni, j_rtc_config);
rtc_config->prune_turn_ports =
GetBooleanField(jni, j_rtc_config, j_prune_turn_ports_id);
rtc_config->presume_writable_when_fully_relayed = GetBooleanField(
jni, j_rtc_config, j_presume_writable_when_fully_relayed_id);
Java_RTCConfiguration_getPruneTurnPorts(jni, j_rtc_config);
rtc_config->presume_writable_when_fully_relayed =
Java_RTCConfiguration_getPresumeWritableWhenFullyRelayed(jni,
j_rtc_config);
jobject j_ice_check_min_interval =
GetNullableObjectField(jni, j_rtc_config, j_ice_check_min_interval_id);
Java_RTCConfiguration_getIceCheckMinInterval(jni, j_rtc_config);
rtc_config->ice_check_min_interval =
JavaToNativeOptionalInt(jni, j_ice_check_min_interval);
rtc_config->disable_ipv6_on_wifi =
GetBooleanField(jni, j_rtc_config, j_disable_ipv6_on_wifi_id);
Java_RTCConfiguration_getDisableIPv6OnWifi(jni, j_rtc_config);
rtc_config->max_ipv6_networks =
GetIntField(jni, j_rtc_config, j_max_ipv6_networks_id);
jobject j_ice_regather_interval_range = GetNullableObjectField(
jni, j_rtc_config, j_ice_regather_interval_range_id);
Java_RTCConfiguration_getMaxIPv6Networks(jni, j_rtc_config);
jobject j_ice_regather_interval_range =
Java_RTCConfiguration_getIceRegatherIntervalRange(jni, j_rtc_config);
if (!IsNull(jni, j_ice_regather_interval_range)) {
int min = jni->CallIntMethod(j_ice_regather_interval_range, get_min_id);
int max = jni->CallIntMethod(j_ice_regather_interval_range, get_max_id);
int min = Java_IntervalRange_getMin(jni, j_ice_regather_interval_range);
int max = Java_IntervalRange_getMax(jni, j_ice_regather_interval_range);
rtc_config->ice_regather_interval_range.emplace(min, max);
}
if (!IsNull(jni, j_turn_customizer)) {
rtc_config->turn_customizer = reinterpret_cast<webrtc::TurnCustomizer*>(
GetLongField(jni, j_turn_customizer, j_native_turn_customizer_id));
Java_TurnCustomizer_getNativeTurnCustomizer(jni, j_turn_customizer));
}
}
rtc::KeyType GetRtcConfigKeyType(JNIEnv* env, jobject j_rtc_config) {
return JavaToNativeKeyType(
env, Java_RTCConfiguration_getKeyType(env, j_rtc_config));
}
PeerConnectionObserverJni::PeerConnectionObserverJni(JNIEnv* jni,
jobject j_observer)
: j_observer_global_(jni, j_observer) {}
PeerConnectionObserverJni::~PeerConnectionObserverJni() {
ScopedLocalRefFrame local_ref_frame(jni());
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env);
while (!remote_streams_.empty())
DisposeRemoteStream(remote_streams_.begin());
}
@ -380,7 +291,8 @@ void PeerConnectionObserverJni::AddNativeVideoTrackToJavaStream(
void PeerConnectionObserverJni::OnAudioTrackAddedToStream(
AudioTrackInterface* track,
MediaStreamInterface* stream) {
ScopedLocalRefFrame local_ref_frame(jni());
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env);
jobject j_stream = GetOrCreateJavaStream(stream);
AddNativeAudioTrackToJavaStream(track, j_stream);
}
@ -388,7 +300,8 @@ void PeerConnectionObserverJni::OnAudioTrackAddedToStream(
void PeerConnectionObserverJni::OnVideoTrackAddedToStream(
VideoTrackInterface* track,
MediaStreamInterface* stream) {
ScopedLocalRefFrame local_ref_frame(jni());
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env);
jobject j_stream = GetOrCreateJavaStream(stream);
AddNativeVideoTrackToJavaStream(track, j_stream);
}
@ -489,10 +402,11 @@ jobject PeerConnectionObserverJni::GetOrCreateJavaStream(
// Java MediaStream holds one reference. Corresponding Release() is in
// MediaStream_free, triggered by MediaStream.dispose().
stream->AddRef();
JNIEnv* env = AttachCurrentThreadIfNeeded();
jobject j_stream =
Java_MediaStream_Constructor(jni(), jlongFromPointer(stream.get()));
Java_MediaStream_Constructor(env, jlongFromPointer(stream.get()));
remote_streams_[stream] = NewGlobalRef(jni(), j_stream);
remote_streams_[stream] = NewGlobalRef(env, j_stream);
return j_stream;
}
@ -764,32 +678,26 @@ JNI_FUNCTION_DECLARATION(void,
JNI_FUNCTION_DECLARATION(jobject,
PeerConnection_signalingState,
JNIEnv* jni,
JNIEnv* env,
jobject j_pc) {
PeerConnectionInterface::SignalingState state =
ExtractNativePC(jni, j_pc)->signaling_state();
return JavaEnumFromIndexAndClassName(jni, "PeerConnection$SignalingState",
state);
return Java_SignalingState_fromNativeIndex(
env, ExtractNativePC(env, j_pc)->signaling_state());
}
JNI_FUNCTION_DECLARATION(jobject,
PeerConnection_iceConnectionState,
JNIEnv* jni,
JNIEnv* env,
jobject j_pc) {
PeerConnectionInterface::IceConnectionState state =
ExtractNativePC(jni, j_pc)->ice_connection_state();
return JavaEnumFromIndexAndClassName(jni, "PeerConnection$IceConnectionState",
state);
return Java_IceConnectionState_fromNativeIndex(
env, ExtractNativePC(env, j_pc)->ice_connection_state());
}
JNI_FUNCTION_DECLARATION(jobject,
PeerConnection_iceGatheringState,
JNIEnv* jni,
JNIEnv* env,
jobject j_pc) {
PeerConnectionInterface::IceGatheringState state =
ExtractNativePC(jni, j_pc)->ice_gathering_state();
return JavaEnumFromIndexAndClassName(jni, "PeerConnection$IceGatheringState",
state);
return Java_IceGatheringState_fromNativeIndex(
env, ExtractNativePC(env, j_pc)->ice_gathering_state());
}
JNI_FUNCTION_DECLARATION(void,

8
sdk/android/src/jni/pc/peerconnection.h
View File

@ -18,21 +18,19 @@
#include "api/peerconnectioninterface.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/pc/mediaconstraints_jni.h"
#include "sdk/android/src/jni/pc/mediaconstraints.h"
#include "sdk/android/src/jni/pc/rtpreceiver.h"
namespace webrtc {
namespace jni {
void JavaToNativeIceServers(JNIEnv* jni,
jobject j_ice_servers,
PeerConnectionInterface::IceServers* ice_servers);
void JavaToNativeRTCConfiguration(
JNIEnv* jni,
jobject j_rtc_config,
PeerConnectionInterface::RTCConfiguration* rtc_config);
rtc::KeyType GetRtcConfigKeyType(JNIEnv* env, jobject j_rtc_config);
// Adapter between the C++ PeerConnectionObserver interface and the Java
// PeerConnection.Observer interface. Wraps an instance of the Java interface
// and dispatches C++ callbacks to Java.

95
sdk/android/src/jni/pc/peerconnectionfactory_jni.cc → sdk/android/src/jni/pc/peerconnectionfactory.cc
View File

@ -8,6 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "sdk/android/src/jni/pc/peerconnectionfactory.h"
#include <memory>
#include <utility>
@ -23,14 +25,15 @@
#include "rtc_base/event_tracer.h"
#include "rtc_base/stringutils.h"
#include "rtc_base/thread.h"
#include "sdk/android/generated_peerconnection_jni/jni/PeerConnectionFactory_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/pc/androidnetworkmonitor_jni.h"
#include "sdk/android/src/jni/pc/audio_jni.h"
#include "sdk/android/src/jni/pc/java_native_conversion.h"
#include "sdk/android/src/jni/pc/media_jni.h"
#include "sdk/android/src/jni/pc/androidnetworkmonitor.h"
#include "sdk/android/src/jni/pc/audio.h"
#include "sdk/android/src/jni/pc/icecandidate.h"
#include "sdk/android/src/jni/pc/media.h"
#include "sdk/android/src/jni/pc/ownedfactoryandthreads.h"
#include "sdk/android/src/jni/pc/peerconnection.h"
#include "sdk/android/src/jni/pc/video_jni.h"
#include "sdk/android/src/jni/pc/video.h"
#include "system_wrappers/include/field_trial.h"
// Adding 'nogncheck' to disable the gn include headers check.
// We don't want to depend on 'system_wrappers:field_trial_default' because
@ -40,10 +43,29 @@
namespace webrtc {
namespace jni {
namespace {
PeerConnectionFactoryInterface::Options
JavaToNativePeerConnectionFactoryOptions(JNIEnv* jni, jobject options) {
int network_ignore_mask = Java_Options_getNetworkIgnoreMask(jni, options);
bool disable_encryption = Java_Options_getDisableEncryption(jni, options);
bool disable_network_monitor =
Java_Options_getDisableNetworkMonitor(jni, options);
PeerConnectionFactoryInterface::Options native_options;
// This doesn't necessarily match the c++ version of this struct; feel free
// to add more parameters as necessary.
native_options.network_ignore_mask = network_ignore_mask;
native_options.disable_encryption = disable_encryption;
native_options.disable_network_monitor = disable_network_monitor;
return native_options;
}
} // namespace
// Note: Some of the video-specific PeerConnectionFactory methods are
// implemented in "video_jni.cc". This is done so that if an application
// doesn't need video support, it can just link with "null_video_jni.cc"
// instead of "video_jni.cc", which doesn't bring in the video-specific
// implemented in "video.cc". This is done so that if an application
// doesn't need video support, it can just link with "null_video.cc"
// instead of "video.cc", which doesn't bring in the video-specific
// dependencies.
// Field trials initialization string
@ -53,8 +75,26 @@ static char* field_trials_init_string = nullptr;
static bool factory_static_initialized = false;
static bool video_hw_acceleration_enabled = true;
void PeerConnectionFactoryNetworkThreadReady() {
RTC_LOG(LS_INFO) << "Network thread JavaCallback";
JNIEnv* env = AttachCurrentThreadIfNeeded();
Java_PeerConnectionFactory_onNetworkThreadReady(env);
}
void PeerConnectionFactoryWorkerThreadReady() {
RTC_LOG(LS_INFO) << "Worker thread JavaCallback";
JNIEnv* env = AttachCurrentThreadIfNeeded();
Java_PeerConnectionFactory_onWorkerThreadReady(env);
}
void PeerConnectionFactorySignalingThreadReady() {
RTC_LOG(LS_INFO) << "Signaling thread JavaCallback";
JNIEnv* env = AttachCurrentThreadIfNeeded();
Java_PeerConnectionFactory_onSignalingThreadReady(env);
}
JNI_FUNCTION_DECLARATION(jlong,
PeerConnectionFactory_nativeCreateObserver,
PeerConnectionFactory_createNativeObserver,
JNIEnv* jni,
jclass,
jobject j_observer) {
@ -62,7 +102,7 @@ JNI_FUNCTION_DECLARATION(jlong,
}
JNI_FUNCTION_DECLARATION(void,
PeerConnectionFactory_nativeInitializeAndroidGlobals,
PeerConnectionFactory_initializeNativeAndroidGlobals,
JNIEnv* jni,
jclass,
jobject context,
@ -93,14 +133,14 @@ JNI_FUNCTION_DECLARATION(void,
}
JNI_FUNCTION_DECLARATION(void,
PeerConnectionFactory_nativeInitializeInternalTracer,
PeerConnectionFactory_initializeNativeInternalTracer,
JNIEnv* jni,
jclass) {
rtc::tracing::SetupInternalTracer();
}
JNI_FUNCTION_DECLARATION(jstring,
PeerConnectionFactory_nativeFieldTrialsFindFullName,
PeerConnectionFactory_findNativeFieldTrialsFullName,
JNIEnv* jni,
jclass,
jstring j_name) {
@ -132,7 +172,7 @@ JNI_FUNCTION_DECLARATION(void,
}
JNI_FUNCTION_DECLARATION(void,
PeerConnectionFactory_nativeShutdownInternalTracer,
PeerConnectionFactory_shutdownNativeInternalTracer,
JNIEnv* jni,
jclass) {
rtc::tracing::ShutdownInternalTracer();
@ -252,7 +292,7 @@ jlong CreatePeerConnectionFactoryForJava(
JNI_FUNCTION_DECLARATION(
jlong,
PeerConnectionFactory_nativeCreatePeerConnectionFactory,
PeerConnectionFactory_createNativePeerConnectionFactory,
JNIEnv* jni,
jclass,
jobject joptions,
@ -265,7 +305,7 @@ JNI_FUNCTION_DECLARATION(
JNI_FUNCTION_DECLARATION(
jlong,
PeerConnectionFactory_nativeCreatePeerConnectionFactoryWithAudioProcessing,
PeerConnectionFactory_createNativePeerConnectionFactoryWithAudioProcessing,
JNIEnv* jni,
jclass,
jobject joptions,
@ -280,7 +320,7 @@ JNI_FUNCTION_DECLARATION(
}
JNI_FUNCTION_DECLARATION(void,
PeerConnectionFactory_nativeFreeFactory,
PeerConnectionFactory_freeNativeFactory,
JNIEnv*,
jclass,
jlong j_p) {
@ -293,7 +333,7 @@ JNI_FUNCTION_DECLARATION(void,
}
JNI_FUNCTION_DECLARATION(void,
PeerConnectionFactory_nativeThreadsCallbacks,
PeerConnectionFactory_invokeNativeThreadsCallbacks,
JNIEnv*,
jclass,
jlong j_p) {
@ -303,7 +343,7 @@ JNI_FUNCTION_DECLARATION(void,
}
JNI_FUNCTION_DECLARATION(jlong,
PeerConnectionFactory_nativeCreateLocalMediaStream,
PeerConnectionFactory_createNativeLocalMediaStream,
JNIEnv* jni,
jclass,
jlong native_factory,
@ -316,7 +356,7 @@ JNI_FUNCTION_DECLARATION(jlong,
}
JNI_FUNCTION_DECLARATION(jlong,
PeerConnectionFactory_nativeCreateAudioSource,
PeerConnectionFactory_createNativeAudioSource,
JNIEnv* jni,
jclass,
jlong native_factory,
@ -333,7 +373,7 @@ JNI_FUNCTION_DECLARATION(jlong,
}
JNI_FUNCTION_DECLARATION(jlong,
PeerConnectionFactory_nativeCreateAudioTrack,
PeerConnectionFactory_createNativeAudioTrack,
JNIEnv* jni,
jclass,
jlong native_factory,
@ -348,7 +388,7 @@ JNI_FUNCTION_DECLARATION(jlong,
}
JNI_FUNCTION_DECLARATION(jboolean,
PeerConnectionFactory_nativeStartAecDump,
PeerConnectionFactory_startNativeAecDump,
JNIEnv* jni,
jclass,
jlong native_factory,
@ -360,7 +400,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
}
JNI_FUNCTION_DECLARATION(void,
PeerConnectionFactory_nativeStopAecDump,
PeerConnectionFactory_stopNativeAecDump,
JNIEnv* jni,
jclass,
jlong native_factory) {
@ -370,7 +410,7 @@ JNI_FUNCTION_DECLARATION(void,
}
JNI_FUNCTION_DECLARATION(void,
PeerConnectionFactory_nativeSetOptions,
PeerConnectionFactory_setNativeOptions,
JNIEnv* jni,
jclass,
jlong native_factory,
@ -393,7 +433,7 @@ JNI_FUNCTION_DECLARATION(void,
}
JNI_FUNCTION_DECLARATION(jlong,
PeerConnectionFactory_nativeCreatePeerConnection,
PeerConnectionFactory_createNativePeerConnection,
JNIEnv* jni,
jclass,
jlong factory,
@ -408,13 +448,8 @@ JNI_FUNCTION_DECLARATION(jlong,
PeerConnectionInterface::RTCConfigurationType::kAggressive);
JavaToNativeRTCConfiguration(jni, j_rtc_config, &rtc_config);
jclass j_rtc_config_class = GetObjectClass(jni, j_rtc_config);
jfieldID j_key_type_id = GetFieldID(jni, j_rtc_config_class, "keyType",
"Lorg/webrtc/PeerConnection$KeyType;");
jobject j_key_type = GetObjectField(jni, j_rtc_config, j_key_type_id);
// Generate non-default certificate.
rtc::KeyType key_type = JavaToNativeKeyType(jni, j_key_type);
rtc::KeyType key_type = GetRtcConfigKeyType(jni, j_rtc_config);
if (key_type != rtc::KT_DEFAULT) {
rtc::scoped_refptr<rtc::RTCCertificate> certificate =
rtc::RTCCertificateGenerator::GenerateCertificate(

26
sdk/android/src/jni/pc/peerconnectionfactory.h Normal file
View File

@ -0,0 +1,26 @@
/*
* 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.
*/
#ifndef SDK_ANDROID_SRC_JNI_PC_PEERCONNECTIONFACTORY_H_
#define SDK_ANDROID_SRC_JNI_PC_PEERCONNECTIONFACTORY_H_
#include <jni.h>
namespace webrtc {
namespace jni {
void PeerConnectionFactoryNetworkThreadReady();
void PeerConnectionFactoryWorkerThreadReady();
void PeerConnectionFactorySignalingThreadReady();
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_PC_PEERCONNECTIONFACTORY_H_

5
sdk/android/src/jni/pc/rtcstatscollectorcallbackwrapper.cc
View File

@ -18,7 +18,6 @@
#include "sdk/android/generated_peerconnection_jni/jni/RTCStatsCollectorCallback_jni.h"
#include "sdk/android/generated_peerconnection_jni/jni/RTCStatsReport_jni.h"
#include "sdk/android/generated_peerconnection_jni/jni/RTCStats_jni.h"
#include "sdk/android/src/jni/classreferenceholder.h"
namespace webrtc {
namespace jni {
@ -116,8 +115,8 @@ jobject NativeToJavaRtcStatsReport(
const rtc::scoped_refptr<const RTCStatsReport>& report) {
jobject j_stats_map =
NativeToJavaMap(env, *report, [](JNIEnv* env, const RTCStats& stats) {
return std::pair<jobject, jobject>(NativeToJavaString(env, stats.id()),
NativeToJavaRtcStats(env, stats));
return std::make_pair(NativeToJavaString(env, stats.id()),
NativeToJavaRtcStats(env, stats));
});
return Java_RTCStatsReport_create(env, report->timestamp_us(), j_stats_map);
}

84
sdk/android/src/jni/pc/rtpparameters.cc Normal file
View File

@ -0,0 +1,84 @@
/*
* 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 "sdk/android/src/jni/pc/rtpparameters.h"
#include "sdk/android/generated_peerconnection_jni/jni/RtpParameters_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/pc/mediastreamtrack.h"
namespace webrtc {
namespace jni {
namespace {
jobject NativeToJavaRtpEncodingParameter(
JNIEnv* env,
const RtpEncodingParameters& encoding) {
return Java_Encoding_Constructor(
env, encoding.active, NativeToJavaInteger(env, encoding.max_bitrate_bps),
encoding.ssrc ? NativeToJavaLong(env, *encoding.ssrc) : nullptr);
}
jobject NativeToJavaRtpCodecParameter(JNIEnv* env,
const RtpCodecParameters& codec) {
return Java_Codec_Constructor(env, codec.payload_type,
NativeToJavaString(env, codec.name),
NativeToJavaMediaType(env, codec.kind),
NativeToJavaInteger(env, codec.clock_rate),
NativeToJavaInteger(env, codec.num_channels));
}
} // namespace
RtpParameters JavaToNativeRtpParameters(JNIEnv* jni, jobject j_parameters) {
RtpParameters parameters;
// Convert encodings.
jobject j_encodings = Java_RtpParameters_getEncodings(jni, j_parameters);
for (jobject j_encoding_parameters : Iterable(jni, j_encodings)) {
RtpEncodingParameters encoding;
encoding.active = Java_Encoding_getActive(jni, j_encoding_parameters);
jobject j_bitrate =
Java_Encoding_getMaxBitrateBps(jni, j_encoding_parameters);
encoding.max_bitrate_bps = JavaToNativeOptionalInt(jni, j_bitrate);
jobject j_ssrc = Java_Encoding_getSsrc(jni, j_encoding_parameters);
if (!IsNull(jni, j_ssrc))
encoding.ssrc = JavaToNativeLong(jni, j_ssrc);
parameters.encodings.push_back(encoding);
}
// Convert codecs.
jobject j_codecs = Java_RtpParameters_getCodecs(jni, j_parameters);
for (jobject j_codec : Iterable(jni, j_codecs)) {
RtpCodecParameters codec;
codec.payload_type = Java_Codec_getPayloadType(jni, j_codec);
codec.name = JavaToStdString(jni, Java_Codec_getName(jni, j_codec));
codec.kind = JavaToNativeMediaType(jni, Java_Codec_getKind(jni, j_codec));
codec.clock_rate =
JavaToNativeOptionalInt(jni, Java_Codec_getClockRate(jni, j_codec));
codec.num_channels =
JavaToNativeOptionalInt(jni, Java_Codec_getNumChannels(jni, j_codec));
parameters.codecs.push_back(codec);
}
return parameters;
}
jobject NativeToJavaRtpParameters(JNIEnv* env,
const RtpParameters& parameters) {
return Java_RtpParameters_Constructor(
env,
NativeToJavaList(env, parameters.encodings,
&NativeToJavaRtpEncodingParameter),
NativeToJavaList(env, parameters.codecs, &NativeToJavaRtpCodecParameter));
}
} // namespace jni
} // namespace webrtc

27
sdk/android/src/jni/pc/rtpparameters.h Normal file
View File

@ -0,0 +1,27 @@
/*
* 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.
*/
#ifndef SDK_ANDROID_SRC_JNI_PC_RTPPARAMETERS_H_
#define SDK_ANDROID_SRC_JNI_PC_RTPPARAMETERS_H_
#include <jni.h>
#include "api/rtpparameters.h"
namespace webrtc {
namespace jni {
RtpParameters JavaToNativeRtpParameters(JNIEnv* jni, jobject j_parameters);
jobject NativeToJavaRtpParameters(JNIEnv* jni, const RtpParameters& parameters);
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_PC_RTPPARAMETERS_H_

3
sdk/android/src/jni/pc/rtpreceiver.cc
View File

@ -12,7 +12,8 @@
#include "sdk/android/generated_peerconnection_jni/jni/RtpReceiver_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/pc/java_native_conversion.h"
#include "sdk/android/src/jni/pc/mediastreamtrack.h"
#include "sdk/android/src/jni/pc/rtpparameters.h"
namespace webrtc {
namespace jni {

2
sdk/android/src/jni/pc/rtpsender_jni.cc → sdk/android/src/jni/pc/rtpsender.cc
View File

@ -10,7 +10,7 @@
#include "api/rtpsenderinterface.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/pc/java_native_conversion.h"
#include "sdk/android/src/jni/pc/rtpparameters.h"
namespace webrtc {
namespace jni {

64
sdk/android/src/jni/pc/sdpobserver.cc Normal file
View File

@ -0,0 +1,64 @@
/*
* 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 "sdk/android/src/jni/pc/sdpobserver.h"
#include <utility>
#include "api/mediaconstraintsinterface.h"
#include "sdk/android/generated_peerconnection_jni/jni/SdpObserver_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc {
namespace jni {
CreateSdpObserverJni::CreateSdpObserverJni(
JNIEnv* env,
jobject j_observer,
std::unique_ptr<MediaConstraintsInterface> constraints)
: j_observer_global_(env, j_observer),
constraints_(std::move(constraints)) {}
void CreateSdpObserverJni::OnSuccess(SessionDescriptionInterface* desc) {
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env);
Java_SdpObserver_onCreateSuccess(env, *j_observer_global_,
NativeToJavaSessionDescription(env, desc));
// OnSuccess transfers ownership of the description (there's a TODO to make
// it use unique_ptr...).
delete desc;
}
void CreateSdpObserverJni::OnFailure(const std::string& error) {
JNIEnv* env = AttachCurrentThreadIfNeeded();
Java_SdpObserver_onCreateFailure(env, *j_observer_global_,
NativeToJavaString(env, error));
}
SetSdpObserverJni::SetSdpObserverJni(
JNIEnv* env,
jobject j_observer,
std::unique_ptr<MediaConstraintsInterface> constraints)
: j_observer_global_(env, j_observer),
constraints_(std::move(constraints)) {}
void SetSdpObserverJni::OnSuccess() {
JNIEnv* env = AttachCurrentThreadIfNeeded();
Java_SdpObserver_onSetSuccess(env, *j_observer_global_);
}
void SetSdpObserverJni::OnFailure(const std::string& error) {
JNIEnv* env = AttachCurrentThreadIfNeeded();
Java_SdpObserver_onSetFailure(env, *j_observer_global_,
NativeToJavaString(env, error));
}
} // namespace jni
} // namespace webrtc

59
sdk/android/src/jni/pc/sdpobserver.h Normal file
View File

@ -0,0 +1,59 @@
/*
* 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.
*/
#ifndef SDK_ANDROID_SRC_JNI_PC_SDPOBSERVER_H_
#define SDK_ANDROID_SRC_JNI_PC_SDPOBSERVER_H_
#include <memory>
#include <string>
#include "api/peerconnectioninterface.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/pc/sessiondescription.h"
namespace webrtc {
namespace jni {
class CreateSdpObserverJni : public CreateSessionDescriptionObserver {
public:
CreateSdpObserverJni(JNIEnv* env,
jobject j_observer,
std::unique_ptr<MediaConstraintsInterface> constraints);
MediaConstraintsInterface* constraints() { return constraints_.get(); }
void OnSuccess(SessionDescriptionInterface* desc) override;
void OnFailure(const std::string& error) override;
private:
const ScopedGlobalRef<jobject> j_observer_global_;
std::unique_ptr<MediaConstraintsInterface> constraints_;
};
class SetSdpObserverJni : public SetSessionDescriptionObserver {
public:
SetSdpObserverJni(JNIEnv* env,
jobject j_observer,
std::unique_ptr<MediaConstraintsInterface> constraints);
MediaConstraintsInterface* constraints() { return constraints_.get(); }
void OnSuccess() override;
void OnFailure(const std::string& error) override;
private:
const ScopedGlobalRef<jobject> j_observer_global_;
std::unique_ptr<MediaConstraintsInterface> constraints_;
};
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_PC_SDPOBSERVER_H_

110
sdk/android/src/jni/pc/sdpobserver_jni.h
View File

@ -1,110 +0,0 @@
/*
* 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.
*/
#ifndef SDK_ANDROID_SRC_JNI_PC_SDPOBSERVER_JNI_H_
#define SDK_ANDROID_SRC_JNI_PC_SDPOBSERVER_JNI_H_
#include <memory>
#include <string>
#include "api/peerconnectioninterface.h"
#include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc {
namespace jni {
// Adapter for a Java StatsObserver presenting a C++
// CreateSessionDescriptionObserver or SetSessionDescriptionObserver and
// dispatching the callback from C++ back to Java.
template <class T> // T is one of {Create,Set}SessionDescriptionObserver.
class SdpObserverJni : public T {
public:
SdpObserverJni(JNIEnv* jni,
jobject j_observer,
std::unique_ptr<MediaConstraintsInterface> constraints)
: constraints_(std::move(constraints)),
j_observer_global_(jni, j_observer),
j_observer_class_(jni, GetObjectClass(jni, j_observer)) {}
virtual ~SdpObserverJni() {}
// Can't mark override because of templating.
virtual void OnSuccess() {
ScopedLocalRefFrame local_ref_frame(jni());
jmethodID m = GetMethodID(jni(), *j_observer_class_, "onSetSuccess", "()V");
jni()->CallVoidMethod(*j_observer_global_, m);
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
}
// Can't mark override because of templating.
virtual void OnSuccess(SessionDescriptionInterface* desc) {
ScopedLocalRefFrame local_ref_frame(jni());
jmethodID m = GetMethodID(jni(), *j_observer_class_, "onCreateSuccess",
"(Lorg/webrtc/SessionDescription;)V");
jobject j_sdp = NativeToJavaSessionDescription(jni(), desc);
jni()->CallVoidMethod(*j_observer_global_, m, j_sdp);
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
// OnSuccess transfers ownership of the description (there's a TODO to make
// it use unique_ptr...).
delete desc;
}
MediaConstraintsInterface* constraints() { return constraints_.get(); }
protected:
// Common implementation for failure of Set & Create types, distinguished by
// |op| being "Set" or "Create".
void DoOnFailure(const std::string& op, const std::string& error) {
jmethodID m = GetMethodID(jni(), *j_observer_class_, "on" + op + "Failure",
"(Ljava/lang/String;)V");
jstring j_error_string = NativeToJavaString(jni(), error);
jni()->CallVoidMethod(*j_observer_global_, m, j_error_string);
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
}
JNIEnv* jni() { return AttachCurrentThreadIfNeeded(); }
private:
std::unique_ptr<MediaConstraintsInterface> constraints_;
const ScopedGlobalRef<jobject> j_observer_global_;
const ScopedGlobalRef<jclass> j_observer_class_;
};
class CreateSdpObserverJni
: public SdpObserverJni<CreateSessionDescriptionObserver> {
public:
CreateSdpObserverJni(JNIEnv* jni,
jobject j_observer,
std::unique_ptr<MediaConstraintsInterface> constraints)
: SdpObserverJni(jni, j_observer, std::move(constraints)) {}
void OnFailure(const std::string& error) override {
ScopedLocalRefFrame local_ref_frame(jni());
SdpObserverJni::DoOnFailure(std::string("Create"), error);
}
};
class SetSdpObserverJni : public SdpObserverJni<SetSessionDescriptionObserver> {
public:
SetSdpObserverJni(JNIEnv* jni,
jobject j_observer,
std::unique_ptr<MediaConstraintsInterface> constraints)
: SdpObserverJni(jni, j_observer, std::move(constraints)) {}
void OnFailure(const std::string& error) override {
ScopedLocalRefFrame local_ref_frame(jni());
SdpObserverJni::DoOnFailure(std::string("Set"), error);
}
};
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_PC_SDPOBSERVER_JNI_H_

52
sdk/android/src/jni/pc/sessiondescription.cc Normal file
View File

@ -0,0 +1,52 @@
/*
* 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 "sdk/android/src/jni/pc/sessiondescription.h"
#include <string>
#include "rtc_base/logging.h"
#include "sdk/android/generated_peerconnection_jni/jni/SessionDescription_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc {
namespace jni {
std::unique_ptr<SessionDescriptionInterface> JavaToNativeSessionDescription(
JNIEnv* jni,
jobject j_sdp) {
std::string std_type = JavaToStdString(
jni, Java_SessionDescription_getTypeInCanonicalForm(jni, j_sdp));
std::string std_description =
JavaToStdString(jni, Java_SessionDescription_getDescription(jni, j_sdp));
rtc::Optional<SdpType> sdp_type_maybe = SdpTypeFromString(std_type);
if (!sdp_type_maybe) {
RTC_LOG(LS_ERROR) << "Unexpected SDP type: " << std_type;
return nullptr;
}
return CreateSessionDescription(*sdp_type_maybe, std_description);
}
jobject NativeToJavaSessionDescription(
JNIEnv* jni,
const SessionDescriptionInterface* desc) {
std::string sdp;
RTC_CHECK(desc->ToString(&sdp)) << "got so far: " << sdp;
jstring j_description = NativeToJavaString(jni, sdp);
jobject j_type =
Java_Type_fromCanonicalForm(jni, NativeToJavaString(jni, desc->type()));
jobject j_sdp =
Java_SessionDescription_Constructor(jni, j_type, j_description);
CHECK_EXCEPTION(jni) << "error during NewObject";
return j_sdp;
}
} // namespace jni
} // namespace webrtc

32
sdk/android/src/jni/pc/sessiondescription.h Normal file
View File

@ -0,0 +1,32 @@
/*
* 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.
*/
#ifndef SDK_ANDROID_SRC_JNI_PC_SESSIONDESCRIPTION_H_
#define SDK_ANDROID_SRC_JNI_PC_SESSIONDESCRIPTION_H_
#include <jni.h>
#include <memory>
#include "api/jsep.h"
namespace webrtc {
namespace jni {
std::unique_ptr<SessionDescriptionInterface> JavaToNativeSessionDescription(
JNIEnv* jni,
jobject j_sdp);
jobject NativeToJavaSessionDescription(JNIEnv* jni,
const SessionDescriptionInterface* desc);
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_PC_SESSIONDESCRIPTION_H_

4
sdk/android/src/jni/pc/statsobserver_jni.cc → sdk/android/src/jni/pc/statsobserver.cc
View File

@ -8,7 +8,9 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "sdk/android/src/jni/pc/statsobserver_jni.h"
#include "sdk/android/src/jni/pc/statsobserver.h"
#include <vector>
#include "sdk/android/generated_peerconnection_jni/jni/StatsObserver_jni.h"
#include "sdk/android/generated_peerconnection_jni/jni/StatsReport_jni.h"

6
sdk/android/src/jni/pc/statsobserver_jni.h → sdk/android/src/jni/pc/statsobserver.h
View File

@ -8,8 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef SDK_ANDROID_SRC_JNI_PC_STATSOBSERVER_JNI_H_
#define SDK_ANDROID_SRC_JNI_PC_STATSOBSERVER_JNI_H_
#ifndef SDK_ANDROID_SRC_JNI_PC_STATSOBSERVER_H_
#define SDK_ANDROID_SRC_JNI_PC_STATSOBSERVER_H_
#include "api/peerconnectioninterface.h"
#include "sdk/android/src/jni/jni_helpers.h"
@ -32,4 +32,4 @@ class StatsObserverJni : public StatsObserver {
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_PC_STATSOBSERVER_JNI_H_
#endif // SDK_ANDROID_SRC_JNI_PC_STATSOBSERVER_H_

2
sdk/android/src/jni/pc/turncustomizer_jni.cc → sdk/android/src/jni/pc/turncustomizer.cc
View File

@ -15,7 +15,7 @@ namespace webrtc {
namespace jni {
JNI_FUNCTION_DECLARATION(void,
TurnCustomizer_nativeFreeTurnCustomizer,
TurnCustomizer_freeNativeTurnCustomizer,
JNIEnv* jni,
jclass,
jlong j_turn_customizer_pointer) {

18
sdk/android/src/jni/pc/video_jni.cc → sdk/android/src/jni/pc/video.cc
View File

@ -8,7 +8,10 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "sdk/android/src/jni/pc/video.h"
#include <jni.h>
#include <memory>
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h"
@ -17,12 +20,12 @@
#include "media/engine/webrtcvideodecoderfactory.h"
#include "media/engine/webrtcvideoencoderfactory.h"
#include "rtc_base/logging.h"
#include "sdk/android/generated_video_jni/jni/EglBase14_jni.h"
#include "sdk/android/src/jni/androidmediadecoder_jni.h"
#include "sdk/android/src/jni/androidmediaencoder_jni.h"
#include "sdk/android/src/jni/androidvideotracksource.h"
#include "sdk/android/src/jni/classreferenceholder.h"
#include "sdk/android/src/jni/pc/ownedfactoryandthreads.h"
#include "sdk/android/src/jni/surfacetexturehelper_jni.h"
#include "sdk/android/src/jni/surfacetexturehelper.h"
#include "sdk/android/src/jni/videodecoderfactorywrapper.h"
#include "sdk/android/src/jni/videoencoderfactorywrapper.h"
@ -71,7 +74,7 @@ jobject GetJavaSurfaceTextureHelper(
}
JNI_FUNCTION_DECLARATION(jlong,
PeerConnectionFactory_nativeCreateVideoSource,
PeerConnectionFactory_createNativeVideoSource,
JNIEnv* jni,
jclass,
jlong native_factory,
@ -92,7 +95,7 @@ JNI_FUNCTION_DECLARATION(jlong,
}
JNI_FUNCTION_DECLARATION(jlong,
PeerConnectionFactory_nativeCreateVideoTrack,
PeerConnectionFactory_createNativeVideoTrack,
JNIEnv* jni,
jclass,
jlong native_factory,
@ -108,7 +111,7 @@ JNI_FUNCTION_DECLARATION(jlong,
JNI_FUNCTION_DECLARATION(
void,
PeerConnectionFactory_nativeSetVideoHwAccelerationOptions,
PeerConnectionFactory_setNativeVideoHwAccelerationOptions,
JNIEnv* jni,
jclass,
jlong native_factory,
@ -117,15 +120,12 @@ JNI_FUNCTION_DECLARATION(
OwnedFactoryAndThreads* owned_factory =
reinterpret_cast<OwnedFactoryAndThreads*>(native_factory);
jclass j_eglbase14_context_class =
FindClass(jni, "org/webrtc/EglBase14$Context");
if (owned_factory->legacy_encoder_factory()) {
MediaCodecVideoEncoderFactory* encoder_factory =
static_cast<MediaCodecVideoEncoderFactory*>(
owned_factory->legacy_encoder_factory());
if (encoder_factory &&
jni->IsInstanceOf(local_egl_context, j_eglbase14_context_class)) {
Java_Context_isEgl14Context(jni, local_egl_context)) {
RTC_LOG(LS_INFO) << "Set EGL context for HW encoding.";
encoder_factory->SetEGLContext(jni, local_egl_context);
}

6
sdk/android/src/jni/pc/video_jni.h → sdk/android/src/jni/pc/video.h
View File

@ -8,8 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef SDK_ANDROID_SRC_JNI_PC_VIDEO_JNI_H_
#define SDK_ANDROID_SRC_JNI_PC_VIDEO_JNI_H_
#ifndef SDK_ANDROID_SRC_JNI_PC_VIDEO_H_
#define SDK_ANDROID_SRC_JNI_PC_VIDEO_H_
#include <jni.h>
@ -50,4 +50,4 @@ jobject GetJavaSurfaceTextureHelper(
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_PC_VIDEO_JNI_H_
#endif // SDK_ANDROID_SRC_JNI_PC_VIDEO_H_

15
sdk/android/src/jni/surfacetexturehelper_jni.cc → sdk/android/src/jni/surfacetexturehelper.cc
View File

@ -8,8 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "sdk/android/src/jni/surfacetexturehelper_jni.h"
#include "sdk/android/src/jni/surfacetexturehelper.h"
#include "rtc_base/bind.h"
#include "rtc_base/logging.h"
@ -18,6 +17,18 @@
namespace webrtc {
namespace jni {
void SurfaceTextureHelperTextureToYUV(JNIEnv* env,
jobject j_surface_texture_helper,
jobject buffer,
int width,
int height,
int stride,
const NativeHandleImpl& native_handle) {
Java_SurfaceTextureHelper_textureToYUV(
env, j_surface_texture_helper, buffer, width, height, stride,
native_handle.oes_texture_id, native_handle.sampling_matrix.ToJava(env));
}
rtc::scoped_refptr<SurfaceTextureHelper> SurfaceTextureHelper::create(
JNIEnv* jni,
const char* thread_name,

18
sdk/android/src/jni/surfacetexturehelper_jni.h → sdk/android/src/jni/surfacetexturehelper.h
View File

@ -8,8 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef SDK_ANDROID_SRC_JNI_SURFACETEXTUREHELPER_JNI_H_
#define SDK_ANDROID_SRC_JNI_SURFACETEXTUREHELPER_JNI_H_
#ifndef SDK_ANDROID_SRC_JNI_SURFACETEXTUREHELPER_H_
#define SDK_ANDROID_SRC_JNI_SURFACETEXTUREHELPER_H_
#include <jni.h>
@ -42,8 +42,8 @@ namespace jni {
class SurfaceTextureHelper : public rtc::RefCountInterface {
public:
// Might return null if creating the Java SurfaceTextureHelper fails.
static rtc::scoped_refptr<SurfaceTextureHelper> create(
JNIEnv* jni, const char* thread_name, jobject j_egl_context);
static rtc::scoped_refptr<SurfaceTextureHelper>
create(JNIEnv* jni, const char* thread_name, jobject j_egl_context);
jobject GetJavaSurfaceTextureHelper() const;
@ -63,7 +63,15 @@ class SurfaceTextureHelper : public rtc::RefCountInterface {
const ScopedGlobalRef<jobject> j_surface_texture_helper_;
};
void SurfaceTextureHelperTextureToYUV(JNIEnv* env,
jobject j_surface_texture_helper,
jobject buffer,
int width,
int height,
int stride,
const NativeHandleImpl& native_handle);
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_SURFACETEXTUREHELPER_JNI_H_
#endif // SDK_ANDROID_SRC_JNI_SURFACETEXTUREHELPER_H_

103
sdk/android/src/jni/video_renderer_jni.cc → sdk/android/src/jni/video_renderer.cc
View File

@ -12,7 +12,7 @@
#include "api/video/video_frame.h"
#include "media/base/videosinkinterface.h"
#include "sdk/android/src/jni/classreferenceholder.h"
#include "sdk/android/generated_video_jni/jni/VideoRenderer_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/videoframe.h"
@ -24,28 +24,13 @@ namespace jni {
class JavaVideoRendererWrapper : public rtc::VideoSinkInterface<VideoFrame> {
public:
JavaVideoRendererWrapper(JNIEnv* jni, jobject j_callbacks)
: j_callbacks_(jni, j_callbacks),
j_render_frame_id_(
GetMethodID(jni,
GetObjectClass(jni, j_callbacks),
"renderFrame",
"(Lorg/webrtc/VideoRenderer$I420Frame;)V")),
j_frame_class_(jni,
FindClass(jni, "org/webrtc/VideoRenderer$I420Frame")),
j_i420_frame_ctor_id_(GetMethodID(jni,
*j_frame_class_,
"<init>",
"(III[I[Ljava/nio/ByteBuffer;J)V")),
j_texture_frame_ctor_id_(
GetMethodID(jni, *j_frame_class_, "<init>", "(IIII[FJ)V")),
j_byte_buffer_class_(jni, FindClass(jni, "java/nio/ByteBuffer")) {
CHECK_EXCEPTION(jni);
}
: j_callbacks_(jni, j_callbacks) {}
virtual ~JavaVideoRendererWrapper() {}
void OnFrame(const VideoFrame& video_frame) override {
ScopedLocalRefFrame local_ref_frame(jni());
JNIEnv* env = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(env);
jobject j_frame;
if (video_frame.video_frame_buffer()->type() ==
@ -55,84 +40,72 @@ class JavaVideoRendererWrapper : public rtc::VideoSinkInterface<VideoFrame> {
video_frame.video_frame_buffer().get());
switch (android_buffer->android_type()) {
case AndroidVideoFrameBuffer::AndroidType::kTextureBuffer:
j_frame = ToJavaTextureFrame(&video_frame);
j_frame = ToJavaTextureFrame(env, video_frame);
break;
case AndroidVideoFrameBuffer::AndroidType::kJavaBuffer:
j_frame = static_cast<AndroidVideoBuffer*>(android_buffer)
->ToJavaI420Frame(jni(), video_frame.rotation());
j_frame = FromWrappedJavaBuffer(env, video_frame);
break;
default:
RTC_NOTREACHED();
}
} else {
j_frame = ToJavaI420Frame(&video_frame);
j_frame = ToJavaI420Frame(env, video_frame);
}
// |j_callbacks_| is responsible for releasing |j_frame| with
// VideoRenderer.renderFrameDone().
jni()->CallVoidMethod(*j_callbacks_, j_render_frame_id_, j_frame);
CHECK_EXCEPTION(jni());
Java_Callbacks_renderFrame(env, *j_callbacks_, j_frame);
}
private:
// Make a shallow copy of |frame| to be used with Java. The callee has
// ownership of the frame, and the frame should be released with
// VideoRenderer.releaseNativeFrame().
static jlong javaShallowCopy(const VideoFrame* frame) {
return jlongFromPointer(new VideoFrame(*frame));
static jlong javaShallowCopy(const VideoFrame& frame) {
return jlongFromPointer(new VideoFrame(frame));
}
// Return a VideoRenderer.I420Frame referring to the data in |frame|.
jobject ToJavaI420Frame(const VideoFrame* frame) {
jintArray strides = jni()->NewIntArray(3);
jint* strides_array = jni()->GetIntArrayElements(strides, NULL);
jobject FromWrappedJavaBuffer(JNIEnv* env, const VideoFrame& frame) {
return Java_I420Frame_Constructor(
env, frame.rotation(),
static_cast<AndroidVideoBuffer*>(frame.video_frame_buffer().get())
->video_frame_buffer(),
javaShallowCopy(frame));
}
// Return a VideoRenderer.I420Frame referring to the data in |frame|.
jobject ToJavaI420Frame(JNIEnv* env, const VideoFrame& frame) {
rtc::scoped_refptr<I420BufferInterface> i420_buffer =
frame->video_frame_buffer()->ToI420();
strides_array[0] = i420_buffer->StrideY();
strides_array[1] = i420_buffer->StrideU();
strides_array[2] = i420_buffer->StrideV();
jni()->ReleaseIntArrayElements(strides, strides_array, 0);
jobjectArray planes = jni()->NewObjectArray(3, *j_byte_buffer_class_, NULL);
jobject y_buffer = jni()->NewDirectByteBuffer(
frame.video_frame_buffer()->ToI420();
jobject y_buffer = env->NewDirectByteBuffer(
const_cast<uint8_t*>(i420_buffer->DataY()),
i420_buffer->StrideY() * i420_buffer->height());
size_t chroma_height = i420_buffer->ChromaHeight();
jobject u_buffer =
jni()->NewDirectByteBuffer(const_cast<uint8_t*>(i420_buffer->DataU()),
i420_buffer->StrideU() * chroma_height);
env->NewDirectByteBuffer(const_cast<uint8_t*>(i420_buffer->DataU()),
i420_buffer->StrideU() * chroma_height);
jobject v_buffer =
jni()->NewDirectByteBuffer(const_cast<uint8_t*>(i420_buffer->DataV()),
i420_buffer->StrideV() * chroma_height);
jni()->SetObjectArrayElement(planes, 0, y_buffer);
jni()->SetObjectArrayElement(planes, 1, u_buffer);
jni()->SetObjectArrayElement(planes, 2, v_buffer);
return jni()->NewObject(*j_frame_class_, j_i420_frame_ctor_id_,
frame->width(), frame->height(),
static_cast<int>(frame->rotation()), strides,
planes, javaShallowCopy(frame));
env->NewDirectByteBuffer(const_cast<uint8_t*>(i420_buffer->DataV()),
i420_buffer->StrideV() * chroma_height);
return Java_I420Frame_createI420Frame(
env, frame.width(), frame.height(), static_cast<int>(frame.rotation()),
i420_buffer->StrideY(), y_buffer, i420_buffer->StrideU(), u_buffer,
i420_buffer->StrideV(), v_buffer, javaShallowCopy(frame));
}
// Return a VideoRenderer.I420Frame referring texture object in |frame|.
jobject ToJavaTextureFrame(const VideoFrame* frame) {
jobject ToJavaTextureFrame(JNIEnv* env, const VideoFrame& frame) {
NativeHandleImpl handle =
static_cast<AndroidTextureBuffer*>(frame->video_frame_buffer().get())
static_cast<AndroidTextureBuffer*>(frame.video_frame_buffer().get())
->native_handle_impl();
jfloatArray sampling_matrix = handle.sampling_matrix.ToJava(jni());
jfloatArray sampling_matrix = handle.sampling_matrix.ToJava(env);
return jni()->NewObject(
*j_frame_class_, j_texture_frame_ctor_id_, frame->width(),
frame->height(), static_cast<int>(frame->rotation()),
return Java_I420Frame_createTextureFrame(
env, frame.width(), frame.height(), static_cast<int>(frame.rotation()),
handle.oes_texture_id, sampling_matrix, javaShallowCopy(frame));
}
JNIEnv* jni() { return AttachCurrentThreadIfNeeded(); }
ScopedGlobalRef<jobject> j_callbacks_;
jmethodID j_render_frame_id_;
ScopedGlobalRef<jclass> j_frame_class_;
jmethodID j_i420_frame_ctor_id_;
jmethodID j_texture_frame_ctor_id_;
ScopedGlobalRef<jclass> j_byte_buffer_class_;
};
JNI_FUNCTION_DECLARATION(void,
@ -152,17 +125,17 @@ JNI_FUNCTION_DECLARATION(void,
}
JNI_FUNCTION_DECLARATION(jlong,
VideoRenderer_nativeWrapVideoRenderer,
VideoRenderer_createNativeVideoRenderer,
JNIEnv* jni,
jclass,
jobject j_callbacks) {
std::unique_ptr<JavaVideoRendererWrapper> renderer(
new JavaVideoRendererWrapper(jni, j_callbacks));
return (jlong)renderer.release();
return jlongFromPointer(renderer.release());
}
JNI_FUNCTION_DECLARATION(void,
VideoRenderer_nativeCopyPlane,
VideoRenderer_copyPlaneNative,
JNIEnv* jni,
jclass,
jobject j_src_buffer,

43
sdk/android/src/jni/videocodecinfo.cc
View File

@ -10,47 +10,28 @@
#include "sdk/android/src/jni/videocodecinfo.h"
#include "sdk/android/src/jni/classreferenceholder.h"
#include "sdk/android/generated_video_jni/jni/VideoCodecInfo_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc {
namespace jni {
SdpVideoFormat VideoCodecInfoToSdpVideoFormat(JNIEnv* jni, jobject j_info) {
jclass video_codec_info_class = FindClass(jni, "org/webrtc/VideoCodecInfo");
jfieldID name_field =
GetFieldID(jni, video_codec_info_class, "name", "Ljava/lang/String;");
jfieldID params_field =
GetFieldID(jni, video_codec_info_class, "params", "Ljava/util/Map;");
jobject j_params = jni->GetObjectField(j_info, params_field);
jstring j_name =
static_cast<jstring>(jni->GetObjectField(j_info, name_field));
return SdpVideoFormat(JavaToStdString(jni, j_name),
JavaToStdMapStrings(jni, j_params));
return SdpVideoFormat(
JavaToStdString(jni, Java_VideoCodecInfo_getName(jni, j_info)),
JavaToStdMapStrings(jni, Java_VideoCodecInfo_getParams(jni, j_info)));
}
jobject SdpVideoFormatToVideoCodecInfo(JNIEnv* jni,
const SdpVideoFormat& format) {
jclass hash_map_class = jni->FindClass("java/util/HashMap");
jmethodID hash_map_constructor =
jni->GetMethodID(hash_map_class, "<init>", "()V");
jmethodID put_method = jni->GetMethodID(
hash_map_class, "put",
"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
jclass video_codec_info_class = FindClass(jni, "org/webrtc/VideoCodecInfo");
jmethodID video_codec_info_constructor = jni->GetMethodID(
video_codec_info_class, "<init>", "(Ljava/lang/String;Ljava/util/Map;)V");
jobject j_params = jni->NewObject(hash_map_class, hash_map_constructor);
for (auto const& param : format.parameters) {
jni->CallObjectMethod(j_params, put_method,
NativeToJavaString(jni, param.first),
NativeToJavaString(jni, param.second));
}
return jni->NewObject(video_codec_info_class, video_codec_info_constructor,
NativeToJavaString(jni, format.name), j_params);
jobject j_params = NativeToJavaMap(
jni, format.parameters,
[](JNIEnv* env, const std::pair<std::string, std::string>& entry) {
return std::make_pair(NativeToJavaString(env, entry.first),
NativeToJavaString(env, entry.second));
});
return Java_VideoCodecInfo_Constructor(
jni, NativeToJavaString(jni, format.name), j_params);
}
} // namespace jni

13
sdk/android/src/jni/videodecoderfactorywrapper.cc
View File

@ -14,6 +14,7 @@
#include "api/video_codecs/video_decoder.h"
#include "common_types.h" // NOLINT(build/include)
#include "rtc_base/logging.h"
#include "sdk/android/generated_video_jni/jni/VideoDecoderFactory_jni.h"
#include "sdk/android/src/jni/wrappednativecodec.h"
namespace webrtc {
@ -21,20 +22,14 @@ namespace jni {
VideoDecoderFactoryWrapper::VideoDecoderFactoryWrapper(JNIEnv* jni,
jobject decoder_factory)
: decoder_factory_(jni, decoder_factory) {
jclass decoder_factory_class = jni->GetObjectClass(*decoder_factory_);
create_decoder_method_ =
jni->GetMethodID(decoder_factory_class, "createDecoder",
"(Ljava/lang/String;)Lorg/webrtc/VideoDecoder;");
}
: decoder_factory_(jni, decoder_factory) {}
std::unique_ptr<VideoDecoder> VideoDecoderFactoryWrapper::CreateVideoDecoder(
const SdpVideoFormat& format) {
JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni);
jstring name = NativeToJavaString(jni, format.name);
jobject decoder =
jni->CallObjectMethod(*decoder_factory_, create_decoder_method_, name);
jobject decoder = Java_VideoDecoderFactory_createDecoder(
jni, *decoder_factory_, NativeToJavaString(jni, format.name));
return decoder != nullptr ? JavaToNativeVideoDecoder(jni, decoder) : nullptr;
}

1
sdk/android/src/jni/videodecoderfactorywrapper.h
View File

@ -31,7 +31,6 @@ class VideoDecoderFactoryWrapper : public VideoDecoderFactory {
private:
const ScopedGlobalRef<jobject> decoder_factory_;
jmethodID create_decoder_method_;
};
} // namespace jni

1
sdk/android/src/jni/videodecoderwrapper.cc
View File

@ -17,7 +17,6 @@
#include "rtc_base/logging.h"
#include "sdk/android/generated_video_jni/jni/VideoDecoderWrapper_jni.h"
#include "sdk/android/generated_video_jni/jni/VideoDecoder_jni.h"
#include "sdk/android/src/jni/classreferenceholder.h"
#include "sdk/android/src/jni/encodedimage.h"
#include "sdk/android/src/jni/videocodecstatus.h"
#include "sdk/android/src/jni/videoframe.h"

2
sdk/android/src/jni/videofilerenderer_jni.cc → sdk/android/src/jni/videofilerenderer.cc
View File

@ -10,9 +10,9 @@
#include <jni.h>
#include "third_party/libyuv/include/libyuv/scale.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "third_party/libyuv/include/libyuv/scale.h"
namespace webrtc {
namespace jni {

32
sdk/android/src/jni/videoframe.cc
View File

@ -20,8 +20,8 @@
#include "rtc_base/scoped_ref_ptr.h"
#include "rtc_base/timeutils.h"
#include "sdk/android/generated_video_jni/jni/VideoFrame_jni.h"
#include "sdk/android/src/jni/classreferenceholder.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/surfacetexturehelper.h"
#include "sdk/android/src/jni/wrapped_native_i420_buffer.h"
#include "system_wrappers/include/aligned_malloc.h"
#include "third_party/libyuv/include/libyuv/scale.h"
@ -268,20 +268,9 @@ rtc::scoped_refptr<I420BufferInterface> AndroidTextureBuffer::ToI420() {
// TODO(sakal): This call to a deperecated method will be removed when
// AndroidTextureBuffer is removed.
jmethodID transform_mid = GetMethodID(
jni,
GetObjectClass(jni, surface_texture_helper_),
"textureToYUV",
"(Ljava/nio/ByteBuffer;IIII[F)V");
jobject byte_buffer = jni->NewDirectByteBuffer(y_data, size);
jfloatArray sampling_matrix = native_handle_.sampling_matrix.ToJava(jni);
jni->CallVoidMethod(surface_texture_helper_,
transform_mid,
byte_buffer, width(), height(), stride,
native_handle_.oes_texture_id, sampling_matrix);
CHECK_EXCEPTION(jni) << "textureToYUV throwed an exception";
SurfaceTextureHelperTextureToYUV(jni, surface_texture_helper_, byte_buffer,
width(), height(), stride, native_handle_);
return copy;
}
@ -350,21 +339,6 @@ rtc::scoped_refptr<I420BufferInterface> AndroidVideoBuffer::ToI420() {
return AndroidVideoI420Buffer::Adopt(jni, width_, height_, j_i420_buffer);
}
jobject AndroidVideoBuffer::ToJavaI420Frame(JNIEnv* jni, int rotation) {
jclass j_byte_buffer_class = jni->FindClass("java/nio/ByteBuffer");
jclass j_i420_frame_class =
FindClass(jni, "org/webrtc/VideoRenderer$I420Frame");
jmethodID j_i420_frame_ctor_id = GetMethodID(
jni, j_i420_frame_class, "<init>", "(ILorg/webrtc/VideoFrame$Buffer;J)V");
// Java code just uses the native frame to hold a reference to the buffer so
// this is okay.
VideoFrame* native_frame =
new VideoFrame(this, 0 /* timestamp */, 0 /* render_time_ms */,
VideoRotation::kVideoRotation_0 /* rotation */);
return jni->NewObject(j_i420_frame_class, j_i420_frame_ctor_id, rotation,
*j_video_frame_buffer_, jlongFromPointer(native_frame));
}
VideoFrame JavaToNativeFrame(JNIEnv* jni,
jobject j_video_frame,
uint32_t timestamp_rtp) {

3
sdk/android/src/jni/videoframe.h
View File

@ -130,9 +130,6 @@ class AndroidVideoBuffer : public AndroidVideoFrameBuffer {
int scale_width,
int scale_height);
// Returns an instance of VideoRenderer.I420Frame (deprecated)
jobject ToJavaI420Frame(JNIEnv* jni, int rotation);
protected:
// Should not be called directly. Adopts the Java VideoFrame.Buffer. Use
// Create() or Adopt() instead for clarity.

1
sdk/android/src/jni/videotrack_jni.cc → sdk/android/src/jni/videotrack.cc
View File

@ -13,7 +13,6 @@
#include "api/mediastreaminterface.h"
#include "rtc_base/logging.h"
#include "sdk/android/generated_video_jni/jni/VideoSink_jni.h"
#include "sdk/android/src/jni/classreferenceholder.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/videoframe.h"

20
sdk/android/src/jni/wrapped_native_i420_buffer.cc
View File

@ -10,7 +10,7 @@
#include "sdk/android/src/jni/wrapped_native_i420_buffer.h"
#include "sdk/android/src/jni/classreferenceholder.h"
#include "sdk/android/generated_video_jni/jni/WrappedNativeI420Buffer_jni.h"
#include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc {
@ -20,13 +20,6 @@ namespace jni {
jobject WrapI420Buffer(
JNIEnv* jni,
const rtc::scoped_refptr<I420BufferInterface>& i420_buffer) {
jclass j_wrapped_native_i420_buffer_class =
FindClass(jni, "org/webrtc/WrappedNativeI420Buffer");
jmethodID j_wrapped_native_i420_buffer_ctor_id =
GetMethodID(jni, j_wrapped_native_i420_buffer_class, "<init>",
"(IILjava/nio/ByteBuffer;ILjava/nio/ByteBuffer;ILjava/nio/"
"ByteBuffer;IJ)V");
jobject y_buffer =
jni->NewDirectByteBuffer(const_cast<uint8_t*>(i420_buffer->DataY()),
i420_buffer->StrideY() * i420_buffer->height());
@ -37,12 +30,11 @@ jobject WrapI420Buffer(
const_cast<uint8_t*>(i420_buffer->DataV()),
i420_buffer->StrideV() * i420_buffer->ChromaHeight());
jobject j_wrapped_native_i420_buffer = jni->NewObject(
j_wrapped_native_i420_buffer_class, j_wrapped_native_i420_buffer_ctor_id,
i420_buffer->width(), i420_buffer->height(), y_buffer,
i420_buffer->StrideY(), u_buffer, i420_buffer->StrideU(), v_buffer,
i420_buffer->StrideV(), jlongFromPointer(i420_buffer.get()));
CHECK_EXCEPTION(jni);
jobject j_wrapped_native_i420_buffer =
Java_WrappedNativeI420Buffer_Constructor(
jni, i420_buffer->width(), i420_buffer->height(), y_buffer,
i420_buffer->StrideY(), u_buffer, i420_buffer->StrideU(), v_buffer,
i420_buffer->StrideV(), jlongFromPointer(i420_buffer.get()));
return j_wrapped_native_i420_buffer;
}