WebRTC Unity Plugin Rebase

examples/unityplugin/simple_peer_connection.cc

 /*
  *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 56 matching lines @@
   virtual void OnSuccess() { LOG(INFO) << __FUNCTION__; }
   virtual void OnFailure(const std::string& error) {
     LOG(INFO) << __FUNCTION__ << " " << error;
   }
 
  protected:
   DummySetSessionDescriptionObserver() {}
   ~DummySetSessionDescriptionObserver() {}
 };
 
+class DummyCapturer : public cricket::VideoCapturer {
+ public:
+  cricket::CaptureState Start(
+      const cricket::VideoFormat& capture_format) override {
+    return cricket::CS_RUNNING;
+  }
+  void Stop() override {}
+  void AddOrUpdateSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
+                       const rtc::VideoSinkWants& wants) override {}
+
+  bool IsRunning() override { return true; }
+  bool IsScreencast() const override { return false; }
+  bool GetPreferredFourccs(std::vector<uint32_t>* fourccs) override {
+    return true;
+  }
+};
+
 }  // namespace
 
 bool SimplePeerConnection::InitializePeerConnection(const char** turn_urls,
                                                     const int no_of_urls,
                                                     const char* username,
                                                     const char* credential,
                                                     bool is_receiver) {
   RTC_DCHECK(peer_connection_.get() == nullptr);
 
   if (g_peer_connection_factory == nullptr) {
@@ skipping 313 matching lines @@
 
   rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
       g_peer_connection_factory->CreateLocalMediaStream(kStreamLabel);
 
   rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
       g_peer_connection_factory->CreateAudioTrack(
           kAudioLabel, g_peer_connection_factory->CreateAudioSource(nullptr)));
   std::string id = audio_track->id();
   stream->AddTrack(audio_track);
 
+#if defined(WEBRTC_ANDROID)

[GeorgeZ, 2017/09/19 08:21:20]

Dummy capturer should work but may not the best solution here.

Have you tried mandate to get video and audio only in the receiver side as in 
https://chromium-review.googlesource.com/c/external/webrtc/+/648197. I didn't
test it.

[qiangchen, 2017/09/19 17:57:45]

Unfortunately, that does not work. I think this property belongs to
FakeConstraint, and thus not working really. The only usage else is in a
unittest.

So far the easiest work-around is make a dummy capturer.

+  JNIEnv* env = webrtc::jni::GetEnv();
+  jclass pc_factory_class =
+      unity_plugin::FindClass(env, "org/webrtc/UnityUtility");
+  jmethodID load_texture_helper_method = webrtc::jni::GetStaticMethodID(
+      env, pc_factory_class, "LoadSurfaceTextureHelper",
+      "()Lorg/webrtc/SurfaceTextureHelper;");
+  jobject texture_helper =
+      env->CallStaticObjectMethod(pc_factory_class, load_texture_helper_method);
+  CHECK_EXCEPTION(env);
+  RTC_DCHECK(texture_helper != nullptr)
+      << "Cannot get the Surface Texture Helper.";
+
+  rtc::scoped_refptr<webrtc::jni::AndroidVideoTrackSource> source(
+      new rtc::RefCountedObject<webrtc::jni::AndroidVideoTrackSource>(
+          g_signaling_thread.get(), env, texture_helper, false));
+  rtc::scoped_refptr<webrtc::VideoTrackSourceProxy> proxy_source =
+      webrtc::VideoTrackSourceProxy::Create(g_signaling_thread.get(),
+                                            g_worker_thread.get(), source);
+
+  // link with VideoCapturer (Camera);
   if (!audio_only) {
-#if defined(WEBRTC_ANDROID)
-    JNIEnv* env = webrtc::jni::GetEnv();
-    jclass pc_factory_class =
-        unity_plugin::FindClass(env, "org/webrtc/UnityUtility");
-    jmethodID load_texture_helper_method = webrtc::jni::GetStaticMethodID(
-        env, pc_factory_class, "LoadSurfaceTextureHelper",
-        "()Lorg/webrtc/SurfaceTextureHelper;");
-    jobject texture_helper = env->CallStaticObjectMethod(
-        pc_factory_class, load_texture_helper_method);
-    CHECK_EXCEPTION(env);
-    RTC_DCHECK(texture_helper != nullptr)
-        << "Cannot get the Surface Texture Helper.";
-
-    rtc::scoped_refptr<AndroidVideoTrackSource> source(
-        new rtc::RefCountedObject<AndroidVideoTrackSource>(
-            g_signaling_thread.get(), env, texture_helper, false));
-    rtc::scoped_refptr<webrtc::VideoTrackSourceProxy> proxy_source =
-        webrtc::VideoTrackSourceProxy::Create(g_signaling_thread.get(),
-                                              g_worker_thread.get(), source);
-
-    // link with VideoCapturer (Camera);
     jmethodID link_camera_method = webrtc::jni::GetStaticMethodID(
         env, pc_factory_class, "LinkCamera",
         "(JLorg/webrtc/SurfaceTextureHelper;)Lorg/webrtc/VideoCapturer;");
     jobject camera_tmp =
         env->CallStaticObjectMethod(pc_factory_class, link_camera_method,
                                     (jlong)proxy_source.get(), texture_helper);
     CHECK_EXCEPTION(env);
     g_camera = (jobject)env->NewGlobalRef(camera_tmp);
+  }
 
+  rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
+      g_peer_connection_factory->CreateVideoTrack(kVideoLabel,
+                                                  proxy_source.release()));
+  stream->AddTrack(video_track);
+#else
+  std::unique_ptr<cricket::VideoCapturer> capture;
+  if (!audio_only) {
+    capture = OpenVideoCaptureDevice();
+  } else {
+    capture.reset(new DummyCapturer());
+  }
+  if (capture) {
     rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
-        g_peer_connection_factory->CreateVideoTrack(kVideoLabel,
-                                                    proxy_source.release()));
+        g_peer_connection_factory->CreateVideoTrack(
+            kVideoLabel, g_peer_connection_factory->CreateVideoSource(
+                             std::move(capture), nullptr)));
+
     stream->AddTrack(video_track);
-#else
-    std::unique_ptr<cricket::VideoCapturer> capture = OpenVideoCaptureDevice();
-    if (capture) {
-      rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
-          g_peer_connection_factory->CreateVideoTrack(
-              kVideoLabel, g_peer_connection_factory->CreateVideoSource(
-                               std::move(capture), nullptr)));
+  }
 
-      stream->AddTrack(video_track);
-    }
 #endif
     if (local_video_observer_ && !stream->GetVideoTracks().empty()) {
       stream->GetVideoTracks()[0]->AddOrUpdateSink(local_video_observer_.get(),
                                                    rtc::VideoSinkWants());
     }
-  }
 
   if (!peer_connection_->AddStream(stream)) {
     LOG(LS_ERROR) << "Adding stream to PeerConnection failed";
   }
 
   typedef std::pair<std::string,
                     rtc::scoped_refptr<webrtc::MediaStreamInterface>>
       MediaStreamPair;
   active_streams_.insert(MediaStreamPair(stream->label(), stream));
 }
@@ skipping 85 matching lines @@
 
     for (const auto& param : params) {
       uint32_t ssrc = param.ssrc.value_or(0);
       if (ssrc > 0)
         ssrcs.push_back(ssrc);
     }
   }
 
   return ssrcs;
 }