diff --git a/webrtc/examples/unityplugin/classreferenceholder.cc b/webrtc/examples/unityplugin/classreferenceholder.cc index 88146997fe..b009ce4734 100644 --- a/webrtc/examples/unityplugin/classreferenceholder.cc +++ b/webrtc/examples/unityplugin/classreferenceholder.cc @@ -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; } diff --git a/webrtc/examples/unityplugin/classreferenceholder.h b/webrtc/examples/unityplugin/classreferenceholder.h index a3f83e8a23..7d9a71bbb4 100644 --- a/webrtc/examples/unityplugin/classreferenceholder.h +++ b/webrtc/examples/unityplugin/classreferenceholder.h @@ -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. diff --git a/webrtc/examples/unityplugin/jni_onload.cc b/webrtc/examples/unityplugin/jni_onload.cc index b8b4adf367..558dcfbf92 100644 --- a/webrtc/examples/unityplugin/jni_onload.cc +++ b/webrtc/examples/unityplugin/jni_onload.cc @@ -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 diff --git a/webrtc/examples/unityplugin/simple_peer_connection.cc b/webrtc/examples/unityplugin/simple_peer_connection.cc index 57ab885c29..3f3f3fbc58 100644 --- a/webrtc/examples/unityplugin/simple_peer_connection.cc +++ b/webrtc/examples/unityplugin/simple_peer_connection.cc @@ -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 source( - new rtc::RefCountedObject( + rtc::scoped_refptr source( + new rtc::RefCountedObject( g_signaling_thread.get(), env, texture_helper, false)); rtc::scoped_refptr 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 = diff --git a/webrtc/modules/video_coding/codecs/test/android_test_initializer.cc b/webrtc/modules/video_coding/codecs/test/android_test_initializer.cc index df1dd372d9..81942a1568 100644 --- a/webrtc/modules/video_coding/codecs/test/android_test_initializer.cc +++ b/webrtc/modules/video_coding/codecs/test/android_test_initializer.cc @@ -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 diff --git a/webrtc/modules/video_coding/codecs/test/videoprocessor_integrationtest.h b/webrtc/modules/video_coding/codecs/test/videoprocessor_integrationtest.h index f971a01c76..d84145fa46 100644 --- a/webrtc/modules/video_coding/codecs/test/videoprocessor_integrationtest.h +++ b/webrtc/modules/video_coding/codecs/test/videoprocessor_integrationtest.h @@ -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."; diff --git a/webrtc/sdk/android/src/jni/androidhistogram_jni.cc b/webrtc/sdk/android/src/jni/androidhistogram_jni.cc index c94cc4297d..c21b346ba6 100644 --- a/webrtc/sdk/android/src/jni/androidhistogram_jni.cc +++ b/webrtc/sdk/android/src/jni/androidhistogram_jni.cc @@ -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(histogram), - sample); + HistogramAdd(reinterpret_cast(histogram), sample); } } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/androidmediacodeccommon.h b/webrtc/sdk/android/src/jni/androidmediacodeccommon.h index 9aa97a06bb..08224ee029 100644 --- a/webrtc/sdk/android/src/jni/androidmediacodeccommon.h +++ b/webrtc/sdk/android/src/jni/androidmediacodeccommon.h @@ -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_ diff --git a/webrtc/sdk/android/src/jni/androidmediadecoder_jni.cc b/webrtc/sdk/android/src/jni/androidmediadecoder_jni.cc index 3e9f80fd42..dec35ec94e 100644 --- a/webrtc/sdk/android/src/jni/androidmediadecoder_jni.cc +++ b/webrtc/sdk/android/src/jni/androidmediadecoder_jni.cc @@ -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 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> 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 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(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 frame_buffer; + rtc::scoped_refptr 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 i420_buffer = + rtc::scoped_refptr 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 diff --git a/webrtc/sdk/android/src/jni/androidmediadecoder_jni.h b/webrtc/sdk/android/src/jni/androidmediadecoder_jni.h index be536fae56..b971647c6c 100644 --- a/webrtc/sdk/android/src/jni/androidmediadecoder_jni.h +++ b/webrtc/sdk/android/src/jni/androidmediadecoder_jni.h @@ -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 supported_codec_types_; + std::vector supported_codec_types_; }; -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc #endif // WEBRTC_SDK_ANDROID_SRC_JNI_ANDROIDMEDIADECODER_JNI_H_ diff --git a/webrtc/sdk/android/src/jni/androidmediaencoder_jni.cc b/webrtc/sdk/android/src/jni/androidmediaencoder_jni.cc index a8ff7530fc..7c40dac53d 100644 --- a/webrtc/sdk/android/src/jni/androidmediaencoder_jni.cc +++ b/webrtc/sdk/android/src/jni/androidmediaencoder_jni.cc @@ -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* frame_types) override; + int32_t Encode(const VideoFrame& input_image, + const CodecSpecificInfo* /* codec_specific_info */, + const std::vector* 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 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 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() & 0x7FFF; tl0_pic_idx_ = random.Rand(); } -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 profile_level_id = - webrtc::H264::ParseSdpProfileLevelId(codec_.params); + const rtc::Optional 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* frame_types) { + const VideoFrame& frame, + const CodecSpecificInfo* /* codec_specific_info */, + const std::vector* 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 input_buffer( - frame.video_frame_buffer()); + rtc::scoped_refptr 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 i420_buffer = + rtc::scoped_refptr 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 image( - new webrtc::EncodedImage(payload, payload_size, payload_size)); + std::unique_ptr 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 nalu_idxs = - webrtc::H264::FindNaluIndices(payload, payload_size); + const std::vector 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& 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 diff --git a/webrtc/sdk/android/src/jni/androidmediaencoder_jni.h b/webrtc/sdk/android/src/jni/androidmediaencoder_jni.h index 08f5502c86..4b3be4e598 100644 --- a/webrtc/sdk/android/src/jni/androidmediaencoder_jni.h +++ b/webrtc/sdk/android/src/jni/androidmediaencoder_jni.h @@ -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& 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 supported_codecs_with_h264_hp_; }; -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc #endif // WEBRTC_SDK_ANDROID_SRC_JNI_ANDROIDMEDIAENCODER_JNI_H_ diff --git a/webrtc/sdk/android/src/jni/androidmetrics_jni.cc b/webrtc/sdk/android/src/jni/androidmetrics_jni.cc index b0e5deb370..a4eb33b363 100644 --- a/webrtc/sdk/android/src/jni/androidmetrics_jni.cc +++ b/webrtc/sdk/android/src/jni/androidmetrics_jni.cc @@ -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, "", "()V")); - std::map> - histograms; - webrtc::metrics::GetAndReset(&histograms); + std::map> 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 diff --git a/webrtc/sdk/android/src/jni/androidvideotracksource.cc b/webrtc/sdk/android/src/jni/androidvideotracksource.cc index 0444b1d9d7..4c4e87e7b4 100644 --- a/webrtc/sdk/android/src/jni/androidvideotracksource.cc +++ b/webrtc/sdk/android/src/jni/androidvideotracksource.cc @@ -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( - jni, - j_surface_texture_helper)), + surface_texture_helper_(new rtc::RefCountedObject( + 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(width), crop_height / static_cast(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 diff --git a/webrtc/sdk/android/src/jni/androidvideotracksource.h b/webrtc/sdk/android/src/jni/androidvideotracksource.h index 92bc71b24a..3608d02747 100644 --- a/webrtc/sdk/android/src/jni/androidvideotracksource.h +++ b/webrtc/sdk/android/src/jni/androidvideotracksource.h @@ -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 - surface_texture_helper() { + rtc::scoped_refptr 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 surface_texture_helper_; - webrtc_jni::AndroidVideoBufferFactory video_buffer_factory_; + rtc::scoped_refptr 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_ diff --git a/webrtc/sdk/android/src/jni/androidvideotracksource_jni.cc b/webrtc/sdk/android/src/jni/androidvideotracksource_jni.cc index dfad301ff5..fc9f3b2bff 100644 --- a/webrtc/sdk/android/src/jni/androidvideotracksource_jni.cc +++ b/webrtc/sdk/android/src/jni/androidvideotracksource_jni.cc @@ -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(rotation); + return static_cast(rotation); } -namespace webrtc_jni { +} // namespace -static webrtc::AndroidVideoTrackSource* AndroidVideoTrackSourceFromJavaProxy( +namespace jni { + +static AndroidVideoTrackSource* AndroidVideoTrackSourceFromJavaProxy( jlong j_proxy) { - auto proxy_source = reinterpret_cast(j_proxy); - return reinterpret_cast( - proxy_source->internal()); + auto proxy_source = reinterpret_cast(j_proxy); + return reinterpret_cast(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 diff --git a/webrtc/sdk/android/src/jni/classreferenceholder.cc b/webrtc/sdk/android/src/jni/classreferenceholder.cc index 5b309d08d3..c79f936ff5 100644 --- a/webrtc/sdk/android/src/jni/classreferenceholder.cc +++ b/webrtc/sdk/android/src/jni/classreferenceholder.cc @@ -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 diff --git a/webrtc/sdk/android/src/jni/classreferenceholder.h b/webrtc/sdk/android/src/jni/classreferenceholder.h index 0d4ccc44a8..646725ac39 100644 --- a/webrtc/sdk/android/src/jni/classreferenceholder.h +++ b/webrtc/sdk/android/src/jni/classreferenceholder.h @@ -20,7 +20,8 @@ #include #include -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_ diff --git a/webrtc/sdk/android/src/jni/filevideocapturer_jni.cc b/webrtc/sdk/android/src/jni/filevideocapturer_jni.cc index 69d62bcbbc..059dbeffc6 100644 --- a/webrtc/sdk/android/src/jni/filevideocapturer_jni.cc +++ b/webrtc/sdk/android/src/jni/filevideocapturer_jni.cc @@ -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 diff --git a/webrtc/sdk/android/src/jni/jni_helpers.cc b/webrtc/sdk/android/src/jni/jni_helpers.cc index 6e2360811d..bb9bbf4703 100644 --- a/webrtc/sdk/android/src/jni/jni_helpers.cc +++ b/webrtc/sdk/android/src/jni/jni_helpers.cc @@ -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 diff --git a/webrtc/sdk/android/src/jni/jni_helpers.h b/webrtc/sdk/android/src/jni/jni_helpers.h index 7400d3218a..618c8f6240 100644 --- a/webrtc/sdk/android/src/jni/jni_helpers.h +++ b/webrtc/sdk/android/src/jni/jni_helpers.h @@ -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_ diff --git a/webrtc/sdk/android/src/jni/jni_onload.cc b/webrtc/sdk/android/src/jni/jni_onload.cc index ce71920331..8794c12658 100644 --- a/webrtc/sdk/android/src/jni/jni_onload.cc +++ b/webrtc/sdk/android/src/jni/jni_onload.cc @@ -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 diff --git a/webrtc/sdk/android/src/jni/native_handle_impl.cc b/webrtc/sdk/android/src/jni/native_handle_impl.cc index 3be618570d..910235cf07 100644 --- a/webrtc/sdk/android/src/jni/native_handle_impl.cc +++ b/webrtc/sdk/android/src/jni/native_handle_impl.cc @@ -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 AndroidTextureBuffer::ToI420() { +rtc::scoped_refptr 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 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 yuv_data( - static_cast(webrtc::AlignedMalloc(size, kBufferAlignment))); + std::unique_ptr yuv_data( + static_cast(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 copy = webrtc::WrapI420Buffer( + rtc::scoped_refptr 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 AndroidVideoBuffer::ToI420() { +rtc::scoped_refptr 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, "", "(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 buffer = CreateBuffer(jni, j_video_frame_buffer); - return webrtc::VideoFrame(buffer, timestamp_rtp, - timestamp_ns / rtc::kNumNanosecsPerMillisec, - static_cast(rotation)); + return VideoFrame(buffer, timestamp_rtp, + timestamp_ns / rtc::kNumNanosecsPerMillisec, + static_cast(rotation)); } rtc::scoped_refptr AndroidVideoBufferFactory::WrapBuffer( @@ -475,9 +476,8 @@ JavaVideoFrameFactory::JavaVideoFrameFactory(JNIEnv* jni) "(Lorg/webrtc/VideoFrame$Buffer;IJ)V"); } -static bool IsJavaVideoBuffer( - rtc::scoped_refptr buffer) { - if (buffer->type() != webrtc::VideoFrameBuffer::Type::kNative) { +static bool IsJavaVideoBuffer(rtc::scoped_refptr 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 buffer = - frame.video_frame_buffer(); +jobject JavaVideoFrameFactory::ToJavaFrame(JNIEnv* jni, + const VideoFrame& frame) const { + rtc::scoped_refptr 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(buffer.get()); RTC_DCHECK(android_buffer->android_type() == @@ -510,4 +508,5 @@ jobject JavaVideoFrameFactory::ToJavaFrame( static_cast(frame.timestamp_us() * rtc::kNumNanosecsPerMicrosec)); } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/native_handle_impl.h b/webrtc/sdk/android/src/jni/native_handle_impl.h index fc674db9d4..3ad1b6a0fa 100644 --- a/webrtc/sdk/android/src/jni/native_handle_impl.h +++ b/webrtc/sdk/android/src/jni/native_handle_impl.h @@ -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 ToI420() override; + rtc::scoped_refptr 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 ToI420() override; + rtc::scoped_refptr 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 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_ diff --git a/webrtc/sdk/android/src/jni/nv12buffer_jni.cc b/webrtc/sdk/android/src/jni/nv12buffer_jni.cc index e0aab9b8a3..37eb335785 100644 --- a/webrtc/sdk/android/src/jni/nv12buffer_jni.cc +++ b/webrtc/sdk/android/src/jni/nv12buffer_jni.cc @@ -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 diff --git a/webrtc/sdk/android/src/jni/nv21buffer_jni.cc b/webrtc/sdk/android/src/jni/nv21buffer_jni.cc index d013edcf3c..f8ab903f7b 100644 --- a/webrtc/sdk/android/src/jni/nv21buffer_jni.cc +++ b/webrtc/sdk/android/src/jni/nv21buffer_jni.cc @@ -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 diff --git a/webrtc/sdk/android/src/jni/pc/androidnetworkmonitor_jni.cc b/webrtc/sdk/android/src/jni/pc/androidnetworkmonitor_jni.cc index 6b27d840a2..c0f6bd5ce7 100644 --- a/webrtc/sdk/android/src/jni/pc/androidnetworkmonitor_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/androidnetworkmonitor_jni.cc @@ -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(network_handle)); } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/pc/androidnetworkmonitor_jni.h b/webrtc/sdk/android/src/jni/pc/androidnetworkmonitor_jni.h index 07c564765c..71f2528d76 100644 --- a/webrtc/sdk/android/src/jni/pc/androidnetworkmonitor_jni.h +++ b/webrtc/sdk/android/src/jni/pc/androidnetworkmonitor_jni.h @@ -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_ diff --git a/webrtc/sdk/android/src/jni/pc/audio_jni.cc b/webrtc/sdk/android/src/jni/pc/audio_jni.cc index e182e42e31..6bd7df5240 100644 --- a/webrtc/sdk/android/src/jni/pc/audio_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/audio_jni.cc @@ -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 CreateAudioDecoderFactory() { - return webrtc::CreateBuiltinAudioDecoderFactory(); +rtc::scoped_refptr CreateAudioDecoderFactory() { + return CreateBuiltinAudioDecoderFactory(); } -rtc::scoped_refptr CreateAudioEncoderFactory() { - return webrtc::CreateBuiltinAudioEncoderFactory(); +rtc::scoped_refptr CreateAudioEncoderFactory() { + return CreateBuiltinAudioEncoderFactory(); } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/pc/audio_jni.h b/webrtc/sdk/android/src/jni/pc/audio_jni.h index 22cd3ebece..477054ebde 100644 --- a/webrtc/sdk/android/src/jni/pc/audio_jni.h +++ b/webrtc/sdk/android/src/jni/pc/audio_jni.h @@ -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 CreateAudioDecoderFactory(); +rtc::scoped_refptr CreateAudioDecoderFactory(); -rtc::scoped_refptr CreateAudioEncoderFactory(); +rtc::scoped_refptr CreateAudioEncoderFactory(); -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc #endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_AUDIO_JNI_H_ diff --git a/webrtc/sdk/android/src/jni/pc/audiotrack_jni.cc b/webrtc/sdk/android/src/jni/pc/audiotrack_jni.cc index 84492e6609..99a272be8f 100644 --- a/webrtc/sdk/android/src/jni/pc/audiotrack_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/audiotrack_jni.cc @@ -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 source( - reinterpret_cast(j_p)->GetSource()); + rtc::scoped_refptr source( + reinterpret_cast(j_p)->GetSource()); source->SetVolume(volume); } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/pc/callsessionfilerotatinglogsink_jni.cc b/webrtc/sdk/android/src/jni/pc/callsessionfilerotatinglogsink_jni.cc index eeca185355..739dcaa031 100644 --- a/webrtc/sdk/android/src/jni/pc/callsessionfilerotatinglogsink_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/callsessionfilerotatinglogsink_jni.cc @@ -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 diff --git a/webrtc/sdk/android/src/jni/pc/datachannel_jni.cc b/webrtc/sdk/android/src/jni/pc/datachannel_jni.cc index 1a19bcef86..ba28f9bc00 100644 --- a/webrtc/sdk/android/src/jni/pc/datachannel_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/datachannel_jni.cc @@ -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(j_d); + return reinterpret_cast(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 diff --git a/webrtc/sdk/android/src/jni/pc/datachannelobserver_jni.cc b/webrtc/sdk/android/src/jni/pc/datachannelobserver_jni.cc index 971c300061..32bbab0138 100644 --- a/webrtc/sdk/android/src/jni/pc/datachannelobserver_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/datachannelobserver_jni.cc @@ -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(buffer.data.data()), 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 diff --git a/webrtc/sdk/android/src/jni/pc/datachannelobserver_jni.h b/webrtc/sdk/android/src/jni/pc/datachannelobserver_jni.h index 2b837a32fb..a9106a2838 100644 --- a/webrtc/sdk/android/src/jni/pc/datachannelobserver_jni.h +++ b/webrtc/sdk/android/src/jni/pc/datachannelobserver_jni.h @@ -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 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_ diff --git a/webrtc/sdk/android/src/jni/pc/dtmfsender_jni.cc b/webrtc/sdk/android/src/jni/pc/dtmfsender_jni.cc index fd1d195c08..20c0ea78f5 100644 --- a/webrtc/sdk/android/src/jni/pc/dtmfsender_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/dtmfsender_jni.cc @@ -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(j_dtmf_sender_pointer) + return reinterpret_cast(j_dtmf_sender_pointer) ->CanInsertDtmf(); } @@ -30,7 +31,7 @@ JNI_FUNCTION_DECLARATION(jboolean, jstring tones, jint duration, jint inter_tone_gap) { - return reinterpret_cast(j_dtmf_sender_pointer) + return reinterpret_cast(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(j_dtmf_sender_pointer) - ->tones()); + jni, + reinterpret_cast(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(j_dtmf_sender_pointer) + return reinterpret_cast(j_dtmf_sender_pointer) ->duration(); } @@ -58,8 +59,9 @@ JNI_FUNCTION_DECLARATION(jint, JNIEnv* jni, jclass, jlong j_dtmf_sender_pointer) { - return reinterpret_cast(j_dtmf_sender_pointer) + return reinterpret_cast(j_dtmf_sender_pointer) ->inter_tone_gap(); } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/pc/java_native_conversion.cc b/webrtc/sdk/android/src/jni/pc/java_native_conversion.cc index b9f2703196..43c1636548 100644 --- a/webrtc/sdk/android/src/jni/pc/java_native_conversion.cc +++ b/webrtc/sdk/android/src/jni/pc/java_native_conversion.cc @@ -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, "", "(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( 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( 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, "", "()V"); @@ -621,7 +621,7 @@ jobject NativeToJavaRtpParameters(JNIEnv* jni, jmethodID integer_ctor = GetMethodID(jni, integer_class, "", "(I)V"); jmethodID long_ctor = GetMethodID(jni, long_class, "", "(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 diff --git a/webrtc/sdk/android/src/jni/pc/java_native_conversion.h b/webrtc/sdk/android/src/jni/pc/java_native_conversion.h index 0e4e2c1eb4..dc91c135ae 100644 --- a/webrtc/sdk/android/src/jni/pc/java_native_conversion.h +++ b/webrtc/sdk/android/src/jni/pc/java_native_conversion.h @@ -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& 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_ diff --git a/webrtc/sdk/android/src/jni/pc/logging_jni.cc b/webrtc/sdk/android/src/jni/pc/logging_jni.cc index 020eeedeb6..e71670a10c 100644 --- a/webrtc/sdk/android/src/jni/pc/logging_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/logging_jni.cc @@ -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(j_severity), tag) << message; } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/pc/media_jni.cc b/webrtc/sdk/android/src/jni/pc/media_jni.cc index c636992f7d..8d8b6b9fdb 100644 --- a/webrtc/sdk/android/src/jni/pc/media_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/media_jni.cc @@ -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& - audio_encoder_factory, - const rtc::scoped_refptr& - audio_decoder_factory, + AudioDeviceModule* adm, + const rtc::scoped_refptr& audio_encoder_factory, + const rtc::scoped_refptr& audio_decoder_factory, cricket::WebRtcVideoEncoderFactory* video_encoder_factory, cricket::WebRtcVideoDecoderFactory* video_decoder_factory, - rtc::scoped_refptr audio_mixer) { + rtc::scoped_refptr 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 diff --git a/webrtc/sdk/android/src/jni/pc/media_jni.h b/webrtc/sdk/android/src/jni/pc/media_jni.h index e7d4816112..02c3a80a28 100644 --- a/webrtc/sdk/android/src/jni/pc/media_jni.h +++ b/webrtc/sdk/android/src/jni/pc/media_jni.h @@ -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& - audio_encoder_factory, - const rtc::scoped_refptr& - audio_decoder_factory, + AudioDeviceModule* adm, + const rtc::scoped_refptr& audio_encoder_factory, + const rtc::scoped_refptr& audio_decoder_factory, cricket::WebRtcVideoEncoderFactory* video_encoder_factory, cricket::WebRtcVideoDecoderFactory* video_decoder_factory, - rtc::scoped_refptr audio_mixer); + rtc::scoped_refptr audio_mixer); -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc #endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_MEDIA_JNI_H_ diff --git a/webrtc/sdk/android/src/jni/pc/mediaconstraints_jni.cc b/webrtc/sdk/android/src/jni/pc/mediaconstraints_jni.cc index 561ae426ad..f36401dd0e 100644 --- a/webrtc/sdk/android/src/jni/pc/mediaconstraints_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/mediaconstraints_jni.cc @@ -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 diff --git a/webrtc/sdk/android/src/jni/pc/mediaconstraints_jni.h b/webrtc/sdk/android/src/jni/pc/mediaconstraints_jni.h index e0bb3827d6..98282344e2 100644 --- a/webrtc/sdk/android/src/jni/pc/mediaconstraints_jni.h +++ b/webrtc/sdk/android/src/jni/pc/mediaconstraints_jni.h @@ -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_ diff --git a/webrtc/sdk/android/src/jni/pc/mediasource_jni.cc b/webrtc/sdk/android/src/jni/pc/mediasource_jni.cc index 0771b76fd0..6c3c230d1c 100644 --- a/webrtc/sdk/android/src/jni/pc/mediasource_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/mediasource_jni.cc @@ -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 p( - reinterpret_cast(j_p)); + rtc::scoped_refptr p( + reinterpret_cast(j_p)); return JavaEnumFromIndexAndClassName(jni, "MediaSource$State", p->state()); } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/pc/mediastream_jni.cc b/webrtc/sdk/android/src/jni/pc/mediastream_jni.cc index 7204de26ce..74dc2c5f41 100644 --- a/webrtc/sdk/android/src/jni/pc/mediastream_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/mediastream_jni.cc @@ -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(pointer)->AddTrack( - reinterpret_cast(j_audio_track_pointer)); + return reinterpret_cast(pointer)->AddTrack( + reinterpret_cast(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(pointer)->AddTrack( - reinterpret_cast(j_video_track_pointer)); + return reinterpret_cast(pointer)->AddTrack( + reinterpret_cast(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(pointer)->RemoveTrack( - reinterpret_cast(j_audio_track_pointer)); + return reinterpret_cast(pointer)->RemoveTrack( + reinterpret_cast(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(pointer)->RemoveTrack( - reinterpret_cast(j_video_track_pointer)); + return reinterpret_cast(pointer)->RemoveTrack( + reinterpret_cast(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(j_p)->label()); + jni, reinterpret_cast(j_p)->label()); } JNI_FUNCTION_DECLARATION(void, MediaStream_free, JNIEnv*, jclass, jlong j_p) { - CHECK_RELEASE(reinterpret_cast(j_p)); + CHECK_RELEASE(reinterpret_cast(j_p)); } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/pc/mediastreamtrack_jni.cc b/webrtc/sdk/android/src/jni/pc/mediastreamtrack_jni.cc index cae33fd6f2..e5af8659df 100644 --- a/webrtc/sdk/android/src/jni/pc/mediastreamtrack_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/mediastreamtrack_jni.cc @@ -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(j_p)->id()); + jni, reinterpret_cast(j_p)->id()); } JNI_FUNCTION_DECLARATION(jstring, @@ -28,7 +29,7 @@ JNI_FUNCTION_DECLARATION(jstring, jclass, jlong j_p) { return JavaStringFromStdString( - jni, reinterpret_cast(j_p)->kind()); + jni, reinterpret_cast(j_p)->kind()); } JNI_FUNCTION_DECLARATION(jboolean, @@ -36,7 +37,7 @@ JNI_FUNCTION_DECLARATION(jboolean, JNIEnv* jni, jclass, jlong j_p) { - return reinterpret_cast(j_p)->enabled(); + return reinterpret_cast(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(j_p)->state()); + reinterpret_cast(j_p)->state()); } JNI_FUNCTION_DECLARATION(jboolean, @@ -55,8 +56,9 @@ JNI_FUNCTION_DECLARATION(jboolean, jclass, jlong j_p, jboolean enabled) { - return reinterpret_cast(j_p)->set_enabled( + return reinterpret_cast(j_p)->set_enabled( enabled); } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/pc/null_audio_jni.cc b/webrtc/sdk/android/src/jni/pc/null_audio_jni.cc index 90d6cdfce1..85c97980cf 100644 --- a/webrtc/sdk/android/src/jni/pc/null_audio_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/null_audio_jni.cc @@ -10,14 +10,16 @@ #include "webrtc/sdk/android/src/jni/pc/audio_jni.h" -namespace webrtc_jni { +namespace webrtc { +namespace jni { -rtc::scoped_refptr CreateAudioDecoderFactory() { +rtc::scoped_refptr CreateAudioDecoderFactory() { return nullptr; } -rtc::scoped_refptr CreateAudioEncoderFactory() { +rtc::scoped_refptr CreateAudioEncoderFactory() { return nullptr; } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/pc/null_media_jni.cc b/webrtc/sdk/android/src/jni/pc/null_media_jni.cc index 43458ae7ad..2f2ff6d4af 100644 --- a/webrtc/sdk/android/src/jni/pc/null_media_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/null_media_jni.cc @@ -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& - audio_encoder_factory, - const rtc::scoped_refptr& - audio_decoder_factory, + AudioDeviceModule* adm, + const rtc::scoped_refptr& audio_encoder_factory, + const rtc::scoped_refptr& audio_decoder_factory, cricket::WebRtcVideoEncoderFactory* video_encoder_factory, cricket::WebRtcVideoDecoderFactory* video_decoder_factory, - rtc::scoped_refptr audio_mixer) { + rtc::scoped_refptr audio_mixer) { return nullptr; } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/pc/null_video_jni.cc b/webrtc/sdk/android/src/jni/pc/null_video_jni.cc index 49a77ec91a..b9bf8de92f 100644 --- a/webrtc/sdk/android/src/jni/pc/null_video_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/null_video_jni.cc @@ -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 diff --git a/webrtc/sdk/android/src/jni/pc/ownedfactoryandthreads.cc b/webrtc/sdk/android/src/jni/pc/ownedfactoryandthreads.cc index 41c2397372..062270cd99 100644 --- a/webrtc/sdk/android/src/jni/pc/ownedfactoryandthreads.cc +++ b/webrtc/sdk/android/src/jni/pc/ownedfactoryandthreads.cc @@ -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(j_p)->factory(); @@ -61,4 +62,5 @@ void OwnedFactoryAndThreads::InvokeJavaCallbacksOnFactoryThreads() { [this] { JavaCallbackOnFactoryThreads(); }); } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/pc/ownedfactoryandthreads.h b/webrtc/sdk/android/src/jni/pc/ownedfactoryandthreads.h index 408471ef64..ce69c121d5 100644 --- a/webrtc/sdk/android/src/jni/pc/ownedfactoryandthreads.h +++ b/webrtc/sdk/android/src/jni/pc/ownedfactoryandthreads.h @@ -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_ diff --git a/webrtc/sdk/android/src/jni/pc/peerconnection_jni.cc b/webrtc/sdk/android/src/jni/pc/peerconnection_jni.cc index dab518244b..1e83435acc 100644 --- a/webrtc/sdk/android/src/jni/pc/peerconnection_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/peerconnection_jni.cc @@ -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 ExtractNativePC( +static rtc::scoped_refptr 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( - reinterpret_cast(j_p)); + return rtc::scoped_refptr( + reinterpret_cast(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 channel( + DataChannelInit init = JavaToNativeDataChannelInit(jni, j_init); + rtc::scoped_refptr 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(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 candidate( - webrtc::CreateIceCandidate(sdp_mid, j_sdp_mline_index, sdp, nullptr)); + std::unique_ptr 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(native_stream)); + reinterpret_cast(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(native_stream)); + reinterpret_cast(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 sender = + rtc::scoped_refptr 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 observer( new rtc::RefCountedObject(jni, j_observer)); return ExtractNativePC(jni, j_pc)->GetStats( - observer, - reinterpret_cast(native_track), - webrtc::PeerConnectionInterface::kStatsOutputLevelStandard); + observer, reinterpret_cast(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 diff --git a/webrtc/sdk/android/src/jni/pc/peerconnectionfactory_jni.cc b/webrtc/sdk/android/src/jni/pc/peerconnectionfactory_jni.cc index 52df977653..e9e8020248 100644 --- a/webrtc/sdk/android/src/jni/pc/peerconnectionfactory_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/peerconnectionfactory_jni.cc @@ -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 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 audio_mixer = nullptr; - std::unique_ptr call_factory( - CreateCallFactory()); - std::unique_ptr rtc_event_log_factory( + AudioDeviceModule* adm = nullptr; + rtc::scoped_refptr audio_mixer = nullptr; + std::unique_ptr call_factory(CreateCallFactory()); + std::unique_ptr rtc_event_log_factory( CreateRtcEventLogFactory()); std::unique_ptr media_engine(CreateMediaEngine( adm, audio_encoder_factory, audio_decoder_factory, video_encoder_factory, video_decoder_factory, audio_mixer)); - rtc::scoped_refptr factory( + rtc::scoped_refptr 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(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 factory( + rtc::scoped_refptr factory( factoryFromJava(native_factory)); - rtc::scoped_refptr stream( + rtc::scoped_refptr stream( factory->CreateLocalMediaStream(JavaToStdString(jni, label))); return (jlong)stream.release(); } @@ -261,11 +261,11 @@ JNI_FUNCTION_DECLARATION(jlong, jobject j_constraints) { std::unique_ptr constraints( new MediaConstraintsJni(jni, j_constraints)); - rtc::scoped_refptr factory( + rtc::scoped_refptr factory( factoryFromJava(native_factory)); cricket::AudioOptions options; CopyConstraintsIntoAudioOptions(constraints.get(), &options); - rtc::scoped_refptr source( + rtc::scoped_refptr 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 factory( + rtc::scoped_refptr factory( factoryFromJava(native_factory)); - rtc::scoped_refptr track( - factory->CreateAudioTrack( - JavaToStdString(jni, id), - reinterpret_cast(native_source))); + rtc::scoped_refptr track(factory->CreateAudioTrack( + JavaToStdString(jni, id), + reinterpret_cast(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 factory( + rtc::scoped_refptr 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 factory( + rtc::scoped_refptr factory( factoryFromJava(native_factory)); factory->StopAecDump(); } @@ -314,9 +313,9 @@ JNI_FUNCTION_DECLARATION(void, jclass, jlong native_factory, jobject options) { - rtc::scoped_refptr factory( + rtc::scoped_refptr 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 f( - reinterpret_cast( + rtc::scoped_refptr f( + reinterpret_cast( 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(observer_p); observer->SetConstraints(new MediaConstraintsJni(jni, j_constraints)); CopyConstraintsIntoRtcConfiguration(observer->constraints(), &rtc_config); - rtc::scoped_refptr pc( + rtc::scoped_refptr pc( f->CreatePeerConnection(rtc_config, nullptr, nullptr, observer)); return (jlong)pc.release(); } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/pc/peerconnectionobserver_jni.cc b/webrtc/sdk/android/src/jni/pc/peerconnectionobserver_jni.cc index 1876792593..d65c95c2c5 100644 --- a/webrtc/sdk/android/src/jni/pc/peerconnectionobserver_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/peerconnectionobserver_jni.cc @@ -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 stream) { + rtc::scoped_refptr 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 stream) { + rtc::scoped_refptr 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 channel) { + rtc::scoped_refptr 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 receiver, - const std::vector>& - streams) { + rtc::scoped_refptr receiver, + const std::vector>& 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& stream) { + const rtc::scoped_refptr& 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>& - streams) { + const std::vector>& 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 diff --git a/webrtc/sdk/android/src/jni/pc/peerconnectionobserver_jni.h b/webrtc/sdk/android/src/jni/pc/peerconnectionobserver_jni.h index 2d9d749a6b..d543b35e15 100644 --- a/webrtc/sdk/android/src/jni/pc/peerconnectionobserver_jni.h +++ b/webrtc/sdk/android/src/jni/pc/peerconnectionobserver_jni.h @@ -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& 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 stream) override; - void OnRemoveStream( - rtc::scoped_refptr stream) override; - void OnDataChannel( - rtc::scoped_refptr channel) override; + PeerConnectionInterface::IceGatheringState new_state) override; + void OnAddStream(rtc::scoped_refptr stream) override; + void OnRemoveStream(rtc::scoped_refptr stream) override; + void OnDataChannel(rtc::scoped_refptr channel) override; void OnRenegotiationNeeded() override; - void OnAddTrack( - rtc::scoped_refptr receiver, - const std::vector>& - streams) override; + void OnAddTrack(rtc::scoped_refptr receiver, + const std::vector>& + streams) override; void SetConstraints(MediaConstraintsJni* constraints); const MediaConstraintsJni* constraints() { return constraints_.get(); } private: - typedef std::map - NativeToJavaStreamsMap; - typedef std::map - NativeToJavaRtpReceiverMap; + typedef std::map NativeToJavaStreamsMap; + typedef std::map 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& stream); + const rtc::scoped_refptr& stream); // Converts array of streams, creating or re-using Java streams as necessary. jobjectArray NativeToJavaMediaStreamArray( JNIEnv* jni, - const std::vector>& - streams); + const std::vector>& streams); const ScopedGlobalRef j_observer_global_; const ScopedGlobalRef j_observer_class_; @@ -95,6 +89,7 @@ class PeerConnectionObserverJni : public webrtc::PeerConnectionObserver { std::unique_ptr constraints_; }; -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc #endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_PEERCONNECTIONOBSERVER_JNI_H_ diff --git a/webrtc/sdk/android/src/jni/pc/rtcstatscollectorcallbackwrapper.cc b/webrtc/sdk/android/src/jni/pc/rtcstatscollectorcallbackwrapper.cc index 6da9580490..5be96f575b 100644 --- a/webrtc/sdk/android/src/jni/pc/rtcstatscollectorcallbackwrapper.cc +++ b/webrtc/sdk/android/src/jni/pc/rtcstatscollectorcallbackwrapper.cc @@ -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& report) { + const rtc::scoped_refptr& 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& report) { + const rtc::scoped_refptr& 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>()); + case RTCStatsMemberInterface::kBool: { + jobject value = jni->NewObject(j_boolean_class_, j_boolean_ctor_, + *member->cast_to>()); 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>()); + *member->cast_to>()); 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>()); - 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>()); + (jlong)*member->cast_to>()); 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>()); + 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>()); + *member->cast_to>()); CHECK_EXCEPTION(jni) << "error during NewObject"; return value; } - case webrtc::RTCStatsMemberInterface::kString: { + case RTCStatsMemberInterface::kString: { return JavaStringFromStdString( - jni, *member->cast_to>()); + jni, *member->cast_to>()); } - case webrtc::RTCStatsMemberInterface::kSequenceBool: { + case RTCStatsMemberInterface::kSequenceBool: { const std::vector& values = - *member->cast_to>>(); + *member->cast_to>>(); 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& values = - *member->cast_to>>(); + *member->cast_to>>(); 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& values = - *member->cast_to>>(); + *member->cast_to>>(); 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& values = - *member->cast_to>>(); + *member->cast_to>>(); 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& values = - *member->cast_to>>(); + *member->cast_to>>(); 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& values = - *member->cast_to>>(); + *member->cast_to>>(); 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& values = - *member->cast_to>>(); + *member->cast_to>>(); 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 diff --git a/webrtc/sdk/android/src/jni/pc/rtcstatscollectorcallbackwrapper.h b/webrtc/sdk/android/src/jni/pc/rtcstatscollectorcallbackwrapper.h index 8feb19a83e..57270745e1 100644 --- a/webrtc/sdk/android/src/jni/pc/rtcstatscollectorcallbackwrapper.h +++ b/webrtc/sdk/android/src/jni/pc/rtcstatscollectorcallbackwrapper.h @@ -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& report) override; + const rtc::scoped_refptr& report) override; private: // Helper functions for converting C++ RTCStatsReport to Java equivalent. - jobject ReportToJava( - JNIEnv* jni, - const rtc::scoped_refptr& 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& report); + jobject StatsToJava(JNIEnv* jni, const RTCStats& stats); + jobject MemberToJava(JNIEnv* jni, const RTCStatsMemberInterface* member); const ScopedGlobalRef j_callback_global_; const ScopedGlobalRef 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_ diff --git a/webrtc/sdk/android/src/jni/pc/rtpreceiver_jni.cc b/webrtc/sdk/android/src/jni/pc/rtpreceiver_jni.cc index 4c92e5e52e..2a4ed951c9 100644 --- a/webrtc/sdk/android/src/jni/pc/rtpreceiver_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/rtpreceiver_jni.cc @@ -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(j_rtp_receiver_pointer) + reinterpret_cast(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, ¶meters); - return reinterpret_cast(j_rtp_receiver_pointer) + return reinterpret_cast(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(j_rtp_receiver_pointer) + RtpParameters parameters = + reinterpret_cast(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(j_rtp_receiver_pointer) - ->id()); + reinterpret_cast(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(j_rtp_receiver_pointer) + reinterpret_cast(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(j_rtp_receiver_pointer) + reinterpret_cast(j_rtp_receiver_pointer) ->SetObserver(nullptr); RtpReceiverObserverJni* observer = reinterpret_cast(j_observer_pointer); @@ -92,4 +92,5 @@ JNI_FUNCTION_DECLARATION(void, } } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/pc/rtpreceiverobserver_jni.cc b/webrtc/sdk/android/src/jni/pc/rtpreceiverobserver_jni.cc index 5a94c5b52d..89a348f4c1 100644 --- a/webrtc/sdk/android/src/jni/pc/rtpreceiverobserver_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/rtpreceiverobserver_jni.cc @@ -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 diff --git a/webrtc/sdk/android/src/jni/pc/rtpreceiverobserver_jni.h b/webrtc/sdk/android/src/jni/pc/rtpreceiverobserver_jni.h index eada47bf17..ef58f9728f 100644 --- a/webrtc/sdk/android/src/jni/pc/rtpreceiverobserver_jni.h +++ b/webrtc/sdk/android/src/jni/pc/rtpreceiverobserver_jni.h @@ -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 j_observer_global_; }; -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc #endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_RTPRECEIVEROBSERVER_JNI_H_ diff --git a/webrtc/sdk/android/src/jni/pc/rtpsender_jni.cc b/webrtc/sdk/android/src/jni/pc/rtpsender_jni.cc index dd13f736c3..8cd1dcc7fe 100644 --- a/webrtc/sdk/android/src/jni/pc/rtpsender_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/rtpsender_jni.cc @@ -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(j_rtp_sender_pointer) - ->SetTrack(reinterpret_cast( - j_track_pointer)); + return reinterpret_cast(j_rtp_sender_pointer) + ->SetTrack(reinterpret_cast(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(j_rtp_sender_pointer) + reinterpret_cast(j_rtp_sender_pointer) ->track() .release()); } @@ -42,7 +42,7 @@ JNI_FUNCTION_DECLARATION(jlong, jclass, jlong j_rtp_sender_pointer) { return jlongFromPointer( - reinterpret_cast(j_rtp_sender_pointer) + reinterpret_cast(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, ¶meters); - return reinterpret_cast(j_rtp_sender_pointer) + return reinterpret_cast(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(j_rtp_sender_pointer) + RtpParameters parameters = + reinterpret_cast(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(j_rtp_sender_pointer) - ->id()); + jni, reinterpret_cast(j_rtp_sender_pointer)->id()); } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/pc/sdpobserver_jni.h b/webrtc/sdk/android/src/jni/pc/sdpobserver_jni.h index 0113954065..14b9575e5f 100644 --- a/webrtc/sdk/android/src/jni/pc/sdpobserver_jni.h +++ b/webrtc/sdk/android/src/jni/pc/sdpobserver_jni.h @@ -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 { + : public SdpObserverJni { public: CreateSdpObserverJni(JNIEnv* jni, jobject j_observer, @@ -89,8 +90,7 @@ class CreateSdpObserverJni } }; -class SetSdpObserverJni - : public SdpObserverJni { +class SetSdpObserverJni : public SdpObserverJni { 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_ diff --git a/webrtc/sdk/android/src/jni/pc/statsobserver_jni.cc b/webrtc/sdk/android/src/jni/pc/statsobserver_jni.cc index aeb4a44ef2..f72d1ae901 100644 --- a/webrtc/sdk/android/src/jni/pc/statsobserver_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/statsobserver_jni.cc @@ -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) "", "(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 diff --git a/webrtc/sdk/android/src/jni/pc/statsobserver_jni.h b/webrtc/sdk/android/src/jni/pc/statsobserver_jni.h index bfdd499017..15430407ea 100644 --- a/webrtc/sdk/android/src/jni/pc/statsobserver_jni.h +++ b/webrtc/sdk/android/src/jni/pc/statsobserver_jni.h @@ -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 j_observer_global_; const ScopedGlobalRef 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_ diff --git a/webrtc/sdk/android/src/jni/pc/video_jni.cc b/webrtc/sdk/android/src/jni/pc/video_jni.cc index 5362c28e7e..4712d4f6ab 100644 --- a/webrtc/sdk/android/src/jni/pc/video_jni.cc +++ b/webrtc/sdk/android/src/jni/pc/video_jni.cc @@ -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(native_factory); - rtc::scoped_refptr source( - new rtc::RefCountedObject( + rtc::scoped_refptr source( + new rtc::RefCountedObject( factory->signaling_thread(), jni, j_surface_texture_helper, is_screencast)); - rtc::scoped_refptr proxy_source = - webrtc::VideoTrackSourceProxy::Create(factory->signaling_thread(), - factory->worker_thread(), source); + rtc::scoped_refptr 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 factory( factoryFromJava(native_factory)); - rtc::scoped_refptr track( - factory->CreateVideoTrack( - JavaToStdString(jni, id), - reinterpret_cast(native_source))); + rtc::scoped_refptr track(factory->CreateVideoTrack( + JavaToStdString(jni, id), + reinterpret_cast(native_source))); return (jlong)track.release(); } @@ -126,4 +126,5 @@ JNI_FUNCTION_DECLARATION( } } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/pc/video_jni.h b/webrtc/sdk/android/src/jni/pc/video_jni.h index 81125de7bd..016ce0a11a 100644 --- a/webrtc/sdk/android/src/jni/pc/video_jni.h +++ b/webrtc/sdk/android/src/jni/pc/video_jni.h @@ -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& surface_texture_helper); -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc #endif // WEBRTC_SDK_ANDROID_SRC_JNI_PC_VIDEO_JNI_H_ diff --git a/webrtc/sdk/android/src/jni/surfacetexturehelper_jni.cc b/webrtc/sdk/android/src/jni/surfacetexturehelper_jni.cc index 2576f1d33e..cfc2904b16 100644 --- a/webrtc/sdk/android/src/jni/surfacetexturehelper_jni.cc +++ b/webrtc/sdk/android/src/jni/surfacetexturehelper_jni.cc @@ -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::create( JNIEnv* jni, @@ -71,12 +72,14 @@ void SurfaceTextureHelper::ReturnTextureFrame() const { jni) << "error during SurfaceTextureHelper.returnTextureFrame"; } -rtc::scoped_refptr -SurfaceTextureHelper::CreateTextureFrame(int width, int height, +rtc::scoped_refptr SurfaceTextureHelper::CreateTextureFrame( + int width, + int height, const NativeHandleImpl& native_handle) { return new rtc::RefCountedObject( width, height, native_handle, *j_surface_texture_helper_, rtc::Bind(&SurfaceTextureHelper::ReturnTextureFrame, this)); } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/surfacetexturehelper_jni.h b/webrtc/sdk/android/src/jni/surfacetexturehelper_jni.h index 084aa33884..82e36cfb5f 100644 --- a/webrtc/sdk/android/src/jni/surfacetexturehelper_jni.h +++ b/webrtc/sdk/android/src/jni/surfacetexturehelper_jni.h @@ -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 CreateTextureFrame( + rtc::scoped_refptr 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_ diff --git a/webrtc/sdk/android/src/jni/video_renderer_jni.cc b/webrtc/sdk/android/src/jni/video_renderer_jni.cc index 7156fceee8..07244bc6a8 100644 --- a/webrtc/sdk/android/src/jni/video_renderer_jni.cc +++ b/webrtc/sdk/android/src/jni/video_renderer_jni.cc @@ -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 { +class JavaVideoRendererWrapper : public rtc::VideoSinkInterface { 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( 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 i420_buffer = + rtc::scoped_refptr 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(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(j_frame_ptr); + delete reinterpret_cast(j_frame_ptr); } JNI_FUNCTION_DECLARATION(jlong, @@ -194,4 +194,5 @@ JNI_FUNCTION_DECLARATION(void, } } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/videodecoderfactorywrapper.cc b/webrtc/sdk/android/src/jni/videodecoderfactorywrapper.cc index 4e825ada10..dba8fe2b5b 100644 --- a/webrtc/sdk/android/src/jni/videodecoderfactorywrapper.cc +++ b/webrtc/sdk/android/src/jni/videodecoderfactorywrapper.cc @@ -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 diff --git a/webrtc/sdk/android/src/jni/videodecoderfactorywrapper.h b/webrtc/sdk/android/src/jni/videodecoderfactorywrapper.h index 0e98a9550d..43c86cbd29 100644 --- a/webrtc/sdk/android/src/jni/videodecoderfactorywrapper.h +++ b/webrtc/sdk/android/src/jni/videodecoderfactorywrapper.h @@ -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 decoder_factory_; jmethodID create_decoder_method_; }; -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc #endif // WEBRTC_SDK_ANDROID_SRC_JNI_VIDEODECODERFACTORYWRAPPER_H_ diff --git a/webrtc/sdk/android/src/jni/videodecoderwrapper.cc b/webrtc/sdk/android/src/jni/videodecoderwrapper.cc index 3a64febabd..536e8746d2 100644 --- a/webrtc/sdk/android/src/jni/videodecoderwrapper.cc +++ b/webrtc/sdk/android/src/jni/videodecoderwrapper.cc @@ -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 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 VideoDecoderWrapper::ParseQP( - const webrtc::EncodedImage& input_image) { + const EncodedImage& input_image) { if (input_image.qp_ != -1) { return rtc::Optional(input_image.qp_); } rtc::Optional 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(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(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 diff --git a/webrtc/sdk/android/src/jni/videodecoderwrapper.h b/webrtc/sdk/android/src/jni/videodecoderwrapper.h index 828884d739..19cf92fb98 100644 --- a/webrtc/sdk/android/src/jni/videodecoderwrapper.h +++ b/webrtc/sdk/android/src/jni/videodecoderwrapper.h @@ -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 ParseQP(const webrtc::EncodedImage& input_image); + rtc::Optional 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 frame_extra_infos_; bool qp_parsing_enabled_; - webrtc::H264BitstreamParser h264_bitstream_parser_; + H264BitstreamParser h264_bitstream_parser_; - webrtc::DecodedImageCallback* callback_; + DecodedImageCallback* callback_; const ScopedGlobalRef decoder_; const ScopedGlobalRef 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_ diff --git a/webrtc/sdk/android/src/jni/videofilerenderer_jni.cc b/webrtc/sdk/android/src/jni/videofilerenderer_jni.cc index 42c59916d1..638994da24 100644 --- a/webrtc/sdk/android/src/jni/videofilerenderer_jni.cc +++ b/webrtc/sdk/android/src/jni/videofilerenderer_jni.cc @@ -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 diff --git a/webrtc/sdk/android/src/jni/videoframe_jni.cc b/webrtc/sdk/android/src/jni/videoframe_jni.cc index d761fb954b..f6ba46fb3d 100644 --- a/webrtc/sdk/android/src/jni/videoframe_jni.cc +++ b/webrtc/sdk/android/src/jni/videoframe_jni.cc @@ -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 diff --git a/webrtc/sdk/android/src/jni/videotrack_jni.cc b/webrtc/sdk/android/src/jni/videotrack_jni.cc index 9368acffbd..ed22c54e45 100644 --- a/webrtc/sdk/android/src/jni/videotrack_jni.cc +++ b/webrtc/sdk/android/src/jni/videotrack_jni.cc @@ -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 { +class VideoSinkWrapper : public rtc::VideoSinkInterface { 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(j_native_track) + reinterpret_cast(j_native_track) ->AddOrUpdateSink( - reinterpret_cast*>( - j_native_sink), + reinterpret_cast*>(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(j_native_track) - ->RemoveSink( - reinterpret_cast*>( - j_native_sink)); + reinterpret_cast(j_native_track) + ->RemoveSink(reinterpret_cast*>( + 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*>( - j_native_sink); + delete reinterpret_cast*>(j_native_sink); } -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc diff --git a/webrtc/sdk/android/src/jni/wrapped_native_i420_buffer.cc b/webrtc/sdk/android/src/jni/wrapped_native_i420_buffer.cc index 6a819e4a26..1f26a83091 100644 --- a/webrtc/sdk/android/src/jni/wrapped_native_i420_buffer.cc +++ b/webrtc/sdk/android/src/jni/wrapped_native_i420_buffer.cc @@ -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& i420_buffer) { + const rtc::scoped_refptr& 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 diff --git a/webrtc/sdk/android/src/jni/wrapped_native_i420_buffer.h b/webrtc/sdk/android/src/jni/wrapped_native_i420_buffer.h index 3eaedd6b05..024287799e 100644 --- a/webrtc/sdk/android/src/jni/wrapped_native_i420_buffer.h +++ b/webrtc/sdk/android/src/jni/wrapped_native_i420_buffer.h @@ -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& i420_buffer); + const rtc::scoped_refptr& i420_buffer); -} // namespace webrtc_jni +} // namespace jni +} // namespace webrtc #endif // WEBRTC_SDK_ANDROID_SRC_JNI_WRAPPED_NATIVE_I420_BUFFER_H_