Build WebRTC with data channel only.

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

 /*
  *  Copyright 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 102 matching lines @@
 using webrtc::StatsObserver;
 using webrtc::StatsReport;
 using webrtc::StatsReports;
 using webrtc::VideoTrackSourceInterface;
 using webrtc::VideoTrackInterface;
 using webrtc::VideoTrackVector;
 using webrtc::kVideoCodecVP8;
 
 namespace webrtc_jni {
 
+WebRtcVideoEncoderFactory* CreateVideoEncoderFactory();
+
+WebRtcVideoDecoderFactory* CreateVideoDecoderFactory();
+
+rtc::scoped_refptr<webrtc::AndroidVideoTrackSource>
+CreateAndroidVideoTrackSource(rtc::Thread* signaling_thread,
+                              JNIEnv* jni,
+                              jobject j_egl_context,
+                              bool is_screencast = false);
+
+jobject GetSurfaceTextureHelper(
+    rtc::scoped_refptr<SurfaceTextureHelper> surface_texture_helper);
+
+void EncoderFactorySetEGLContext(MediaCodecVideoEncoderFactory* encoder_factory,
+                                 JNIEnv* jni,
+                                 jobject local_egl_context);
+
+void DecoderFactorySetEGLContext(MediaCodecVideoDecoderFactory* decoder_factory,
+                                 JNIEnv* jni,
+                                 jobject remote_egl_context);
+
 // Field trials initialization string
 static char *field_trials_init_string = NULL;
 
 // Set in PeerConnectionFactory_initializeAndroidGlobals().
 static bool factory_static_initialized = false;
 static bool video_hw_acceleration_enabled = true;
 static jobject j_application_context = nullptr;
 
 // Return the (singleton) Java Enum object corresponding to |index|;
 // |state_class_fragment| is something like "MediaSource$State".
@@ skipping 704 matching lines @@
   }
 
   const ScopedGlobalRef<jobject> j_observer_global_;
   const ScopedGlobalRef<jclass> j_observer_class_;
   const ScopedGlobalRef<jclass> j_stats_report_class_;
   const jmethodID j_stats_report_ctor_;
   const ScopedGlobalRef<jclass> j_value_class_;
   const jmethodID j_value_ctor_;
 };
 
-// Wrapper dispatching rtc::VideoSinkInterface to a Java VideoRenderer
-// instance.
-class JavaVideoRendererWrapper
-    : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
- public:
-  JavaVideoRendererWrapper(JNIEnv* jni, jobject j_callbacks)
-      : j_callbacks_(jni, j_callbacks),
-        j_render_frame_id_(GetMethodID(
-            jni, GetObjectClass(jni, j_callbacks), "renderFrame",
-            "(Lorg/webrtc/VideoRenderer$I420Frame;)V")),
-        j_frame_class_(jni,
-                       FindClass(jni, "org/webrtc/VideoRenderer$I420Frame")),
-        j_i420_frame_ctor_id_(GetMethodID(
-            jni, *j_frame_class_, "<init>", "(III[I[Ljava/nio/ByteBuffer;J)V")),
-        j_texture_frame_ctor_id_(GetMethodID(
-            jni, *j_frame_class_, "<init>",
-            "(IIII[FJ)V")),
-        j_byte_buffer_class_(jni, FindClass(jni, "java/nio/ByteBuffer")) {
-    CHECK_EXCEPTION(jni);
-  }
-
-  virtual ~JavaVideoRendererWrapper() {}
-
-  void OnFrame(const webrtc::VideoFrame& video_frame) override {
-    ScopedLocalRefFrame local_ref_frame(jni());
-    jobject j_frame =
-        (video_frame.video_frame_buffer()->native_handle() != nullptr)
-            ? CricketToJavaTextureFrame(&video_frame)
-            : CricketToJavaI420Frame(&video_frame);
-    // |j_callbacks_| is responsible for releasing |j_frame| with
-    // VideoRenderer.renderFrameDone().
-    jni()->CallVoidMethod(*j_callbacks_, j_render_frame_id_, j_frame);
-    CHECK_EXCEPTION(jni());
-  }
-
- private:
-  // Make a shallow copy of |frame| to be used with Java. The callee has
-  // ownership of the frame, and the frame should be released with
-  // VideoRenderer.releaseNativeFrame().
-  static jlong javaShallowCopy(const webrtc::VideoFrame* frame) {
-    return jlongFromPointer(new webrtc::VideoFrame(*frame));
-  }
-
-  // Return a VideoRenderer.I420Frame referring to the data in |frame|.
-  jobject CricketToJavaI420Frame(const webrtc::VideoFrame* frame) {
-    jintArray strides = jni()->NewIntArray(3);
-    jint* strides_array = jni()->GetIntArrayElements(strides, NULL);
-    strides_array[0] = frame->video_frame_buffer()->StrideY();
-    strides_array[1] = frame->video_frame_buffer()->StrideU();
-    strides_array[2] = frame->video_frame_buffer()->StrideV();
-    jni()->ReleaseIntArrayElements(strides, strides_array, 0);
-    jobjectArray planes = jni()->NewObjectArray(3, *j_byte_buffer_class_, NULL);
-    jobject y_buffer = jni()->NewDirectByteBuffer(
-        const_cast<uint8_t*>(frame->video_frame_buffer()->DataY()),
-        frame->video_frame_buffer()->StrideY() *
-            frame->video_frame_buffer()->height());
-    size_t chroma_height = (frame->height() + 1) / 2;
-    jobject u_buffer = jni()->NewDirectByteBuffer(
-        const_cast<uint8_t*>(frame->video_frame_buffer()->DataU()),
-        frame->video_frame_buffer()->StrideU() * chroma_height);
-    jobject v_buffer = jni()->NewDirectByteBuffer(
-        const_cast<uint8_t*>(frame->video_frame_buffer()->DataV()),
-        frame->video_frame_buffer()->StrideV() * chroma_height);
-
-    jni()->SetObjectArrayElement(planes, 0, y_buffer);
-    jni()->SetObjectArrayElement(planes, 1, u_buffer);
-    jni()->SetObjectArrayElement(planes, 2, v_buffer);
-    return jni()->NewObject(
-        *j_frame_class_, j_i420_frame_ctor_id_,
-        frame->width(), frame->height(),
-        static_cast<int>(frame->rotation()),
-        strides, planes, javaShallowCopy(frame));
-  }
-
-  // Return a VideoRenderer.I420Frame referring texture object in |frame|.
-  jobject CricketToJavaTextureFrame(const webrtc::VideoFrame* frame) {
-    NativeHandleImpl* handle = reinterpret_cast<NativeHandleImpl*>(
-        frame->video_frame_buffer()->native_handle());
-    jfloatArray sampling_matrix = handle->sampling_matrix.ToJava(jni());
-
-    return jni()->NewObject(
-        *j_frame_class_, j_texture_frame_ctor_id_,
-        frame->width(), frame->height(),
-        static_cast<int>(frame->rotation()),
-        handle->oes_texture_id, sampling_matrix, javaShallowCopy(frame));
-  }
-
-  JNIEnv* jni() {
-    return AttachCurrentThreadIfNeeded();
-  }
-
-  ScopedGlobalRef<jobject> j_callbacks_;
-  jmethodID j_render_frame_id_;
-  ScopedGlobalRef<jclass> j_frame_class_;
-  jmethodID j_i420_frame_ctor_id_;
-  jmethodID j_texture_frame_ctor_id_;
-  ScopedGlobalRef<jclass> j_byte_buffer_class_;
-};
-
 // 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 RtpReceiverObserver : public RtpReceiverObserverInterface {
  public:
   RtpReceiverObserver(JNIEnv* jni, jobject j_observer)
       : j_observer_global_(jni, j_observer) {}
 
   ~RtpReceiverObserver() override {}
 
@@ skipping 122 matching lines @@
 
 JOW(void, PeerConnection_freeObserver)(JNIEnv*, jclass, jlong j_p) {
   PCOJava* p = reinterpret_cast<PCOJava*>(j_p);
   delete p;
 }
 
 JOW(void, MediaSource_free)(JNIEnv*, jclass, jlong j_p) {
   reinterpret_cast<rtc::RefCountInterface*>(j_p)->Release();
 }
 
-JOW(void, VideoRenderer_freeWrappedVideoRenderer)(JNIEnv*, jclass, jlong j_p) {
-  delete reinterpret_cast<JavaVideoRendererWrapper*>(j_p);
-}
-
-JOW(void, VideoRenderer_releaseNativeFrame)(
-    JNIEnv* jni, jclass, jlong j_frame_ptr) {
-  delete reinterpret_cast<const webrtc::VideoFrame*>(j_frame_ptr);
-}
-
 JOW(void, MediaStreamTrack_free)(JNIEnv*, jclass, jlong j_p) {
   reinterpret_cast<MediaStreamTrackInterface*>(j_p)->Release();
 }
 
 JOW(jboolean, MediaStream_nativeAddAudioTrack)(
     JNIEnv* jni, jclass, jlong pointer, jlong j_audio_track_pointer) {
   return reinterpret_cast<MediaStreamInterface*>(pointer)->AddTrack(
       reinterpret_cast<AudioTrackInterface*>(j_audio_track_pointer));
 }
 
@@ skipping 240 matching lines @@
   WebRtcVideoDecoderFactory* decoder_factory = nullptr;
   rtc::NetworkMonitorFactory* network_monitor_factory = nullptr;
 
   PeerConnectionFactoryInterface::Options options;
   bool has_options = joptions != NULL;
   if (has_options) {
     options = ParseOptionsFromJava(jni, joptions);
   }
 
   if (video_hw_acceleration_enabled) {
-    encoder_factory = new MediaCodecVideoEncoderFactory();
-    decoder_factory = new MediaCodecVideoDecoderFactory();
+    encoder_factory = CreateVideoEncoderFactory();
+    decoder_factory = CreateVideoDecoderFactory();
   }
   // Do not create network_monitor_factory only if the options are
   // provided and disable_network_monitor therein is set to true.
   if (!(has_options && options.disable_network_monitor)) {
     network_monitor_factory = new AndroidNetworkMonitorFactory();
     rtc::NetworkMonitorFactory::SetFactory(network_monitor_factory);
   }
 
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       webrtc::CreatePeerConnectionFactory(
@@ skipping 43 matching lines @@
       factory->CreateLocalMediaStream(JavaToStdString(jni, label)));
   return (jlong)stream.release();
 }
 
 JOW(jlong, PeerConnectionFactory_nativeCreateVideoSource)
 (JNIEnv* jni, jclass, jlong native_factory, jobject j_egl_context,
     jboolean is_screencast) {
   OwnedFactoryAndThreads* factory =
       reinterpret_cast<OwnedFactoryAndThreads*>(native_factory);
 
-  rtc::scoped_refptr<webrtc::AndroidVideoTrackSource> source(
-      new rtc::RefCountedObject<webrtc::AndroidVideoTrackSource>(
-          factory->signaling_thread(), jni, j_egl_context, is_screencast));
+  rtc::scoped_refptr<webrtc::AndroidVideoTrackSource> source =
+      CreateAndroidVideoTrackSource(factory->signaling_thread(), jni,
+                                    j_egl_context, is_screencast);
+  if (!source) {
+    return (jlong)0;
+  }
   rtc::scoped_refptr<webrtc::VideoTrackSourceProxy> proxy_source =
       webrtc::VideoTrackSourceProxy::Create(factory->signaling_thread(),
                                             factory->worker_thread(), source);
 
   return (jlong)proxy_source.release();
 }
 
 JOW(void, PeerConnectionFactory_nativeInitializeVideoCapturer)
 (JNIEnv* jni,
  jclass,
  jlong native_factory,
  jobject j_video_capturer,
  jlong native_source,
  jobject j_frame_observer) {
   LOG(LS_INFO) << "PeerConnectionFactory_nativeInitializeVideoCapturer";
+
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
+
   auto proxy_source =
       reinterpret_cast<webrtc::VideoTrackSourceProxy*>(native_source);
   auto source = reinterpret_cast<webrtc::AndroidVideoTrackSource*>(
       proxy_source->internal());
+  if (!source) {
+    LOG(LS_WARNING) << "The AndroidVideoTrackSource is unset.";
+    return;
+  }
+
   rtc::scoped_refptr<SurfaceTextureHelper> surface_texture_helper =
       source->surface_texture_helper();
   jni->CallVoidMethod(
       j_video_capturer,
       GetMethodID(jni, FindClass(jni, "org/webrtc/VideoCapturer"), "initialize",
                   "(Lorg/webrtc/SurfaceTextureHelper;Landroid/content/"
                   "Context;Lorg/webrtc/VideoCapturer$CapturerObserver;)V"),
-      surface_texture_helper
-          ? surface_texture_helper->GetJavaSurfaceTextureHelper()
-          : nullptr,
-      j_application_context, j_frame_observer);
+      GetSurfaceTextureHelper(surface_texture_helper), j_application_context,
+      j_frame_observer);
   CHECK_EXCEPTION(jni) << "error during VideoCapturer.initialize()";
 }
 
 JOW(jlong, PeerConnectionFactory_nativeCreateVideoTrack)(
     JNIEnv* jni, jclass, jlong native_factory, jstring id,
     jlong native_source) {
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   rtc::scoped_refptr<VideoTrackInterface> track(factory->CreateVideoTrack(
       JavaToStdString(jni, id),
@@ skipping 67 matching lines @@
 
   jclass j_eglbase14_context_class =
       FindClass(jni, "org/webrtc/EglBase14$Context");
 
   MediaCodecVideoEncoderFactory* encoder_factory =
       static_cast<MediaCodecVideoEncoderFactory*>
           (owned_factory->encoder_factory());
   if (encoder_factory &&
       jni->IsInstanceOf(local_egl_context, j_eglbase14_context_class)) {
     LOG(LS_INFO) << "Set EGL context for HW encoding.";
-    encoder_factory->SetEGLContext(jni, local_egl_context);
+    EncoderFactorySetEGLContext(encoder_factory, jni, local_egl_context);
   }
 
   MediaCodecVideoDecoderFactory* decoder_factory =
       static_cast<MediaCodecVideoDecoderFactory*>
           (owned_factory->decoder_factory());
   if (decoder_factory) {
     LOG(LS_INFO) << "Set EGL context for HW decoding.";
-    decoder_factory->SetEGLContext(jni, remote_egl_context);
+    DecoderFactorySetEGLContext(decoder_factory, jni, remote_egl_context);
   }
 }
 
 static PeerConnectionInterface::IceTransportsType
 JavaIceTransportsTypeToNativeType(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")
@@ skipping 614 matching lines @@
   ExtractNativePC(jni, j_pc)->Close();
   return;
 }
 
 JOW(jobject, MediaSource_nativeState)(JNIEnv* jni, jclass, jlong j_p) {
   rtc::scoped_refptr<MediaSourceInterface> p(
       reinterpret_cast<MediaSourceInterface*>(j_p));
   return JavaEnumFromIndex(jni, "MediaSource$State", p->state());
 }
 
-JOW(jlong, VideoRenderer_nativeWrapVideoRenderer)(
-    JNIEnv* jni, jclass, jobject j_callbacks) {
-  std::unique_ptr<JavaVideoRendererWrapper> renderer(
-      new JavaVideoRendererWrapper(jni, j_callbacks));
-  return (jlong)renderer.release();
-}
-
-JOW(void, VideoRenderer_nativeCopyPlane)(
-    JNIEnv *jni, jclass, jobject j_src_buffer, jint width, jint height,
-    jint src_stride, jobject j_dst_buffer, jint dst_stride) {
-  size_t src_size = jni->GetDirectBufferCapacity(j_src_buffer);
-  size_t dst_size = jni->GetDirectBufferCapacity(j_dst_buffer);
-  RTC_CHECK(src_stride >= width) << "Wrong source stride " << src_stride;
-  RTC_CHECK(dst_stride >= width) << "Wrong destination stride " << dst_stride;
-  RTC_CHECK(src_size >= src_stride * height)
-      << "Insufficient source buffer capacity " << src_size;
-  RTC_CHECK(dst_size >= dst_stride * height)
-      << "Insufficient destination buffer capacity " << dst_size;
-  uint8_t *src =
-      reinterpret_cast<uint8_t*>(jni->GetDirectBufferAddress(j_src_buffer));
-  uint8_t *dst =
-      reinterpret_cast<uint8_t*>(jni->GetDirectBufferAddress(j_dst_buffer));
-  if (src_stride == dst_stride) {
-    memcpy(dst, src, src_stride * height);
-  } else {
-    for (int i = 0; i < height; i++) {
-      memcpy(dst, src, width);
-      src += src_stride;
-      dst += dst_stride;
-    }
-  }
-}
-
 JOW(void, FileVideoCapturer_nativeI420ToNV21)(
     JNIEnv *jni, jclass, jbyteArray j_src_buffer, jint width, jint height,
     jbyteArray j_dst_buffer) {
   size_t src_size = jni->GetArrayLength(j_src_buffer);
   size_t dst_size = jni->GetArrayLength(j_dst_buffer);
   int src_stride = width;
   int dst_stride = width;
   RTC_CHECK_GE(src_size, src_stride * height * 3 / 2);
   RTC_CHECK_GE(dst_size, dst_stride * height * 3 / 2);
 
@@ skipping 511 matching lines @@
   return reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer)
       ->inter_tone_gap();
 }
 
 JOW(void, DtmfSender_free)
 (JNIEnv* jni, jclass, jlong j_dtmf_sender_pointer) {
   reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer)->Release();
 }
 
 }  // namespace webrtc_jni