[Experiment] Alpha Channel Support

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 117 matching lines @@
   return true;
 }
 
 void SimplePeerConnection::OnSuccess(
     webrtc::SessionDescriptionInterface* desc) {
   peer_connection_->SetLocalDescription(
       DummySetSessionDescriptionObserver::Create(), desc);
 
   std::string sdp;
   desc->ToString(&sdp);
-
   if (OnLocalSdpReady)
     OnLocalSdpReady(desc->type().c_str(), sdp.c_str());
 }
 
 void SimplePeerConnection::OnFailure(const std::string& error) {
   LOG(LERROR) << error;
 
   if (OnFailureMessage)
     OnFailureMessage(error.c_str());
 }
@@ skipping 175 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 (!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>(
+    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);
-    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);
+    if (!audio_only) {
+      // 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 = 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)));
+  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, g_peer_connection_factory->CreateVideoSource(
+                             std::move(capture), nullptr)));
 
-      stream->AddTrack(video_track);
-    }
+    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;
 }