1 /*
2 * Copyright 2018 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "media/base/fake_media_engine.h"
12
13 #include <memory>
14 #include <utility>
15
16 #include "absl/algorithm/container.h"
17 #include "absl/strings/match.h"
18 #include "rtc_base/checks.h"
19
20 namespace cricket {
21
DtmfInfo(uint32_t ssrc,int event_code,int duration)22 FakeVoiceMediaChannel::DtmfInfo::DtmfInfo(uint32_t ssrc,
23 int event_code,
24 int duration)
25 : ssrc(ssrc), event_code(event_code), duration(duration) {}
26
VoiceChannelAudioSink(AudioSource * source)27 FakeVoiceMediaChannel::VoiceChannelAudioSink::VoiceChannelAudioSink(
28 AudioSource* source)
29 : source_(source) {
30 source_->SetSink(this);
31 }
~VoiceChannelAudioSink()32 FakeVoiceMediaChannel::VoiceChannelAudioSink::~VoiceChannelAudioSink() {
33 if (source_) {
34 source_->SetSink(nullptr);
35 }
36 }
OnData(const void * audio_data,int bits_per_sample,int sample_rate,size_t number_of_channels,size_t number_of_frames,absl::optional<int64_t> absolute_capture_timestamp_ms)37 void FakeVoiceMediaChannel::VoiceChannelAudioSink::OnData(
38 const void* audio_data,
39 int bits_per_sample,
40 int sample_rate,
41 size_t number_of_channels,
42 size_t number_of_frames,
43 absl::optional<int64_t> absolute_capture_timestamp_ms) {}
OnClose()44 void FakeVoiceMediaChannel::VoiceChannelAudioSink::OnClose() {
45 source_ = nullptr;
46 }
source() const47 AudioSource* FakeVoiceMediaChannel::VoiceChannelAudioSink::source() const {
48 return source_;
49 }
50
FakeVoiceMediaChannel(FakeVoiceEngine * engine,const AudioOptions & options)51 FakeVoiceMediaChannel::FakeVoiceMediaChannel(FakeVoiceEngine* engine,
52 const AudioOptions& options)
53 : engine_(engine), max_bps_(-1) {
54 output_scalings_[0] = 1.0; // For default channel.
55 SetOptions(options);
56 }
~FakeVoiceMediaChannel()57 FakeVoiceMediaChannel::~FakeVoiceMediaChannel() {
58 if (engine_) {
59 engine_->UnregisterChannel(this);
60 }
61 }
recv_codecs() const62 const std::vector<AudioCodec>& FakeVoiceMediaChannel::recv_codecs() const {
63 return recv_codecs_;
64 }
send_codecs() const65 const std::vector<AudioCodec>& FakeVoiceMediaChannel::send_codecs() const {
66 return send_codecs_;
67 }
codecs() const68 const std::vector<AudioCodec>& FakeVoiceMediaChannel::codecs() const {
69 return send_codecs();
70 }
71 const std::vector<FakeVoiceMediaChannel::DtmfInfo>&
dtmf_info_queue() const72 FakeVoiceMediaChannel::dtmf_info_queue() const {
73 return dtmf_info_queue_;
74 }
options() const75 const AudioOptions& FakeVoiceMediaChannel::options() const {
76 return options_;
77 }
max_bps() const78 int FakeVoiceMediaChannel::max_bps() const {
79 return max_bps_;
80 }
SetSendParameters(const AudioSendParameters & params)81 bool FakeVoiceMediaChannel::SetSendParameters(
82 const AudioSendParameters& params) {
83 set_send_rtcp_parameters(params.rtcp);
84 return (SetSendCodecs(params.codecs) &&
85 SetSendExtmapAllowMixed(params.extmap_allow_mixed) &&
86 SetSendRtpHeaderExtensions(params.extensions) &&
87 SetMaxSendBandwidth(params.max_bandwidth_bps) &&
88 SetOptions(params.options));
89 }
SetRecvParameters(const AudioRecvParameters & params)90 bool FakeVoiceMediaChannel::SetRecvParameters(
91 const AudioRecvParameters& params) {
92 set_recv_rtcp_parameters(params.rtcp);
93 return (SetRecvCodecs(params.codecs) &&
94 SetRecvRtpHeaderExtensions(params.extensions));
95 }
SetPlayout(bool playout)96 void FakeVoiceMediaChannel::SetPlayout(bool playout) {
97 set_playout(playout);
98 }
SetSend(bool send)99 void FakeVoiceMediaChannel::SetSend(bool send) {
100 set_sending(send);
101 }
SetAudioSend(uint32_t ssrc,bool enable,const AudioOptions * options,AudioSource * source)102 bool FakeVoiceMediaChannel::SetAudioSend(uint32_t ssrc,
103 bool enable,
104 const AudioOptions* options,
105 AudioSource* source) {
106 if (!SetLocalSource(ssrc, source)) {
107 return false;
108 }
109 if (!RtpHelper<VoiceMediaChannel>::MuteStream(ssrc, !enable)) {
110 return false;
111 }
112 if (enable && options) {
113 return SetOptions(*options);
114 }
115 return true;
116 }
HasSource(uint32_t ssrc) const117 bool FakeVoiceMediaChannel::HasSource(uint32_t ssrc) const {
118 return local_sinks_.find(ssrc) != local_sinks_.end();
119 }
AddRecvStream(const StreamParams & sp)120 bool FakeVoiceMediaChannel::AddRecvStream(const StreamParams& sp) {
121 if (!RtpHelper<VoiceMediaChannel>::AddRecvStream(sp))
122 return false;
123 output_scalings_[sp.first_ssrc()] = 1.0;
124 output_delays_[sp.first_ssrc()] = 0;
125 return true;
126 }
RemoveRecvStream(uint32_t ssrc)127 bool FakeVoiceMediaChannel::RemoveRecvStream(uint32_t ssrc) {
128 if (!RtpHelper<VoiceMediaChannel>::RemoveRecvStream(ssrc))
129 return false;
130 output_scalings_.erase(ssrc);
131 output_delays_.erase(ssrc);
132 return true;
133 }
CanInsertDtmf()134 bool FakeVoiceMediaChannel::CanInsertDtmf() {
135 for (std::vector<AudioCodec>::const_iterator it = send_codecs_.begin();
136 it != send_codecs_.end(); ++it) {
137 // Find the DTMF telephone event "codec".
138 if (absl::EqualsIgnoreCase(it->name, "telephone-event")) {
139 return true;
140 }
141 }
142 return false;
143 }
InsertDtmf(uint32_t ssrc,int event_code,int duration)144 bool FakeVoiceMediaChannel::InsertDtmf(uint32_t ssrc,
145 int event_code,
146 int duration) {
147 dtmf_info_queue_.push_back(DtmfInfo(ssrc, event_code, duration));
148 return true;
149 }
SetOutputVolume(uint32_t ssrc,double volume)150 bool FakeVoiceMediaChannel::SetOutputVolume(uint32_t ssrc, double volume) {
151 if (output_scalings_.find(ssrc) != output_scalings_.end()) {
152 output_scalings_[ssrc] = volume;
153 return true;
154 }
155 return false;
156 }
SetDefaultOutputVolume(double volume)157 bool FakeVoiceMediaChannel::SetDefaultOutputVolume(double volume) {
158 for (auto& entry : output_scalings_) {
159 entry.second = volume;
160 }
161 return true;
162 }
GetOutputVolume(uint32_t ssrc,double * volume)163 bool FakeVoiceMediaChannel::GetOutputVolume(uint32_t ssrc, double* volume) {
164 if (output_scalings_.find(ssrc) == output_scalings_.end())
165 return false;
166 *volume = output_scalings_[ssrc];
167 return true;
168 }
SetBaseMinimumPlayoutDelayMs(uint32_t ssrc,int delay_ms)169 bool FakeVoiceMediaChannel::SetBaseMinimumPlayoutDelayMs(uint32_t ssrc,
170 int delay_ms) {
171 if (output_delays_.find(ssrc) == output_delays_.end()) {
172 return false;
173 } else {
174 output_delays_[ssrc] = delay_ms;
175 return true;
176 }
177 }
GetBaseMinimumPlayoutDelayMs(uint32_t ssrc) const178 absl::optional<int> FakeVoiceMediaChannel::GetBaseMinimumPlayoutDelayMs(
179 uint32_t ssrc) const {
180 const auto it = output_delays_.find(ssrc);
181 if (it != output_delays_.end()) {
182 return it->second;
183 }
184 return absl::nullopt;
185 }
GetStats(VoiceMediaInfo * info,bool get_and_clear_legacy_stats)186 bool FakeVoiceMediaChannel::GetStats(VoiceMediaInfo* info,
187 bool get_and_clear_legacy_stats) {
188 return false;
189 }
SetRawAudioSink(uint32_t ssrc,std::unique_ptr<webrtc::AudioSinkInterface> sink)190 void FakeVoiceMediaChannel::SetRawAudioSink(
191 uint32_t ssrc,
192 std::unique_ptr<webrtc::AudioSinkInterface> sink) {
193 sink_ = std::move(sink);
194 }
SetDefaultRawAudioSink(std::unique_ptr<webrtc::AudioSinkInterface> sink)195 void FakeVoiceMediaChannel::SetDefaultRawAudioSink(
196 std::unique_ptr<webrtc::AudioSinkInterface> sink) {
197 sink_ = std::move(sink);
198 }
GetSources(uint32_t ssrc) const199 std::vector<webrtc::RtpSource> FakeVoiceMediaChannel::GetSources(
200 uint32_t ssrc) const {
201 return std::vector<webrtc::RtpSource>();
202 }
SetRecvCodecs(const std::vector<AudioCodec> & codecs)203 bool FakeVoiceMediaChannel::SetRecvCodecs(
204 const std::vector<AudioCodec>& codecs) {
205 if (fail_set_recv_codecs()) {
206 // Fake the failure in SetRecvCodecs.
207 return false;
208 }
209 recv_codecs_ = codecs;
210 return true;
211 }
SetSendCodecs(const std::vector<AudioCodec> & codecs)212 bool FakeVoiceMediaChannel::SetSendCodecs(
213 const std::vector<AudioCodec>& codecs) {
214 if (fail_set_send_codecs()) {
215 // Fake the failure in SetSendCodecs.
216 return false;
217 }
218 send_codecs_ = codecs;
219 return true;
220 }
SetMaxSendBandwidth(int bps)221 bool FakeVoiceMediaChannel::SetMaxSendBandwidth(int bps) {
222 max_bps_ = bps;
223 return true;
224 }
SetOptions(const AudioOptions & options)225 bool FakeVoiceMediaChannel::SetOptions(const AudioOptions& options) {
226 // Does a "merge" of current options and set options.
227 options_.SetAll(options);
228 return true;
229 }
SetLocalSource(uint32_t ssrc,AudioSource * source)230 bool FakeVoiceMediaChannel::SetLocalSource(uint32_t ssrc, AudioSource* source) {
231 auto it = local_sinks_.find(ssrc);
232 if (source) {
233 if (it != local_sinks_.end()) {
234 RTC_CHECK(it->second->source() == source);
235 } else {
236 local_sinks_.insert(std::make_pair(
237 ssrc, std::make_unique<VoiceChannelAudioSink>(source)));
238 }
239 } else {
240 if (it != local_sinks_.end()) {
241 local_sinks_.erase(it);
242 }
243 }
244 return true;
245 }
246
CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo & info,uint32_t ssrc,int event_code,int duration)247 bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info,
248 uint32_t ssrc,
249 int event_code,
250 int duration) {
251 return (info.duration == duration && info.event_code == event_code &&
252 info.ssrc == ssrc);
253 }
254
FakeVideoMediaChannel(FakeVideoEngine * engine,const VideoOptions & options)255 FakeVideoMediaChannel::FakeVideoMediaChannel(FakeVideoEngine* engine,
256 const VideoOptions& options)
257 : engine_(engine), max_bps_(-1) {
258 SetOptions(options);
259 }
~FakeVideoMediaChannel()260 FakeVideoMediaChannel::~FakeVideoMediaChannel() {
261 if (engine_) {
262 engine_->UnregisterChannel(this);
263 }
264 }
recv_codecs() const265 const std::vector<VideoCodec>& FakeVideoMediaChannel::recv_codecs() const {
266 return recv_codecs_;
267 }
send_codecs() const268 const std::vector<VideoCodec>& FakeVideoMediaChannel::send_codecs() const {
269 return send_codecs_;
270 }
codecs() const271 const std::vector<VideoCodec>& FakeVideoMediaChannel::codecs() const {
272 return send_codecs();
273 }
rendering() const274 bool FakeVideoMediaChannel::rendering() const {
275 return playout();
276 }
options() const277 const VideoOptions& FakeVideoMediaChannel::options() const {
278 return options_;
279 }
280 const std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*>&
sinks() const281 FakeVideoMediaChannel::sinks() const {
282 return sinks_;
283 }
max_bps() const284 int FakeVideoMediaChannel::max_bps() const {
285 return max_bps_;
286 }
SetSendParameters(const VideoSendParameters & params)287 bool FakeVideoMediaChannel::SetSendParameters(
288 const VideoSendParameters& params) {
289 set_send_rtcp_parameters(params.rtcp);
290 return (SetSendCodecs(params.codecs) &&
291 SetSendExtmapAllowMixed(params.extmap_allow_mixed) &&
292 SetSendRtpHeaderExtensions(params.extensions) &&
293 SetMaxSendBandwidth(params.max_bandwidth_bps));
294 }
SetRecvParameters(const VideoRecvParameters & params)295 bool FakeVideoMediaChannel::SetRecvParameters(
296 const VideoRecvParameters& params) {
297 set_recv_rtcp_parameters(params.rtcp);
298 return (SetRecvCodecs(params.codecs) &&
299 SetRecvRtpHeaderExtensions(params.extensions));
300 }
AddSendStream(const StreamParams & sp)301 bool FakeVideoMediaChannel::AddSendStream(const StreamParams& sp) {
302 return RtpHelper<VideoMediaChannel>::AddSendStream(sp);
303 }
RemoveSendStream(uint32_t ssrc)304 bool FakeVideoMediaChannel::RemoveSendStream(uint32_t ssrc) {
305 return RtpHelper<VideoMediaChannel>::RemoveSendStream(ssrc);
306 }
GetSendCodec(VideoCodec * send_codec)307 bool FakeVideoMediaChannel::GetSendCodec(VideoCodec* send_codec) {
308 if (send_codecs_.empty()) {
309 return false;
310 }
311 *send_codec = send_codecs_[0];
312 return true;
313 }
SetSink(uint32_t ssrc,rtc::VideoSinkInterface<webrtc::VideoFrame> * sink)314 bool FakeVideoMediaChannel::SetSink(
315 uint32_t ssrc,
316 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
317 auto it = sinks_.find(ssrc);
318 if (it == sinks_.end()) {
319 return false;
320 }
321 it->second = sink;
322 return true;
323 }
SetDefaultSink(rtc::VideoSinkInterface<webrtc::VideoFrame> * sink)324 void FakeVideoMediaChannel::SetDefaultSink(
325 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {}
HasSink(uint32_t ssrc) const326 bool FakeVideoMediaChannel::HasSink(uint32_t ssrc) const {
327 return sinks_.find(ssrc) != sinks_.end() && sinks_.at(ssrc) != nullptr;
328 }
SetSend(bool send)329 bool FakeVideoMediaChannel::SetSend(bool send) {
330 return set_sending(send);
331 }
SetVideoSend(uint32_t ssrc,const VideoOptions * options,rtc::VideoSourceInterface<webrtc::VideoFrame> * source)332 bool FakeVideoMediaChannel::SetVideoSend(
333 uint32_t ssrc,
334 const VideoOptions* options,
335 rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
336 if (options) {
337 if (!SetOptions(*options)) {
338 return false;
339 }
340 }
341 sources_[ssrc] = source;
342 return true;
343 }
HasSource(uint32_t ssrc) const344 bool FakeVideoMediaChannel::HasSource(uint32_t ssrc) const {
345 return sources_.find(ssrc) != sources_.end() && sources_.at(ssrc) != nullptr;
346 }
AddRecvStream(const StreamParams & sp)347 bool FakeVideoMediaChannel::AddRecvStream(const StreamParams& sp) {
348 if (!RtpHelper<VideoMediaChannel>::AddRecvStream(sp))
349 return false;
350 sinks_[sp.first_ssrc()] = NULL;
351 output_delays_[sp.first_ssrc()] = 0;
352 return true;
353 }
RemoveRecvStream(uint32_t ssrc)354 bool FakeVideoMediaChannel::RemoveRecvStream(uint32_t ssrc) {
355 if (!RtpHelper<VideoMediaChannel>::RemoveRecvStream(ssrc))
356 return false;
357 sinks_.erase(ssrc);
358 output_delays_.erase(ssrc);
359 return true;
360 }
FillBitrateInfo(BandwidthEstimationInfo * bwe_info)361 void FakeVideoMediaChannel::FillBitrateInfo(BandwidthEstimationInfo* bwe_info) {
362 }
GetStats(VideoMediaInfo * info)363 bool FakeVideoMediaChannel::GetStats(VideoMediaInfo* info) {
364 return false;
365 }
GetSources(uint32_t ssrc) const366 std::vector<webrtc::RtpSource> FakeVideoMediaChannel::GetSources(
367 uint32_t ssrc) const {
368 return {};
369 }
SetBaseMinimumPlayoutDelayMs(uint32_t ssrc,int delay_ms)370 bool FakeVideoMediaChannel::SetBaseMinimumPlayoutDelayMs(uint32_t ssrc,
371 int delay_ms) {
372 if (output_delays_.find(ssrc) == output_delays_.end()) {
373 return false;
374 } else {
375 output_delays_[ssrc] = delay_ms;
376 return true;
377 }
378 }
GetBaseMinimumPlayoutDelayMs(uint32_t ssrc) const379 absl::optional<int> FakeVideoMediaChannel::GetBaseMinimumPlayoutDelayMs(
380 uint32_t ssrc) const {
381 const auto it = output_delays_.find(ssrc);
382 if (it != output_delays_.end()) {
383 return it->second;
384 }
385 return absl::nullopt;
386 }
SetRecvCodecs(const std::vector<VideoCodec> & codecs)387 bool FakeVideoMediaChannel::SetRecvCodecs(
388 const std::vector<VideoCodec>& codecs) {
389 if (fail_set_recv_codecs()) {
390 // Fake the failure in SetRecvCodecs.
391 return false;
392 }
393 recv_codecs_ = codecs;
394 return true;
395 }
SetSendCodecs(const std::vector<VideoCodec> & codecs)396 bool FakeVideoMediaChannel::SetSendCodecs(
397 const std::vector<VideoCodec>& codecs) {
398 if (fail_set_send_codecs()) {
399 // Fake the failure in SetSendCodecs.
400 return false;
401 }
402 send_codecs_ = codecs;
403
404 return true;
405 }
SetOptions(const VideoOptions & options)406 bool FakeVideoMediaChannel::SetOptions(const VideoOptions& options) {
407 options_ = options;
408 return true;
409 }
410
SetMaxSendBandwidth(int bps)411 bool FakeVideoMediaChannel::SetMaxSendBandwidth(int bps) {
412 max_bps_ = bps;
413 return true;
414 }
415
SetRecordableEncodedFrameCallback(uint32_t ssrc,std::function<void (const webrtc::RecordableEncodedFrame &)> callback)416 void FakeVideoMediaChannel::SetRecordableEncodedFrameCallback(
417 uint32_t ssrc,
418 std::function<void(const webrtc::RecordableEncodedFrame&)> callback) {}
419
ClearRecordableEncodedFrameCallback(uint32_t ssrc)420 void FakeVideoMediaChannel::ClearRecordableEncodedFrameCallback(uint32_t ssrc) {
421 }
422
GenerateKeyFrame(uint32_t ssrc)423 void FakeVideoMediaChannel::GenerateKeyFrame(uint32_t ssrc) {}
424
FakeDataMediaChannel(void * unused,const DataOptions & options)425 FakeDataMediaChannel::FakeDataMediaChannel(void* unused,
426 const DataOptions& options)
427 : send_blocked_(false), max_bps_(-1) {}
~FakeDataMediaChannel()428 FakeDataMediaChannel::~FakeDataMediaChannel() {}
recv_codecs() const429 const std::vector<DataCodec>& FakeDataMediaChannel::recv_codecs() const {
430 return recv_codecs_;
431 }
send_codecs() const432 const std::vector<DataCodec>& FakeDataMediaChannel::send_codecs() const {
433 return send_codecs_;
434 }
codecs() const435 const std::vector<DataCodec>& FakeDataMediaChannel::codecs() const {
436 return send_codecs();
437 }
max_bps() const438 int FakeDataMediaChannel::max_bps() const {
439 return max_bps_;
440 }
SetSendParameters(const DataSendParameters & params)441 bool FakeDataMediaChannel::SetSendParameters(const DataSendParameters& params) {
442 set_send_rtcp_parameters(params.rtcp);
443 return (SetSendCodecs(params.codecs) &&
444 SetMaxSendBandwidth(params.max_bandwidth_bps));
445 }
SetRecvParameters(const DataRecvParameters & params)446 bool FakeDataMediaChannel::SetRecvParameters(const DataRecvParameters& params) {
447 set_recv_rtcp_parameters(params.rtcp);
448 return SetRecvCodecs(params.codecs);
449 }
SetSend(bool send)450 bool FakeDataMediaChannel::SetSend(bool send) {
451 return set_sending(send);
452 }
SetReceive(bool receive)453 bool FakeDataMediaChannel::SetReceive(bool receive) {
454 set_playout(receive);
455 return true;
456 }
AddRecvStream(const StreamParams & sp)457 bool FakeDataMediaChannel::AddRecvStream(const StreamParams& sp) {
458 if (!RtpHelper<DataMediaChannel>::AddRecvStream(sp))
459 return false;
460 return true;
461 }
RemoveRecvStream(uint32_t ssrc)462 bool FakeDataMediaChannel::RemoveRecvStream(uint32_t ssrc) {
463 if (!RtpHelper<DataMediaChannel>::RemoveRecvStream(ssrc))
464 return false;
465 return true;
466 }
SendData(const SendDataParams & params,const rtc::CopyOnWriteBuffer & payload,SendDataResult * result)467 bool FakeDataMediaChannel::SendData(const SendDataParams& params,
468 const rtc::CopyOnWriteBuffer& payload,
469 SendDataResult* result) {
470 if (send_blocked_) {
471 *result = SDR_BLOCK;
472 return false;
473 } else {
474 last_sent_data_params_ = params;
475 last_sent_data_ = std::string(payload.data<char>(), payload.size());
476 return true;
477 }
478 }
last_sent_data_params()479 SendDataParams FakeDataMediaChannel::last_sent_data_params() {
480 return last_sent_data_params_;
481 }
last_sent_data()482 std::string FakeDataMediaChannel::last_sent_data() {
483 return last_sent_data_;
484 }
is_send_blocked()485 bool FakeDataMediaChannel::is_send_blocked() {
486 return send_blocked_;
487 }
set_send_blocked(bool blocked)488 void FakeDataMediaChannel::set_send_blocked(bool blocked) {
489 send_blocked_ = blocked;
490 }
SetRecvCodecs(const std::vector<DataCodec> & codecs)491 bool FakeDataMediaChannel::SetRecvCodecs(const std::vector<DataCodec>& codecs) {
492 if (fail_set_recv_codecs()) {
493 // Fake the failure in SetRecvCodecs.
494 return false;
495 }
496 recv_codecs_ = codecs;
497 return true;
498 }
SetSendCodecs(const std::vector<DataCodec> & codecs)499 bool FakeDataMediaChannel::SetSendCodecs(const std::vector<DataCodec>& codecs) {
500 if (fail_set_send_codecs()) {
501 // Fake the failure in SetSendCodecs.
502 return false;
503 }
504 send_codecs_ = codecs;
505 return true;
506 }
SetMaxSendBandwidth(int bps)507 bool FakeDataMediaChannel::SetMaxSendBandwidth(int bps) {
508 max_bps_ = bps;
509 return true;
510 }
511
FakeVoiceEngine()512 FakeVoiceEngine::FakeVoiceEngine() : fail_create_channel_(false) {
513 // Add a fake audio codec. Note that the name must not be "" as there are
514 // sanity checks against that.
515 SetCodecs({AudioCodec(101, "fake_audio_codec", 0, 0, 1)});
516 }
Init()517 void FakeVoiceEngine::Init() {}
GetAudioState() const518 rtc::scoped_refptr<webrtc::AudioState> FakeVoiceEngine::GetAudioState() const {
519 return rtc::scoped_refptr<webrtc::AudioState>();
520 }
CreateMediaChannel(webrtc::Call * call,const MediaConfig & config,const AudioOptions & options,const webrtc::CryptoOptions & crypto_options)521 VoiceMediaChannel* FakeVoiceEngine::CreateMediaChannel(
522 webrtc::Call* call,
523 const MediaConfig& config,
524 const AudioOptions& options,
525 const webrtc::CryptoOptions& crypto_options) {
526 if (fail_create_channel_) {
527 return nullptr;
528 }
529
530 FakeVoiceMediaChannel* ch = new FakeVoiceMediaChannel(this, options);
531 channels_.push_back(ch);
532 return ch;
533 }
GetChannel(size_t index)534 FakeVoiceMediaChannel* FakeVoiceEngine::GetChannel(size_t index) {
535 return (channels_.size() > index) ? channels_[index] : NULL;
536 }
UnregisterChannel(VoiceMediaChannel * channel)537 void FakeVoiceEngine::UnregisterChannel(VoiceMediaChannel* channel) {
538 channels_.erase(absl::c_find(channels_, channel));
539 }
send_codecs() const540 const std::vector<AudioCodec>& FakeVoiceEngine::send_codecs() const {
541 return send_codecs_;
542 }
recv_codecs() const543 const std::vector<AudioCodec>& FakeVoiceEngine::recv_codecs() const {
544 return recv_codecs_;
545 }
SetCodecs(const std::vector<AudioCodec> & codecs)546 void FakeVoiceEngine::SetCodecs(const std::vector<AudioCodec>& codecs) {
547 send_codecs_ = codecs;
548 recv_codecs_ = codecs;
549 }
SetRecvCodecs(const std::vector<AudioCodec> & codecs)550 void FakeVoiceEngine::SetRecvCodecs(const std::vector<AudioCodec>& codecs) {
551 recv_codecs_ = codecs;
552 }
SetSendCodecs(const std::vector<AudioCodec> & codecs)553 void FakeVoiceEngine::SetSendCodecs(const std::vector<AudioCodec>& codecs) {
554 send_codecs_ = codecs;
555 }
GetInputLevel()556 int FakeVoiceEngine::GetInputLevel() {
557 return 0;
558 }
StartAecDump(webrtc::FileWrapper file,int64_t max_size_bytes)559 bool FakeVoiceEngine::StartAecDump(webrtc::FileWrapper file,
560 int64_t max_size_bytes) {
561 return false;
562 }
StopAecDump()563 void FakeVoiceEngine::StopAecDump() {}
564
565 std::vector<webrtc::RtpHeaderExtensionCapability>
GetRtpHeaderExtensions() const566 FakeVoiceEngine::GetRtpHeaderExtensions() const {
567 return header_extensions_;
568 }
569
SetRtpHeaderExtensions(std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions)570 void FakeVoiceEngine::SetRtpHeaderExtensions(
571 std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions) {
572 header_extensions_ = std::move(header_extensions);
573 }
574
FakeVideoEngine()575 FakeVideoEngine::FakeVideoEngine()
576 : capture_(false), fail_create_channel_(false) {
577 // Add a fake video codec. Note that the name must not be "" as there are
578 // sanity checks against that.
579 send_codecs_.push_back(VideoCodec(0, "fake_video_codec"));
580 recv_codecs_.push_back(VideoCodec(0, "fake_video_codec"));
581 }
SetOptions(const VideoOptions & options)582 bool FakeVideoEngine::SetOptions(const VideoOptions& options) {
583 options_ = options;
584 return true;
585 }
CreateMediaChannel(webrtc::Call * call,const MediaConfig & config,const VideoOptions & options,const webrtc::CryptoOptions & crypto_options,webrtc::VideoBitrateAllocatorFactory * video_bitrate_allocator_factory)586 VideoMediaChannel* FakeVideoEngine::CreateMediaChannel(
587 webrtc::Call* call,
588 const MediaConfig& config,
589 const VideoOptions& options,
590 const webrtc::CryptoOptions& crypto_options,
591 webrtc::VideoBitrateAllocatorFactory* video_bitrate_allocator_factory) {
592 if (fail_create_channel_) {
593 return nullptr;
594 }
595
596 FakeVideoMediaChannel* ch = new FakeVideoMediaChannel(this, options);
597 channels_.emplace_back(ch);
598 return ch;
599 }
GetChannel(size_t index)600 FakeVideoMediaChannel* FakeVideoEngine::GetChannel(size_t index) {
601 return (channels_.size() > index) ? channels_[index] : nullptr;
602 }
UnregisterChannel(VideoMediaChannel * channel)603 void FakeVideoEngine::UnregisterChannel(VideoMediaChannel* channel) {
604 auto it = absl::c_find(channels_, channel);
605 RTC_DCHECK(it != channels_.end());
606 channels_.erase(it);
607 }
send_codecs() const608 std::vector<VideoCodec> FakeVideoEngine::send_codecs() const {
609 return send_codecs_;
610 }
611
recv_codecs() const612 std::vector<VideoCodec> FakeVideoEngine::recv_codecs() const {
613 return recv_codecs_;
614 }
615
SetSendCodecs(const std::vector<VideoCodec> & codecs)616 void FakeVideoEngine::SetSendCodecs(const std::vector<VideoCodec>& codecs) {
617 send_codecs_ = codecs;
618 }
619
SetRecvCodecs(const std::vector<VideoCodec> & codecs)620 void FakeVideoEngine::SetRecvCodecs(const std::vector<VideoCodec>& codecs) {
621 recv_codecs_ = codecs;
622 }
623
SetCapture(bool capture)624 bool FakeVideoEngine::SetCapture(bool capture) {
625 capture_ = capture;
626 return true;
627 }
628 std::vector<webrtc::RtpHeaderExtensionCapability>
GetRtpHeaderExtensions() const629 FakeVideoEngine::GetRtpHeaderExtensions() const {
630 return header_extensions_;
631 }
SetRtpHeaderExtensions(std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions)632 void FakeVideoEngine::SetRtpHeaderExtensions(
633 std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions) {
634 header_extensions_ = std::move(header_extensions);
635 }
636
FakeMediaEngine()637 FakeMediaEngine::FakeMediaEngine()
638 : CompositeMediaEngine(std::make_unique<FakeVoiceEngine>(),
639 std::make_unique<FakeVideoEngine>()),
640 voice_(static_cast<FakeVoiceEngine*>(&voice())),
641 video_(static_cast<FakeVideoEngine*>(&video())) {}
~FakeMediaEngine()642 FakeMediaEngine::~FakeMediaEngine() {}
SetAudioCodecs(const std::vector<AudioCodec> & codecs)643 void FakeMediaEngine::SetAudioCodecs(const std::vector<AudioCodec>& codecs) {
644 voice_->SetCodecs(codecs);
645 }
SetAudioRecvCodecs(const std::vector<AudioCodec> & codecs)646 void FakeMediaEngine::SetAudioRecvCodecs(
647 const std::vector<AudioCodec>& codecs) {
648 voice_->SetRecvCodecs(codecs);
649 }
SetAudioSendCodecs(const std::vector<AudioCodec> & codecs)650 void FakeMediaEngine::SetAudioSendCodecs(
651 const std::vector<AudioCodec>& codecs) {
652 voice_->SetSendCodecs(codecs);
653 }
SetVideoCodecs(const std::vector<VideoCodec> & codecs)654 void FakeMediaEngine::SetVideoCodecs(const std::vector<VideoCodec>& codecs) {
655 video_->SetSendCodecs(codecs);
656 video_->SetRecvCodecs(codecs);
657 }
658
GetVoiceChannel(size_t index)659 FakeVoiceMediaChannel* FakeMediaEngine::GetVoiceChannel(size_t index) {
660 return voice_->GetChannel(index);
661 }
GetVideoChannel(size_t index)662 FakeVideoMediaChannel* FakeMediaEngine::GetVideoChannel(size_t index) {
663 return video_->GetChannel(index);
664 }
665
set_fail_create_channel(bool fail)666 void FakeMediaEngine::set_fail_create_channel(bool fail) {
667 voice_->fail_create_channel_ = fail;
668 video_->fail_create_channel_ = fail;
669 }
670
CreateChannel(const MediaConfig & config)671 DataMediaChannel* FakeDataEngine::CreateChannel(const MediaConfig& config) {
672 FakeDataMediaChannel* ch = new FakeDataMediaChannel(this, DataOptions());
673 channels_.push_back(ch);
674 return ch;
675 }
GetChannel(size_t index)676 FakeDataMediaChannel* FakeDataEngine::GetChannel(size_t index) {
677 return (channels_.size() > index) ? channels_[index] : NULL;
678 }
UnregisterChannel(DataMediaChannel * channel)679 void FakeDataEngine::UnregisterChannel(DataMediaChannel* channel) {
680 channels_.erase(absl::c_find(channels_, channel));
681 }
SetDataCodecs(const std::vector<DataCodec> & data_codecs)682 void FakeDataEngine::SetDataCodecs(const std::vector<DataCodec>& data_codecs) {
683 data_codecs_ = data_codecs;
684 }
data_codecs()685 const std::vector<DataCodec>& FakeDataEngine::data_codecs() {
686 return data_codecs_;
687 }
688
689 } // namespace cricket
690