mirror of
https://github.com/mollyim/webrtc.git
synced 2025-05-17 07:37:51 +01:00
317a1f09ed
WebRTC is now using C++14 so there is no need to use the Abseil version of std::make_unique. This CL has been created with the following steps: git grep -l absl::make_unique | sort | uniq > /tmp/make_unique.txt git grep -l absl::WrapUnique | sort | uniq > /tmp/wrap_unique.txt git grep -l "#include <memory>" | sort | uniq > /tmp/memory.txt diff --new-line-format="" --unchanged-line-format="" \ /tmp/make_unique.txt /tmp/wrap_unique.txt | sort | \ uniq > /tmp/only_make_unique.txt diff --new-line-format="" --unchanged-line-format="" \ /tmp/only_make_unique.txt /tmp/memory.txt | \ xargs grep -l "absl/memory" > /tmp/add-memory.txt git grep -l "\babsl::make_unique\b" | \ xargs sed -i "s/\babsl::make_unique\b/std::make_unique/g" git checkout PRESUBMIT.py abseil-in-webrtc.md cat /tmp/add-memory.txt | \ xargs sed -i \ 's/#include "absl\/memory\/memory.h"/#include <memory>/g' git cl format # Manual fix order of the new inserted #include <memory> cat /tmp/only_make_unique | xargs grep -l "#include <memory>" | \ xargs sed -i '/#include "absl\/memory\/memory.h"/d' git ls-files | grep BUILD.gn | \ xargs sed -i '/\/\/third_party\/abseil-cpp\/absl\/memory/d' python tools_webrtc/gn_check_autofix.py \ -m tryserver.webrtc -b linux_rel # Repead the gn_check_autofix step for other platforms git ls-files | grep BUILD.gn | \ xargs sed -i 's/absl\/memory:memory/absl\/memory/g' git cl format Bug: webrtc:10945 Change-Id: I3fe28ea80f4dd3ba3cf28effd151d5e1f19aff89 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/153221 Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org> Reviewed-by: Alessio Bazzica <alessiob@webrtc.org> Reviewed-by: Karl Wiberg <kwiberg@webrtc.org> Cr-Commit-Position: refs/heads/master@{#29209}
239 lines
8.9 KiB
Text
239 lines
8.9 KiB
Text
/*
|
|
* Copyright 2018 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.
|
|
*/
|
|
|
|
#include "examples/objcnativeapi/objc/objc_call_client.h"
|
|
|
|
#include <memory>
|
|
#include <utility>
|
|
|
|
#import "sdk/objc/base/RTCVideoRenderer.h"
|
|
#import "sdk/objc/components/video_codec/RTCDefaultVideoDecoderFactory.h"
|
|
#import "sdk/objc/components/video_codec/RTCDefaultVideoEncoderFactory.h"
|
|
#import "sdk/objc/helpers/RTCCameraPreviewView.h"
|
|
|
|
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
|
|
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
|
|
#include "api/peer_connection_interface.h"
|
|
#include "api/rtc_event_log/rtc_event_log_factory.h"
|
|
#include "api/task_queue/default_task_queue_factory.h"
|
|
#include "media/engine/webrtc_media_engine.h"
|
|
#include "modules/audio_processing/include/audio_processing.h"
|
|
#include "sdk/objc/native/api/video_capturer.h"
|
|
#include "sdk/objc/native/api/video_decoder_factory.h"
|
|
#include "sdk/objc/native/api/video_encoder_factory.h"
|
|
#include "sdk/objc/native/api/video_renderer.h"
|
|
|
|
namespace webrtc_examples {
|
|
|
|
namespace {
|
|
|
|
class CreateOfferObserver : public webrtc::CreateSessionDescriptionObserver {
|
|
public:
|
|
explicit CreateOfferObserver(rtc::scoped_refptr<webrtc::PeerConnectionInterface> pc);
|
|
|
|
void OnSuccess(webrtc::SessionDescriptionInterface* desc) override;
|
|
void OnFailure(webrtc::RTCError error) override;
|
|
|
|
private:
|
|
const rtc::scoped_refptr<webrtc::PeerConnectionInterface> pc_;
|
|
};
|
|
|
|
class SetRemoteSessionDescriptionObserver : public webrtc::SetRemoteDescriptionObserverInterface {
|
|
public:
|
|
void OnSetRemoteDescriptionComplete(webrtc::RTCError error) override;
|
|
};
|
|
|
|
class SetLocalSessionDescriptionObserver : public webrtc::SetSessionDescriptionObserver {
|
|
public:
|
|
void OnSuccess() override;
|
|
void OnFailure(webrtc::RTCError error) override;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
ObjCCallClient::ObjCCallClient()
|
|
: call_started_(false), pc_observer_(std::make_unique<PCObserver>(this)) {
|
|
thread_checker_.Detach();
|
|
CreatePeerConnectionFactory();
|
|
}
|
|
|
|
void ObjCCallClient::Call(RTCVideoCapturer* capturer, id<RTCVideoRenderer> remote_renderer) {
|
|
RTC_DCHECK_RUN_ON(&thread_checker_);
|
|
|
|
rtc::CritScope lock(&pc_mutex_);
|
|
if (call_started_) {
|
|
RTC_LOG(LS_WARNING) << "Call already started.";
|
|
return;
|
|
}
|
|
call_started_ = true;
|
|
|
|
remote_sink_ = webrtc::ObjCToNativeVideoRenderer(remote_renderer);
|
|
|
|
video_source_ =
|
|
webrtc::ObjCToNativeVideoCapturer(capturer, signaling_thread_.get(), worker_thread_.get());
|
|
|
|
CreatePeerConnection();
|
|
Connect();
|
|
}
|
|
|
|
void ObjCCallClient::Hangup() {
|
|
RTC_DCHECK_RUN_ON(&thread_checker_);
|
|
|
|
call_started_ = false;
|
|
|
|
{
|
|
rtc::CritScope lock(&pc_mutex_);
|
|
if (pc_ != nullptr) {
|
|
pc_->Close();
|
|
pc_ = nullptr;
|
|
}
|
|
}
|
|
|
|
remote_sink_ = nullptr;
|
|
video_source_ = nullptr;
|
|
}
|
|
|
|
void ObjCCallClient::CreatePeerConnectionFactory() {
|
|
network_thread_ = rtc::Thread::CreateWithSocketServer();
|
|
network_thread_->SetName("network_thread", nullptr);
|
|
RTC_CHECK(network_thread_->Start()) << "Failed to start thread";
|
|
|
|
worker_thread_ = rtc::Thread::Create();
|
|
worker_thread_->SetName("worker_thread", nullptr);
|
|
RTC_CHECK(worker_thread_->Start()) << "Failed to start thread";
|
|
|
|
signaling_thread_ = rtc::Thread::Create();
|
|
signaling_thread_->SetName("signaling_thread", nullptr);
|
|
RTC_CHECK(signaling_thread_->Start()) << "Failed to start thread";
|
|
|
|
webrtc::PeerConnectionFactoryDependencies dependencies;
|
|
dependencies.network_thread = network_thread_.get();
|
|
dependencies.worker_thread = worker_thread_.get();
|
|
dependencies.signaling_thread = signaling_thread_.get();
|
|
dependencies.task_queue_factory = webrtc::CreateDefaultTaskQueueFactory();
|
|
cricket::MediaEngineDependencies media_deps;
|
|
media_deps.task_queue_factory = dependencies.task_queue_factory.get();
|
|
media_deps.audio_encoder_factory = webrtc::CreateBuiltinAudioEncoderFactory();
|
|
media_deps.audio_decoder_factory = webrtc::CreateBuiltinAudioDecoderFactory();
|
|
media_deps.video_encoder_factory =
|
|
webrtc::ObjCToNativeVideoEncoderFactory([[RTCDefaultVideoEncoderFactory alloc] init]);
|
|
media_deps.video_decoder_factory =
|
|
webrtc::ObjCToNativeVideoDecoderFactory([[RTCDefaultVideoDecoderFactory alloc] init]);
|
|
media_deps.audio_processing = webrtc::AudioProcessingBuilder().Create();
|
|
dependencies.media_engine = cricket::CreateMediaEngine(std::move(media_deps));
|
|
RTC_LOG(LS_INFO) << "Media engine created: " << dependencies.media_engine.get();
|
|
dependencies.call_factory = webrtc::CreateCallFactory();
|
|
dependencies.event_log_factory =
|
|
std::make_unique<webrtc::RtcEventLogFactory>(dependencies.task_queue_factory.get());
|
|
pcf_ = webrtc::CreateModularPeerConnectionFactory(std::move(dependencies));
|
|
RTC_LOG(LS_INFO) << "PeerConnectionFactory created: " << pcf_;
|
|
}
|
|
|
|
void ObjCCallClient::CreatePeerConnection() {
|
|
rtc::CritScope lock(&pc_mutex_);
|
|
webrtc::PeerConnectionInterface::RTCConfiguration config;
|
|
config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
|
|
// DTLS SRTP has to be disabled for loopback to work.
|
|
config.enable_dtls_srtp = false;
|
|
webrtc::PeerConnectionDependencies pc_dependencies(pc_observer_.get());
|
|
pc_ = pcf_->CreatePeerConnection(config, std::move(pc_dependencies));
|
|
RTC_LOG(LS_INFO) << "PeerConnection created: " << pc_;
|
|
|
|
rtc::scoped_refptr<webrtc::VideoTrackInterface> local_video_track =
|
|
pcf_->CreateVideoTrack("video", video_source_);
|
|
pc_->AddTransceiver(local_video_track);
|
|
RTC_LOG(LS_INFO) << "Local video sink set up: " << local_video_track;
|
|
|
|
for (const rtc::scoped_refptr<webrtc::RtpTransceiverInterface>& tranceiver :
|
|
pc_->GetTransceivers()) {
|
|
rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> track = tranceiver->receiver()->track();
|
|
if (track && track->kind() == webrtc::MediaStreamTrackInterface::kVideoKind) {
|
|
static_cast<webrtc::VideoTrackInterface*>(track.get())
|
|
->AddOrUpdateSink(remote_sink_.get(), rtc::VideoSinkWants());
|
|
RTC_LOG(LS_INFO) << "Remote video sink set up: " << track;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ObjCCallClient::Connect() {
|
|
rtc::CritScope lock(&pc_mutex_);
|
|
pc_->CreateOffer(new rtc::RefCountedObject<CreateOfferObserver>(pc_),
|
|
webrtc::PeerConnectionInterface::RTCOfferAnswerOptions());
|
|
}
|
|
|
|
ObjCCallClient::PCObserver::PCObserver(ObjCCallClient* client) : client_(client) {}
|
|
|
|
void ObjCCallClient::PCObserver::OnSignalingChange(
|
|
webrtc::PeerConnectionInterface::SignalingState new_state) {
|
|
RTC_LOG(LS_INFO) << "OnSignalingChange: " << new_state;
|
|
}
|
|
|
|
void ObjCCallClient::PCObserver::OnDataChannel(
|
|
rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) {
|
|
RTC_LOG(LS_INFO) << "OnDataChannel";
|
|
}
|
|
|
|
void ObjCCallClient::PCObserver::OnRenegotiationNeeded() {
|
|
RTC_LOG(LS_INFO) << "OnRenegotiationNeeded";
|
|
}
|
|
|
|
void ObjCCallClient::PCObserver::OnIceConnectionChange(
|
|
webrtc::PeerConnectionInterface::IceConnectionState new_state) {
|
|
RTC_LOG(LS_INFO) << "OnIceConnectionChange: " << new_state;
|
|
}
|
|
|
|
void ObjCCallClient::PCObserver::OnIceGatheringChange(
|
|
webrtc::PeerConnectionInterface::IceGatheringState new_state) {
|
|
RTC_LOG(LS_INFO) << "OnIceGatheringChange: " << new_state;
|
|
}
|
|
|
|
void ObjCCallClient::PCObserver::OnIceCandidate(const webrtc::IceCandidateInterface* candidate) {
|
|
RTC_LOG(LS_INFO) << "OnIceCandidate: " << candidate->server_url();
|
|
rtc::CritScope lock(&client_->pc_mutex_);
|
|
RTC_DCHECK(client_->pc_ != nullptr);
|
|
client_->pc_->AddIceCandidate(candidate);
|
|
}
|
|
|
|
CreateOfferObserver::CreateOfferObserver(rtc::scoped_refptr<webrtc::PeerConnectionInterface> pc)
|
|
: pc_(pc) {}
|
|
|
|
void CreateOfferObserver::OnSuccess(webrtc::SessionDescriptionInterface* desc) {
|
|
std::string sdp;
|
|
desc->ToString(&sdp);
|
|
RTC_LOG(LS_INFO) << "Created offer: " << sdp;
|
|
|
|
// Ownership of desc was transferred to us, now we transfer it forward.
|
|
pc_->SetLocalDescription(new rtc::RefCountedObject<SetLocalSessionDescriptionObserver>(), desc);
|
|
|
|
// Generate a fake answer.
|
|
std::unique_ptr<webrtc::SessionDescriptionInterface> answer(
|
|
webrtc::CreateSessionDescription(webrtc::SdpType::kAnswer, sdp));
|
|
pc_->SetRemoteDescription(std::move(answer),
|
|
new rtc::RefCountedObject<SetRemoteSessionDescriptionObserver>());
|
|
}
|
|
|
|
void CreateOfferObserver::OnFailure(webrtc::RTCError error) {
|
|
RTC_LOG(LS_INFO) << "Failed to create offer: " << error.message();
|
|
}
|
|
|
|
void SetRemoteSessionDescriptionObserver::OnSetRemoteDescriptionComplete(webrtc::RTCError error) {
|
|
RTC_LOG(LS_INFO) << "Set remote description: " << error.message();
|
|
}
|
|
|
|
void SetLocalSessionDescriptionObserver::OnSuccess() {
|
|
RTC_LOG(LS_INFO) << "Set local description success!";
|
|
}
|
|
|
|
void SetLocalSessionDescriptionObserver::OnFailure(webrtc::RTCError error) {
|
|
RTC_LOG(LS_INFO) << "Set local description failure: " << error.message();
|
|
}
|
|
|
|
} // namespace webrtc_examples
|