AndroidVideoTrackSource implementation

webrtc/api/android/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 26 matching lines @@
 
 #include <jni.h>
 #undef JNIEXPORT
 #define JNIEXPORT __attribute__((visibility("default")))
 
 #include <limits>
 #include <memory>
 #include <utility>
 
 #include "webrtc/api/androidvideocapturer.h"
+#include "webrtc/api/androidvideotracksource.h"
 #include "webrtc/api/android/jni/androidmediadecoder_jni.h"
 #include "webrtc/api/android/jni/androidmediaencoder_jni.h"
 #include "webrtc/api/android/jni/androidnetworkmonitor_jni.h"
 #include "webrtc/api/android/jni/androidvideocapturer_jni.h"
 #include "webrtc/api/android/jni/classreferenceholder.h"
 #include "webrtc/api/android/jni/jni_helpers.h"
 #include "webrtc/api/android/jni/native_handle_impl.h"
 #include "webrtc/api/mediaconstraintsinterface.h"
 #include "webrtc/api/peerconnectioninterface.h"
 #include "webrtc/api/rtpreceiverinterface.h"
 #include "webrtc/api/rtpsenderinterface.h"
+#include "webrtc/api/videosourceproxy.h"
 #include "webrtc/api/webrtcsdp.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/event_tracer.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/logsinks.h"
 #include "webrtc/base/messagequeue.h"
 #include "webrtc/base/networkmonitor.h"
 #include "webrtc/base/rtccertificategenerator.h"
 #include "webrtc/base/ssladapter.h"
@@ skipping 41 matching lines @@
 using webrtc::kVideoCodecVP8;
 
 namespace webrtc_jni {
 
 // 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".
 static jobject JavaEnumFromIndex(
     JNIEnv* jni, const std::string& state_class_fragment, int index) {
   const std::string state_class = "org/webrtc/" + state_class_fragment;
   return JavaEnumFromIndex(jni, FindClass(jni, state_class.c_str()),
                            state_class, index);
 }
 
@@ skipping 795 matching lines @@
 JOW(void, PeerConnection_freePeerConnection)(JNIEnv*, jclass, jlong j_p) {
   CHECK_RELEASE(reinterpret_cast<PeerConnectionInterface*>(j_p));
 }
 
 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) {
-  CHECK_RELEASE(reinterpret_cast<MediaSourceInterface*>(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 cricket::VideoFrame*>(j_frame_ptr);
 }
@@ skipping 33 matching lines @@
 
 JOW(void, MediaStream_free)(JNIEnv*, jclass, jlong j_p) {
   CHECK_RELEASE(reinterpret_cast<MediaStreamInterface*>(j_p));
 }
 
 JOW(jlong, PeerConnectionFactory_nativeCreateObserver)(
     JNIEnv * jni, jclass, jobject j_observer) {
   return (jlong)new PCOJava(jni, j_observer);
 }
 
-JOW(jboolean, PeerConnectionFactory_initializeAndroidGlobals)(
-    JNIEnv* jni, jclass, jobject context,
-    jboolean initialize_audio, jboolean initialize_video,
-    jboolean video_hw_acceleration) {
+JOW(jboolean, PeerConnectionFactory_initializeAndroidGlobals)
+(JNIEnv* jni,
+ jclass,
+ jobject context,
+ jboolean initialize_audio,
+ jboolean initialize_video,
+ jboolean video_hw_acceleration) {
   bool failure = false;
   video_hw_acceleration_enabled = video_hw_acceleration;
   AndroidNetworkMonitor::SetAndroidContext(jni, context);
   if (!factory_static_initialized) {
+    RTC_DCHECK(j_application_context == nullptr);
+    j_application_context = NewGlobalRef(jni, context);
+
     if (initialize_video) {
       failure |= AndroidVideoCapturerJni::SetAndroidObjects(jni, context);
     }
     if (initialize_audio)
       failure |= webrtc::VoiceEngine::SetAndroidObjects(GetJVM(), context);
     factory_static_initialized = true;
   }
   return !failure;
 }
 
@@ skipping 62 matching lines @@
         factory_(factory) {}
 
   ~OwnedFactoryAndThreads() {
     CHECK_RELEASE(factory_);
     if (network_monitor_factory_ != nullptr) {
       rtc::NetworkMonitorFactory::ReleaseFactory(network_monitor_factory_);
     }
   }
 
   PeerConnectionFactoryInterface* factory() { return factory_; }
+  Thread* signaling_thread() { return signaling_thread_.get(); }
+  Thread* worker_thread() { return worker_thread_.get(); }
   WebRtcVideoEncoderFactory* encoder_factory() { return encoder_factory_; }
   WebRtcVideoDecoderFactory* decoder_factory() { return decoder_factory_; }
   rtc::NetworkMonitorFactory* network_monitor_factory() {
     return network_monitor_factory_;
   }
   void clear_network_monitor_factory() { network_monitor_factory_ = nullptr; }
   void InvokeJavaCallbacksOnFactoryThreads();
 
  private:
   void JavaCallbackOnFactoryThreads();
@@ skipping 175 matching lines @@
   // native factory and constraints.
   std::unique_ptr<ConstraintsWrapper> constraints(
       new ConstraintsWrapper(jni, j_constraints));
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   rtc::scoped_refptr<VideoTrackSourceInterface> source(
       factory->CreateVideoSource(capturer.release(), constraints.get()));
   return (jlong)source.release();
 }
 
+JOW(jlong, PeerConnectionFactory_nativeCreateVideoSource2)
+(JNIEnv* jni, jclass, jlong native_factory, jobject j_egl_context) {
+  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));
+  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());
+  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);
+  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),
       reinterpret_cast<VideoTrackSourceInterface*>(native_source)));
   return (jlong)track.release();
 }
@@ skipping 1008 matching lines @@
   return JavaStringFromStdString(
       jni,
       reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)->id());
 }
 
 JOW(void, RtpReceiver_free)(JNIEnv* jni, jclass, jlong j_rtp_receiver_pointer) {
   reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)->Release();
 }
 
 }  // namespace webrtc_jni