1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "WebrtcCallWrapper.h"
#include "jsapi/PeerConnectionCtx.h"
#include "MediaConduitInterface.h"
#include "TaskQueueWrapper.h"
// libwebrtc includes
#include "api/environment/environment.h"
#include "api/environment/environment_factory.h"
#include "call/rtp_transport_controller_send_factory.h"
namespace mozilla {
/* static */ RefPtr<WebrtcCallWrapper> WebrtcCallWrapper::Create(
const dom::RTCStatsTimestampMaker& aTimestampMaker,
UniquePtr<media::ShutdownBlockingTicket> aShutdownTicket,
const RefPtr<SharedWebrtcState>& aSharedState) {
auto eventLog = MakeUnique<webrtc::RtcEventLogNull>();
auto taskQueueFactory = MakeUnique<SharedThreadPoolWebRtcTaskQueueFactory>();
auto videoBitrateAllocatorFactory =
WrapUnique(webrtc::CreateBuiltinVideoBitrateAllocatorFactory().release());
RefPtr<WebrtcCallWrapper> wrapper = new WebrtcCallWrapper(
aSharedState, std::move(videoBitrateAllocatorFactory),
std::move(eventLog), std::move(taskQueueFactory), aTimestampMaker,
std::move(aShutdownTicket));
webrtc::Environment env = CreateEnvironment(
wrapper->mEventLog.get(), wrapper->mClock.GetRealTimeClockRaw(),
wrapper->mTaskQueueFactory.get(), aSharedState->mTrials.get());
wrapper->mCallThread->Dispatch(
NS_NewRunnableFunction(__func__, [wrapper, aSharedState, env] {
webrtc::CallConfig config(env, nullptr);
config.audio_state =
webrtc::AudioState::Create(aSharedState->mAudioStateConfig);
wrapper->SetCall(WrapUnique(webrtc::Call::Create(config).release()));
}));
return wrapper;
}
void WebrtcCallWrapper::SetCall(UniquePtr<webrtc::Call> aCall) {
MOZ_ASSERT(mCallThread->IsOnCurrentThread());
MOZ_ASSERT(!mCall);
mCall = std::move(aCall);
}
webrtc::Call* WebrtcCallWrapper::Call() const {
MOZ_ASSERT(mCallThread->IsOnCurrentThread());
return mCall.get();
}
void WebrtcCallWrapper::UnsetRemoteSSRC(uint32_t aSsrc) {
MOZ_ASSERT(mCallThread->IsOnCurrentThread());
for (const auto& conduit : mConduits) {
conduit->UnsetRemoteSSRC(aSsrc);
}
}
void WebrtcCallWrapper::RegisterConduit(MediaSessionConduit* conduit) {
MOZ_ASSERT(mCallThread->IsOnCurrentThread());
mConduits.insert(conduit);
}
void WebrtcCallWrapper::UnregisterConduit(MediaSessionConduit* conduit) {
MOZ_ASSERT(mCallThread->IsOnCurrentThread());
mConduits.erase(conduit);
}
void WebrtcCallWrapper::Destroy() {
MOZ_ASSERT(mCallThread->IsOnCurrentThread());
mCall = nullptr;
mShutdownTicket = nullptr;
}
const dom::RTCStatsTimestampMaker& WebrtcCallWrapper::GetTimestampMaker()
const {
return mClock.mTimestampMaker;
}
WebrtcCallWrapper::~WebrtcCallWrapper() { MOZ_ASSERT(!mCall); }
WebrtcCallWrapper::WebrtcCallWrapper(
RefPtr<SharedWebrtcState> aSharedState,
UniquePtr<webrtc::VideoBitrateAllocatorFactory>
aVideoBitrateAllocatorFactory,
UniquePtr<webrtc::RtcEventLog> aEventLog,
UniquePtr<webrtc::TaskQueueFactory> aTaskQueueFactory,
const dom::RTCStatsTimestampMaker& aTimestampMaker,
UniquePtr<media::ShutdownBlockingTicket> aShutdownTicket)
: mSharedState(std::move(aSharedState)),
mClock(aTimestampMaker),
mShutdownTicket(std::move(aShutdownTicket)),
mCallThread(mSharedState->mCallWorkerThread),
mAudioDecoderFactory(mSharedState->mAudioDecoderFactory),
mVideoBitrateAllocatorFactory(std::move(aVideoBitrateAllocatorFactory)),
mEventLog(std::move(aEventLog)),
mTaskQueueFactory(std::move(aTaskQueueFactory)) {}
} // namespace mozilla
|
