admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Android: Replace webrtc_jni namespace with nested jni namespace

Browse Source 
This CL replaces:
namespace webrtc_jni {
with:
namespace webrtc {
namespace jni {

The main benefit is that we don't have to use the webrtc:: qualifier
inside the jni namespace so we can reduce some clutter.

BUG=None

Review-Url: https://codereview.webrtc.org/3009613002
Cr-Commit-Position: refs/heads/master@{#19569}
This commit is contained in:
magjed 2017-08-28 16:24:06 -07:00 committed by Commit Bot
parent b59e7df40f
commit a3d4f68fb4
78 changed files with 858 additions and 776 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
webrtc/examples/unityplugin/classreferenceholder.cc
View File

@ -36,12 +36,12 @@ static ClassReferenceHolder* g_class_reference_holder = nullptr;
void LoadGlobalClassReferenceHolder() {
RTC_CHECK(g_class_reference_holder == nullptr);
g_class_reference_holder = new ClassReferenceHolder(webrtc_jni::GetEnv());
g_class_reference_holder = new ClassReferenceHolder(webrtc::jni::GetEnv());
}
void FreeGlobalClassReferenceHolder() {
g_class_reference_holder->FreeReferences(
webrtc_jni::AttachCurrentThreadIfNeeded());
webrtc::jni::AttachCurrentThreadIfNeeded());
delete g_class_reference_holder;
g_class_reference_holder = nullptr;
}

2
webrtc/examples/unityplugin/classreferenceholder.h
View File

@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
// This is a supplement of webrtc_jni::ClassReferenceHolder.
// This is a supplement of webrtc::jni::ClassReferenceHolder.
// The purpose of this ClassReferenceHolder is to load the example
// specific java class into JNI c++ side, so that our c++ code can
// call those java functions.

6
webrtc/examples/unityplugin/jni_onload.cc
View File

@ -17,7 +17,8 @@
#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
extern "C" jint JNIEXPORT JNICALL JNI_OnLoad(JavaVM* jvm, void* reserved) {
jint ret = InitGlobalJniVariables(jvm);
@ -38,4 +39,5 @@ extern "C" void JNIEXPORT JNICALL JNI_OnUnLoad(JavaVM* jvm, void* reserved) {
RTC_CHECK(rtc::CleanupSSL()) << "Failed to CleanupSSL()";
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

14
webrtc/examples/unityplugin/simple_peer_connection.cc
View File

@ -164,10 +164,10 @@ void SimplePeerConnection::DeletePeerConnection() {
#if defined(WEBRTC_ANDROID)
if (g_camera) {
JNIEnv* env = webrtc_jni::GetEnv();
JNIEnv* env = webrtc::jni::GetEnv();
jclass pc_factory_class =
unity_plugin::FindClass(env, "org/webrtc/UnityUtility");
jmethodID stop_camera_method = webrtc_jni::GetStaticMethodID(
jmethodID stop_camera_method = webrtc::jni::GetStaticMethodID(
env, pc_factory_class, "StopCamera", "(Lorg/webrtc/VideoCapturer;)V");
env->CallStaticVoidMethod(pc_factory_class, stop_camera_method, g_camera);
@ -409,10 +409,10 @@ void SimplePeerConnection::AddStreams(bool audio_only) {
if (!audio_only) {
#if defined(WEBRTC_ANDROID)
JNIEnv* env = webrtc_jni::GetEnv();
JNIEnv* env = webrtc::jni::GetEnv();
jclass pc_factory_class =
unity_plugin::FindClass(env, "org/webrtc/UnityUtility");
jmethodID load_texture_helper_method = webrtc_jni::GetStaticMethodID(
jmethodID load_texture_helper_method = webrtc::jni::GetStaticMethodID(
env, pc_factory_class, "LoadSurfaceTextureHelper",
"()Lorg/webrtc/SurfaceTextureHelper;");
jobject texture_helper = env->CallStaticObjectMethod(
@ -421,15 +421,15 @@ void SimplePeerConnection::AddStreams(bool audio_only) {
RTC_DCHECK(texture_helper != nullptr)
<< "Cannot get the Surface Texture Helper.";
rtc::scoped_refptr<webrtc::AndroidVideoTrackSource> source(
new rtc::RefCountedObject<webrtc::AndroidVideoTrackSource>(
rtc::scoped_refptr<AndroidVideoTrackSource> source(
new rtc::RefCountedObject<AndroidVideoTrackSource>(
g_signaling_thread.get(), env, texture_helper, false));
rtc::scoped_refptr<webrtc::VideoTrackSourceProxy> proxy_source =
webrtc::VideoTrackSourceProxy::Create(g_signaling_thread.get(),
g_worker_thread.get(), source);
// link with VideoCapturer (Camera);
jmethodID link_camera_method = webrtc_jni::GetStaticMethodID(
jmethodID link_camera_method = webrtc::jni::GetStaticMethodID(
env, pc_factory_class, "LinkCamera",
"(JLorg/webrtc/SurfaceTextureHelper;)Lorg/webrtc/VideoCapturer;");
jobject camera_tmp =

4
webrtc/modules/video_coding/codecs/test/android_test_initializer.cc
View File

@ -40,10 +40,10 @@ void EnsureInitializedOnce() {
JavaVM* jvm = NULL;
RTC_CHECK_EQ(0, jni->GetJavaVM(&jvm));
jint ret = webrtc_jni::InitGlobalJniVariables(jvm);
jint ret = jni::InitGlobalJniVariables(jvm);
RTC_DCHECK_GE(ret, 0);
webrtc_jni::LoadGlobalClassReferenceHolder();
jni::LoadGlobalClassReferenceHolder();
}
} // namespace

4
webrtc/modules/video_coding/codecs/test/videoprocessor_integrationtest.h
View File

@ -134,8 +134,8 @@ class VideoProcessorIntegrationTest : public testing::Test {
if (config_.hw_codec) {
#if defined(WEBRTC_VIDEOPROCESSOR_INTEGRATIONTEST_HW_CODECS_ENABLED)
#if defined(WEBRTC_ANDROID)
encoder_factory_.reset(new webrtc_jni::MediaCodecVideoEncoderFactory());
decoder_factory_.reset(new webrtc_jni::MediaCodecVideoDecoderFactory());
encoder_factory_.reset(new jni::MediaCodecVideoEncoderFactory());
decoder_factory_.reset(new jni::MediaCodecVideoDecoderFactory());
#elif defined(WEBRTC_IOS)
EXPECT_EQ(kVideoCodecH264, config_.codec_settings.codecType)
<< "iOS HW codecs only support H264.";

14
webrtc/sdk/android/src/jni/androidhistogram_jni.cc
View File

@ -16,7 +16,8 @@
#include "webrtc/system_wrappers/include/metrics.h"
// Enables collection of native histograms and creating them.
namespace webrtc_jni {
namespace webrtc {
namespace jni {
JNI_FUNCTION_DECLARATION(jlong,
Histogram_nativeCreateCounts,
@ -28,7 +29,7 @@ JNI_FUNCTION_DECLARATION(jlong,
jint buckets) {
std::string name = JavaToStdString(jni, j_name);
return jlongFromPointer(
webrtc::metrics::HistogramFactoryGetCounts(name, min, max, buckets));
metrics::HistogramFactoryGetCounts(name, min, max, buckets));
}
JNI_FUNCTION_DECLARATION(jlong,
@ -38,8 +39,7 @@ JNI_FUNCTION_DECLARATION(jlong,
jstring j_name,
jint max) {
std::string name = JavaToStdString(jni, j_name);
return jlongFromPointer(
webrtc::metrics::HistogramFactoryGetEnumeration(name, max));
return jlongFromPointer(metrics::HistogramFactoryGetEnumeration(name, max));
}
JNI_FUNCTION_DECLARATION(void,
@ -49,9 +49,9 @@ JNI_FUNCTION_DECLARATION(void,
jlong histogram,
jint sample) {
if (histogram) {
HistogramAdd(reinterpret_cast<webrtc::metrics::Histogram*>(histogram),
sample);
HistogramAdd(reinterpret_cast<metrics::Histogram*>(histogram), sample);
}
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

6
webrtc/sdk/android/src/jni/androidmediacodeccommon.h
View File

@ -19,7 +19,8 @@
#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Uncomment this define to enable verbose logging for every encoded/decoded
// video frame.
@ -82,6 +83,7 @@ static inline bool CheckException(JNIEnv* jni) {
return false;
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_ANDROIDMEDIACODECCOMMON_H_

41
webrtc/sdk/android/src/jni/androidmediadecoder_jni.cc
View File

@ -39,18 +39,8 @@ using rtc::Bind;
using rtc::Thread;
using rtc::ThreadManager;
using webrtc::CodecSpecificInfo;
using webrtc::DecodedImageCallback;
using webrtc::EncodedImage;
using webrtc::VideoFrame;
using webrtc::RTPFragmentationHeader;
using webrtc::VideoCodec;
using webrtc::VideoCodecType;
using webrtc::kVideoCodecH264;
using webrtc::kVideoCodecVP8;
using webrtc::kVideoCodecVP9;
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Logging macros.
#define TAG_DECODER "MediaCodecVideoDecoder"
@ -66,8 +56,7 @@ namespace webrtc_jni {
enum { kMaxWarningLogFrames = 2 };
class MediaCodecVideoDecoder : public webrtc::VideoDecoder,
public rtc::MessageHandler {
class MediaCodecVideoDecoder : public VideoDecoder, public rtc::MessageHandler {
public:
explicit MediaCodecVideoDecoder(
JNIEnv* jni, VideoCodecType codecType, jobject render_egl_context);
@ -121,7 +110,7 @@ class MediaCodecVideoDecoder : public webrtc::VideoDecoder,
bool sw_fallback_required_;
bool use_surface_;
VideoCodec codec_;
webrtc::I420BufferPool decoded_frame_pool_;
I420BufferPool decoded_frame_pool_;
rtc::scoped_refptr<SurfaceTextureHelper> surface_texture_helper_;
DecodedImageCallback* callback_;
int frames_received_; // Number of frames received by decoder.
@ -134,7 +123,7 @@ class MediaCodecVideoDecoder : public webrtc::VideoDecoder,
int current_decoding_time_ms_; // Overall decoding time in the current second
int current_delay_time_ms_; // Overall delay time in the current second.
uint32_t max_pending_frames_; // Maximum number of pending input frames.
webrtc::H264BitstreamParser h264_bitstream_parser_;
H264BitstreamParser h264_bitstream_parser_;
std::deque<rtc::Optional<uint8_t>> pending_frame_qps_;
// State that is constant for the lifetime of this object once the ctor
@ -561,7 +550,7 @@ int32_t MediaCodecVideoDecoder::Decode(
// Always start with a complete key frame.
if (key_frame_required_) {
if (inputImage._frameType != webrtc::kVideoFrameKey) {
if (inputImage._frameType != kVideoFrameKey) {
ALOGE << "Decode() - key frame is required";
return WEBRTC_VIDEO_CODEC_ERROR;
}
@ -661,7 +650,7 @@ int32_t MediaCodecVideoDecoder::DecodeOnCodecThread(
rtc::Optional<uint8_t> qp;
if (codecType_ == kVideoCodecVP8) {
int qp_int;
if (webrtc::vp8::GetQp(inputImage._buffer, inputImage._length, &qp_int)) {
if (vp8::GetQp(inputImage._buffer, inputImage._length, &qp_int)) {
qp = rtc::Optional<uint8_t>(qp_int);
}
} else if (codecType_ == kVideoCodecH264) {
@ -726,7 +715,7 @@ bool MediaCodecVideoDecoder::DeliverPendingOutputs(
int width = GetIntField(jni, *j_media_codec_video_decoder_, j_width_field_);
int height = GetIntField(jni, *j_media_codec_video_decoder_, j_height_field_);
rtc::scoped_refptr<webrtc::VideoFrameBuffer> frame_buffer;
rtc::scoped_refptr<VideoFrameBuffer> frame_buffer;
int64_t presentation_timestamps_ms = 0;
int64_t output_timestamps_ms = 0;
int64_t output_ntp_timestamps_ms = 0;
@ -753,7 +742,7 @@ bool MediaCodecVideoDecoder::DeliverPendingOutputs(
frame_delayed_ms = GetLongField(
jni, j_decoder_output_buffer, j_texture_frame_delay_ms_field_);
// Create webrtc::VideoFrameBuffer with native texture handle.
// Create VideoFrameBuffer with native texture handle.
frame_buffer = surface_texture_helper_->CreateTextureFrame(
width, height, NativeHandleImpl(jni, texture_id, j_transform_matrix));
} else {
@ -805,7 +794,7 @@ bool MediaCodecVideoDecoder::DeliverPendingOutputs(
payload += output_buffer_offset;
// Create yuv420 frame.
rtc::scoped_refptr<webrtc::I420Buffer> i420_buffer =
rtc::scoped_refptr<I420Buffer> i420_buffer =
decoded_frame_pool_.CreateBuffer(width, height);
if (color_format == COLOR_FormatYUV420Planar) {
RTC_CHECK_EQ(0, stride % 2);
@ -903,7 +892,7 @@ bool MediaCodecVideoDecoder::DeliverPendingOutputs(
// If the frame was dropped, frame_buffer is left as nullptr.
if (frame_buffer) {
VideoFrame decoded_frame(frame_buffer, 0, 0, webrtc::kVideoRotation_0);
VideoFrame decoded_frame(frame_buffer, 0, 0, kVideoRotation_0);
decoded_frame.set_timestamp(output_timestamps_ms);
decoded_frame.set_ntp_time_ms(output_ntp_timestamps_ms);
@ -1004,7 +993,7 @@ void MediaCodecVideoDecoderFactory::SetEGLContext(
}
}
webrtc::VideoDecoder* MediaCodecVideoDecoderFactory::CreateVideoDecoder(
VideoDecoder* MediaCodecVideoDecoderFactory::CreateVideoDecoder(
VideoCodecType type) {
if (supported_codec_types_.empty()) {
ALOGW << "No HW video decoder for type " << (int)type;
@ -1022,8 +1011,7 @@ webrtc::VideoDecoder* MediaCodecVideoDecoderFactory::CreateVideoDecoder(
return nullptr;
}
void MediaCodecVideoDecoderFactory::DestroyVideoDecoder(
webrtc::VideoDecoder* decoder) {
void MediaCodecVideoDecoderFactory::DestroyVideoDecoder(VideoDecoder* decoder) {
ALOGD << "Destroy video decoder.";
delete decoder;
}
@ -1032,4 +1020,5 @@ const char* MediaCodecVideoDecoder::ImplementationName() const {
return "MediaCodec";
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

13
webrtc/sdk/android/src/jni/androidmediadecoder_jni.h
View File

@ -14,7 +14,8 @@
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
#include "webrtc/media/engine/webrtcvideodecoderfactory.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Implementation of Android MediaCodec based decoder factory.
class MediaCodecVideoDecoderFactory
@ -26,16 +27,16 @@ class MediaCodecVideoDecoderFactory
void SetEGLContext(JNIEnv* jni, jobject render_egl_context);
// WebRtcVideoDecoderFactory implementation.
webrtc::VideoDecoder* CreateVideoDecoder(webrtc::VideoCodecType type)
override;
VideoDecoder* CreateVideoDecoder(VideoCodecType type) override;
void DestroyVideoDecoder(webrtc::VideoDecoder* decoder) override;
void DestroyVideoDecoder(VideoDecoder* decoder) override;
private:
jobject egl_context_;
std::vector<webrtc::VideoCodecType> supported_codec_types_;
std::vector<VideoCodecType> supported_codec_types_;
};
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_ANDROIDMEDIADECODER_JNI_H_

188
webrtc/sdk/android/src/jni/androidmediaencoder_jni.cc
View File

@ -50,18 +50,8 @@ using rtc::Bind;
using rtc::Thread;
using rtc::ThreadManager;
using webrtc::CodecSpecificInfo;
using webrtc::EncodedImage;
using webrtc::VideoFrame;
using webrtc::RTPFragmentationHeader;
using webrtc::VideoCodec;
using webrtc::VideoCodecType;
using webrtc::kVideoCodecH264;
using webrtc::kVideoCodecVP8;
using webrtc::kVideoCodecVP9;
using webrtc::QualityScaler;
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Maximum supported HW video encoder fps.
#define MAX_VIDEO_FPS 30
@ -93,32 +83,32 @@ const char kH264HighProfileFieldTrial[] = "WebRTC-H264HighProfile";
const char kCustomQPThresholdsFieldTrial[] = "WebRTC-CustomQPThresholds";
} // namespace
// MediaCodecVideoEncoder is a webrtc::VideoEncoder implementation that uses
// MediaCodecVideoEncoder is a VideoEncoder implementation that uses
// Android's MediaCodec SDK API behind the scenes to implement (hopefully)
// HW-backed video encode. This C++ class is implemented as a very thin shim,
// delegating all of the interesting work to org.webrtc.MediaCodecVideoEncoder.
// MediaCodecVideoEncoder must be operated on a single task queue, currently
// this is the encoder queue from ViE encoder.
class MediaCodecVideoEncoder : public webrtc::VideoEncoder {
class MediaCodecVideoEncoder : public VideoEncoder {
public:
virtual ~MediaCodecVideoEncoder();
MediaCodecVideoEncoder(JNIEnv* jni,
const cricket::VideoCodec& codec,
jobject egl_context);
// webrtc::VideoEncoder implementation.
int32_t InitEncode(const webrtc::VideoCodec* codec_settings,
// VideoEncoder implementation.
int32_t InitEncode(const VideoCodec* codec_settings,
int32_t /* number_of_cores */,
size_t /* max_payload_size */) override;
int32_t Encode(const webrtc::VideoFrame& input_image,
const webrtc::CodecSpecificInfo* /* codec_specific_info */,
const std::vector<webrtc::FrameType>* frame_types) override;
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* /* codec_specific_info */,
const std::vector<FrameType>* frame_types) override;
int32_t RegisterEncodeCompleteCallback(
webrtc::EncodedImageCallback* callback) override;
EncodedImageCallback* callback) override;
int32_t Release() override;
int32_t SetChannelParameters(uint32_t /* packet_loss */,
int64_t /* rtt */) override;
int32_t SetRateAllocation(const webrtc::BitrateAllocation& rate_allocation,
int32_t SetRateAllocation(const BitrateAllocation& rate_allocation,
uint32_t frame_rate) override;
bool SupportsNativeHandle() const override { return egl_context_ != nullptr; }
@ -170,19 +160,17 @@ class MediaCodecVideoEncoder : public webrtc::VideoEncoder {
// Reconfigure to match |frame| in width, height. Also reconfigures the
// encoder if |frame| is a texture/byte buffer and the encoder is initialized
// for byte buffer/texture. Returns false if reconfiguring fails.
bool MaybeReconfigureEncoder(JNIEnv* jni, const webrtc::VideoFrame& frame);
bool MaybeReconfigureEncoder(JNIEnv* jni, const VideoFrame& frame);
// Returns true if the frame is a texture frame and we should use surface
// based encoding.
bool IsTextureFrame(JNIEnv* jni, const webrtc::VideoFrame& frame);
bool IsTextureFrame(JNIEnv* jni, const VideoFrame& frame);
bool EncodeByteBuffer(JNIEnv* jni,
bool key_frame,
const webrtc::VideoFrame& frame,
const VideoFrame& frame,
int input_buffer_index);
bool EncodeTexture(JNIEnv* jni,
bool key_frame,
const webrtc::VideoFrame& frame);
bool EncodeTexture(JNIEnv* jni, bool key_frame, const VideoFrame& frame);
// Encodes a new style org.webrtc.VideoFrame. Might be a I420 or a texture
// frame.
bool EncodeJavaFrame(JNIEnv* jni,
@ -219,7 +207,7 @@ class MediaCodecVideoEncoder : public webrtc::VideoEncoder {
// Type of video codec.
const cricket::VideoCodec codec_;
webrtc::EncodedImageCallback* callback_;
EncodedImageCallback* callback_;
// State that is constant for the lifetime of this object once the ctor
// returns.
@ -273,7 +261,7 @@ class MediaCodecVideoEncoder : public webrtc::VideoEncoder {
InputFrameInfo(int64_t encode_start_time,
int32_t frame_timestamp,
int64_t frame_render_time_ms,
webrtc::VideoRotation rotation)
VideoRotation rotation)
: encode_start_time(encode_start_time),
frame_timestamp(frame_timestamp),
frame_render_time_ms(frame_render_time_ms),
@ -284,15 +272,15 @@ class MediaCodecVideoEncoder : public webrtc::VideoEncoder {
// Input frame information.
const int32_t frame_timestamp;
const int64_t frame_render_time_ms;
const webrtc::VideoRotation rotation;
const VideoRotation rotation;
};
std::list<InputFrameInfo> input_frame_infos_;
int32_t output_timestamp_; // Last output frame timestamp from
// |input_frame_infos_|.
int64_t output_render_time_ms_; // Last output frame render time from
// |input_frame_infos_|.
webrtc::VideoRotation output_rotation_; // Last output frame rotation from
// |input_frame_infos_|.
VideoRotation output_rotation_; // Last output frame rotation from
// |input_frame_infos_|.
// Frame size in bytes fed to MediaCodec.
int yuv_size_;
@ -300,14 +288,14 @@ class MediaCodecVideoEncoder : public webrtc::VideoEncoder {
// value and the next Encode() call being ignored.
bool drop_next_input_frame_;
bool scale_;
webrtc::H264::Profile profile_;
H264::Profile profile_;
// Global references; must be deleted in Release().
std::vector<jobject> input_buffers_;
webrtc::H264BitstreamParser h264_bitstream_parser_;
H264BitstreamParser h264_bitstream_parser_;
// VP9 variables to populate codec specific structure.
webrtc::GofInfoVP9 gof_; // Contains each frame's temporal information for
// non-flexible VP9 mode.
GofInfoVP9 gof_; // Contains each frame's temporal information for
// non-flexible VP9 mode.
size_t gof_idx_;
// EGL context - owned by factory, should not be allocated/destroyed
@ -319,7 +307,7 @@ class MediaCodecVideoEncoder : public webrtc::VideoEncoder {
// corresponding to a large image change).
int64_t last_frame_received_ms_;
int frames_received_since_last_key_;
webrtc::VideoCodecMode codec_mode_;
VideoCodecMode codec_mode_;
// RTP state.
uint16_t picture_id_;
@ -412,15 +400,14 @@ MediaCodecVideoEncoder::MediaCodecVideoEncoder(JNIEnv* jni,
ProcessHWError(true /* reset_if_fallback_unavailable */);
}
webrtc::Random random(rtc::TimeMicros());
Random random(rtc::TimeMicros());
picture_id_ = random.Rand<uint16_t>() & 0x7FFF;
tl0_pic_idx_ = random.Rand<uint8_t>();
}
int32_t MediaCodecVideoEncoder::InitEncode(
const webrtc::VideoCodec* codec_settings,
int32_t /* number_of_cores */,
size_t /* max_payload_size */) {
int32_t MediaCodecVideoEncoder::InitEncode(const VideoCodec* codec_settings,
int32_t /* number_of_cores */,
size_t /* max_payload_size */) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
if (codec_settings == NULL) {
ALOGE << "NULL VideoCodec instance";
@ -452,10 +439,10 @@ int32_t MediaCodecVideoEncoder::InitEncode(
ALOGD << "Encoder automatic resize " << (scale_ ? "enabled" : "disabled");
// Check allowed H.264 profile
profile_ = webrtc::H264::Profile::kProfileBaseline;
profile_ = H264::Profile::kProfileBaseline;
if (codec_type == kVideoCodecH264) {
const rtc::Optional<webrtc::H264::ProfileLevelId> profile_level_id =
webrtc::H264::ParseSdpProfileLevelId(codec_.params);
const rtc::Optional<H264::ProfileLevelId> profile_level_id =
H264::ParseSdpProfileLevelId(codec_.params);
RTC_DCHECK(profile_level_id);
profile_ = profile_level_id->profile;
ALOGD << "H.264 profile: " << profile_;
@ -553,7 +540,7 @@ int32_t MediaCodecVideoEncoder::ProcessHWErrorOnEncode() {
}
VideoCodecType MediaCodecVideoEncoder::GetCodecType() const {
return webrtc::PayloadStringToCodecType(codec_.name);
return PayloadStringToCodecType(codec_.name);
}
int32_t MediaCodecVideoEncoder::InitEncodeInternal(int width,
@ -602,7 +589,7 @@ int32_t MediaCodecVideoEncoder::InitEncodeInternal(int width,
input_frame_infos_.clear();
drop_next_input_frame_ = false;
use_surface_ = use_surface;
gof_.SetGofInfoVP9(webrtc::TemporalStructureMode::kTemporalStructureMode1);
gof_.SetGofInfoVP9(TemporalStructureMode::kTemporalStructureMode1);
gof_idx_ = 0;
last_frame_received_ms_ = -1;
frames_received_since_last_key_ = kMinKeyFrameInterval;
@ -686,9 +673,9 @@ int32_t MediaCodecVideoEncoder::InitEncodeInternal(int width,
}
int32_t MediaCodecVideoEncoder::Encode(
const webrtc::VideoFrame& frame,
const webrtc::CodecSpecificInfo* /* codec_specific_info */,
const std::vector<webrtc::FrameType>* frame_types) {
const VideoFrame& frame,
const CodecSpecificInfo* /* codec_specific_info */,
const std::vector<FrameType>* frame_types) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
if (sw_fallback_required_)
return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
@ -701,7 +688,7 @@ int32_t MediaCodecVideoEncoder::Encode(
}
bool send_key_frame = false;
if (codec_mode_ == webrtc::kRealtimeVideo) {
if (codec_mode_ == kRealtimeVideo) {
++frames_received_since_last_key_;
int64_t now_ms = rtc::TimeMillis();
if (last_frame_received_ms_ != -1 &&
@ -761,8 +748,7 @@ int32_t MediaCodecVideoEncoder::Encode(
}
consecutive_full_queue_frame_drops_ = 0;
rtc::scoped_refptr<webrtc::VideoFrameBuffer> input_buffer(
frame.video_frame_buffer());
rtc::scoped_refptr<VideoFrameBuffer> input_buffer(frame.video_frame_buffer());
VideoFrame input_frame(input_buffer, frame.timestamp(),
frame.render_time_ms(), frame.rotation());
@ -773,7 +759,7 @@ int32_t MediaCodecVideoEncoder::Encode(
}
const bool key_frame =
frame_types->front() != webrtc::kVideoFrameDelta || send_key_frame;
frame_types->front() != kVideoFrameDelta || send_key_frame;
bool encode_status = true;
int j_input_buffer_index = -1;
@ -803,7 +789,7 @@ int32_t MediaCodecVideoEncoder::Encode(
}
if (input_frame.video_frame_buffer()->type() !=
webrtc::VideoFrameBuffer::Type::kNative) {
VideoFrameBuffer::Type::kNative) {
encode_status =
EncodeByteBuffer(jni, key_frame, input_frame, j_input_buffer_index);
} else {
@ -852,9 +838,8 @@ int32_t MediaCodecVideoEncoder::Encode(
return WEBRTC_VIDEO_CODEC_OK;
}
bool MediaCodecVideoEncoder::MaybeReconfigureEncoder(
JNIEnv* jni,
const webrtc::VideoFrame& frame) {
bool MediaCodecVideoEncoder::MaybeReconfigureEncoder(JNIEnv* jni,
const VideoFrame& frame) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
bool is_texture = IsTextureFrame(jni, frame);
@ -888,9 +873,8 @@ bool MediaCodecVideoEncoder::MaybeReconfigureEncoder(
}
bool MediaCodecVideoEncoder::IsTextureFrame(JNIEnv* jni,
const webrtc::VideoFrame& frame) {
if (frame.video_frame_buffer()->type() !=
webrtc::VideoFrameBuffer::Type::kNative) {
const VideoFrame& frame) {
if (frame.video_frame_buffer()->type() != VideoFrameBuffer::Type::kNative) {
return false;
}
@ -911,12 +895,12 @@ bool MediaCodecVideoEncoder::IsTextureFrame(JNIEnv* jni,
bool MediaCodecVideoEncoder::EncodeByteBuffer(JNIEnv* jni,
bool key_frame,
const webrtc::VideoFrame& frame,
const VideoFrame& frame,
int input_buffer_index) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
RTC_CHECK(!use_surface_);
rtc::scoped_refptr<webrtc::I420BufferInterface> i420_buffer =
rtc::scoped_refptr<I420BufferInterface> i420_buffer =
frame.video_frame_buffer()->ToI420();
if (!FillInputBuffer(jni, input_buffer_index, i420_buffer->DataY(),
i420_buffer->StrideY(), i420_buffer->DataU(),
@ -962,7 +946,7 @@ bool MediaCodecVideoEncoder::FillInputBuffer(JNIEnv* jni,
bool MediaCodecVideoEncoder::EncodeTexture(JNIEnv* jni,
bool key_frame,
const webrtc::VideoFrame& frame) {
const VideoFrame& frame) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
RTC_CHECK(use_surface_);
NativeHandleImpl handle =
@ -997,7 +981,7 @@ bool MediaCodecVideoEncoder::EncodeJavaFrame(JNIEnv* jni,
}
int32_t MediaCodecVideoEncoder::RegisterEncodeCompleteCallback(
webrtc::EncodedImageCallback* callback) {
EncodedImageCallback* callback) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni);
@ -1038,7 +1022,7 @@ int32_t MediaCodecVideoEncoder::Release() {
}
int32_t MediaCodecVideoEncoder::SetRateAllocation(
const webrtc::BitrateAllocation& rate_allocation,
const BitrateAllocation& rate_allocation,
uint32_t frame_rate) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
const uint32_t new_bit_rate = rate_allocation.get_sum_kbps();
@ -1147,35 +1131,33 @@ bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) {
// Callback - return encoded frame.
const VideoCodecType codec_type = GetCodecType();
webrtc::EncodedImageCallback::Result callback_result(
webrtc::EncodedImageCallback::Result::OK);
EncodedImageCallback::Result callback_result(
EncodedImageCallback::Result::OK);
if (callback_) {
std::unique_ptr<webrtc::EncodedImage> image(
new webrtc::EncodedImage(payload, payload_size, payload_size));
std::unique_ptr<EncodedImage> image(
new EncodedImage(payload, payload_size, payload_size));
image->_encodedWidth = width_;
image->_encodedHeight = height_;
image->_timeStamp = output_timestamp_;
image->capture_time_ms_ = output_render_time_ms_;
image->rotation_ = output_rotation_;
image->content_type_ =
(codec_mode_ == webrtc::VideoCodecMode::kScreensharing)
? webrtc::VideoContentType::SCREENSHARE
: webrtc::VideoContentType::UNSPECIFIED;
image->timing_.flags = webrtc::TimingFrameFlags::kInvalid;
image->_frameType =
(key_frame ? webrtc::kVideoFrameKey : webrtc::kVideoFrameDelta);
image->content_type_ = (codec_mode_ == VideoCodecMode::kScreensharing)
? VideoContentType::SCREENSHARE
: VideoContentType::UNSPECIFIED;
image->timing_.flags = TimingFrameFlags::kInvalid;
image->_frameType = (key_frame ? kVideoFrameKey : kVideoFrameDelta);
image->_completeFrame = true;
webrtc::CodecSpecificInfo info;
CodecSpecificInfo info;
memset(&info, 0, sizeof(info));
info.codecType = codec_type;
if (codec_type == kVideoCodecVP8) {
info.codecSpecific.VP8.pictureId = picture_id_;
info.codecSpecific.VP8.nonReference = false;
info.codecSpecific.VP8.simulcastIdx = 0;
info.codecSpecific.VP8.temporalIdx = webrtc::kNoTemporalIdx;
info.codecSpecific.VP8.temporalIdx = kNoTemporalIdx;
info.codecSpecific.VP8.layerSync = false;
info.codecSpecific.VP8.tl0PicIdx = webrtc::kNoTl0PicIdx;
info.codecSpecific.VP8.keyIdx = webrtc::kNoKeyIdx;
info.codecSpecific.VP8.tl0PicIdx = kNoTl0PicIdx;
info.codecSpecific.VP8.keyIdx = kNoKeyIdx;
} else if (codec_type == kVideoCodecVP9) {
if (key_frame) {
gof_idx_ = 0;
@ -1185,8 +1167,8 @@ bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) {
info.codecSpecific.VP9.flexible_mode = false;
info.codecSpecific.VP9.ss_data_available = key_frame ? true : false;
info.codecSpecific.VP9.tl0_pic_idx = tl0_pic_idx_++;
info.codecSpecific.VP9.temporal_idx = webrtc::kNoTemporalIdx;
info.codecSpecific.VP9.spatial_idx = webrtc::kNoSpatialIdx;
info.codecSpecific.VP9.temporal_idx = kNoTemporalIdx;
info.codecSpecific.VP9.spatial_idx = kNoSpatialIdx;
info.codecSpecific.VP9.temporal_up_switch = true;
info.codecSpecific.VP9.inter_layer_predicted = false;
info.codecSpecific.VP9.gof_idx =
@ -1203,7 +1185,7 @@ bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) {
picture_id_ = (picture_id_ + 1) & 0x7FFF;
// Generate a header describing a single fragment.
webrtc::RTPFragmentationHeader header;
RTPFragmentationHeader header;
memset(&header, 0, sizeof(header));
if (codec_type == kVideoCodecVP8 || codec_type == kVideoCodecVP9) {
header.VerifyAndAllocateFragmentationHeader(1);
@ -1213,13 +1195,13 @@ bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) {
header.fragmentationTimeDiff[0] = 0;
if (codec_type == kVideoCodecVP8) {
int qp;
if (webrtc::vp8::GetQp(payload, payload_size, &qp)) {
if (vp8::GetQp(payload, payload_size, &qp)) {
current_acc_qp_ += qp;
image->qp_ = qp;
}
} else if (codec_type == kVideoCodecVP9) {
int qp;
if (webrtc::vp9::GetQp(payload, payload_size, &qp)) {
if (vp9::GetQp(payload, payload_size, &qp)) {
current_acc_qp_ += qp;
image->qp_ = qp;
}
@ -1232,8 +1214,8 @@ bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) {
image->qp_ = qp;
}
// For H.264 search for start codes.
const std::vector<webrtc::H264::NaluIndex> nalu_idxs =
webrtc::H264::FindNaluIndices(payload, payload_size);
const std::vector<H264::NaluIndex> nalu_idxs =
H264::FindNaluIndices(payload, payload_size);
if (nalu_idxs.empty()) {
ALOGE << "Start code is not found!";
ALOGE << "Data:" << image->_buffer[0] << " " << image->_buffer[1]
@ -1316,12 +1298,12 @@ void MediaCodecVideoEncoder::LogStatistics(bool force_log) {
}
}
webrtc::VideoEncoder::ScalingSettings
MediaCodecVideoEncoder::GetScalingSettings() const {
if (webrtc::field_trial::IsEnabled(kCustomQPThresholdsFieldTrial)) {
VideoEncoder::ScalingSettings MediaCodecVideoEncoder::GetScalingSettings()
const {
if (field_trial::IsEnabled(kCustomQPThresholdsFieldTrial)) {
const VideoCodecType codec_type = GetCodecType();
std::string experiment_string =
webrtc::field_trial::FindFullName(kCustomQPThresholdsFieldTrial);
field_trial::FindFullName(kCustomQPThresholdsFieldTrial);
ALOGD << "QP custom thresholds: " << experiment_string << " for codec "
<< codec_type;
int low_vp8_qp_threshold;
@ -1391,11 +1373,11 @@ MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory()
// TODO(magjed): Enumerate actual level instead of using hardcoded level
// 3.1. Level 3.1 is 1280x720@30fps which is enough for now.
cricket::VideoCodec constrained_high(cricket::kH264CodecName);
const webrtc::H264::ProfileLevelId constrained_high_profile(
webrtc::H264::kProfileConstrainedHigh, webrtc::H264::kLevel3_1);
const H264::ProfileLevelId constrained_high_profile(
H264::kProfileConstrainedHigh, H264::kLevel3_1);
constrained_high.SetParam(
cricket::kH264FmtpProfileLevelId,
*webrtc::H264::ProfileLevelIdToString(constrained_high_profile));
*H264::ProfileLevelIdToString(constrained_high_profile));
constrained_high.SetParam(cricket::kH264FmtpLevelAsymmetryAllowed, "1");
constrained_high.SetParam(cricket::kH264FmtpPacketizationMode, "1");
supported_codecs_with_h264_hp_.push_back(constrained_high);
@ -1412,11 +1394,11 @@ MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory()
// profile as long as we have decode support for it and still send Baseline
// since Baseline is a subset of the High profile.
cricket::VideoCodec constrained_baseline(cricket::kH264CodecName);
const webrtc::H264::ProfileLevelId constrained_baseline_profile(
webrtc::H264::kProfileConstrainedBaseline, webrtc::H264::kLevel3_1);
const H264::ProfileLevelId constrained_baseline_profile(
H264::kProfileConstrainedBaseline, H264::kLevel3_1);
constrained_baseline.SetParam(
cricket::kH264FmtpProfileLevelId,
*webrtc::H264::ProfileLevelIdToString(constrained_baseline_profile));
*H264::ProfileLevelIdToString(constrained_baseline_profile));
constrained_baseline.SetParam(cricket::kH264FmtpLevelAsymmetryAllowed, "1");
constrained_baseline.SetParam(cricket::kH264FmtpPacketizationMode, "1");
supported_codecs_.push_back(constrained_baseline);
@ -1445,7 +1427,7 @@ void MediaCodecVideoEncoderFactory::SetEGLContext(
}
}
webrtc::VideoEncoder* MediaCodecVideoEncoderFactory::CreateVideoEncoder(
VideoEncoder* MediaCodecVideoEncoderFactory::CreateVideoEncoder(
const cricket::VideoCodec& codec) {
if (supported_codecs().empty()) {
ALOGW << "No HW video encoder for codec " << codec.name;
@ -1463,15 +1445,14 @@ webrtc::VideoEncoder* MediaCodecVideoEncoderFactory::CreateVideoEncoder(
const std::vector<cricket::VideoCodec>&
MediaCodecVideoEncoderFactory::supported_codecs() const {
if (webrtc::field_trial::IsEnabled(kH264HighProfileFieldTrial)) {
if (field_trial::IsEnabled(kH264HighProfileFieldTrial)) {
return supported_codecs_with_h264_hp_;
} else {
return supported_codecs_;
}
}
void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
webrtc::VideoEncoder* encoder) {
void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(VideoEncoder* encoder) {
ALOGD << "Destroy video encoder.";
delete encoder;
}
@ -1500,4 +1481,5 @@ JNI_FUNCTION_DECLARATION(void,
stride_u, buffer_v, stride_v);
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

11
webrtc/sdk/android/src/jni/androidmediaencoder_jni.h
View File

@ -16,7 +16,8 @@
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
#include "webrtc/media/engine/webrtcvideoencoderfactory.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Implementation of Android MediaCodec based encoder factory.
class MediaCodecVideoEncoderFactory
@ -28,10 +29,9 @@ class MediaCodecVideoEncoderFactory
void SetEGLContext(JNIEnv* jni, jobject egl_context);
// WebRtcVideoEncoderFactory implementation.
webrtc::VideoEncoder* CreateVideoEncoder(
const cricket::VideoCodec& codec) override;
VideoEncoder* CreateVideoEncoder(const cricket::VideoCodec& codec) override;
const std::vector<cricket::VideoCodec>& supported_codecs() const override;
void DestroyVideoEncoder(webrtc::VideoEncoder* encoder) override;
void DestroyVideoEncoder(VideoEncoder* encoder) override;
private:
jobject egl_context_;
@ -41,6 +41,7 @@ class MediaCodecVideoEncoderFactory
std::vector<cricket::VideoCodec> supported_codecs_with_h264_hp_;
};
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_ANDROIDMEDIAENCODER_JNI_H_

13
webrtc/sdk/android/src/jni/androidmetrics_jni.cc
View File

@ -17,10 +17,11 @@
#include "webrtc/system_wrappers/include/metrics_default.h"
// Enables collection of native histograms and creating them.
namespace webrtc_jni {
namespace webrtc {
namespace jni {
JNI_FUNCTION_DECLARATION(void, Metrics_nativeEnable, JNIEnv* jni, jclass) {
webrtc::metrics::Enable();
metrics::Enable();
}
// Gets and clears native histograms.
@ -39,9 +40,8 @@ JNI_FUNCTION_DECLARATION(jobject,
jobject j_metrics = jni->NewObject(
j_metrics_class, GetMethodID(jni, j_metrics_class, "<init>", "()V"));
std::map<std::string, std::unique_ptr<webrtc::metrics::SampleInfo>>
histograms;
webrtc::metrics::GetAndReset(&histograms);
std::map<std::string, std::unique_ptr<metrics::SampleInfo>> histograms;
metrics::GetAndReset(&histograms);
for (const auto& kv : histograms) {
// Create and add samples to |HistogramInfo|.
jobject j_info = jni->NewObject(
@ -61,4 +61,5 @@ JNI_FUNCTION_DECLARATION(jobject,
return j_metrics;
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

24
webrtc/sdk/android/src/jni/androidvideotracksource.cc
View File

@ -21,6 +21,7 @@ const int kRequiredResolutionAlignment = 2;
}
namespace webrtc {
namespace jni {
AndroidVideoTrackSource::AndroidVideoTrackSource(
rtc::Thread* signaling_thread,
@ -29,17 +30,16 @@ AndroidVideoTrackSource::AndroidVideoTrackSource(
bool is_screencast)
: AdaptedVideoTrackSource(kRequiredResolutionAlignment),
signaling_thread_(signaling_thread),
surface_texture_helper_(
new rtc::RefCountedObject<webrtc_jni::SurfaceTextureHelper>(
jni,
j_surface_texture_helper)),
surface_texture_helper_(new rtc::RefCountedObject<SurfaceTextureHelper>(
jni,
j_surface_texture_helper)),
video_buffer_factory_(jni),
is_screencast_(is_screencast) {
LOG(LS_INFO) << "AndroidVideoTrackSource ctor";
camera_thread_checker_.DetachFromThread();
jclass j_video_frame_buffer_class =
webrtc_jni::FindClass(jni, "org/webrtc/VideoFrame$Buffer");
FindClass(jni, "org/webrtc/VideoFrame$Buffer");
j_crop_and_scale_id_ =
jni->GetMethodID(j_video_frame_buffer_class, "cropAndScale",
"(IIIIII)Lorg/webrtc/VideoFrame$Buffer;");
@ -115,7 +115,7 @@ void AndroidVideoTrackSource::OnTextureFrameCaptured(
int height,
VideoRotation rotation,
int64_t timestamp_ns,
const webrtc_jni::NativeHandleImpl& handle) {
const NativeHandleImpl& handle) {
RTC_DCHECK(camera_thread_checker_.CalledOnValidThread());
int64_t camera_time_us = timestamp_ns / rtc::kNumNanosecsPerMicrosec;
@ -136,7 +136,7 @@ void AndroidVideoTrackSource::OnTextureFrameCaptured(
return;
}
webrtc_jni::Matrix matrix = handle.sampling_matrix;
Matrix matrix = handle.sampling_matrix;
matrix.Crop(crop_width / static_cast<float>(width),
crop_height / static_cast<float>(height),
@ -153,11 +153,10 @@ void AndroidVideoTrackSource::OnTextureFrameCaptured(
rotation = kVideoRotation_0;
}
OnFrame(VideoFrame(
surface_texture_helper_->CreateTextureFrame(
adapted_width, adapted_height,
webrtc_jni::NativeHandleImpl(handle.oes_texture_id, matrix)),
rotation, translated_camera_time_us));
OnFrame(VideoFrame(surface_texture_helper_->CreateTextureFrame(
adapted_width, adapted_height,
NativeHandleImpl(handle.oes_texture_id, matrix)),
rotation, translated_camera_time_us));
}
void AndroidVideoTrackSource::OnFrameCaptured(JNIEnv* jni,
@ -209,3 +208,4 @@ void AndroidVideoTrackSource::OnOutputFormatRequest(int width,
}
} // namespace webrtc
} // namespace webrtc

11
webrtc/sdk/android/src/jni/androidvideotracksource.h
View File

@ -24,6 +24,7 @@
#include "webrtc/sdk/android/src/jni/surfacetexturehelper_jni.h"
namespace webrtc {
namespace jni {
class AndroidVideoTrackSource : public rtc::AdaptedVideoTrackSource {
public:
@ -59,7 +60,7 @@ class AndroidVideoTrackSource : public rtc::AdaptedVideoTrackSource {
int height,
VideoRotation rotation,
int64_t timestamp_ns,
const webrtc_jni::NativeHandleImpl& handle);
const NativeHandleImpl& handle);
void OnFrameCaptured(JNIEnv* jni,
int width,
@ -70,8 +71,7 @@ class AndroidVideoTrackSource : public rtc::AdaptedVideoTrackSource {
void OnOutputFormatRequest(int width, int height, int fps);
rtc::scoped_refptr<webrtc_jni::SurfaceTextureHelper>
surface_texture_helper() {
rtc::scoped_refptr<SurfaceTextureHelper> surface_texture_helper() {
return surface_texture_helper_;
}
@ -83,13 +83,14 @@ class AndroidVideoTrackSource : public rtc::AdaptedVideoTrackSource {
rtc::TimestampAligner timestamp_aligner_;
NV12ToI420Scaler nv12toi420_scaler_;
I420BufferPool buffer_pool_;
rtc::scoped_refptr<webrtc_jni::SurfaceTextureHelper> surface_texture_helper_;
webrtc_jni::AndroidVideoBufferFactory video_buffer_factory_;
rtc::scoped_refptr<SurfaceTextureHelper> surface_texture_helper_;
AndroidVideoBufferFactory video_buffer_factory_;
const bool is_screencast_;
jmethodID j_crop_and_scale_id_;
};
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_API_ANDROID_JNI_ANDROIDVIDEOTRACKSOURCE_H_

41
webrtc/sdk/android/src/jni/androidvideotracksource_jni.cc
View File

@ -14,19 +14,24 @@
#include "webrtc/sdk/android/src/jni/androidvideotracksource.h"
#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
static webrtc::VideoRotation jintToVideoRotation(jint rotation) {
namespace webrtc {
namespace {
static VideoRotation jintToVideoRotation(jint rotation) {
RTC_DCHECK(rotation == 0 || rotation == 90 || rotation == 180 ||
rotation == 270);
return static_cast<webrtc::VideoRotation>(rotation);
return static_cast<VideoRotation>(rotation);
}
namespace webrtc_jni {
} // namespace
static webrtc::AndroidVideoTrackSource* AndroidVideoTrackSourceFromJavaProxy(
namespace jni {
static AndroidVideoTrackSource* AndroidVideoTrackSourceFromJavaProxy(
jlong j_proxy) {
auto proxy_source = reinterpret_cast<webrtc::VideoTrackSourceProxy*>(j_proxy);
return reinterpret_cast<webrtc::AndroidVideoTrackSource*>(
proxy_source->internal());
auto proxy_source = reinterpret_cast<VideoTrackSourceProxy*>(j_proxy);
return reinterpret_cast<AndroidVideoTrackSource*>(proxy_source->internal());
}
JNI_FUNCTION_DECLARATION(
@ -41,7 +46,7 @@ JNI_FUNCTION_DECLARATION(
jint height,
jint rotation,
jlong timestamp) {
webrtc::AndroidVideoTrackSource* source =
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
jbyte* bytes = jni->GetByteArrayElements(j_frame, nullptr);
source->OnByteBufferFrameCaptured(bytes, length, width, height,
@ -61,7 +66,7 @@ JNI_FUNCTION_DECLARATION(
jfloatArray j_transform_matrix,
jint j_rotation,
jlong j_timestamp) {
webrtc::AndroidVideoTrackSource* source =
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
source->OnTextureFrameCaptured(
j_width, j_height, jintToVideoRotation(j_rotation), j_timestamp,
@ -78,7 +83,7 @@ JNI_FUNCTION_DECLARATION(void,
jint j_rotation,
jlong j_timestamp_ns,
jobject j_video_frame_buffer) {
webrtc::AndroidVideoTrackSource* source =
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
source->OnFrameCaptured(jni, j_width, j_height, j_timestamp_ns,
jintToVideoRotation(j_rotation),
@ -92,11 +97,10 @@ JNI_FUNCTION_DECLARATION(void,
jlong j_source,
jboolean j_success) {
LOG(LS_INFO) << "AndroidVideoTrackSourceObserve_nativeCapturerStarted";
webrtc::AndroidVideoTrackSource* source =
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
source->SetState(j_success
? webrtc::AndroidVideoTrackSource::SourceState::kLive
: webrtc::AndroidVideoTrackSource::SourceState::kEnded);
source->SetState(j_success ? AndroidVideoTrackSource::SourceState::kLive
: AndroidVideoTrackSource::SourceState::kEnded);
}
JNI_FUNCTION_DECLARATION(void,
@ -105,9 +109,9 @@ JNI_FUNCTION_DECLARATION(void,
jclass,
jlong j_source) {
LOG(LS_INFO) << "AndroidVideoTrackSourceObserve_nativeCapturerStopped";
webrtc::AndroidVideoTrackSource* source =
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
source->SetState(webrtc::AndroidVideoTrackSource::SourceState::kEnded);
source->SetState(AndroidVideoTrackSource::SourceState::kEnded);
}
JNI_FUNCTION_DECLARATION(void,
@ -119,9 +123,10 @@ JNI_FUNCTION_DECLARATION(void,
jint j_height,
jint j_fps) {
LOG(LS_INFO) << "VideoSource_nativeAdaptOutputFormat";
webrtc::AndroidVideoTrackSource* source =
AndroidVideoTrackSource* source =
AndroidVideoTrackSourceFromJavaProxy(j_source);
source->OnOutputFormatRequest(j_width, j_height, j_fps);
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

6
webrtc/sdk/android/src/jni/classreferenceholder.cc
View File

@ -11,7 +11,8 @@
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// ClassReferenceHolder holds global reference to Java classes in app/webrtc.
class ClassReferenceHolder {
@ -153,4 +154,5 @@ jclass FindClass(JNIEnv* jni, const char* name) {
return g_class_reference_holder->GetClass(name);
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

12
webrtc/sdk/android/src/jni/classreferenceholder.h
View File

@ -20,7 +20,8 @@
#include <map>
#include <string>
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// LoadGlobalClassReferenceHolder must be called in JNI_OnLoad.
void LoadGlobalClassReferenceHolder();
@ -31,6 +32,15 @@ void FreeGlobalClassReferenceHolder();
// process.
jclass FindClass(JNIEnv* jni, const char* name);
} // namespace jni
} // namespace webrtc
// TODO(magjed): Remove once external clients are updated.
namespace webrtc_jni {
using webrtc::jni::LoadGlobalClassReferenceHolder;
using webrtc::jni::FreeGlobalClassReferenceHolder;
} // namespace webrtc_jni
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_CLASSREFERENCEHOLDER_H_

6
webrtc/sdk/android/src/jni/filevideocapturer_jni.cc
View File

@ -14,7 +14,8 @@
#include "webrtc/rtc_base/checks.h"
#include "webrtc/rtc_base/logging.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
extern "C" JNIEXPORT void JNICALL
Java_org_webrtc_FileVideoCapturer_nativeI420ToNV21(JNIEnv* jni,
@ -57,4 +58,5 @@ Java_org_webrtc_FileVideoCapturer_nativeI420ToNV21(JNIEnv* jni,
}
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

6
webrtc/sdk/android/src/jni/jni_helpers.cc
View File

@ -17,7 +17,8 @@
#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
static JavaVM* g_jvm = nullptr;
@ -385,4 +386,5 @@ bool Iterable::Iterator::AtEnd() const {
return jni_ == nullptr || IsNull(jni_, iterator_);
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

12
webrtc/sdk/android/src/jni/jni_helpers.h
View File

@ -39,7 +39,8 @@
#define JNI_FUNCTION_DECLARATION(rettype, name, ...) \
extern "C" JNIEXPORT rettype JNICALL Java_org_webrtc_##name(__VA_ARGS__)
namespace webrtc_jni {
namespace webrtc {
namespace jni {
jint InitGlobalJniVariables(JavaVM *jvm);
@ -204,6 +205,15 @@ class Iterable {
RTC_DISALLOW_COPY_AND_ASSIGN(Iterable);
};
} // namespace jni
} // namespace webrtc
// TODO(magjed): Remove once external clients are updated.
namespace webrtc_jni {
using webrtc::jni::AttachCurrentThreadIfNeeded;
using webrtc::jni::InitGlobalJniVariables;
} // namespace webrtc_jni
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_JNI_HELPERS_H_

6
webrtc/sdk/android/src/jni/jni_onload.cc
View File

@ -16,7 +16,8 @@
#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
extern "C" jint JNIEXPORT JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) {
jint ret = InitGlobalJniVariables(jvm);
@ -35,4 +36,5 @@ extern "C" void JNIEXPORT JNICALL JNI_OnUnLoad(JavaVM *jvm, void *reserved) {
RTC_CHECK(rtc::CleanupSSL()) << "Failed to CleanupSSL()";
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

63
webrtc/sdk/android/src/jni/native_handle_impl.cc
View File

@ -24,11 +24,12 @@
#include "webrtc/sdk/android/src/jni/wrapped_native_i420_buffer.h"
#include "webrtc/system_wrappers/include/aligned_malloc.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
namespace {
class AndroidVideoI420Buffer : public webrtc::I420BufferInterface {
class AndroidVideoI420Buffer : public I420BufferInterface {
public:
// Wraps an existing reference to a Java VideoBuffer. Retain will not be
// called but release will be called when the C++ object is destroyed.
@ -167,14 +168,14 @@ jfloatArray Matrix::ToJava(JNIEnv* jni) const {
return matrix;
}
void Matrix::Rotate(webrtc::VideoRotation rotation) {
void Matrix::Rotate(VideoRotation rotation) {
// Texture coordinates are in the range 0 to 1. The transformation of the last
// row in each rotation matrix is needed for proper translation, e.g, to
// mirror x, we don't replace x by -x, but by 1-x.
switch (rotation) {
case webrtc::kVideoRotation_0:
case kVideoRotation_0:
break;
case webrtc::kVideoRotation_90: {
case kVideoRotation_90: {
const float ROTATE_90[16] =
{ elem_[4], elem_[5], elem_[6], elem_[7],
-elem_[0], -elem_[1], -elem_[2], -elem_[3],
@ -183,7 +184,7 @@ void Matrix::Rotate(webrtc::VideoRotation rotation) {
elem_[2] + elem_[14], elem_[3] + elem_[15]};
memcpy(elem_, ROTATE_90, sizeof(elem_));
} break;
case webrtc::kVideoRotation_180: {
case kVideoRotation_180: {
const float ROTATE_180[16] =
{ -elem_[0], -elem_[1], -elem_[2], -elem_[3],
-elem_[4], -elem_[5], -elem_[6], -elem_[7],
@ -192,7 +193,7 @@ void Matrix::Rotate(webrtc::VideoRotation rotation) {
elem_[2] + elem_[6] + elem_[14], elem_[3] + elem_[11]+ elem_[15]};
memcpy(elem_, ROTATE_180, sizeof(elem_));
} break;
case webrtc::kVideoRotation_270: {
case kVideoRotation_270: {
const float ROTATE_270[16] =
{ -elem_[4], -elem_[5], -elem_[6], -elem_[7],
elem_[0], elem_[1], elem_[2], elem_[3],
@ -261,7 +262,7 @@ AndroidTextureBuffer::~AndroidTextureBuffer() {
no_longer_used_cb_();
}
webrtc::VideoFrameBuffer::Type AndroidTextureBuffer::type() const {
VideoFrameBuffer::Type AndroidTextureBuffer::type() const {
return Type::kNative;
}
@ -277,7 +278,7 @@ int AndroidTextureBuffer::height() const {
return height_;
}
rtc::scoped_refptr<webrtc::I420BufferInterface> AndroidTextureBuffer::ToI420() {
rtc::scoped_refptr<I420BufferInterface> AndroidTextureBuffer::ToI420() {
int uv_width = (width() + 7) / 8;
int stride = 8 * uv_width;
int uv_height = (height() + 1) / 2;
@ -291,16 +292,16 @@ rtc::scoped_refptr<webrtc::I420BufferInterface> AndroidTextureBuffer::ToI420() {
// system_wrappers/include/aligned_malloc.h violate current DEPS
// rules. We get away for now only because it is indirectly included
// by i420_buffer.h
std::unique_ptr<uint8_t, webrtc::AlignedFreeDeleter> yuv_data(
static_cast<uint8_t*>(webrtc::AlignedMalloc(size, kBufferAlignment)));
std::unique_ptr<uint8_t, AlignedFreeDeleter> yuv_data(
static_cast<uint8_t*>(AlignedMalloc(size, kBufferAlignment)));
// See YuvConverter.java for the required layout.
uint8_t* y_data = yuv_data.get();
uint8_t* u_data = y_data + height() * stride;
uint8_t* v_data = u_data + stride/2;
rtc::scoped_refptr<webrtc::I420BufferInterface> copy = webrtc::WrapI420Buffer(
rtc::scoped_refptr<I420BufferInterface> copy = webrtc::WrapI420Buffer(
width(), height(), y_data, stride, u_data, stride, v_data, stride,
rtc::Bind(&webrtc::AlignedFree, yuv_data.release()));
rtc::Bind(&AlignedFree, yuv_data.release()));
JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni);
@ -366,7 +367,7 @@ jobject AndroidVideoBuffer::video_frame_buffer() const {
return *j_video_frame_buffer_;
}
webrtc::VideoFrameBuffer::Type AndroidVideoBuffer::type() const {
VideoFrameBuffer::Type AndroidVideoBuffer::type() const {
return Type::kNative;
}
@ -378,7 +379,7 @@ int AndroidVideoBuffer::height() const {
return height_;
}
rtc::scoped_refptr<webrtc::I420BufferInterface> AndroidVideoBuffer::ToI420() {
rtc::scoped_refptr<I420BufferInterface> AndroidVideoBuffer::ToI420() {
JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni);
@ -405,9 +406,9 @@ jobject AndroidVideoBuffer::ToJavaI420Frame(JNIEnv* jni, int rotation) {
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.
webrtc::VideoFrame* native_frame = new webrtc::VideoFrame(
this, 0 /* timestamp */, 0 /* render_time_ms */,
webrtc::VideoRotation::kVideoRotation_0 /* rotation */);
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));
}
@ -434,7 +435,7 @@ AndroidVideoBufferFactory::AndroidVideoBufferFactory(JNIEnv* jni)
j_get_height_id_(
GetMethodID(jni, *j_video_frame_buffer_class_, "getHeight", "()I")) {}
webrtc::VideoFrame AndroidVideoBufferFactory::CreateFrame(
VideoFrame AndroidVideoBufferFactory::CreateFrame(
JNIEnv* jni,
jobject j_video_frame,
uint32_t timestamp_rtp) const {
@ -445,9 +446,9 @@ webrtc::VideoFrame AndroidVideoBufferFactory::CreateFrame(
jni->CallLongMethod(j_video_frame, j_get_timestamp_ns_id_);
rtc::scoped_refptr<AndroidVideoBuffer> buffer =
CreateBuffer(jni, j_video_frame_buffer);
return webrtc::VideoFrame(buffer, timestamp_rtp,
timestamp_ns / rtc::kNumNanosecsPerMillisec,
static_cast<webrtc::VideoRotation>(rotation));
return VideoFrame(buffer, timestamp_rtp,
timestamp_ns / rtc::kNumNanosecsPerMillisec,
static_cast<VideoRotation>(rotation));
}
rtc::scoped_refptr<AndroidVideoBuffer> AndroidVideoBufferFactory::WrapBuffer(
@ -475,9 +476,8 @@ JavaVideoFrameFactory::JavaVideoFrameFactory(JNIEnv* jni)
"(Lorg/webrtc/VideoFrame$Buffer;IJ)V");
}
static bool IsJavaVideoBuffer(
rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer) {
if (buffer->type() != webrtc::VideoFrameBuffer::Type::kNative) {
static bool IsJavaVideoBuffer(rtc::scoped_refptr<VideoFrameBuffer> buffer) {
if (buffer->type() != VideoFrameBuffer::Type::kNative) {
return false;
}
AndroidVideoFrameBuffer* android_buffer =
@ -486,14 +486,12 @@ static bool IsJavaVideoBuffer(
AndroidVideoFrameBuffer::AndroidType::kJavaBuffer;
}
jobject JavaVideoFrameFactory::ToJavaFrame(
JNIEnv* jni,
const webrtc::VideoFrame& frame) const {
rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer =
frame.video_frame_buffer();
jobject JavaVideoFrameFactory::ToJavaFrame(JNIEnv* jni,
const VideoFrame& frame) const {
rtc::scoped_refptr<VideoFrameBuffer> buffer = frame.video_frame_buffer();
jobject j_buffer;
if (IsJavaVideoBuffer(buffer)) {
RTC_DCHECK(buffer->type() == webrtc::VideoFrameBuffer::Type::kNative);
RTC_DCHECK(buffer->type() == VideoFrameBuffer::Type::kNative);
AndroidVideoFrameBuffer* android_buffer =
static_cast<AndroidVideoFrameBuffer*>(buffer.get());
RTC_DCHECK(android_buffer->android_type() ==
@ -510,4 +508,5 @@ jobject JavaVideoFrameFactory::ToJavaFrame(
static_cast<jlong>(frame.timestamp_us() * rtc::kNumNanosecsPerMicrosec));
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

22
webrtc/sdk/android/src/jni/native_handle_impl.h
View File

@ -19,7 +19,8 @@
#include "webrtc/rtc_base/callback.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Open gl texture matrix, in column-major order. Operations are
// in-place.
@ -37,7 +38,7 @@ class Matrix {
float crop_x,
float crop_y);
void Rotate(webrtc::VideoRotation rotation);
void Rotate(VideoRotation rotation);
private:
Matrix() {}
@ -62,7 +63,7 @@ struct NativeHandleImpl {
// Java-based frames.
// TODO(sakal): Remove this and AndroidTextureBuffer once they are no longer
// needed.
class AndroidVideoFrameBuffer : public webrtc::VideoFrameBuffer {
class AndroidVideoFrameBuffer : public VideoFrameBuffer {
public:
enum class AndroidType { kTextureBuffer, kJavaBuffer };
@ -85,7 +86,7 @@ class AndroidTextureBuffer : public AndroidVideoFrameBuffer {
int width() const override;
int height() const override;
rtc::scoped_refptr<webrtc::I420BufferInterface> ToI420() override;
rtc::scoped_refptr<I420BufferInterface> ToI420() override;
AndroidType android_type() override { return AndroidType::kTextureBuffer; }
@ -137,7 +138,7 @@ class AndroidVideoBuffer : public AndroidVideoFrameBuffer {
int width() const override;
int height() const override;
rtc::scoped_refptr<webrtc::I420BufferInterface> ToI420() override;
rtc::scoped_refptr<I420BufferInterface> ToI420() override;
AndroidType android_type() override { return AndroidType::kJavaBuffer; }
@ -152,9 +153,9 @@ class AndroidVideoBufferFactory {
public:
explicit AndroidVideoBufferFactory(JNIEnv* jni);
webrtc::VideoFrame CreateFrame(JNIEnv* jni,
jobject j_video_frame,
uint32_t timestamp_rtp) const;
VideoFrame CreateFrame(JNIEnv* jni,
jobject j_video_frame,
uint32_t timestamp_rtp) const;
// Wraps a buffer to AndroidVideoBuffer without incrementing the reference
// count.
@ -183,13 +184,14 @@ class JavaVideoFrameFactory {
public:
JavaVideoFrameFactory(JNIEnv* jni);
jobject ToJavaFrame(JNIEnv* jni, const webrtc::VideoFrame& frame) const;
jobject ToJavaFrame(JNIEnv* jni, const VideoFrame& frame) const;
private:
ScopedGlobalRef<jclass> j_video_frame_class_;
jmethodID j_video_frame_constructor_id_;
};
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_NATIVE_HANDLE_IMPL_H_

6
webrtc/sdk/android/src/jni/nv12buffer_jni.cc
View File

@ -16,7 +16,8 @@
#include "webrtc/rtc_base/checks.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
extern "C" JNIEXPORT void JNICALL
Java_org_webrtc_NV12Buffer_nativeCropAndScale(JNIEnv* jni,
@ -73,4 +74,5 @@ Java_org_webrtc_NV12Buffer_nativeCropAndScale(JNIEnv* jni,
scale_height, libyuv::kFilterBox);
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

8
webrtc/sdk/android/src/jni/nv21buffer_jni.cc
View File

@ -17,7 +17,8 @@
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
#include "webrtc/rtc_base/checks.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
extern "C" JNIEXPORT void JNICALL
Java_org_webrtc_NV21Buffer_nativeCropAndScale(JNIEnv* jni,
@ -61,7 +62,7 @@ Java_org_webrtc_NV21Buffer_nativeCropAndScale(JNIEnv* jni,
src_y += crop_x + crop_y * src_stride_y;
src_uv += crop_chroma_x + crop_chroma_y * src_stride_uv;
webrtc::NV12ToI420Scaler scaler;
NV12ToI420Scaler scaler;
// U- and V-planes are swapped because this is NV21 not NV12.
scaler.NV12ToI420Scale(src_y, src_stride_y, src_uv, src_stride_uv, crop_width,
crop_height, dst_y, dst_stride_y, dst_v, dst_stride_v,
@ -70,4 +71,5 @@ Java_org_webrtc_NV21Buffer_nativeCropAndScale(JNIEnv* jni,
jni->ReleaseByteArrayElements(j_src, src_bytes, JNI_ABORT);
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

6
webrtc/sdk/android/src/jni/pc/androidnetworkmonitor_jni.cc
View File

@ -20,7 +20,8 @@
#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
enum AndroidSdkVersion {
SDK_VERSION_LOLLIPOP = 21,
@ -442,4 +443,5 @@ JNI_FUNCTION_DECLARATION(void,
static_cast<NetworkHandle>(network_handle));
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

12
webrtc/sdk/android/src/jni/pc/androidnetworkmonitor_jni.h
View File

@ -20,7 +20,8 @@
#include "webrtc/rtc_base/thread_checker.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
typedef int64_t NetworkHandle;
@ -92,6 +93,15 @@ class AndroidNetworkMonitorFactory : public rtc::NetworkMonitorFactory {
rtc::NetworkMonitorInterface* CreateNetworkMonitor() override;
};
} // namespace jni
} // namespace webrtc
// TODO(magjed): Remove once external clients are updated.
namespace webrtc_jni {
using webrtc::jni::AndroidNetworkMonitor;
using webrtc::jni::AndroidNetworkMonitorFactory;
} // namespace webrtc_jni
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_ANDROIDNETWORKMONITOR_JNI_H_

14
webrtc/sdk/android/src/jni/pc/audio_jni.cc
View File

@ -13,14 +13,16 @@
#include "webrtc/api/audio_codecs/builtin_audio_decoder_factory.h"
#include "webrtc/api/audio_codecs/builtin_audio_encoder_factory.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
rtc::scoped_refptr<webrtc::AudioDecoderFactory> CreateAudioDecoderFactory() {
return webrtc::CreateBuiltinAudioDecoderFactory();
rtc::scoped_refptr<AudioDecoderFactory> CreateAudioDecoderFactory() {
return CreateBuiltinAudioDecoderFactory();
}
rtc::scoped_refptr<webrtc::AudioEncoderFactory> CreateAudioEncoderFactory() {
return webrtc::CreateBuiltinAudioEncoderFactory();
rtc::scoped_refptr<AudioEncoderFactory> CreateAudioEncoderFactory() {
return CreateBuiltinAudioEncoderFactory();
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

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

@ -17,12 +17,14 @@
#include "webrtc/api/audio_codecs/audio_encoder_factory.h" // nogncheck
#include "webrtc/rtc_base/scoped_ref_ptr.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
rtc::scoped_refptr<webrtc::AudioDecoderFactory> CreateAudioDecoderFactory();
rtc::scoped_refptr<AudioDecoderFactory> CreateAudioDecoderFactory();
rtc::scoped_refptr<webrtc::AudioEncoderFactory> CreateAudioEncoderFactory();
rtc::scoped_refptr<AudioEncoderFactory> CreateAudioEncoderFactory();
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_AUDIO_JNI_H_

10
webrtc/sdk/android/src/jni/pc/audiotrack_jni.cc
View File

@ -11,7 +11,8 @@
#include "webrtc/api/mediastreaminterface.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
JNI_FUNCTION_DECLARATION(void,
AudioTrack_nativeSetVolume,
@ -19,9 +20,10 @@ JNI_FUNCTION_DECLARATION(void,
jclass,
jlong j_p,
jdouble volume) {
rtc::scoped_refptr<webrtc::AudioSourceInterface> source(
reinterpret_cast<webrtc::AudioTrackInterface*>(j_p)->GetSource());
rtc::scoped_refptr<AudioSourceInterface> source(
reinterpret_cast<AudioTrackInterface*>(j_p)->GetSource());
source->SetVolume(volume);
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

6
webrtc/sdk/android/src/jni/pc/callsessionfilerotatinglogsink_jni.cc
View File

@ -11,7 +11,8 @@
#include "webrtc/rtc_base/logsinks.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
JNI_FUNCTION_DECLARATION(jlong,
CallSessionFileRotatingLogSink_nativeAddSink,
@ -76,4 +77,5 @@ JNI_FUNCTION_DECLARATION(jbyteArray,
return result;
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

13
webrtc/sdk/android/src/jni/pc/datachannel_jni.cc
View File

@ -14,14 +14,14 @@
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
#include "webrtc/sdk/android/src/jni/pc/datachannelobserver_jni.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
static webrtc::DataChannelInterface* ExtractNativeDC(JNIEnv* jni,
jobject j_dc) {
static DataChannelInterface* ExtractNativeDC(JNIEnv* jni, jobject j_dc) {
jfieldID native_dc_id =
GetFieldID(jni, GetObjectClass(jni, j_dc), "nativeDataChannel", "J");
jlong j_d = GetLongField(jni, j_dc, native_dc_id);
return reinterpret_cast<webrtc::DataChannelInterface*>(j_d);
return reinterpret_cast<DataChannelInterface*>(j_d);
}
JNI_FUNCTION_DECLARATION(jlong,
@ -87,7 +87,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
jbyteArray data,
jboolean binary) {
jbyte* bytes = jni->GetByteArrayElements(data, NULL);
bool ret = ExtractNativeDC(jni, j_dc)->Send(webrtc::DataBuffer(
bool ret = ExtractNativeDC(jni, j_dc)->Send(DataBuffer(
rtc::CopyOnWriteBuffer(bytes, jni->GetArrayLength(data)), binary));
jni->ReleaseByteArrayElements(data, bytes, JNI_ABORT);
return ret;
@ -97,4 +97,5 @@ JNI_FUNCTION_DECLARATION(void, DataChannel_dispose, JNIEnv* jni, jobject j_dc) {
CHECK_RELEASE(ExtractNativeDC(jni, j_dc));
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

8
webrtc/sdk/android/src/jni/pc/datachannelobserver_jni.cc
View File

@ -12,7 +12,8 @@
#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Convenience, used since callbacks occur on the signaling thread, which may
// be a non-Java thread.
@ -52,7 +53,7 @@ void DataChannelObserverJni::OnStateChange() {
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
}
void DataChannelObserverJni::OnMessage(const webrtc::DataBuffer& buffer) {
void DataChannelObserverJni::OnMessage(const DataBuffer& buffer) {
ScopedLocalRefFrame local_ref_frame(jni());
jobject byte_buffer = jni()->NewDirectByteBuffer(
const_cast<char*>(buffer.data.data<char>()), buffer.data.size());
@ -62,4 +63,5 @@ void DataChannelObserverJni::OnMessage(const webrtc::DataBuffer& buffer) {
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

10
webrtc/sdk/android/src/jni/pc/datachannelobserver_jni.h
View File

@ -14,18 +14,19 @@
#include "webrtc/api/datachannelinterface.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Adapter for a Java DataChannel$Observer presenting a C++ DataChannelObserver
// and dispatching the callback from C++ back to Java.
class DataChannelObserverJni : public webrtc::DataChannelObserver {
class DataChannelObserverJni : public DataChannelObserver {
public:
DataChannelObserverJni(JNIEnv* jni, jobject j_observer);
virtual ~DataChannelObserverJni() {}
void OnBufferedAmountChange(uint64_t previous_amount) override;
void OnStateChange() override;
void OnMessage(const webrtc::DataBuffer& buffer) override;
void OnMessage(const DataBuffer& buffer) override;
private:
const ScopedGlobalRef<jobject> j_observer_global_;
@ -37,6 +38,7 @@ class DataChannelObserverJni : public webrtc::DataChannelObserver {
const jmethodID j_buffer_ctor_;
};
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_DATACHANNELOBSERVER_JNI_H_

18
webrtc/sdk/android/src/jni/pc/dtmfsender_jni.cc
View File

@ -11,14 +11,15 @@
#include "webrtc/api/dtmfsenderinterface.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
JNI_FUNCTION_DECLARATION(jboolean,
DtmfSender_nativeCanInsertDtmf,
JNIEnv* jni,
jclass,
jlong j_dtmf_sender_pointer) {
return reinterpret_cast<webrtc::DtmfSenderInterface*>(j_dtmf_sender_pointer)
return reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer)
->CanInsertDtmf();
}
@ -30,7 +31,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
jstring tones,
jint duration,
jint inter_tone_gap) {
return reinterpret_cast<webrtc::DtmfSenderInterface*>(j_dtmf_sender_pointer)
return reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer)
->InsertDtmf(JavaToStdString(jni, tones), duration, inter_tone_gap);
}
@ -40,8 +41,8 @@ JNI_FUNCTION_DECLARATION(jstring,
jclass,
jlong j_dtmf_sender_pointer) {
return JavaStringFromStdString(
jni, reinterpret_cast<webrtc::DtmfSenderInterface*>(j_dtmf_sender_pointer)
->tones());
jni,
reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer)->tones());
}
JNI_FUNCTION_DECLARATION(jint,
@ -49,7 +50,7 @@ JNI_FUNCTION_DECLARATION(jint,
JNIEnv* jni,
jclass,
jlong j_dtmf_sender_pointer) {
return reinterpret_cast<webrtc::DtmfSenderInterface*>(j_dtmf_sender_pointer)
return reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer)
->duration();
}
@ -58,8 +59,9 @@ JNI_FUNCTION_DECLARATION(jint,
JNIEnv* jni,
jclass,
jlong j_dtmf_sender_pointer) {
return reinterpret_cast<webrtc::DtmfSenderInterface*>(j_dtmf_sender_pointer)
return reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer)
->inter_tone_gap();
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

121
webrtc/sdk/android/src/jni/pc/java_native_conversion.cc
View File

@ -15,11 +15,11 @@
#include "webrtc/pc/webrtcsdp.h"
#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
webrtc::DataChannelInit JavaToNativeDataChannelInit(JNIEnv* jni,
jobject j_init) {
webrtc::DataChannelInit init;
DataChannelInit JavaToNativeDataChannelInit(JNIEnv* jni, jobject j_init) {
DataChannelInit init;
jclass j_init_class = FindClass(jni, "org/webrtc/DataChannel$Init");
jfieldID ordered_id = GetFieldID(jni, j_init_class, "ordered", "Z");
@ -93,7 +93,7 @@ cricket::Candidate JavaToNativeCandidate(JNIEnv* jni, jobject j_candidate) {
std::string sdp =
JavaToStdString(jni, GetStringField(jni, j_candidate, j_sdp_id));
cricket::Candidate candidate;
if (!webrtc::SdpDeserializeCandidate(sdp_mid, sdp, &candidate, NULL)) {
if (!SdpDeserializeCandidate(sdp_mid, sdp, &candidate, NULL)) {
LOG(LS_ERROR) << "SdpDescrializeCandidate failed with sdp " << sdp;
}
return candidate;
@ -102,7 +102,7 @@ cricket::Candidate JavaToNativeCandidate(JNIEnv* jni, jobject j_candidate) {
jobject NativeToJavaCandidate(JNIEnv* jni,
jclass* candidate_class,
const cricket::Candidate& candidate) {
std::string sdp = webrtc::SdpSerializeCandidate(candidate);
std::string sdp = SdpSerializeCandidate(candidate);
RTC_CHECK(!sdp.empty()) << "got an empty ICE candidate";
jmethodID ctor = GetMethodID(jni, *candidate_class, "<init>",
"(Ljava/lang/String;ILjava/lang/String;)V");
@ -130,9 +130,8 @@ jobjectArray NativeToJavaCandidateArray(
return java_candidates;
}
webrtc::SessionDescriptionInterface* JavaToNativeSessionDescription(
JNIEnv* jni,
jobject j_sdp) {
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);
@ -149,12 +148,12 @@ webrtc::SessionDescriptionInterface* JavaToNativeSessionDescription(
jstring j_description = (jstring)GetObjectField(jni, j_sdp, j_description_id);
std::string std_description = JavaToStdString(jni, j_description);
return webrtc::CreateSessionDescription(std_type, std_description, NULL);
return CreateSessionDescription(std_type, std_description, NULL);
}
jobject NativeToJavaSessionDescription(
JNIEnv* jni,
const webrtc::SessionDescriptionInterface* desc) {
const SessionDescriptionInterface* desc) {
std::string sdp;
RTC_CHECK(desc->ToString(&sdp)) << "got so far: " << sdp;
jstring j_description = JavaStringFromStdString(jni, sdp);
@ -178,7 +177,7 @@ jobject NativeToJavaSessionDescription(
return j_sdp;
}
webrtc::PeerConnectionFactoryInterface::Options
PeerConnectionFactoryInterface::Options
JavaToNativePeerConnectionFactoryOptions(JNIEnv* jni, jobject options) {
jclass options_class = jni->GetObjectClass(options);
jfieldID network_ignore_mask_field =
@ -196,7 +195,7 @@ JavaToNativePeerConnectionFactoryOptions(JNIEnv* jni, jobject options) {
bool disable_network_monitor =
jni->GetBooleanField(options, disable_network_monitor_field);
webrtc::PeerConnectionFactoryInterface::Options native_options;
PeerConnectionFactoryInterface::Options native_options;
// This doesn't necessarily match the c++ version of this struct; feel free
// to add more parameters as necessary.
@ -206,80 +205,82 @@ JavaToNativePeerConnectionFactoryOptions(JNIEnv* jni, jobject options) {
return native_options;
}
webrtc::PeerConnectionInterface::IceTransportsType
JavaToNativeIceTransportsType(JNIEnv* jni, jobject j_ice_transports_type) {
PeerConnectionInterface::IceTransportsType JavaToNativeIceTransportsType(
JNIEnv* jni,
jobject j_ice_transports_type) {
std::string enum_name =
GetJavaEnumName(jni, "org/webrtc/PeerConnection$IceTransportsType",
j_ice_transports_type);
if (enum_name == "ALL")
return webrtc::PeerConnectionInterface::kAll;
return PeerConnectionInterface::kAll;
if (enum_name == "RELAY")
return webrtc::PeerConnectionInterface::kRelay;
return PeerConnectionInterface::kRelay;
if (enum_name == "NOHOST")
return webrtc::PeerConnectionInterface::kNoHost;
return PeerConnectionInterface::kNoHost;
if (enum_name == "NONE")
return webrtc::PeerConnectionInterface::kNone;
return PeerConnectionInterface::kNone;
RTC_CHECK(false) << "Unexpected IceTransportsType enum_name " << enum_name;
return webrtc::PeerConnectionInterface::kAll;
return PeerConnectionInterface::kAll;
}
webrtc::PeerConnectionInterface::BundlePolicy JavaToNativeBundlePolicy(
PeerConnectionInterface::BundlePolicy JavaToNativeBundlePolicy(
JNIEnv* jni,
jobject j_bundle_policy) {
std::string enum_name = GetJavaEnumName(
jni, "org/webrtc/PeerConnection$BundlePolicy", j_bundle_policy);
if (enum_name == "BALANCED")
return webrtc::PeerConnectionInterface::kBundlePolicyBalanced;
return PeerConnectionInterface::kBundlePolicyBalanced;
if (enum_name == "MAXBUNDLE")
return webrtc::PeerConnectionInterface::kBundlePolicyMaxBundle;
return PeerConnectionInterface::kBundlePolicyMaxBundle;
if (enum_name == "MAXCOMPAT")
return webrtc::PeerConnectionInterface::kBundlePolicyMaxCompat;
return PeerConnectionInterface::kBundlePolicyMaxCompat;
RTC_CHECK(false) << "Unexpected BundlePolicy enum_name " << enum_name;
return webrtc::PeerConnectionInterface::kBundlePolicyBalanced;
return PeerConnectionInterface::kBundlePolicyBalanced;
}
webrtc::PeerConnectionInterface::RtcpMuxPolicy JavaToNativeRtcpMuxPolicy(
PeerConnectionInterface::RtcpMuxPolicy JavaToNativeRtcpMuxPolicy(
JNIEnv* jni,
jobject j_rtcp_mux_policy) {
std::string enum_name = GetJavaEnumName(
jni, "org/webrtc/PeerConnection$RtcpMuxPolicy", j_rtcp_mux_policy);
if (enum_name == "NEGOTIATE")
return webrtc::PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
return PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
if (enum_name == "REQUIRE")
return webrtc::PeerConnectionInterface::kRtcpMuxPolicyRequire;
return PeerConnectionInterface::kRtcpMuxPolicyRequire;
RTC_CHECK(false) << "Unexpected RtcpMuxPolicy enum_name " << enum_name;
return webrtc::PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
return PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
}
webrtc::PeerConnectionInterface::TcpCandidatePolicy
JavaToNativeTcpCandidatePolicy(JNIEnv* jni, jobject j_tcp_candidate_policy) {
PeerConnectionInterface::TcpCandidatePolicy JavaToNativeTcpCandidatePolicy(
JNIEnv* jni,
jobject j_tcp_candidate_policy) {
std::string enum_name =
GetJavaEnumName(jni, "org/webrtc/PeerConnection$TcpCandidatePolicy",
j_tcp_candidate_policy);
if (enum_name == "ENABLED")
return webrtc::PeerConnectionInterface::kTcpCandidatePolicyEnabled;
return PeerConnectionInterface::kTcpCandidatePolicyEnabled;
if (enum_name == "DISABLED")
return webrtc::PeerConnectionInterface::kTcpCandidatePolicyDisabled;
return PeerConnectionInterface::kTcpCandidatePolicyDisabled;
RTC_CHECK(false) << "Unexpected TcpCandidatePolicy enum_name " << enum_name;
return webrtc::PeerConnectionInterface::kTcpCandidatePolicyEnabled;
return PeerConnectionInterface::kTcpCandidatePolicyEnabled;
}
webrtc::PeerConnectionInterface::CandidateNetworkPolicy
PeerConnectionInterface::CandidateNetworkPolicy
JavaToNativeCandidateNetworkPolicy(JNIEnv* jni,
jobject j_candidate_network_policy) {
std::string enum_name =
@ -287,14 +288,14 @@ JavaToNativeCandidateNetworkPolicy(JNIEnv* jni,
j_candidate_network_policy);
if (enum_name == "ALL")
return webrtc::PeerConnectionInterface::kCandidateNetworkPolicyAll;
return PeerConnectionInterface::kCandidateNetworkPolicyAll;
if (enum_name == "LOW_COST")
return webrtc::PeerConnectionInterface::kCandidateNetworkPolicyLowCost;
return PeerConnectionInterface::kCandidateNetworkPolicyLowCost;
RTC_CHECK(false) << "Unexpected CandidateNetworkPolicy enum_name "
<< enum_name;
return webrtc::PeerConnectionInterface::kCandidateNetworkPolicyAll;
return PeerConnectionInterface::kCandidateNetworkPolicyAll;
}
rtc::KeyType JavaToNativeKeyType(JNIEnv* jni, jobject j_key_type) {
@ -310,23 +311,23 @@ rtc::KeyType JavaToNativeKeyType(JNIEnv* jni, jobject j_key_type) {
return rtc::KT_ECDSA;
}
webrtc::PeerConnectionInterface::ContinualGatheringPolicy
PeerConnectionInterface::ContinualGatheringPolicy
JavaToNativeContinualGatheringPolicy(JNIEnv* jni, jobject j_gathering_policy) {
std::string enum_name =
GetJavaEnumName(jni, "org/webrtc/PeerConnection$ContinualGatheringPolicy",
j_gathering_policy);
if (enum_name == "GATHER_ONCE")
return webrtc::PeerConnectionInterface::GATHER_ONCE;
return PeerConnectionInterface::GATHER_ONCE;
if (enum_name == "GATHER_CONTINUALLY")
return webrtc::PeerConnectionInterface::GATHER_CONTINUALLY;
return PeerConnectionInterface::GATHER_CONTINUALLY;
RTC_CHECK(false) << "Unexpected ContinualGatheringPolicy enum name "
<< enum_name;
return webrtc::PeerConnectionInterface::GATHER_ONCE;
return PeerConnectionInterface::GATHER_ONCE;
}
webrtc::PeerConnectionInterface::TlsCertPolicy JavaToNativeTlsCertPolicy(
PeerConnectionInterface::TlsCertPolicy JavaToNativeTlsCertPolicy(
JNIEnv* jni,
jobject j_ice_server_tls_cert_policy) {
std::string enum_name =
@ -334,19 +335,18 @@ webrtc::PeerConnectionInterface::TlsCertPolicy JavaToNativeTlsCertPolicy(
j_ice_server_tls_cert_policy);
if (enum_name == "TLS_CERT_POLICY_SECURE")
return webrtc::PeerConnectionInterface::kTlsCertPolicySecure;
return PeerConnectionInterface::kTlsCertPolicySecure;
if (enum_name == "TLS_CERT_POLICY_INSECURE_NO_CHECK")
return webrtc::PeerConnectionInterface::kTlsCertPolicyInsecureNoCheck;
return PeerConnectionInterface::kTlsCertPolicyInsecureNoCheck;
RTC_CHECK(false) << "Unexpected TlsCertPolicy enum_name " << enum_name;
return webrtc::PeerConnectionInterface::kTlsCertPolicySecure;
return PeerConnectionInterface::kTlsCertPolicySecure;
}
void JavaToNativeIceServers(
JNIEnv* jni,
jobject j_ice_servers,
webrtc::PeerConnectionInterface::IceServers* ice_servers) {
void 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_uri_id =
@ -368,11 +368,11 @@ void JavaToNativeIceServers(
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));
webrtc::PeerConnectionInterface::TlsCertPolicy tls_cert_policy =
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));
webrtc::PeerConnectionInterface::IceServer server;
PeerConnectionInterface::IceServer server;
server.uri = JavaToStdString(jni, uri);
server.username = JavaToStdString(jni, username);
server.password = JavaToStdString(jni, password);
@ -385,7 +385,7 @@ void JavaToNativeIceServers(
void JavaToNativeRTCConfiguration(
JNIEnv* jni,
jobject j_rtc_config,
webrtc::PeerConnectionInterface::RTCConfiguration* rtc_config) {
PeerConnectionInterface::RTCConfiguration* rtc_config) {
jclass j_rtc_config_class = GetObjectClass(jni, j_rtc_config);
jfieldID j_ice_transports_type_id =
@ -516,7 +516,7 @@ void JavaToNativeRTCConfiguration(
void JavaToNativeRtpParameters(JNIEnv* jni,
jobject j_parameters,
webrtc::RtpParameters* parameters) {
RtpParameters* parameters) {
RTC_CHECK(parameters != nullptr);
jclass parameters_class = jni->FindClass("org/webrtc/RtpParameters");
jfieldID encodings_id =
@ -540,7 +540,7 @@ void JavaToNativeRtpParameters(JNIEnv* jni,
jmethodID long_value_id = GetMethodID(jni, j_long_class, "longValue", "()J");
for (jobject j_encoding_parameters : Iterable(jni, j_encodings)) {
webrtc::RtpEncodingParameters encoding;
RtpEncodingParameters encoding;
encoding.active = GetBooleanField(jni, j_encoding_parameters, active_id);
jobject j_bitrate =
GetNullableObjectField(jni, j_encoding_parameters, bitrate_id);
@ -572,7 +572,7 @@ void JavaToNativeRtpParameters(JNIEnv* jni,
GetFieldID(jni, codec_class, "numChannels", "Ljava/lang/Integer;");
for (jobject j_codec : Iterable(jni, j_codecs)) {
webrtc::RtpCodecParameters codec;
RtpCodecParameters codec;
codec.payload_type = GetIntField(jni, j_codec, payload_type_id);
codec.name = JavaToStdString(jni, GetStringField(jni, j_codec, name_id));
codec.kind =
@ -595,7 +595,7 @@ void JavaToNativeRtpParameters(JNIEnv* jni,
}
jobject NativeToJavaRtpParameters(JNIEnv* jni,
const webrtc::RtpParameters& parameters) {
const RtpParameters& parameters) {
jclass parameters_class = jni->FindClass("org/webrtc/RtpParameters");
jmethodID parameters_ctor =
GetMethodID(jni, parameters_class, "<init>", "()V");
@ -621,7 +621,7 @@ jobject NativeToJavaRtpParameters(JNIEnv* jni,
jmethodID integer_ctor = GetMethodID(jni, integer_class, "<init>", "(I)V");
jmethodID long_ctor = GetMethodID(jni, long_class, "<init>", "(J)V");
for (const webrtc::RtpEncodingParameters& encoding : parameters.encodings) {
for (const RtpEncodingParameters& encoding : parameters.encodings) {
jobject j_encoding_parameters =
jni->NewObject(encoding_class, encoding_ctor);
CHECK_EXCEPTION(jni) << "error during NewObject";
@ -664,7 +664,7 @@ jobject NativeToJavaRtpParameters(JNIEnv* jni,
jfieldID num_channels_id =
GetFieldID(jni, codec_class, "numChannels", "Ljava/lang/Integer;");
for (const webrtc::RtpCodecParameters& codec : parameters.codecs) {
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);
@ -697,4 +697,5 @@ jobject NativeToJavaRtpParameters(JNIEnv* jni,
return j_parameters;
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

55
webrtc/sdk/android/src/jni/pc/java_native_conversion.h
View File

@ -27,10 +27,10 @@
// PeerConnection-related structures. Similar to some methods in jni_helpers.h,
// but specifically for structures tied to the PeerConnection API.
namespace webrtc_jni {
namespace webrtc {
namespace jni {
webrtc::DataChannelInit JavaToNativeDataChannelInit(JNIEnv* jni,
jobject j_init);
DataChannelInit JavaToNativeDataChannelInit(JNIEnv* jni, jobject j_init);
cricket::MediaType JavaToNativeMediaType(JNIEnv* jni, jobject j_media_type);
@ -46,67 +46,66 @@ jobjectArray NativeToJavaCandidateArray(
JNIEnv* jni,
const std::vector<cricket::Candidate>& candidates);
webrtc::SessionDescriptionInterface* JavaToNativeSessionDescription(
JNIEnv* jni,
jobject j_sdp);
SessionDescriptionInterface* JavaToNativeSessionDescription(JNIEnv* jni,
jobject j_sdp);
jobject NativeToJavaSessionDescription(
JNIEnv* jni,
const webrtc::SessionDescriptionInterface* desc);
jobject NativeToJavaSessionDescription(JNIEnv* jni,
const SessionDescriptionInterface* desc);
webrtc::PeerConnectionFactoryInterface::Options
PeerConnectionFactoryInterface::Options
JavaToNativePeerConnectionFactoryOptions(JNIEnv* jni, jobject options);
/*****************************************************
* Below are all things that go into RTCConfiguration.
*****************************************************/
webrtc::PeerConnectionInterface::IceTransportsType
JavaToNativeIceTransportsType(JNIEnv* jni, jobject j_ice_transports_type);
PeerConnectionInterface::IceTransportsType JavaToNativeIceTransportsType(
JNIEnv* jni,
jobject j_ice_transports_type);
webrtc::PeerConnectionInterface::BundlePolicy JavaToNativeBundlePolicy(
PeerConnectionInterface::BundlePolicy JavaToNativeBundlePolicy(
JNIEnv* jni,
jobject j_bundle_policy);
webrtc::PeerConnectionInterface::RtcpMuxPolicy JavaToNativeRtcpMuxPolicy(
PeerConnectionInterface::RtcpMuxPolicy JavaToNativeRtcpMuxPolicy(
JNIEnv* jni,
jobject j_rtcp_mux_policy);
webrtc::PeerConnectionInterface::TcpCandidatePolicy
JavaToNativeTcpCandidatePolicy(JNIEnv* jni, jobject j_tcp_candidate_policy);
PeerConnectionInterface::TcpCandidatePolicy JavaToNativeTcpCandidatePolicy(
JNIEnv* jni,
jobject j_tcp_candidate_policy);
webrtc::PeerConnectionInterface::CandidateNetworkPolicy
PeerConnectionInterface::CandidateNetworkPolicy
JavaToNativeCandidateNetworkPolicy(JNIEnv* jni,
jobject j_candidate_network_policy);
rtc::KeyType JavaToNativeKeyType(JNIEnv* jni, jobject j_key_type);
webrtc::PeerConnectionInterface::ContinualGatheringPolicy
PeerConnectionInterface::ContinualGatheringPolicy
JavaToNativeContinualGatheringPolicy(JNIEnv* jni, jobject j_gathering_policy);
webrtc::PeerConnectionInterface::TlsCertPolicy JavaToNativeTlsCertPolicy(
PeerConnectionInterface::TlsCertPolicy JavaToNativeTlsCertPolicy(
JNIEnv* jni,
jobject j_ice_server_tls_cert_policy);
void JavaToNativeIceServers(
JNIEnv* jni,
jobject j_ice_servers,
webrtc::PeerConnectionInterface::IceServers* ice_servers);
void JavaToNativeIceServers(JNIEnv* jni,
jobject j_ice_servers,
PeerConnectionInterface::IceServers* ice_servers);
void JavaToNativeRTCConfiguration(
JNIEnv* jni,
jobject j_rtc_config,
webrtc::PeerConnectionInterface::RTCConfiguration* rtc_config);
PeerConnectionInterface::RTCConfiguration* rtc_config);
/*********************************************************
* RtpParameters, used for RtpSender and RtpReceiver APIs.
*********************************************************/
void JavaToNativeRtpParameters(JNIEnv* jni,
jobject j_parameters,
webrtc::RtpParameters* parameters);
RtpParameters* parameters);
jobject NativeToJavaRtpParameters(JNIEnv* jni,
const webrtc::RtpParameters& parameters);
jobject NativeToJavaRtpParameters(JNIEnv* jni, const RtpParameters& parameters);
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_JAVA_NATIVE_CONVERSION_H_

15
webrtc/sdk/android/src/jni/pc/logging_jni.cc
View File

@ -15,7 +15,8 @@
#include "webrtc/system_wrappers/include/logcat_trace_context.h"
#include "webrtc/system_wrappers/include/trace.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
JNI_FUNCTION_DECLARATION(void,
Logging_nativeEnableTracing,
@ -24,16 +25,15 @@ JNI_FUNCTION_DECLARATION(void,
jstring j_path,
jint nativeLevels) {
std::string path = JavaToStdString(jni, j_path);
if (nativeLevels != webrtc::kTraceNone) {
webrtc::Trace::set_level_filter(nativeLevels);
if (nativeLevels != kTraceNone) {
Trace::set_level_filter(nativeLevels);
if (path != "logcat:") {
RTC_CHECK_EQ(0, webrtc::Trace::SetTraceFile(path.c_str(), false))
RTC_CHECK_EQ(0, Trace::SetTraceFile(path.c_str(), false))
<< "SetTraceFile failed";
} else {
// Intentionally leak this to avoid needing to reason about its lifecycle.
// It keeps no state and functions only as a dispatch point.
static webrtc::LogcatTraceContext* g_trace_callback =
new webrtc::LogcatTraceContext();
static LogcatTraceContext* g_trace_callback = new LogcatTraceContext();
}
}
}
@ -75,4 +75,5 @@ JNI_FUNCTION_DECLARATION(void,
LOG_TAG(static_cast<rtc::LoggingSeverity>(j_severity), tag) << message;
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

22
webrtc/sdk/android/src/jni/pc/media_jni.cc
View File

@ -14,28 +14,28 @@
#include "webrtc/media/engine/webrtcmediaengine.h"
#include "webrtc/modules/audio_processing/include/audio_processing.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
webrtc::CallFactoryInterface* CreateCallFactory() {
CallFactoryInterface* CreateCallFactory() {
return webrtc::CreateCallFactory().release();
}
webrtc::RtcEventLogFactoryInterface* CreateRtcEventLogFactory() {
RtcEventLogFactoryInterface* CreateRtcEventLogFactory() {
return webrtc::CreateRtcEventLogFactory().release();
}
cricket::MediaEngineInterface* CreateMediaEngine(
webrtc::AudioDeviceModule* adm,
const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
audio_encoder_factory,
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
audio_decoder_factory,
AudioDeviceModule* adm,
const rtc::scoped_refptr<AudioEncoderFactory>& audio_encoder_factory,
const rtc::scoped_refptr<AudioDecoderFactory>& audio_decoder_factory,
cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer) {
rtc::scoped_refptr<AudioMixer> audio_mixer) {
return cricket::WebRtcMediaEngineFactory::Create(
adm, audio_encoder_factory, audio_decoder_factory, video_encoder_factory,
video_decoder_factory, audio_mixer, webrtc::AudioProcessing::Create());
video_decoder_factory, audio_mixer, AudioProcessing::Create());
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

20
webrtc/sdk/android/src/jni/pc/media_jni.h
View File

@ -28,21 +28,21 @@ class WebRtcVideoEncoderFactory;
class WebRtcVideoDecoderFactory;
} // namespace cricket
namespace webrtc_jni {
namespace webrtc {
namespace jni {
webrtc::CallFactoryInterface* CreateCallFactory();
webrtc::RtcEventLogFactoryInterface* CreateRtcEventLogFactory();
CallFactoryInterface* CreateCallFactory();
RtcEventLogFactoryInterface* CreateRtcEventLogFactory();
cricket::MediaEngineInterface* CreateMediaEngine(
webrtc::AudioDeviceModule* adm,
const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
audio_encoder_factory,
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
audio_decoder_factory,
AudioDeviceModule* adm,
const rtc::scoped_refptr<AudioEncoderFactory>& audio_encoder_factory,
const rtc::scoped_refptr<AudioDecoderFactory>& audio_decoder_factory,
cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer);
rtc::scoped_refptr<AudioMixer> audio_mixer);
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_MEDIA_JNI_H_

6
webrtc/sdk/android/src/jni/pc/mediaconstraints_jni.cc
View File

@ -10,7 +10,8 @@
#include "webrtc/sdk/android/src/jni/pc/mediaconstraints_jni.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
MediaConstraintsJni::MediaConstraintsJni(JNIEnv* jni, jobject j_constraints) {
PopulateConstraintsFromJavaPairList(jni, j_constraints, "mandatory",
@ -44,4 +45,5 @@ void MediaConstraintsJni::PopulateConstraintsFromJavaPairList(
}
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

8
webrtc/sdk/android/src/jni/pc/mediaconstraints_jni.h
View File

@ -14,11 +14,12 @@
#include "webrtc/api/mediaconstraintsinterface.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Wrapper for a Java MediaConstraints object. Copies all needed data so when
// the constructor returns the Java object is no longer needed.
class MediaConstraintsJni : public webrtc::MediaConstraintsInterface {
class MediaConstraintsJni : public MediaConstraintsInterface {
public:
MediaConstraintsJni(JNIEnv* jni, jobject j_constraints);
virtual ~MediaConstraintsJni() {}
@ -38,6 +39,7 @@ class MediaConstraintsJni : public webrtc::MediaConstraintsInterface {
Constraints optional_;
};
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_MEDIACONSTRAINTS_JNI_H_

10
webrtc/sdk/android/src/jni/pc/mediasource_jni.cc
View File

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

26
webrtc/sdk/android/src/jni/pc/mediastream_jni.cc
View File

@ -11,7 +11,8 @@
#include "webrtc/api/mediastreaminterface.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
JNI_FUNCTION_DECLARATION(jboolean,
MediaStream_nativeAddAudioTrack,
@ -19,8 +20,8 @@ JNI_FUNCTION_DECLARATION(jboolean,
jclass,
jlong pointer,
jlong j_audio_track_pointer) {
return reinterpret_cast<webrtc::MediaStreamInterface*>(pointer)->AddTrack(
reinterpret_cast<webrtc::AudioTrackInterface*>(j_audio_track_pointer));
return reinterpret_cast<MediaStreamInterface*>(pointer)->AddTrack(
reinterpret_cast<AudioTrackInterface*>(j_audio_track_pointer));
}
JNI_FUNCTION_DECLARATION(jboolean,
@ -29,8 +30,8 @@ JNI_FUNCTION_DECLARATION(jboolean,
jclass,
jlong pointer,
jlong j_video_track_pointer) {
return reinterpret_cast<webrtc::MediaStreamInterface*>(pointer)->AddTrack(
reinterpret_cast<webrtc::VideoTrackInterface*>(j_video_track_pointer));
return reinterpret_cast<MediaStreamInterface*>(pointer)->AddTrack(
reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer));
}
JNI_FUNCTION_DECLARATION(jboolean,
@ -39,8 +40,8 @@ JNI_FUNCTION_DECLARATION(jboolean,
jclass,
jlong pointer,
jlong j_audio_track_pointer) {
return reinterpret_cast<webrtc::MediaStreamInterface*>(pointer)->RemoveTrack(
reinterpret_cast<webrtc::AudioTrackInterface*>(j_audio_track_pointer));
return reinterpret_cast<MediaStreamInterface*>(pointer)->RemoveTrack(
reinterpret_cast<AudioTrackInterface*>(j_audio_track_pointer));
}
JNI_FUNCTION_DECLARATION(jboolean,
@ -49,8 +50,8 @@ JNI_FUNCTION_DECLARATION(jboolean,
jclass,
jlong pointer,
jlong j_video_track_pointer) {
return reinterpret_cast<webrtc::MediaStreamInterface*>(pointer)->RemoveTrack(
reinterpret_cast<webrtc::VideoTrackInterface*>(j_video_track_pointer));
return reinterpret_cast<MediaStreamInterface*>(pointer)->RemoveTrack(
reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer));
}
JNI_FUNCTION_DECLARATION(jstring,
@ -59,11 +60,12 @@ JNI_FUNCTION_DECLARATION(jstring,
jclass,
jlong j_p) {
return JavaStringFromStdString(
jni, reinterpret_cast<webrtc::MediaStreamInterface*>(j_p)->label());
jni, reinterpret_cast<MediaStreamInterface*>(j_p)->label());
}
JNI_FUNCTION_DECLARATION(void, MediaStream_free, JNIEnv*, jclass, jlong j_p) {
CHECK_RELEASE(reinterpret_cast<webrtc::MediaStreamInterface*>(j_p));
CHECK_RELEASE(reinterpret_cast<MediaStreamInterface*>(j_p));
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

16
webrtc/sdk/android/src/jni/pc/mediastreamtrack_jni.cc
View File

@ -11,7 +11,8 @@
#include "webrtc/api/mediastreaminterface.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
JNI_FUNCTION_DECLARATION(jstring,
MediaStreamTrack_nativeId,
@ -19,7 +20,7 @@ JNI_FUNCTION_DECLARATION(jstring,
jclass,
jlong j_p) {
return JavaStringFromStdString(
jni, reinterpret_cast<webrtc::MediaStreamTrackInterface*>(j_p)->id());
jni, reinterpret_cast<MediaStreamTrackInterface*>(j_p)->id());
}
JNI_FUNCTION_DECLARATION(jstring,
@ -28,7 +29,7 @@ JNI_FUNCTION_DECLARATION(jstring,
jclass,
jlong j_p) {
return JavaStringFromStdString(
jni, reinterpret_cast<webrtc::MediaStreamTrackInterface*>(j_p)->kind());
jni, reinterpret_cast<MediaStreamTrackInterface*>(j_p)->kind());
}
JNI_FUNCTION_DECLARATION(jboolean,
@ -36,7 +37,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
JNIEnv* jni,
jclass,
jlong j_p) {
return reinterpret_cast<webrtc::MediaStreamTrackInterface*>(j_p)->enabled();
return reinterpret_cast<MediaStreamTrackInterface*>(j_p)->enabled();
}
JNI_FUNCTION_DECLARATION(jobject,
@ -46,7 +47,7 @@ JNI_FUNCTION_DECLARATION(jobject,
jlong j_p) {
return JavaEnumFromIndexAndClassName(
jni, "MediaStreamTrack$State",
reinterpret_cast<webrtc::MediaStreamTrackInterface*>(j_p)->state());
reinterpret_cast<MediaStreamTrackInterface*>(j_p)->state());
}
JNI_FUNCTION_DECLARATION(jboolean,
@ -55,8 +56,9 @@ JNI_FUNCTION_DECLARATION(jboolean,
jclass,
jlong j_p,
jboolean enabled) {
return reinterpret_cast<webrtc::MediaStreamTrackInterface*>(j_p)->set_enabled(
return reinterpret_cast<MediaStreamTrackInterface*>(j_p)->set_enabled(
enabled);
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

10
webrtc/sdk/android/src/jni/pc/null_audio_jni.cc
View File

@ -10,14 +10,16 @@
#include "webrtc/sdk/android/src/jni/pc/audio_jni.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
rtc::scoped_refptr<webrtc::AudioDecoderFactory> CreateAudioDecoderFactory() {
rtc::scoped_refptr<AudioDecoderFactory> CreateAudioDecoderFactory() {
return nullptr;
}
rtc::scoped_refptr<webrtc::AudioEncoderFactory> CreateAudioEncoderFactory() {
rtc::scoped_refptr<AudioEncoderFactory> CreateAudioEncoderFactory() {
return nullptr;
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

20
webrtc/sdk/android/src/jni/pc/null_media_jni.cc
View File

@ -10,26 +10,26 @@
#include "webrtc/sdk/android/src/jni/pc/media_jni.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
webrtc::CallFactoryInterface* CreateCallFactory() {
CallFactoryInterface* CreateCallFactory() {
return nullptr;
}
webrtc::RtcEventLogFactoryInterface* CreateRtcEventLogFactory() {
RtcEventLogFactoryInterface* CreateRtcEventLogFactory() {
return nullptr;
}
cricket::MediaEngineInterface* CreateMediaEngine(
webrtc::AudioDeviceModule* adm,
const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
audio_encoder_factory,
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
audio_decoder_factory,
AudioDeviceModule* adm,
const rtc::scoped_refptr<AudioEncoderFactory>& audio_encoder_factory,
const rtc::scoped_refptr<AudioDecoderFactory>& audio_decoder_factory,
cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer) {
rtc::scoped_refptr<AudioMixer> audio_mixer) {
return nullptr;
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

6
webrtc/sdk/android/src/jni/pc/null_video_jni.cc
View File

@ -10,7 +10,8 @@
#include "webrtc/sdk/android/src/jni/pc/video_jni.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
cricket::WebRtcVideoEncoderFactory* CreateVideoEncoderFactory(
JNIEnv* jni,
@ -29,4 +30,5 @@ jobject GetJavaSurfaceTextureHelper(
return nullptr;
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

6
webrtc/sdk/android/src/jni/pc/ownedfactoryandthreads.cc
View File

@ -14,7 +14,8 @@
#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
PeerConnectionFactoryInterface* factoryFromJava(jlong j_p) {
return reinterpret_cast<OwnedFactoryAndThreads*>(j_p)->factory();
@ -61,4 +62,5 @@ void OwnedFactoryAndThreads::InvokeJavaCallbacksOnFactoryThreads() {
[this] { JavaCallbackOnFactoryThreads(); });
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

7
webrtc/sdk/android/src/jni/pc/ownedfactoryandthreads.h
View File

@ -21,9 +21,9 @@
using cricket::WebRtcVideoDecoderFactory;
using cricket::WebRtcVideoEncoderFactory;
using rtc::Thread;
using webrtc::PeerConnectionFactoryInterface;
namespace webrtc_jni {
namespace webrtc {
namespace jni {
PeerConnectionFactoryInterface* factoryFromJava(jlong j_p);
@ -75,6 +75,7 @@ class OwnedFactoryAndThreads {
PeerConnectionFactoryInterface* factory_; // Const after ctor except dtor.
};
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_OWNEDFACTORYANDTHREADS_H_

47
webrtc/sdk/android/src/jni/pc/peerconnection_jni.cc
View File

@ -45,16 +45,17 @@
#include "webrtc/sdk/android/src/jni/pc/statsobserver_jni.h"
#include "webrtc/system_wrappers/include/trace.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
static rtc::scoped_refptr<webrtc::PeerConnectionInterface> ExtractNativePC(
static 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<webrtc::PeerConnectionInterface>(
reinterpret_cast<webrtc::PeerConnectionInterface*>(j_p));
return rtc::scoped_refptr<PeerConnectionInterface>(
reinterpret_cast<PeerConnectionInterface*>(j_p));
}
JNI_FUNCTION_DECLARATION(void,
@ -71,7 +72,7 @@ JNI_FUNCTION_DECLARATION(jobject,
PeerConnection_getLocalDescription,
JNIEnv* jni,
jobject j_pc) {
const webrtc::SessionDescriptionInterface* sdp =
const SessionDescriptionInterface* sdp =
ExtractNativePC(jni, j_pc)->local_description();
return sdp ? NativeToJavaSessionDescription(jni, sdp) : NULL;
}
@ -80,7 +81,7 @@ JNI_FUNCTION_DECLARATION(jobject,
PeerConnection_getRemoteDescription,
JNIEnv* jni,
jobject j_pc) {
const webrtc::SessionDescriptionInterface* sdp =
const SessionDescriptionInterface* sdp =
ExtractNativePC(jni, j_pc)->remote_description();
return sdp ? NativeToJavaSessionDescription(jni, sdp) : NULL;
}
@ -91,8 +92,8 @@ JNI_FUNCTION_DECLARATION(jobject,
jobject j_pc,
jstring j_label,
jobject j_init) {
webrtc::DataChannelInit init = JavaToNativeDataChannelInit(jni, j_init);
rtc::scoped_refptr<webrtc::DataChannelInterface> channel(
DataChannelInit init = JavaToNativeDataChannelInit(jni, j_init);
rtc::scoped_refptr<DataChannelInterface> channel(
ExtractNativePC(jni, j_pc)->CreateDataChannel(
JavaToStdString(jni, j_label), &init));
// Mustn't pass channel.get() directly through NewObject to avoid reading its
@ -177,8 +178,8 @@ JNI_FUNCTION_DECLARATION(jboolean,
// in the observer object.
PeerConnectionObserverJni* observer =
reinterpret_cast<PeerConnectionObserverJni*>(native_observer);
webrtc::PeerConnectionInterface::RTCConfiguration rtc_config(
webrtc::PeerConnectionInterface::RTCConfigurationType::kAggressive);
PeerConnectionInterface::RTCConfiguration rtc_config(
PeerConnectionInterface::RTCConfigurationType::kAggressive);
JavaToNativeRTCConfiguration(jni, j_rtc_config, &rtc_config);
CopyConstraintsIntoRtcConfiguration(observer->constraints(), &rtc_config);
return ExtractNativePC(jni, j_pc)->SetConfiguration(rtc_config);
@ -193,8 +194,8 @@ JNI_FUNCTION_DECLARATION(jboolean,
jstring j_candidate_sdp) {
std::string sdp_mid = JavaToStdString(jni, j_sdp_mid);
std::string sdp = JavaToStdString(jni, j_candidate_sdp);
std::unique_ptr<webrtc::IceCandidateInterface> candidate(
webrtc::CreateIceCandidate(sdp_mid, j_sdp_mline_index, sdp, nullptr));
std::unique_ptr<IceCandidateInterface> candidate(
CreateIceCandidate(sdp_mid, j_sdp_mline_index, sdp, nullptr));
return ExtractNativePC(jni, j_pc)->AddIceCandidate(candidate.get());
}
@ -218,7 +219,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
jobject j_pc,
jlong native_stream) {
return ExtractNativePC(jni, j_pc)->AddStream(
reinterpret_cast<webrtc::MediaStreamInterface*>(native_stream));
reinterpret_cast<MediaStreamInterface*>(native_stream));
}
JNI_FUNCTION_DECLARATION(void,
@ -227,7 +228,7 @@ JNI_FUNCTION_DECLARATION(void,
jobject j_pc,
jlong native_stream) {
ExtractNativePC(jni, j_pc)->RemoveStream(
reinterpret_cast<webrtc::MediaStreamInterface*>(native_stream));
reinterpret_cast<MediaStreamInterface*>(native_stream));
}
JNI_FUNCTION_DECLARATION(jobject,
@ -242,7 +243,7 @@ JNI_FUNCTION_DECLARATION(jobject,
std::string kind = JavaToStdString(jni, j_kind);
std::string stream_id = JavaToStdString(jni, j_stream_id);
rtc::scoped_refptr<webrtc::RtpSenderInterface> sender =
rtc::scoped_refptr<RtpSenderInterface> sender =
ExtractNativePC(jni, j_pc)->CreateSender(kind, stream_id);
if (!sender.get()) {
return nullptr;
@ -327,9 +328,8 @@ JNI_FUNCTION_DECLARATION(bool,
rtc::scoped_refptr<StatsObserverJni> observer(
new rtc::RefCountedObject<StatsObserverJni>(jni, j_observer));
return ExtractNativePC(jni, j_pc)->GetStats(
observer,
reinterpret_cast<webrtc::MediaStreamTrackInterface*>(native_track),
webrtc::PeerConnectionInterface::kStatsOutputLevelStandard);
observer, reinterpret_cast<MediaStreamTrackInterface*>(native_track),
PeerConnectionInterface::kStatsOutputLevelStandard);
}
JNI_FUNCTION_DECLARATION(void,
@ -350,7 +350,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
jobject j_min,
jobject j_current,
jobject j_max) {
webrtc::PeerConnectionInterface::BitrateParameters params;
PeerConnectionInterface::BitrateParameters params;
jclass j_integer_class = jni->FindClass("java/lang/Integer");
jmethodID int_value_id = GetMethodID(jni, j_integer_class, "intValue", "()I");
if (!IsNull(jni, j_min)) {
@ -389,7 +389,7 @@ JNI_FUNCTION_DECLARATION(jobject,
PeerConnection_signalingState,
JNIEnv* jni,
jobject j_pc) {
webrtc::PeerConnectionInterface::SignalingState state =
PeerConnectionInterface::SignalingState state =
ExtractNativePC(jni, j_pc)->signaling_state();
return JavaEnumFromIndexAndClassName(jni, "PeerConnection$SignalingState",
state);
@ -399,7 +399,7 @@ JNI_FUNCTION_DECLARATION(jobject,
PeerConnection_iceConnectionState,
JNIEnv* jni,
jobject j_pc) {
webrtc::PeerConnectionInterface::IceConnectionState state =
PeerConnectionInterface::IceConnectionState state =
ExtractNativePC(jni, j_pc)->ice_connection_state();
return JavaEnumFromIndexAndClassName(jni, "PeerConnection$IceConnectionState",
state);
@ -409,7 +409,7 @@ JNI_FUNCTION_DECLARATION(jobject,
PeerConnection_iceGatheringState,
JNIEnv* jni,
jobject j_pc) {
webrtc::PeerConnectionInterface::IceGatheringState state =
PeerConnectionInterface::IceGatheringState state =
ExtractNativePC(jni, j_pc)->ice_gathering_state();
return JavaEnumFromIndexAndClassName(jni, "PeerConnection$IceGatheringState",
state);
@ -423,4 +423,5 @@ JNI_FUNCTION_DECLARATION(void,
return;
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

66
webrtc/sdk/android/src/jni/pc/peerconnectionfactory_jni.cc
View File

@ -32,7 +32,8 @@
#include "webrtc/system_wrappers/include/field_trial_default.h" // nogncheck
#include "webrtc/system_wrappers/include/trace.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Note: Some of the video-specific PeerConnectionFactory methods are
// implemented in "video_jni.cc". This is done so that if an application
@ -63,7 +64,7 @@ JNI_FUNCTION_DECLARATION(void,
jboolean video_hw_acceleration) {
video_hw_acceleration_enabled = video_hw_acceleration;
if (!factory_static_initialized) {
webrtc::JVM::Initialize(GetJVM());
JVM::Initialize(GetJVM());
factory_static_initialized = true;
}
}
@ -83,7 +84,7 @@ JNI_FUNCTION_DECLARATION(void,
jni->ReleaseStringUTFChars(j_trials_init_string, init_string);
LOG(LS_INFO) << "initializeFieldTrials: " << field_trials_init_string;
}
webrtc::field_trial::InitFieldTrialsFromString(field_trials_init_string);
field_trial::InitFieldTrialsFromString(field_trials_init_string);
}
JNI_FUNCTION_DECLARATION(void,
@ -99,7 +100,7 @@ JNI_FUNCTION_DECLARATION(jstring,
jclass,
jstring j_name) {
return JavaStringFromStdString(
jni, webrtc::field_trial::FindFullName(JavaToStdString(jni, j_name)));
jni, field_trial::FindFullName(JavaToStdString(jni, j_name)));
}
JNI_FUNCTION_DECLARATION(jboolean,
@ -146,7 +147,7 @@ JNI_FUNCTION_DECLARATION(
// webrtc/rtc_base/ are convoluted, we simply wrap here to avoid having to
// think about ramifications of auto-wrapping there.
rtc::ThreadManager::Instance()->WrapCurrentThread();
webrtc::Trace::CreateTrace();
Trace::CreateTrace();
std::unique_ptr<rtc::Thread> network_thread =
rtc::Thread::CreateWithSocketServer();
@ -167,7 +168,7 @@ JNI_FUNCTION_DECLARATION(
auto audio_encoder_factory = CreateAudioEncoderFactory();
auto audio_decoder_factory = CreateAudioDecoderFactory();
webrtc::PeerConnectionFactoryInterface::Options options;
PeerConnectionFactoryInterface::Options options;
bool has_options = joptions != NULL;
if (has_options) {
options = JavaToNativePeerConnectionFactoryOptions(jni, joptions);
@ -184,17 +185,16 @@ JNI_FUNCTION_DECLARATION(
rtc::NetworkMonitorFactory::SetFactory(network_monitor_factory);
}
webrtc::AudioDeviceModule* adm = nullptr;
rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer = nullptr;
std::unique_ptr<webrtc::CallFactoryInterface> call_factory(
CreateCallFactory());
std::unique_ptr<webrtc::RtcEventLogFactoryInterface> rtc_event_log_factory(
AudioDeviceModule* adm = nullptr;
rtc::scoped_refptr<AudioMixer> audio_mixer = nullptr;
std::unique_ptr<CallFactoryInterface> call_factory(CreateCallFactory());
std::unique_ptr<RtcEventLogFactoryInterface> rtc_event_log_factory(
CreateRtcEventLogFactory());
std::unique_ptr<cricket::MediaEngineInterface> media_engine(CreateMediaEngine(
adm, audio_encoder_factory, audio_decoder_factory, video_encoder_factory,
video_decoder_factory, audio_mixer));
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
CreateModularPeerConnectionFactory(
network_thread.get(), worker_thread.get(), signaling_thread.get(),
adm, audio_encoder_factory, audio_decoder_factory,
@ -223,11 +223,11 @@ JNI_FUNCTION_DECLARATION(void,
jlong j_p) {
delete reinterpret_cast<OwnedFactoryAndThreads*>(j_p);
if (field_trials_init_string) {
webrtc::field_trial::InitFieldTrialsFromString(NULL);
field_trial::InitFieldTrialsFromString(NULL);
delete field_trials_init_string;
field_trials_init_string = NULL;
}
webrtc::Trace::ReturnTrace();
Trace::ReturnTrace();
}
JNI_FUNCTION_DECLARATION(void,
@ -246,9 +246,9 @@ JNI_FUNCTION_DECLARATION(jlong,
jclass,
jlong native_factory,
jstring label) {
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
factoryFromJava(native_factory));
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream(
rtc::scoped_refptr<MediaStreamInterface> stream(
factory->CreateLocalMediaStream(JavaToStdString(jni, label)));
return (jlong)stream.release();
}
@ -261,11 +261,11 @@ JNI_FUNCTION_DECLARATION(jlong,
jobject j_constraints) {
std::unique_ptr<MediaConstraintsJni> constraints(
new MediaConstraintsJni(jni, j_constraints));
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
factoryFromJava(native_factory));
cricket::AudioOptions options;
CopyConstraintsIntoAudioOptions(constraints.get(), &options);
rtc::scoped_refptr<webrtc::AudioSourceInterface> source(
rtc::scoped_refptr<AudioSourceInterface> source(
factory->CreateAudioSource(options));
return (jlong)source.release();
}
@ -277,12 +277,11 @@ JNI_FUNCTION_DECLARATION(jlong,
jlong native_factory,
jstring id,
jlong native_source) {
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
factoryFromJava(native_factory));
rtc::scoped_refptr<webrtc::AudioTrackInterface> track(
factory->CreateAudioTrack(
JavaToStdString(jni, id),
reinterpret_cast<webrtc::AudioSourceInterface*>(native_source)));
rtc::scoped_refptr<AudioTrackInterface> track(factory->CreateAudioTrack(
JavaToStdString(jni, id),
reinterpret_cast<AudioSourceInterface*>(native_source)));
return (jlong)track.release();
}
@ -293,7 +292,7 @@ JNI_FUNCTION_DECLARATION(jboolean,
jlong native_factory,
jint file,
jint filesize_limit_bytes) {
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
factoryFromJava(native_factory));
return factory->StartAecDump(file, filesize_limit_bytes);
}
@ -303,7 +302,7 @@ JNI_FUNCTION_DECLARATION(void,
JNIEnv* jni,
jclass,
jlong native_factory) {
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
factoryFromJava(native_factory));
factory->StopAecDump();
}
@ -314,9 +313,9 @@ JNI_FUNCTION_DECLARATION(void,
jclass,
jlong native_factory,
jobject options) {
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
factoryFromJava(native_factory));
webrtc::PeerConnectionFactoryInterface::Options options_to_set =
PeerConnectionFactoryInterface::Options options_to_set =
JavaToNativePeerConnectionFactoryOptions(jni, options);
factory->SetOptions(options_to_set);
@ -339,12 +338,12 @@ JNI_FUNCTION_DECLARATION(jlong,
jobject j_rtc_config,
jobject j_constraints,
jlong observer_p) {
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> f(
reinterpret_cast<webrtc::PeerConnectionFactoryInterface*>(
rtc::scoped_refptr<PeerConnectionFactoryInterface> f(
reinterpret_cast<PeerConnectionFactoryInterface*>(
factoryFromJava(factory)));
webrtc::PeerConnectionInterface::RTCConfiguration rtc_config(
webrtc::PeerConnectionInterface::RTCConfigurationType::kAggressive);
PeerConnectionInterface::RTCConfiguration rtc_config(
PeerConnectionInterface::RTCConfigurationType::kAggressive);
JavaToNativeRTCConfiguration(jni, j_rtc_config, &rtc_config);
jclass j_rtc_config_class = GetObjectClass(jni, j_rtc_config);
@ -369,9 +368,10 @@ JNI_FUNCTION_DECLARATION(jlong,
reinterpret_cast<PeerConnectionObserverJni*>(observer_p);
observer->SetConstraints(new MediaConstraintsJni(jni, j_constraints));
CopyConstraintsIntoRtcConfiguration(observer->constraints(), &rtc_config);
rtc::scoped_refptr<webrtc::PeerConnectionInterface> pc(
rtc::scoped_refptr<PeerConnectionInterface> pc(
f->CreatePeerConnection(rtc_config, nullptr, nullptr, observer));
return (jlong)pc.release();
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

30
webrtc/sdk/android/src/jni/pc/peerconnectionobserver_jni.cc
View File

@ -15,7 +15,8 @@
#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
#include "webrtc/sdk/android/src/jni/pc/java_native_conversion.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Convenience, used since callbacks occur on the signaling thread, which may
// be a non-Java thread.
@ -52,7 +53,7 @@ PeerConnectionObserverJni::~PeerConnectionObserverJni() {
}
void PeerConnectionObserverJni::OnIceCandidate(
const webrtc::IceCandidateInterface* candidate) {
const IceCandidateInterface* candidate) {
ScopedLocalRefFrame local_ref_frame(jni());
std::string sdp;
RTC_CHECK(candidate->ToString(&sdp)) << "got so far: " << sdp;
@ -83,7 +84,7 @@ void PeerConnectionObserverJni::OnIceCandidatesRemoved(
}
void PeerConnectionObserverJni::OnSignalingChange(
webrtc::PeerConnectionInterface::SignalingState new_state) {
PeerConnectionInterface::SignalingState new_state) {
ScopedLocalRefFrame local_ref_frame(jni());
jmethodID m = GetMethodID(jni(), *j_observer_class_, "onSignalingChange",
"(Lorg/webrtc/PeerConnection$SignalingState;)V");
@ -94,7 +95,7 @@ void PeerConnectionObserverJni::OnSignalingChange(
}
void PeerConnectionObserverJni::OnIceConnectionChange(
webrtc::PeerConnectionInterface::IceConnectionState new_state) {
PeerConnectionInterface::IceConnectionState new_state) {
ScopedLocalRefFrame local_ref_frame(jni());
jmethodID m =
GetMethodID(jni(), *j_observer_class_, "onIceConnectionChange",
@ -114,7 +115,7 @@ void PeerConnectionObserverJni::OnIceConnectionReceivingChange(bool receiving) {
}
void PeerConnectionObserverJni::OnIceGatheringChange(
webrtc::PeerConnectionInterface::IceGatheringState new_state) {
PeerConnectionInterface::IceGatheringState new_state) {
ScopedLocalRefFrame local_ref_frame(jni());
jmethodID m = GetMethodID(jni(), *j_observer_class_, "onIceGatheringChange",
"(Lorg/webrtc/PeerConnection$IceGatheringState;)V");
@ -125,7 +126,7 @@ void PeerConnectionObserverJni::OnIceGatheringChange(
}
void PeerConnectionObserverJni::OnAddStream(
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
rtc::scoped_refptr<MediaStreamInterface> stream) {
ScopedLocalRefFrame local_ref_frame(jni());
// The stream could be added into the remote_streams_ map when calling
// OnAddTrack.
@ -176,7 +177,7 @@ void PeerConnectionObserverJni::OnAddStream(
}
void PeerConnectionObserverJni::OnRemoveStream(
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
rtc::scoped_refptr<MediaStreamInterface> stream) {
ScopedLocalRefFrame local_ref_frame(jni());
NativeToJavaStreamsMap::iterator it = remote_streams_.find(stream);
RTC_CHECK(it != remote_streams_.end())
@ -193,7 +194,7 @@ void PeerConnectionObserverJni::OnRemoveStream(
}
void PeerConnectionObserverJni::OnDataChannel(
rtc::scoped_refptr<webrtc::DataChannelInterface> channel) {
rtc::scoped_refptr<DataChannelInterface> channel) {
ScopedLocalRefFrame local_ref_frame(jni());
jobject j_channel =
jni()->NewObject(*j_data_channel_class_, j_data_channel_ctor_,
@ -223,9 +224,8 @@ void PeerConnectionObserverJni::OnRenegotiationNeeded() {
}
void PeerConnectionObserverJni::OnAddTrack(
rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&
streams) {
rtc::scoped_refptr<RtpReceiverInterface> receiver,
const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {
ScopedLocalRefFrame local_ref_frame(jni());
jobject j_rtp_receiver =
jni()->NewObject(*j_rtp_receiver_class_, j_rtp_receiver_ctor_,
@ -272,7 +272,7 @@ void PeerConnectionObserverJni::DisposeRtpReceiver(
// If the NativeToJavaStreamsMap contains the stream, return it.
// Otherwise, create a new Java MediaStream.
jobject PeerConnectionObserverJni::GetOrCreateJavaStream(
const rtc::scoped_refptr<webrtc::MediaStreamInterface>& stream) {
const rtc::scoped_refptr<MediaStreamInterface>& stream) {
NativeToJavaStreamsMap::iterator it = remote_streams_.find(stream);
if (it != remote_streams_.end()) {
return it->second;
@ -292,8 +292,7 @@ jobject PeerConnectionObserverJni::GetOrCreateJavaStream(
jobjectArray PeerConnectionObserverJni::NativeToJavaMediaStreamArray(
JNIEnv* jni,
const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&
streams) {
const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {
jobjectArray java_streams =
jni->NewObjectArray(streams.size(), *j_media_stream_class_, nullptr);
CHECK_EXCEPTION(jni) << "error during NewObjectArray";
@ -304,4 +303,5 @@ jobjectArray PeerConnectionObserverJni::NativeToJavaMediaStreamArray(
return java_streams;
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

43
webrtc/sdk/android/src/jni/pc/peerconnectionobserver_jni.h
View File

@ -19,48 +19,43 @@
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
#include "webrtc/sdk/android/src/jni/pc/mediaconstraints_jni.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// 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.
class PeerConnectionObserverJni : public webrtc::PeerConnectionObserver {
class PeerConnectionObserverJni : public PeerConnectionObserver {
public:
PeerConnectionObserverJni(JNIEnv* jni, jobject j_observer);
virtual ~PeerConnectionObserverJni();
// Implementation of PeerConnectionObserver interface, which propagates
// the callbacks to the Java observer.
void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override;
void OnIceCandidate(const IceCandidateInterface* candidate) override;
void OnIceCandidatesRemoved(
const std::vector<cricket::Candidate>& candidates) override;
void OnSignalingChange(
webrtc::PeerConnectionInterface::SignalingState new_state) override;
PeerConnectionInterface::SignalingState new_state) override;
void OnIceConnectionChange(
webrtc::PeerConnectionInterface::IceConnectionState new_state) override;
PeerConnectionInterface::IceConnectionState new_state) override;
void OnIceConnectionReceivingChange(bool receiving) override;
void OnIceGatheringChange(
webrtc::PeerConnectionInterface::IceGatheringState new_state) override;
void OnAddStream(
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override;
void OnRemoveStream(
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override;
void OnDataChannel(
rtc::scoped_refptr<webrtc::DataChannelInterface> channel) override;
PeerConnectionInterface::IceGatheringState new_state) override;
void OnAddStream(rtc::scoped_refptr<MediaStreamInterface> stream) override;
void OnRemoveStream(rtc::scoped_refptr<MediaStreamInterface> stream) override;
void OnDataChannel(rtc::scoped_refptr<DataChannelInterface> channel) override;
void OnRenegotiationNeeded() override;
void OnAddTrack(
rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&
streams) override;
void OnAddTrack(rtc::scoped_refptr<RtpReceiverInterface> receiver,
const std::vector<rtc::scoped_refptr<MediaStreamInterface>>&
streams) override;
void SetConstraints(MediaConstraintsJni* constraints);
const MediaConstraintsJni* constraints() { return constraints_.get(); }
private:
typedef std::map<webrtc::MediaStreamInterface*, jobject>
NativeToJavaStreamsMap;
typedef std::map<webrtc::RtpReceiverInterface*, jobject>
NativeToJavaRtpReceiverMap;
typedef std::map<MediaStreamInterface*, jobject> NativeToJavaStreamsMap;
typedef std::map<RtpReceiverInterface*, jobject> NativeToJavaRtpReceiverMap;
void DisposeRemoteStream(const NativeToJavaStreamsMap::iterator& it);
void DisposeRtpReceiver(const NativeToJavaRtpReceiverMap::iterator& it);
@ -68,13 +63,12 @@ class PeerConnectionObserverJni : public webrtc::PeerConnectionObserver {
// If the NativeToJavaStreamsMap contains the stream, return it.
// Otherwise, create a new Java MediaStream.
jobject GetOrCreateJavaStream(
const rtc::scoped_refptr<webrtc::MediaStreamInterface>& stream);
const rtc::scoped_refptr<MediaStreamInterface>& stream);
// Converts array of streams, creating or re-using Java streams as necessary.
jobjectArray NativeToJavaMediaStreamArray(
JNIEnv* jni,
const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&
streams);
const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams);
const ScopedGlobalRef<jobject> j_observer_global_;
const ScopedGlobalRef<jclass> j_observer_class_;
@ -95,6 +89,7 @@ class PeerConnectionObserverJni : public webrtc::PeerConnectionObserver {
std::unique_ptr<MediaConstraintsJni> constraints_;
};
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_PEERCONNECTIONOBSERVER_JNI_H_

88
webrtc/sdk/android/src/jni/pc/rtcstatscollectorcallbackwrapper.cc
View File

@ -15,7 +15,8 @@
#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
RTCStatsCollectorCallbackWrapper::RTCStatsCollectorCallbackWrapper(
JNIEnv* jni,
@ -57,7 +58,7 @@ RTCStatsCollectorCallbackWrapper::RTCStatsCollectorCallbackWrapper(
j_string_class_(FindClass(jni, "java/lang/String")) {}
void RTCStatsCollectorCallbackWrapper::OnStatsDelivered(
const rtc::scoped_refptr<const webrtc::RTCStatsReport>& report) {
const rtc::scoped_refptr<const RTCStatsReport>& report) {
JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni);
jobject j_report = ReportToJava(jni, report);
@ -69,11 +70,11 @@ void RTCStatsCollectorCallbackWrapper::OnStatsDelivered(
jobject RTCStatsCollectorCallbackWrapper::ReportToJava(
JNIEnv* jni,
const rtc::scoped_refptr<const webrtc::RTCStatsReport>& report) {
const rtc::scoped_refptr<const RTCStatsReport>& report) {
jobject j_stats_map =
jni->NewObject(j_linked_hash_map_class_, j_linked_hash_map_ctor_);
CHECK_EXCEPTION(jni) << "error during NewObject";
for (const webrtc::RTCStats& stats : *report) {
for (const RTCStats& stats : *report) {
// Create a local reference frame for each RTCStats, since there is a
// maximum number of references that can be created in one frame.
ScopedLocalRefFrame local_ref_frame(jni);
@ -88,14 +89,13 @@ jobject RTCStatsCollectorCallbackWrapper::ReportToJava(
return j_report;
}
jobject RTCStatsCollectorCallbackWrapper::StatsToJava(
JNIEnv* jni,
const webrtc::RTCStats& stats) {
jobject RTCStatsCollectorCallbackWrapper::StatsToJava(JNIEnv* jni,
const RTCStats& stats) {
jstring j_type = JavaStringFromStdString(jni, stats.type());
jstring j_id = JavaStringFromStdString(jni, stats.id());
jobject j_members =
jni->NewObject(j_linked_hash_map_class_, j_linked_hash_map_ctor_);
for (const webrtc::RTCStatsMemberInterface* member : stats.Members()) {
for (const RTCStatsMemberInterface* member : stats.Members()) {
if (!member->is_defined()) {
continue;
}
@ -115,57 +115,56 @@ jobject RTCStatsCollectorCallbackWrapper::StatsToJava(
jobject RTCStatsCollectorCallbackWrapper::MemberToJava(
JNIEnv* jni,
const webrtc::RTCStatsMemberInterface* member) {
const RTCStatsMemberInterface* member) {
switch (member->type()) {
case webrtc::RTCStatsMemberInterface::kBool: {
jobject value =
jni->NewObject(j_boolean_class_, j_boolean_ctor_,
*member->cast_to<webrtc::RTCStatsMember<bool>>());
case RTCStatsMemberInterface::kBool: {
jobject value = jni->NewObject(j_boolean_class_, j_boolean_ctor_,
*member->cast_to<RTCStatsMember<bool>>());
CHECK_EXCEPTION(jni) << "error during NewObject";
return value;
}
case webrtc::RTCStatsMemberInterface::kInt32: {
case RTCStatsMemberInterface::kInt32: {
jobject value =
jni->NewObject(j_integer_class_, j_integer_ctor_,
*member->cast_to<webrtc::RTCStatsMember<int32_t>>());
*member->cast_to<RTCStatsMember<int32_t>>());
CHECK_EXCEPTION(jni) << "error during NewObject";
return value;
}
case webrtc::RTCStatsMemberInterface::kUint32: {
jobject value = jni->NewObject(
j_long_class_, j_long_ctor_,
(jlong)*member->cast_to<webrtc::RTCStatsMember<uint32_t>>());
CHECK_EXCEPTION(jni) << "error during NewObject";
return value;
}
case webrtc::RTCStatsMemberInterface::kInt64: {
case RTCStatsMemberInterface::kUint32: {
jobject value =
jni->NewObject(j_long_class_, j_long_ctor_,
*member->cast_to<webrtc::RTCStatsMember<int64_t>>());
(jlong)*member->cast_to<RTCStatsMember<uint32_t>>());
CHECK_EXCEPTION(jni) << "error during NewObject";
return value;
}
case webrtc::RTCStatsMemberInterface::kUint64: {
case RTCStatsMemberInterface::kInt64: {
jobject value =
jni->NewObject(j_long_class_, j_long_ctor_,
*member->cast_to<RTCStatsMember<int64_t>>());
CHECK_EXCEPTION(jni) << "error during NewObject";
return value;
}
case RTCStatsMemberInterface::kUint64: {
jobject value =
jni->NewObject(j_big_integer_class_, j_big_integer_ctor_,
JavaStringFromStdString(jni, member->ValueToString()));
CHECK_EXCEPTION(jni) << "error during NewObject";
return value;
}
case webrtc::RTCStatsMemberInterface::kDouble: {
case RTCStatsMemberInterface::kDouble: {
jobject value =
jni->NewObject(j_double_class_, j_double_ctor_,
*member->cast_to<webrtc::RTCStatsMember<double>>());
*member->cast_to<RTCStatsMember<double>>());
CHECK_EXCEPTION(jni) << "error during NewObject";
return value;
}
case webrtc::RTCStatsMemberInterface::kString: {
case RTCStatsMemberInterface::kString: {
return JavaStringFromStdString(
jni, *member->cast_to<webrtc::RTCStatsMember<std::string>>());
jni, *member->cast_to<RTCStatsMember<std::string>>());
}
case webrtc::RTCStatsMemberInterface::kSequenceBool: {
case RTCStatsMemberInterface::kSequenceBool: {
const std::vector<bool>& values =
*member->cast_to<webrtc::RTCStatsMember<std::vector<bool>>>();
*member->cast_to<RTCStatsMember<std::vector<bool>>>();
jobjectArray j_values =
jni->NewObjectArray(values.size(), j_boolean_class_, nullptr);
CHECK_EXCEPTION(jni) << "error during NewObjectArray";
@ -177,9 +176,9 @@ jobject RTCStatsCollectorCallbackWrapper::MemberToJava(
}
return j_values;
}
case webrtc::RTCStatsMemberInterface::kSequenceInt32: {
case RTCStatsMemberInterface::kSequenceInt32: {
const std::vector<int32_t>& values =
*member->cast_to<webrtc::RTCStatsMember<std::vector<int32_t>>>();
*member->cast_to<RTCStatsMember<std::vector<int32_t>>>();
jobjectArray j_values =
jni->NewObjectArray(values.size(), j_integer_class_, nullptr);
CHECK_EXCEPTION(jni) << "error during NewObjectArray";
@ -191,9 +190,9 @@ jobject RTCStatsCollectorCallbackWrapper::MemberToJava(
}
return j_values;
}
case webrtc::RTCStatsMemberInterface::kSequenceUint32: {
case RTCStatsMemberInterface::kSequenceUint32: {
const std::vector<uint32_t>& values =
*member->cast_to<webrtc::RTCStatsMember<std::vector<uint32_t>>>();
*member->cast_to<RTCStatsMember<std::vector<uint32_t>>>();
jobjectArray j_values =
jni->NewObjectArray(values.size(), j_long_class_, nullptr);
CHECK_EXCEPTION(jni) << "error during NewObjectArray";
@ -204,9 +203,9 @@ jobject RTCStatsCollectorCallbackWrapper::MemberToJava(
}
return j_values;
}
case webrtc::RTCStatsMemberInterface::kSequenceInt64: {
case RTCStatsMemberInterface::kSequenceInt64: {
const std::vector<int64_t>& values =
*member->cast_to<webrtc::RTCStatsMember<std::vector<int64_t>>>();
*member->cast_to<RTCStatsMember<std::vector<int64_t>>>();
jobjectArray j_values =
jni->NewObjectArray(values.size(), j_long_class_, nullptr);
CHECK_EXCEPTION(jni) << "error during NewObjectArray";
@ -217,9 +216,9 @@ jobject RTCStatsCollectorCallbackWrapper::MemberToJava(
}
return j_values;
}
case webrtc::RTCStatsMemberInterface::kSequenceUint64: {
case RTCStatsMemberInterface::kSequenceUint64: {
const std::vector<uint64_t>& values =
*member->cast_to<webrtc::RTCStatsMember<std::vector<uint64_t>>>();
*member->cast_to<RTCStatsMember<std::vector<uint64_t>>>();
jobjectArray j_values =
jni->NewObjectArray(values.size(), j_big_integer_class_, nullptr);
CHECK_EXCEPTION(jni) << "error during NewObjectArray";
@ -232,9 +231,9 @@ jobject RTCStatsCollectorCallbackWrapper::MemberToJava(
}
return j_values;
}
case webrtc::RTCStatsMemberInterface::kSequenceDouble: {
case RTCStatsMemberInterface::kSequenceDouble: {
const std::vector<double>& values =
*member->cast_to<webrtc::RTCStatsMember<std::vector<double>>>();
*member->cast_to<RTCStatsMember<std::vector<double>>>();
jobjectArray j_values =
jni->NewObjectArray(values.size(), j_double_class_, nullptr);
CHECK_EXCEPTION(jni) << "error during NewObjectArray";
@ -246,9 +245,9 @@ jobject RTCStatsCollectorCallbackWrapper::MemberToJava(
}
return j_values;
}
case webrtc::RTCStatsMemberInterface::kSequenceString: {
case RTCStatsMemberInterface::kSequenceString: {
const std::vector<std::string>& values =
*member->cast_to<webrtc::RTCStatsMember<std::vector<std::string>>>();
*member->cast_to<RTCStatsMember<std::vector<std::string>>>();
jobjectArray j_values =
jni->NewObjectArray(values.size(), j_string_class_, nullptr);
CHECK_EXCEPTION(jni) << "error during NewObjectArray";
@ -264,4 +263,5 @@ jobject RTCStatsCollectorCallbackWrapper::MemberToJava(
return nullptr;
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

21
webrtc/sdk/android/src/jni/pc/rtcstatscollectorcallbackwrapper.h
View File

@ -16,27 +16,25 @@
#include "webrtc/api/peerconnectioninterface.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Adapter for a Java RTCStatsCollectorCallback presenting a C++
// RTCStatsCollectorCallback and dispatching the callback from C++ back to
// Java.
class RTCStatsCollectorCallbackWrapper
: public webrtc::RTCStatsCollectorCallback {
class RTCStatsCollectorCallbackWrapper : public RTCStatsCollectorCallback {
public:
RTCStatsCollectorCallbackWrapper(JNIEnv* jni, jobject j_callback);
void OnStatsDelivered(
const rtc::scoped_refptr<const webrtc::RTCStatsReport>& report) override;
const rtc::scoped_refptr<const RTCStatsReport>& report) override;
private:
// Helper functions for converting C++ RTCStatsReport to Java equivalent.
jobject ReportToJava(
JNIEnv* jni,
const rtc::scoped_refptr<const webrtc::RTCStatsReport>& report);
jobject StatsToJava(JNIEnv* jni, const webrtc::RTCStats& stats);
jobject MemberToJava(JNIEnv* jni,
const webrtc::RTCStatsMemberInterface* member);
jobject ReportToJava(JNIEnv* jni,
const rtc::scoped_refptr<const RTCStatsReport>& report);
jobject StatsToJava(JNIEnv* jni, const RTCStats& stats);
jobject MemberToJava(JNIEnv* jni, const RTCStatsMemberInterface* member);
const ScopedGlobalRef<jobject> j_callback_global_;
const ScopedGlobalRef<jclass> j_callback_class_;
@ -60,6 +58,7 @@ class RTCStatsCollectorCallbackWrapper
const jclass j_string_class_;
};
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_RTCSTATSCOLLECTORCALLBACKWRAPPER_H_

23
webrtc/sdk/android/src/jni/pc/rtpreceiver_jni.cc
View File

@ -13,7 +13,8 @@
#include "webrtc/sdk/android/src/jni/pc/java_native_conversion.h"
#include "webrtc/sdk/android/src/jni/pc/rtpreceiverobserver_jni.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
JNI_FUNCTION_DECLARATION(jlong,
RtpReceiver_nativeGetTrack,
@ -22,7 +23,7 @@ JNI_FUNCTION_DECLARATION(jlong,
jlong j_rtp_receiver_pointer,
jlong j_track_pointer) {
return jlongFromPointer(
reinterpret_cast<webrtc::RtpReceiverInterface*>(j_rtp_receiver_pointer)
reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)
->track()
.release());
}
@ -36,9 +37,9 @@ JNI_FUNCTION_DECLARATION(jboolean,
if (IsNull(jni, j_parameters)) {
return false;
}
webrtc::RtpParameters parameters;
RtpParameters parameters;
JavaToNativeRtpParameters(jni, j_parameters, &parameters);
return reinterpret_cast<webrtc::RtpReceiverInterface*>(j_rtp_receiver_pointer)
return reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)
->SetParameters(parameters);
}
@ -47,8 +48,8 @@ JNI_FUNCTION_DECLARATION(jobject,
JNIEnv* jni,
jclass,
jlong j_rtp_receiver_pointer) {
webrtc::RtpParameters parameters =
reinterpret_cast<webrtc::RtpReceiverInterface*>(j_rtp_receiver_pointer)
RtpParameters parameters =
reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)
->GetParameters();
return NativeToJavaRtpParameters(jni, parameters);
}
@ -60,8 +61,7 @@ JNI_FUNCTION_DECLARATION(jstring,
jlong j_rtp_receiver_pointer) {
return JavaStringFromStdString(
jni,
reinterpret_cast<webrtc::RtpReceiverInterface*>(j_rtp_receiver_pointer)
->id());
reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)->id());
}
JNI_FUNCTION_DECLARATION(jlong,
@ -72,7 +72,7 @@ JNI_FUNCTION_DECLARATION(jlong,
jobject j_observer) {
RtpReceiverObserverJni* rtpReceiverObserver =
new RtpReceiverObserverJni(jni, j_observer);
reinterpret_cast<webrtc::RtpReceiverInterface*>(j_rtp_receiver_pointer)
reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)
->SetObserver(rtpReceiverObserver);
return jlongFromPointer(rtpReceiverObserver);
}
@ -83,7 +83,7 @@ JNI_FUNCTION_DECLARATION(void,
jclass,
jlong j_rtp_receiver_pointer,
jlong j_observer_pointer) {
reinterpret_cast<webrtc::RtpReceiverInterface*>(j_rtp_receiver_pointer)
reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)
->SetObserver(nullptr);
RtpReceiverObserverJni* observer =
reinterpret_cast<RtpReceiverObserverJni*>(j_observer_pointer);
@ -92,4 +92,5 @@ JNI_FUNCTION_DECLARATION(void,
}
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

6
webrtc/sdk/android/src/jni/pc/rtpreceiverobserver_jni.cc
View File

@ -12,7 +12,8 @@
#include "webrtc/sdk/android/src/jni/pc/java_native_conversion.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
void RtpReceiverObserverJni::OnFirstPacketReceived(
cricket::MediaType media_type) {
@ -29,4 +30,5 @@ void RtpReceiverObserverJni::OnFirstPacketReceived(
CHECK_EXCEPTION(jni) << "error during CallVoidMethod";
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

8
webrtc/sdk/android/src/jni/pc/rtpreceiverobserver_jni.h
View File

@ -14,12 +14,13 @@
#include "webrtc/api/rtpreceiverinterface.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Adapter between the C++ RtpReceiverObserverInterface and the Java
// RtpReceiver.Observer interface. Wraps an instance of the Java interface and
// dispatches C++ callbacks to Java.
class RtpReceiverObserverJni : public webrtc::RtpReceiverObserverInterface {
class RtpReceiverObserverJni : public RtpReceiverObserverInterface {
public:
RtpReceiverObserverJni(JNIEnv* jni, jobject j_observer)
: j_observer_global_(jni, j_observer) {}
@ -32,6 +33,7 @@ class RtpReceiverObserverJni : public webrtc::RtpReceiverObserverInterface {
const ScopedGlobalRef<jobject> j_observer_global_;
};
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_RTPRECEIVEROBSERVER_JNI_H_

26
webrtc/sdk/android/src/jni/pc/rtpsender_jni.cc
View File

@ -12,7 +12,8 @@
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
#include "webrtc/sdk/android/src/jni/pc/java_native_conversion.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
JNI_FUNCTION_DECLARATION(jboolean,
RtpSender_nativeSetTrack,
@ -20,9 +21,8 @@ JNI_FUNCTION_DECLARATION(jboolean,
jclass,
jlong j_rtp_sender_pointer,
jlong j_track_pointer) {
return reinterpret_cast<webrtc::RtpSenderInterface*>(j_rtp_sender_pointer)
->SetTrack(reinterpret_cast<webrtc::MediaStreamTrackInterface*>(
j_track_pointer));
return reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)
->SetTrack(reinterpret_cast<MediaStreamTrackInterface*>(j_track_pointer));
}
JNI_FUNCTION_DECLARATION(jlong,
@ -31,7 +31,7 @@ JNI_FUNCTION_DECLARATION(jlong,
jclass,
jlong j_rtp_sender_pointer) {
return jlongFromPointer(
reinterpret_cast<webrtc::RtpSenderInterface*>(j_rtp_sender_pointer)
reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)
->track()
.release());
}
@ -42,7 +42,7 @@ JNI_FUNCTION_DECLARATION(jlong,
jclass,
jlong j_rtp_sender_pointer) {
return jlongFromPointer(
reinterpret_cast<webrtc::RtpSenderInterface*>(j_rtp_sender_pointer)
reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)
->GetDtmfSender()
.release());
}
@ -56,9 +56,9 @@ JNI_FUNCTION_DECLARATION(jboolean,
if (IsNull(jni, j_parameters)) {
return false;
}
webrtc::RtpParameters parameters;
RtpParameters parameters;
JavaToNativeRtpParameters(jni, j_parameters, &parameters);
return reinterpret_cast<webrtc::RtpSenderInterface*>(j_rtp_sender_pointer)
return reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)
->SetParameters(parameters);
}
@ -67,8 +67,8 @@ JNI_FUNCTION_DECLARATION(jobject,
JNIEnv* jni,
jclass,
jlong j_rtp_sender_pointer) {
webrtc::RtpParameters parameters =
reinterpret_cast<webrtc::RtpSenderInterface*>(j_rtp_sender_pointer)
RtpParameters parameters =
reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)
->GetParameters();
return NativeToJavaRtpParameters(jni, parameters);
}
@ -79,8 +79,8 @@ JNI_FUNCTION_DECLARATION(jstring,
jclass,
jlong j_rtp_sender_pointer) {
return JavaStringFromStdString(
jni, reinterpret_cast<webrtc::RtpSenderInterface*>(j_rtp_sender_pointer)
->id());
jni, reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)->id());
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

13
webrtc/sdk/android/src/jni/pc/sdpobserver_jni.h
View File

@ -18,7 +18,8 @@
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
#include "webrtc/sdk/android/src/jni/pc/mediaconstraints_jni.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Adapter for a Java StatsObserver presenting a C++
// CreateSessionDescriptionObserver or SetSessionDescriptionObserver and
@ -44,7 +45,7 @@ class SdpObserverJni : public T {
}
// Can't mark override because of templating.
virtual void OnSuccess(webrtc::SessionDescriptionInterface* desc) {
virtual void OnSuccess(SessionDescriptionInterface* desc) {
ScopedLocalRefFrame local_ref_frame(jni());
jmethodID m = GetMethodID(jni(), *j_observer_class_, "onCreateSuccess",
"(Lorg/webrtc/SessionDescription;)V");
@ -76,7 +77,7 @@ class SdpObserverJni : public T {
};
class CreateSdpObserverJni
: public SdpObserverJni<webrtc::CreateSessionDescriptionObserver> {
: public SdpObserverJni<CreateSessionDescriptionObserver> {
public:
CreateSdpObserverJni(JNIEnv* jni,
jobject j_observer,
@ -89,8 +90,7 @@ class CreateSdpObserverJni
}
};
class SetSdpObserverJni
: public SdpObserverJni<webrtc::SetSessionDescriptionObserver> {
class SetSdpObserverJni : public SdpObserverJni<SetSessionDescriptionObserver> {
public:
SetSdpObserverJni(JNIEnv* jni,
jobject j_observer,
@ -103,6 +103,7 @@ class SetSdpObserverJni
}
};
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_SDPOBSERVER_JNI_H_

18
webrtc/sdk/android/src/jni/pc/statsobserver_jni.cc
View File

@ -12,7 +12,8 @@
#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Convenience, used since callbacks occur on the signaling thread, which may
// be a non-Java thread.
@ -35,7 +36,7 @@ StatsObserverJni::StatsObserverJni(JNIEnv* jni, jobject j_observer)
"<init>",
"(Ljava/lang/String;Ljava/lang/String;)V")) {}
void StatsObserverJni::OnComplete(const webrtc::StatsReports& reports) {
void StatsObserverJni::OnComplete(const StatsReports& reports) {
ScopedLocalRefFrame local_ref_frame(jni());
jobjectArray j_reports = ReportsToJava(jni(), reports);
jmethodID m = GetMethodID(jni(), *j_observer_class_, "onComplete",
@ -44,9 +45,8 @@ void StatsObserverJni::OnComplete(const webrtc::StatsReports& reports) {
CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
}
jobjectArray StatsObserverJni::ReportsToJava(
JNIEnv* jni,
const webrtc::StatsReports& reports) {
jobjectArray StatsObserverJni::ReportsToJava(JNIEnv* jni,
const StatsReports& reports) {
jobjectArray reports_array =
jni->NewObjectArray(reports.size(), *j_stats_report_class_, NULL);
int i = 0;
@ -63,9 +63,8 @@ jobjectArray StatsObserverJni::ReportsToJava(
return reports_array;
}
jobjectArray StatsObserverJni::ValuesToJava(
JNIEnv* jni,
const webrtc::StatsReport::Values& values) {
jobjectArray StatsObserverJni::ValuesToJava(JNIEnv* jni,
const StatsReport::Values& values) {
jobjectArray j_values =
jni->NewObjectArray(values.size(), *j_value_class_, NULL);
int i = 0;
@ -82,4 +81,5 @@ jobjectArray StatsObserverJni::ValuesToJava(
return j_values;
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

17
webrtc/sdk/android/src/jni/pc/statsobserver_jni.h
View File

@ -14,21 +14,21 @@
#include "webrtc/api/peerconnectioninterface.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Adapter for a Java StatsObserver presenting a C++ webrtc::StatsObserver and
// Adapter for a Java StatsObserver presenting a C++ StatsObserver and
// dispatching the callback from C++ back to Java.
class StatsObserverJni : public webrtc::StatsObserver {
class StatsObserverJni : public StatsObserver {
public:
StatsObserverJni(JNIEnv* jni, jobject j_observer);
void OnComplete(const webrtc::StatsReports& reports) override;
void OnComplete(const StatsReports& reports) override;
private:
jobjectArray ReportsToJava(JNIEnv* jni, const webrtc::StatsReports& reports);
jobjectArray ReportsToJava(JNIEnv* jni, const StatsReports& reports);
jobjectArray ValuesToJava(JNIEnv* jni,
const webrtc::StatsReport::Values& values);
jobjectArray ValuesToJava(JNIEnv* jni, const StatsReport::Values& values);
const ScopedGlobalRef<jobject> j_observer_global_;
const ScopedGlobalRef<jclass> j_observer_class_;
@ -38,6 +38,7 @@ class StatsObserverJni : public webrtc::StatsObserver {
const jmethodID j_value_ctor_;
};
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_STATSOBSERVER_JNI_H_

23
webrtc/sdk/android/src/jni/pc/video_jni.cc
View File

@ -22,7 +22,8 @@
#include "webrtc/sdk/android/src/jni/surfacetexturehelper_jni.h"
#include "webrtc/sdk/android/src/jni/videodecoderfactorywrapper.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// TODO(sakal): Remove this once MediaCodecVideoDecoder/Encoder are no longer
// used and all applications inject their own codecs.
@ -67,13 +68,13 @@ JNI_FUNCTION_DECLARATION(jlong,
OwnedFactoryAndThreads* factory =
reinterpret_cast<OwnedFactoryAndThreads*>(native_factory);
rtc::scoped_refptr<webrtc::AndroidVideoTrackSource> source(
new rtc::RefCountedObject<webrtc::AndroidVideoTrackSource>(
rtc::scoped_refptr<AndroidVideoTrackSource> source(
new rtc::RefCountedObject<AndroidVideoTrackSource>(
factory->signaling_thread(), jni, j_surface_texture_helper,
is_screencast));
rtc::scoped_refptr<webrtc::VideoTrackSourceProxy> proxy_source =
webrtc::VideoTrackSourceProxy::Create(factory->signaling_thread(),
factory->worker_thread(), source);
rtc::scoped_refptr<VideoTrackSourceProxy> proxy_source =
VideoTrackSourceProxy::Create(factory->signaling_thread(),
factory->worker_thread(), source);
return (jlong)proxy_source.release();
}
@ -87,10 +88,9 @@ JNI_FUNCTION_DECLARATION(jlong,
jlong native_source) {
rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
factoryFromJava(native_factory));
rtc::scoped_refptr<webrtc::VideoTrackInterface> track(
factory->CreateVideoTrack(
JavaToStdString(jni, id),
reinterpret_cast<webrtc::VideoTrackSourceInterface*>(native_source)));
rtc::scoped_refptr<VideoTrackInterface> track(factory->CreateVideoTrack(
JavaToStdString(jni, id),
reinterpret_cast<VideoTrackSourceInterface*>(native_source)));
return (jlong)track.release();
}
@ -126,4 +126,5 @@ JNI_FUNCTION_DECLARATION(
}
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

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

@ -20,7 +20,8 @@ class WebRtcVideoEncoderFactory;
class WebRtcVideoDecoderFactory;
} // namespace cricket
namespace webrtc_jni {
namespace webrtc {
namespace jni {
class SurfaceTextureHelper;
@ -35,6 +36,7 @@ cricket::WebRtcVideoDecoderFactory* CreateVideoDecoderFactory(
jobject GetJavaSurfaceTextureHelper(
const rtc::scoped_refptr<SurfaceTextureHelper>& surface_texture_helper);
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_VIDEO_JNI_H_

11
webrtc/sdk/android/src/jni/surfacetexturehelper_jni.cc
View File

@ -16,7 +16,8 @@
#include "webrtc/rtc_base/logging.h"
#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
rtc::scoped_refptr<SurfaceTextureHelper> SurfaceTextureHelper::create(
JNIEnv* jni,
@ -71,12 +72,14 @@ void SurfaceTextureHelper::ReturnTextureFrame() const {
jni) << "error during SurfaceTextureHelper.returnTextureFrame";
}
rtc::scoped_refptr<webrtc::VideoFrameBuffer>
SurfaceTextureHelper::CreateTextureFrame(int width, int height,
rtc::scoped_refptr<VideoFrameBuffer> SurfaceTextureHelper::CreateTextureFrame(
int width,
int height,
const NativeHandleImpl& native_handle) {
return new rtc::RefCountedObject<AndroidTextureBuffer>(
width, height, native_handle, *j_surface_texture_helper_,
rtc::Bind(&SurfaceTextureHelper::ReturnTextureFrame, this));
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

10
webrtc/sdk/android/src/jni/surfacetexturehelper_jni.h
View File

@ -19,10 +19,11 @@
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
#include "webrtc/sdk/android/src/jni/native_handle_impl.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Helper class to create and synchronize access to an Android SurfaceTexture.
// It is used for creating webrtc::VideoFrameBuffers from a SurfaceTexture when
// It is used for creating VideoFrameBuffers from a SurfaceTexture when
// the SurfaceTexture has been updated.
// When the VideoFrameBuffer is released, this class returns the buffer to the
// java SurfaceTextureHelper so it can be updated safely. The VideoFrameBuffer
@ -46,7 +47,7 @@ class SurfaceTextureHelper : public rtc::RefCountInterface {
jobject GetJavaSurfaceTextureHelper() const;
rtc::scoped_refptr<webrtc::VideoFrameBuffer> CreateTextureFrame(
rtc::scoped_refptr<VideoFrameBuffer> CreateTextureFrame(
int width,
int height,
const NativeHandleImpl& native_handle);
@ -63,6 +64,7 @@ class SurfaceTextureHelper : public rtc::RefCountInterface {
const jmethodID j_return_texture_method_;
};
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_SURFACETEXTUREHELPER_JNI_H_

25
webrtc/sdk/android/src/jni/video_renderer_jni.cc
View File

@ -16,12 +16,12 @@
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
#include "webrtc/sdk/android/src/jni/native_handle_impl.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Wrapper dispatching rtc::VideoSinkInterface to a Java VideoRenderer
// instance.
class JavaVideoRendererWrapper
: public rtc::VideoSinkInterface<webrtc::VideoFrame> {
class JavaVideoRendererWrapper : public rtc::VideoSinkInterface<VideoFrame> {
public:
JavaVideoRendererWrapper(JNIEnv* jni, jobject j_callbacks)
: j_callbacks_(jni, j_callbacks),
@ -44,12 +44,12 @@ class JavaVideoRendererWrapper
virtual ~JavaVideoRendererWrapper() {}
void OnFrame(const webrtc::VideoFrame& video_frame) override {
void OnFrame(const VideoFrame& video_frame) override {
ScopedLocalRefFrame local_ref_frame(jni());
jobject j_frame;
if (video_frame.video_frame_buffer()->type() ==
webrtc::VideoFrameBuffer::Type::kNative) {
VideoFrameBuffer::Type::kNative) {
AndroidVideoFrameBuffer* android_buffer =
static_cast<AndroidVideoFrameBuffer*>(
video_frame.video_frame_buffer().get());
@ -77,15 +77,15 @@ class JavaVideoRendererWrapper
// 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 webrtc::VideoFrame* frame) {
return jlongFromPointer(new webrtc::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 webrtc::VideoFrame* frame) {
jobject ToJavaI420Frame(const VideoFrame* frame) {
jintArray strides = jni()->NewIntArray(3);
jint* strides_array = jni()->GetIntArrayElements(strides, NULL);
rtc::scoped_refptr<webrtc::I420BufferInterface> i420_buffer =
rtc::scoped_refptr<I420BufferInterface> i420_buffer =
frame->video_frame_buffer()->ToI420();
strides_array[0] = i420_buffer->StrideY();
strides_array[1] = i420_buffer->StrideU();
@ -113,7 +113,7 @@ class JavaVideoRendererWrapper
}
// Return a VideoRenderer.I420Frame referring texture object in |frame|.
jobject ToJavaTextureFrame(const webrtc::VideoFrame* frame) {
jobject ToJavaTextureFrame(const VideoFrame* frame) {
NativeHandleImpl handle =
static_cast<AndroidTextureBuffer*>(frame->video_frame_buffer().get())
->native_handle_impl();
@ -148,7 +148,7 @@ JNI_FUNCTION_DECLARATION(void,
JNIEnv* jni,
jclass,
jlong j_frame_ptr) {
delete reinterpret_cast<const webrtc::VideoFrame*>(j_frame_ptr);
delete reinterpret_cast<const VideoFrame*>(j_frame_ptr);
}
JNI_FUNCTION_DECLARATION(jlong,
@ -194,4 +194,5 @@ JNI_FUNCTION_DECLARATION(void,
}
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

15
webrtc/sdk/android/src/jni/videodecoderfactorywrapper.cc
View File

@ -15,7 +15,8 @@
#include "webrtc/rtc_base/logging.h"
#include "webrtc/sdk/android/src/jni/videodecoderwrapper.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
VideoDecoderFactoryWrapper::VideoDecoderFactoryWrapper(JNIEnv* jni,
jobject decoder_factory)
@ -26,20 +27,20 @@ VideoDecoderFactoryWrapper::VideoDecoderFactoryWrapper(JNIEnv* jni,
"(Ljava/lang/String;)Lorg/webrtc/VideoDecoder;");
}
webrtc::VideoDecoder* VideoDecoderFactoryWrapper::CreateVideoDecoder(
webrtc::VideoCodecType type) {
VideoDecoder* VideoDecoderFactoryWrapper::CreateVideoDecoder(
VideoCodecType type) {
JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni);
const char* type_payload = webrtc::CodecTypeToPayloadString(type);
const char* type_payload = CodecTypeToPayloadString(type);
jstring name = jni->NewStringUTF(type_payload);
jobject decoder =
jni->CallObjectMethod(*decoder_factory_, create_decoder_method_, name);
return decoder != nullptr ? new VideoDecoderWrapper(jni, decoder) : nullptr;
}
void VideoDecoderFactoryWrapper::DestroyVideoDecoder(
webrtc::VideoDecoder* decoder) {
void VideoDecoderFactoryWrapper::DestroyVideoDecoder(VideoDecoder* decoder) {
delete decoder;
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

11
webrtc/sdk/android/src/jni/videodecoderfactorywrapper.h
View File

@ -16,7 +16,8 @@
#include "webrtc/media/engine/webrtcvideodecoderfactory.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Wrapper for Java VideoDecoderFactory class. Delegates method calls through
// JNI and wraps the decoder inside VideoDecoderWrapper.
@ -26,15 +27,15 @@ class VideoDecoderFactoryWrapper : public cricket::WebRtcVideoDecoderFactory {
// Caller takes the ownership of the returned object and it should be released
// by calling DestroyVideoDecoder().
webrtc::VideoDecoder* CreateVideoDecoder(
webrtc::VideoCodecType type) override;
void DestroyVideoDecoder(webrtc::VideoDecoder* decoder) override;
VideoDecoder* CreateVideoDecoder(VideoCodecType type) override;
void DestroyVideoDecoder(VideoDecoder* decoder) override;
private:
const ScopedGlobalRef<jobject> decoder_factory_;
jmethodID create_decoder_method_;
};
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_VIDEODECODERFACTORYWRAPPER_H_

43
webrtc/sdk/android/src/jni/videodecoderwrapper.cc
View File

@ -17,7 +17,8 @@
#include "webrtc/rtc_base/logging.h"
#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
VideoDecoderWrapper::VideoDecoderWrapper(JNIEnv* jni, jobject decoder)
: android_video_buffer_factory_(jni),
@ -76,9 +77,8 @@ VideoDecoderWrapper::VideoDecoderWrapper(JNIEnv* jni, jobject decoder)
qp_parsing_enabled_ = true;
}
int32_t VideoDecoderWrapper::InitDecode(
const webrtc::VideoCodec* codec_settings,
int32_t number_of_cores) {
int32_t VideoDecoderWrapper::InitDecode(const VideoCodec* codec_settings,
int32_t number_of_cores) {
JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni);
@ -113,10 +113,10 @@ int32_t VideoDecoderWrapper::InitDecodeInternal(JNIEnv* jni) {
}
int32_t VideoDecoderWrapper::Decode(
const webrtc::EncodedImage& input_image,
const EncodedImage& input_image,
bool missing_frames,
const webrtc::RTPFragmentationHeader* fragmentation,
const webrtc::CodecSpecificInfo* codec_specific_info,
const RTPFragmentationHeader* fragmentation,
const CodecSpecificInfo* codec_specific_info,
int64_t render_time_ms) {
if (!initialized_) {
// Most likely initializing the codec failed.
@ -141,7 +141,7 @@ int32_t VideoDecoderWrapper::Decode(
}
int32_t VideoDecoderWrapper::RegisterDecodeCompleteCallback(
webrtc::DecodedImageCallback* callback) {
DecodedImageCallback* callback) {
callback_ = callback;
return WEBRTC_VIDEO_CODEC_OK;
}
@ -188,7 +188,7 @@ void VideoDecoderWrapper::OnDecodedFrame(JNIEnv* jni,
// find a matching timestamp.
} while (frame_extra_info.capture_time_ms != capture_time_ms);
webrtc::VideoFrame frame = android_video_buffer_factory_.CreateFrame(
VideoFrame frame = android_video_buffer_factory_.CreateFrame(
jni, jframe, frame_extra_info.timestamp_rtp);
rtc::Optional<int32_t> decoding_time_ms;
@ -214,17 +214,17 @@ void VideoDecoderWrapper::OnDecodedFrame(JNIEnv* jni,
jobject VideoDecoderWrapper::ConvertEncodedImageToJavaEncodedImage(
JNIEnv* jni,
const webrtc::EncodedImage& image) {
const EncodedImage& image) {
jobject buffer = jni->NewDirectByteBuffer(image._buffer, image._length);
jfieldID frame_type_field;
switch (image._frameType) {
case webrtc::kEmptyFrame:
case kEmptyFrame:
frame_type_field = empty_frame_field_;
break;
case webrtc::kVideoFrameKey:
case kVideoFrameKey:
frame_type_field = video_frame_key_field_;
break;
case webrtc::kVideoFrameDelta:
case kVideoFrameDelta:
frame_type_field = video_frame_delta_field_;
break;
default:
@ -261,30 +261,28 @@ int32_t VideoDecoderWrapper::HandleReturnCode(JNIEnv* jni, jobject code) {
}
rtc::Optional<uint8_t> VideoDecoderWrapper::ParseQP(
const webrtc::EncodedImage& input_image) {
const EncodedImage& input_image) {
if (input_image.qp_ != -1) {
return rtc::Optional<uint8_t>(input_image.qp_);
}
rtc::Optional<uint8_t> qp;
switch (codec_settings_.codecType) {
case webrtc::kVideoCodecVP8: {
case kVideoCodecVP8: {
int qp_int;
if (webrtc::vp8::GetQp(input_image._buffer, input_image._length,
&qp_int)) {
if (vp8::GetQp(input_image._buffer, input_image._length, &qp_int)) {
qp = rtc::Optional<uint8_t>(qp_int);
}
break;
}
case webrtc::kVideoCodecVP9: {
case kVideoCodecVP9: {
int qp_int;
if (webrtc::vp9::GetQp(input_image._buffer, input_image._length,
&qp_int)) {
if (vp9::GetQp(input_image._buffer, input_image._length, &qp_int)) {
qp = rtc::Optional<uint8_t>(qp_int);
}
break;
}
case webrtc::kVideoCodecH264: {
case kVideoCodecH264: {
h264_bitstream_parser_.ParseBitstream(input_image._buffer,
input_image._length);
int qp_int;
@ -312,4 +310,5 @@ JNI_FUNCTION_DECLARATION(void,
native_decoder->OnDecodedFrame(jni, jframe, jdecode_time_ms, jqp);
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

31
webrtc/sdk/android/src/jni/videodecoderwrapper.h
View File

@ -19,26 +19,27 @@
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
#include "webrtc/sdk/android/src/jni/native_handle_impl.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// Wraps a Java decoder and delegates all calls to it. Passes
// VideoDecoderWrapperCallback to the decoder on InitDecode. Wraps the received
// frames to AndroidVideoBuffer.
class VideoDecoderWrapper : public webrtc::VideoDecoder {
class VideoDecoderWrapper : public VideoDecoder {
public:
VideoDecoderWrapper(JNIEnv* jni, jobject decoder);
int32_t InitDecode(const webrtc::VideoCodec* codec_settings,
int32_t InitDecode(const VideoCodec* codec_settings,
int32_t number_of_cores) override;
int32_t Decode(const webrtc::EncodedImage& input_image,
int32_t Decode(const EncodedImage& input_image,
bool missing_frames,
const webrtc::RTPFragmentationHeader* fragmentation,
const webrtc::CodecSpecificInfo* codec_specific_info,
const RTPFragmentationHeader* fragmentation,
const CodecSpecificInfo* codec_specific_info,
int64_t render_time_ms) override;
int32_t RegisterDecodeCompleteCallback(
webrtc::DecodedImageCallback* callback) override;
DecodedImageCallback* callback) override;
int32_t Release() override;
@ -69,18 +70,18 @@ class VideoDecoderWrapper : public webrtc::VideoDecoder {
// status code.
int32_t HandleReturnCode(JNIEnv* jni, jobject code);
rtc::Optional<uint8_t> ParseQP(const webrtc::EncodedImage& input_image);
rtc::Optional<uint8_t> ParseQP(const EncodedImage& input_image);
webrtc::VideoCodec codec_settings_;
VideoCodec codec_settings_;
int32_t number_of_cores_;
bool initialized_;
AndroidVideoBufferFactory android_video_buffer_factory_;
std::deque<FrameExtraInfo> frame_extra_infos_;
bool qp_parsing_enabled_;
webrtc::H264BitstreamParser h264_bitstream_parser_;
H264BitstreamParser h264_bitstream_parser_;
webrtc::DecodedImageCallback* callback_;
DecodedImageCallback* callback_;
const ScopedGlobalRef<jobject> decoder_;
const ScopedGlobalRef<jclass> encoded_image_class_;
@ -110,11 +111,11 @@ class VideoDecoderWrapper : public webrtc::VideoDecoder {
jmethodID integer_constructor_;
jmethodID int_value_method_;
jobject ConvertEncodedImageToJavaEncodedImage(
JNIEnv* jni,
const webrtc::EncodedImage& image);
jobject ConvertEncodedImageToJavaEncodedImage(JNIEnv* jni,
const EncodedImage& image);
};
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_VIDEODECODERWRAPPER_H_

6
webrtc/sdk/android/src/jni/videofilerenderer_jni.cc
View File

@ -14,7 +14,8 @@
#include "webrtc/rtc_base/checks.h"
#include "webrtc/rtc_base/logging.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
extern "C" JNIEXPORT void JNICALL
Java_org_webrtc_VideoFileRenderer_nativeI420Scale(JNIEnv* jni,
@ -82,4 +83,5 @@ Java_org_webrtc_VideoFileRenderer_nativeFreeNativeByteBuffer(
::operator delete(data);
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

6
webrtc/sdk/android/src/jni/videoframe_jni.cc
View File

@ -14,7 +14,8 @@
#include "webrtc/rtc_base/checks.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
extern "C" JNIEXPORT void JNICALL
Java_org_webrtc_VideoFrame_nativeCropAndScaleI420(JNIEnv* jni,
@ -59,4 +60,5 @@ Java_org_webrtc_VideoFrame_nativeCropAndScaleI420(JNIEnv* jni,
RTC_DCHECK_EQ(ret, 0) << "I420Scale failed";
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

27
webrtc/sdk/android/src/jni/videotrack_jni.cc
View File

@ -16,17 +16,18 @@
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
#include "webrtc/sdk/android/src/jni/native_handle_impl.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
namespace {
class VideoSinkWrapper : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
class VideoSinkWrapper : public rtc::VideoSinkInterface<VideoFrame> {
public:
VideoSinkWrapper(JNIEnv* jni, jobject j_sink);
~VideoSinkWrapper() override {}
private:
void OnFrame(const webrtc::VideoFrame& frame) override;
void OnFrame(const VideoFrame& frame) override;
jmethodID j_on_frame_method_;
@ -41,7 +42,7 @@ VideoSinkWrapper::VideoSinkWrapper(JNIEnv* jni, jobject j_sink)
"(Lorg/webrtc/VideoFrame;)V");
}
void VideoSinkWrapper::OnFrame(const webrtc::VideoFrame& frame) {
void VideoSinkWrapper::OnFrame(const VideoFrame& frame) {
JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni);
jni->CallVoidMethod(*j_sink_, j_on_frame_method_,
@ -55,10 +56,9 @@ Java_org_webrtc_VideoTrack_nativeAddSink(JNIEnv* jni,
jclass,
jlong j_native_track,
jlong j_native_sink) {
reinterpret_cast<webrtc::VideoTrackInterface*>(j_native_track)
reinterpret_cast<VideoTrackInterface*>(j_native_track)
->AddOrUpdateSink(
reinterpret_cast<rtc::VideoSinkInterface<webrtc::VideoFrame>*>(
j_native_sink),
reinterpret_cast<rtc::VideoSinkInterface<VideoFrame>*>(j_native_sink),
rtc::VideoSinkWants());
}
@ -67,10 +67,9 @@ Java_org_webrtc_VideoTrack_nativeRemoveSink(JNIEnv* jni,
jclass,
jlong j_native_track,
jlong j_native_sink) {
reinterpret_cast<webrtc::VideoTrackInterface*>(j_native_track)
->RemoveSink(
reinterpret_cast<rtc::VideoSinkInterface<webrtc::VideoFrame>*>(
j_native_sink));
reinterpret_cast<VideoTrackInterface*>(j_native_track)
->RemoveSink(reinterpret_cast<rtc::VideoSinkInterface<VideoFrame>*>(
j_native_sink));
}
extern "C" JNIEXPORT jlong JNICALL
@ -82,8 +81,8 @@ extern "C" JNIEXPORT void JNICALL
Java_org_webrtc_VideoTrack_nativeFreeSink(JNIEnv* jni,
jclass,
jlong j_native_sink) {
delete reinterpret_cast<rtc::VideoSinkInterface<webrtc::VideoFrame>*>(
j_native_sink);
delete reinterpret_cast<rtc::VideoSinkInterface<VideoFrame>*>(j_native_sink);
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

8
webrtc/sdk/android/src/jni/wrapped_native_i420_buffer.cc
View File

@ -13,12 +13,13 @@
#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// TODO(magjed): Write a test for this function.
jobject WrapI420Buffer(
JNIEnv* jni,
const rtc::scoped_refptr<webrtc::I420BufferInterface>& i420_buffer) {
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 =
@ -46,4 +47,5 @@ jobject WrapI420Buffer(
return j_wrapped_native_i420_buffer;
}
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc

8
webrtc/sdk/android/src/jni/wrapped_native_i420_buffer.h
View File

@ -15,14 +15,16 @@
#include "webrtc/api/video/video_frame_buffer.h"
namespace webrtc_jni {
namespace webrtc {
namespace jni {
// This function wraps the C++ I420 buffer and returns a Java
// VideoFrame.I420Buffer as a jobject.
jobject WrapI420Buffer(
JNIEnv* jni,
const rtc::scoped_refptr<webrtc::I420BufferInterface>& i420_buffer);
const rtc::scoped_refptr<I420BufferInterface>& i420_buffer);
} // namespace webrtc_jni
} // namespace jni
} // namespace webrtc
#endif // WEBRTC_SDK_ANDROID_SRC_JNI_WRAPPED_NATIVE_I420_BUFFER_H_