1 /* 2 * Copyright (c) 2004 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 #ifndef MEDIA_BASE_FAKE_MEDIA_ENGINE_H_ 12 #define MEDIA_BASE_FAKE_MEDIA_ENGINE_H_ 13 14 #include <atomic> 15 #include <list> 16 #include <map> 17 #include <memory> 18 #include <set> 19 #include <string> 20 #include <tuple> 21 #include <vector> 22 23 #include "absl/algorithm/container.h" 24 #include "api/call/audio_sink.h" 25 #include "media/base/audio_source.h" 26 #include "media/base/media_engine.h" 27 #include "media/base/rtp_utils.h" 28 #include "media/base/stream_params.h" 29 #include "media/engine/webrtc_video_engine.h" 30 #include "modules/audio_processing/include/audio_processing.h" 31 #include "rtc_base/copy_on_write_buffer.h" 32 #include "rtc_base/network_route.h" 33 #include "rtc_base/thread.h" 34 35 using webrtc::RtpExtension; 36 37 namespace cricket { 38 39 class FakeMediaEngine; 40 class FakeVideoEngine; 41 class FakeVoiceEngine; 42 43 // A common helper class that handles sending and receiving RTP/RTCP packets. 44 template <class Base> 45 class RtpHelper : public Base { 46 public: RtpHelper(webrtc::TaskQueueBase * network_thread)47 explicit RtpHelper(webrtc::TaskQueueBase* network_thread) 48 : Base(network_thread), 49 sending_(false), 50 playout_(false), 51 fail_set_send_codecs_(false), 52 fail_set_recv_codecs_(false), 53 send_ssrc_(0), 54 ready_to_send_(false), 55 transport_overhead_per_packet_(0), 56 num_network_route_changes_(0) {} 57 virtual ~RtpHelper() = default; recv_extensions()58 const std::vector<RtpExtension>& recv_extensions() { 59 return recv_extensions_; 60 } send_extensions()61 const std::vector<RtpExtension>& send_extensions() { 62 return send_extensions_; 63 } sending()64 bool sending() const { return sending_; } playout()65 bool playout() const { return playout_; } rtp_packets()66 const std::list<std::string>& rtp_packets() const { return rtp_packets_; } rtcp_packets()67 const std::list<std::string>& rtcp_packets() const { return rtcp_packets_; } 68 SendRtp(const void * data,size_t len,const rtc::PacketOptions & options)69 bool SendRtp(const void* data, 70 size_t len, 71 const rtc::PacketOptions& options) { 72 if (!sending_) { 73 return false; 74 } 75 rtc::CopyOnWriteBuffer packet(reinterpret_cast<const uint8_t*>(data), len, 76 kMaxRtpPacketLen); 77 return Base::SendPacket(&packet, options); 78 } SendRtcp(const void * data,size_t len)79 bool SendRtcp(const void* data, size_t len) { 80 rtc::CopyOnWriteBuffer packet(reinterpret_cast<const uint8_t*>(data), len, 81 kMaxRtpPacketLen); 82 return Base::SendRtcp(&packet, rtc::PacketOptions()); 83 } 84 CheckRtp(const void * data,size_t len)85 bool CheckRtp(const void* data, size_t len) { 86 bool success = !rtp_packets_.empty(); 87 if (success) { 88 std::string packet = rtp_packets_.front(); 89 rtp_packets_.pop_front(); 90 success = (packet == std::string(static_cast<const char*>(data), len)); 91 } 92 return success; 93 } CheckRtcp(const void * data,size_t len)94 bool CheckRtcp(const void* data, size_t len) { 95 bool success = !rtcp_packets_.empty(); 96 if (success) { 97 std::string packet = rtcp_packets_.front(); 98 rtcp_packets_.pop_front(); 99 success = (packet == std::string(static_cast<const char*>(data), len)); 100 } 101 return success; 102 } CheckNoRtp()103 bool CheckNoRtp() { return rtp_packets_.empty(); } CheckNoRtcp()104 bool CheckNoRtcp() { return rtcp_packets_.empty(); } set_fail_set_send_codecs(bool fail)105 void set_fail_set_send_codecs(bool fail) { fail_set_send_codecs_ = fail; } set_fail_set_recv_codecs(bool fail)106 void set_fail_set_recv_codecs(bool fail) { fail_set_recv_codecs_ = fail; } AddSendStream(const StreamParams & sp)107 virtual bool AddSendStream(const StreamParams& sp) { 108 if (absl::c_linear_search(send_streams_, sp)) { 109 return false; 110 } 111 send_streams_.push_back(sp); 112 rtp_send_parameters_[sp.first_ssrc()] = 113 CreateRtpParametersWithEncodings(sp); 114 return true; 115 } RemoveSendStream(uint32_t ssrc)116 virtual bool RemoveSendStream(uint32_t ssrc) { 117 auto parameters_iterator = rtp_send_parameters_.find(ssrc); 118 if (parameters_iterator != rtp_send_parameters_.end()) { 119 rtp_send_parameters_.erase(parameters_iterator); 120 } 121 return RemoveStreamBySsrc(&send_streams_, ssrc); 122 } ResetUnsignaledRecvStream()123 virtual void ResetUnsignaledRecvStream() {} OnDemuxerCriteriaUpdatePending()124 virtual void OnDemuxerCriteriaUpdatePending() {} OnDemuxerCriteriaUpdateComplete()125 virtual void OnDemuxerCriteriaUpdateComplete() {} 126 AddRecvStream(const StreamParams & sp)127 virtual bool AddRecvStream(const StreamParams& sp) { 128 if (absl::c_linear_search(receive_streams_, sp)) { 129 return false; 130 } 131 receive_streams_.push_back(sp); 132 rtp_receive_parameters_[sp.first_ssrc()] = 133 CreateRtpParametersWithEncodings(sp); 134 return true; 135 } RemoveRecvStream(uint32_t ssrc)136 virtual bool RemoveRecvStream(uint32_t ssrc) { 137 auto parameters_iterator = rtp_receive_parameters_.find(ssrc); 138 if (parameters_iterator != rtp_receive_parameters_.end()) { 139 rtp_receive_parameters_.erase(parameters_iterator); 140 } 141 return RemoveStreamBySsrc(&receive_streams_, ssrc); 142 } 143 GetRtpSendParameters(uint32_t ssrc)144 virtual webrtc::RtpParameters GetRtpSendParameters(uint32_t ssrc) const { 145 auto parameters_iterator = rtp_send_parameters_.find(ssrc); 146 if (parameters_iterator != rtp_send_parameters_.end()) { 147 return parameters_iterator->second; 148 } 149 return webrtc::RtpParameters(); 150 } SetRtpSendParameters(uint32_t ssrc,const webrtc::RtpParameters & parameters,webrtc::SetParametersCallback callback)151 virtual webrtc::RTCError SetRtpSendParameters( 152 uint32_t ssrc, 153 const webrtc::RtpParameters& parameters, 154 webrtc::SetParametersCallback callback) { 155 auto parameters_iterator = rtp_send_parameters_.find(ssrc); 156 if (parameters_iterator != rtp_send_parameters_.end()) { 157 auto result = CheckRtpParametersInvalidModificationAndValues( 158 parameters_iterator->second, parameters); 159 if (!result.ok()) { 160 return webrtc::InvokeSetParametersCallback(callback, result); 161 } 162 163 parameters_iterator->second = parameters; 164 165 return webrtc::InvokeSetParametersCallback(callback, 166 webrtc::RTCError::OK()); 167 } 168 // Replicate the behavior of the real media channel: return false 169 // when setting parameters for unknown SSRCs. 170 return InvokeSetParametersCallback( 171 callback, webrtc::RTCError(webrtc::RTCErrorType::INTERNAL_ERROR)); 172 } 173 GetRtpReceiveParameters(uint32_t ssrc)174 virtual webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const { 175 auto parameters_iterator = rtp_receive_parameters_.find(ssrc); 176 if (parameters_iterator != rtp_receive_parameters_.end()) { 177 return parameters_iterator->second; 178 } 179 return webrtc::RtpParameters(); 180 } GetDefaultRtpReceiveParameters()181 virtual webrtc::RtpParameters GetDefaultRtpReceiveParameters() const { 182 return webrtc::RtpParameters(); 183 } 184 IsStreamMuted(uint32_t ssrc)185 bool IsStreamMuted(uint32_t ssrc) const { 186 bool ret = muted_streams_.find(ssrc) != muted_streams_.end(); 187 // If |ssrc = 0| check if the first send stream is muted. 188 if (!ret && ssrc == 0 && !send_streams_.empty()) { 189 return muted_streams_.find(send_streams_[0].first_ssrc()) != 190 muted_streams_.end(); 191 } 192 return ret; 193 } send_streams()194 const std::vector<StreamParams>& send_streams() const { 195 return send_streams_; 196 } recv_streams()197 const std::vector<StreamParams>& recv_streams() const { 198 return receive_streams_; 199 } HasRecvStream(uint32_t ssrc)200 bool HasRecvStream(uint32_t ssrc) const { 201 return GetStreamBySsrc(receive_streams_, ssrc) != nullptr; 202 } HasSendStream(uint32_t ssrc)203 bool HasSendStream(uint32_t ssrc) const { 204 return GetStreamBySsrc(send_streams_, ssrc) != nullptr; 205 } 206 // TODO(perkj): This is to support legacy unit test that only check one 207 // sending stream. send_ssrc()208 uint32_t send_ssrc() const { 209 if (send_streams_.empty()) 210 return 0; 211 return send_streams_[0].first_ssrc(); 212 } 213 214 // TODO(perkj): This is to support legacy unit test that only check one 215 // sending stream. rtcp_cname()216 const std::string rtcp_cname() { 217 if (send_streams_.empty()) 218 return ""; 219 return send_streams_[0].cname; 220 } send_rtcp_parameters()221 const RtcpParameters& send_rtcp_parameters() { return send_rtcp_parameters_; } recv_rtcp_parameters()222 const RtcpParameters& recv_rtcp_parameters() { return recv_rtcp_parameters_; } 223 ready_to_send()224 bool ready_to_send() const { return ready_to_send_; } 225 transport_overhead_per_packet()226 int transport_overhead_per_packet() const { 227 return transport_overhead_per_packet_; 228 } 229 last_network_route()230 rtc::NetworkRoute last_network_route() const { return last_network_route_; } num_network_route_changes()231 int num_network_route_changes() const { return num_network_route_changes_; } set_num_network_route_changes(int changes)232 void set_num_network_route_changes(int changes) { 233 num_network_route_changes_ = changes; 234 } 235 OnRtcpPacketReceived(rtc::CopyOnWriteBuffer * packet,int64_t packet_time_us)236 void OnRtcpPacketReceived(rtc::CopyOnWriteBuffer* packet, 237 int64_t packet_time_us) { 238 rtcp_packets_.push_back(std::string(packet->cdata<char>(), packet->size())); 239 } 240 241 protected: MuteStream(uint32_t ssrc,bool mute)242 bool MuteStream(uint32_t ssrc, bool mute) { 243 if (!HasSendStream(ssrc) && ssrc != 0) { 244 return false; 245 } 246 if (mute) { 247 muted_streams_.insert(ssrc); 248 } else { 249 muted_streams_.erase(ssrc); 250 } 251 return true; 252 } set_sending(bool send)253 bool set_sending(bool send) { 254 sending_ = send; 255 return true; 256 } set_playout(bool playout)257 void set_playout(bool playout) { playout_ = playout; } SetRecvRtpHeaderExtensions(const std::vector<RtpExtension> & extensions)258 bool SetRecvRtpHeaderExtensions(const std::vector<RtpExtension>& extensions) { 259 recv_extensions_ = extensions; 260 return true; 261 } SetSendExtmapAllowMixed(bool extmap_allow_mixed)262 bool SetSendExtmapAllowMixed(bool extmap_allow_mixed) { 263 if (Base::ExtmapAllowMixed() != extmap_allow_mixed) { 264 Base::SetExtmapAllowMixed(extmap_allow_mixed); 265 } 266 return true; 267 } SetSendRtpHeaderExtensions(const std::vector<RtpExtension> & extensions)268 bool SetSendRtpHeaderExtensions(const std::vector<RtpExtension>& extensions) { 269 send_extensions_ = extensions; 270 return true; 271 } set_send_rtcp_parameters(const RtcpParameters & params)272 void set_send_rtcp_parameters(const RtcpParameters& params) { 273 send_rtcp_parameters_ = params; 274 } set_recv_rtcp_parameters(const RtcpParameters & params)275 void set_recv_rtcp_parameters(const RtcpParameters& params) { 276 recv_rtcp_parameters_ = params; 277 } OnPacketReceived(rtc::CopyOnWriteBuffer packet,int64_t packet_time_us)278 void OnPacketReceived(rtc::CopyOnWriteBuffer packet, 279 int64_t packet_time_us) override { 280 rtp_packets_.push_back(std::string(packet.cdata<char>(), packet.size())); 281 } OnPacketSent(const rtc::SentPacket & sent_packet)282 void OnPacketSent(const rtc::SentPacket& sent_packet) override {} OnReadyToSend(bool ready)283 void OnReadyToSend(bool ready) override { ready_to_send_ = ready; } OnNetworkRouteChanged(absl::string_view transport_name,const rtc::NetworkRoute & network_route)284 void OnNetworkRouteChanged(absl::string_view transport_name, 285 const rtc::NetworkRoute& network_route) override { 286 last_network_route_ = network_route; 287 ++num_network_route_changes_; 288 transport_overhead_per_packet_ = network_route.packet_overhead; 289 } fail_set_send_codecs()290 bool fail_set_send_codecs() const { return fail_set_send_codecs_; } fail_set_recv_codecs()291 bool fail_set_recv_codecs() const { return fail_set_recv_codecs_; } 292 293 private: 294 // TODO(bugs.webrtc.org/12783): This flag is used from more than one thread. 295 // As a workaround for tsan, it's currently std::atomic but that might not 296 // be the appropriate fix. 297 std::atomic<bool> sending_; 298 bool playout_; 299 std::vector<RtpExtension> recv_extensions_; 300 std::vector<RtpExtension> send_extensions_; 301 std::list<std::string> rtp_packets_; 302 std::list<std::string> rtcp_packets_; 303 std::vector<StreamParams> send_streams_; 304 std::vector<StreamParams> receive_streams_; 305 RtcpParameters send_rtcp_parameters_; 306 RtcpParameters recv_rtcp_parameters_; 307 std::set<uint32_t> muted_streams_; 308 std::map<uint32_t, webrtc::RtpParameters> rtp_send_parameters_; 309 std::map<uint32_t, webrtc::RtpParameters> rtp_receive_parameters_; 310 bool fail_set_send_codecs_; 311 bool fail_set_recv_codecs_; 312 uint32_t send_ssrc_; 313 std::string rtcp_cname_; 314 bool ready_to_send_; 315 int transport_overhead_per_packet_; 316 rtc::NetworkRoute last_network_route_; 317 int num_network_route_changes_; 318 }; 319 320 class FakeVoiceMediaChannel : public RtpHelper<VoiceMediaChannel> { 321 public: 322 struct DtmfInfo { 323 DtmfInfo(uint32_t ssrc, int event_code, int duration); 324 uint32_t ssrc; 325 int event_code; 326 int duration; 327 }; 328 FakeVoiceMediaChannel(FakeVoiceEngine* engine, 329 const AudioOptions& options, 330 webrtc::TaskQueueBase* network_thread); 331 ~FakeVoiceMediaChannel(); 332 const std::vector<AudioCodec>& recv_codecs() const; 333 const std::vector<AudioCodec>& send_codecs() const; 334 const std::vector<AudioCodec>& codecs() const; 335 const std::vector<DtmfInfo>& dtmf_info_queue() const; 336 const AudioOptions& options() const; 337 int max_bps() const; 338 bool SetSendParameters(const AudioSendParameters& params) override; 339 340 bool SetRecvParameters(const AudioRecvParameters& params) override; 341 342 void SetPlayout(bool playout) override; 343 void SetSend(bool send) override; 344 bool SetAudioSend(uint32_t ssrc, 345 bool enable, 346 const AudioOptions* options, 347 AudioSource* source) override; 348 349 bool HasSource(uint32_t ssrc) const; 350 351 bool AddRecvStream(const StreamParams& sp) override; 352 bool RemoveRecvStream(uint32_t ssrc) override; 353 354 bool CanInsertDtmf() override; 355 bool InsertDtmf(uint32_t ssrc, int event_code, int duration) override; 356 357 bool SetOutputVolume(uint32_t ssrc, double volume) override; 358 bool SetDefaultOutputVolume(double volume) override; 359 360 bool GetOutputVolume(uint32_t ssrc, double* volume); 361 362 bool SetBaseMinimumPlayoutDelayMs(uint32_t ssrc, int delay_ms) override; 363 absl::optional<int> GetBaseMinimumPlayoutDelayMs( 364 uint32_t ssrc) const override; 365 366 bool GetStats(VoiceMediaInfo* info, bool get_and_clear_legacy_stats) override; 367 368 void SetRawAudioSink( 369 uint32_t ssrc, 370 std::unique_ptr<webrtc::AudioSinkInterface> sink) override; 371 void SetDefaultRawAudioSink( 372 std::unique_ptr<webrtc::AudioSinkInterface> sink) override; 373 374 std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const override; 375 376 private: 377 class VoiceChannelAudioSink : public AudioSource::Sink { 378 public: 379 explicit VoiceChannelAudioSink(AudioSource* source); 380 ~VoiceChannelAudioSink() override; 381 void OnData(const void* audio_data, 382 int bits_per_sample, 383 int sample_rate, 384 size_t number_of_channels, 385 size_t number_of_frames, 386 absl::optional<int64_t> absolute_capture_timestamp_ms) override; 387 void OnClose() override; NumPreferredChannels()388 int NumPreferredChannels() const override { return -1; } 389 AudioSource* source() const; 390 391 private: 392 AudioSource* source_; 393 }; 394 395 bool SetRecvCodecs(const std::vector<AudioCodec>& codecs); 396 bool SetSendCodecs(const std::vector<AudioCodec>& codecs); 397 bool SetMaxSendBandwidth(int bps); 398 bool SetOptions(const AudioOptions& options); 399 bool SetLocalSource(uint32_t ssrc, AudioSource* source); 400 401 FakeVoiceEngine* engine_; 402 std::vector<AudioCodec> recv_codecs_; 403 std::vector<AudioCodec> send_codecs_; 404 std::map<uint32_t, double> output_scalings_; 405 std::map<uint32_t, int> output_delays_; 406 std::vector<DtmfInfo> dtmf_info_queue_; 407 AudioOptions options_; 408 std::map<uint32_t, std::unique_ptr<VoiceChannelAudioSink>> local_sinks_; 409 std::unique_ptr<webrtc::AudioSinkInterface> sink_; 410 int max_bps_; 411 }; 412 413 // A helper function to compare the FakeVoiceMediaChannel::DtmfInfo. 414 bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info, 415 uint32_t ssrc, 416 int event_code, 417 int duration); 418 419 class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> { 420 public: 421 FakeVideoMediaChannel(FakeVideoEngine* engine, 422 const VideoOptions& options, 423 webrtc::TaskQueueBase* network_thread); 424 425 ~FakeVideoMediaChannel(); 426 427 const std::vector<VideoCodec>& recv_codecs() const; 428 const std::vector<VideoCodec>& send_codecs() const; 429 const std::vector<VideoCodec>& codecs() const; 430 bool rendering() const; 431 const VideoOptions& options() const; 432 const std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*>& 433 sinks() const; 434 int max_bps() const; 435 bool SetSendParameters(const VideoSendParameters& params) override; 436 bool SetRecvParameters(const VideoRecvParameters& params) override; 437 bool AddSendStream(const StreamParams& sp) override; 438 bool RemoveSendStream(uint32_t ssrc) override; 439 440 bool GetSendCodec(VideoCodec* send_codec) override; 441 bool SetSink(uint32_t ssrc, 442 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override; 443 void SetDefaultSink( 444 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override; 445 bool HasSink(uint32_t ssrc) const; 446 447 bool SetSend(bool send) override; 448 bool SetVideoSend( 449 uint32_t ssrc, 450 const VideoOptions* options, 451 rtc::VideoSourceInterface<webrtc::VideoFrame>* source) override; 452 453 bool HasSource(uint32_t ssrc) const; 454 bool AddRecvStream(const StreamParams& sp) override; 455 bool RemoveRecvStream(uint32_t ssrc) override; 456 457 void FillBitrateInfo(BandwidthEstimationInfo* bwe_info) override; 458 bool GetStats(VideoMediaInfo* info) override; 459 460 std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const override; 461 462 bool SetBaseMinimumPlayoutDelayMs(uint32_t ssrc, int delay_ms) override; 463 absl::optional<int> GetBaseMinimumPlayoutDelayMs( 464 uint32_t ssrc) const override; 465 466 void SetRecordableEncodedFrameCallback( 467 uint32_t ssrc, 468 std::function<void(const webrtc::RecordableEncodedFrame&)> callback) 469 override; 470 void ClearRecordableEncodedFrameCallback(uint32_t ssrc) override; 471 void RequestRecvKeyFrame(uint32_t ssrc) override; 472 void GenerateSendKeyFrame(uint32_t ssrc, 473 const std::vector<std::string>& rids) override; 474 475 private: 476 bool SetRecvCodecs(const std::vector<VideoCodec>& codecs); 477 bool SetSendCodecs(const std::vector<VideoCodec>& codecs); 478 bool SetOptions(const VideoOptions& options); 479 bool SetMaxSendBandwidth(int bps); 480 481 FakeVideoEngine* engine_; 482 std::vector<VideoCodec> recv_codecs_; 483 std::vector<VideoCodec> send_codecs_; 484 std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*> sinks_; 485 std::map<uint32_t, rtc::VideoSourceInterface<webrtc::VideoFrame>*> sources_; 486 std::map<uint32_t, int> output_delays_; 487 VideoOptions options_; 488 int max_bps_; 489 }; 490 491 class FakeVoiceEngine : public VoiceEngineInterface { 492 public: 493 FakeVoiceEngine(); 494 void Init() override; 495 rtc::scoped_refptr<webrtc::AudioState> GetAudioState() const override; 496 497 VoiceMediaChannel* CreateMediaChannel( 498 webrtc::Call* call, 499 const MediaConfig& config, 500 const AudioOptions& options, 501 const webrtc::CryptoOptions& crypto_options) override; 502 FakeVoiceMediaChannel* GetChannel(size_t index); 503 void UnregisterChannel(VoiceMediaChannel* channel); 504 505 // TODO(ossu): For proper testing, These should either individually settable 506 // or the voice engine should reference mockable factories. 507 const std::vector<AudioCodec>& send_codecs() const override; 508 const std::vector<AudioCodec>& recv_codecs() const override; 509 void SetCodecs(const std::vector<AudioCodec>& codecs); 510 void SetRecvCodecs(const std::vector<AudioCodec>& codecs); 511 void SetSendCodecs(const std::vector<AudioCodec>& codecs); 512 int GetInputLevel(); 513 bool StartAecDump(webrtc::FileWrapper file, int64_t max_size_bytes) override; 514 void StopAecDump() override; 515 std::vector<webrtc::RtpHeaderExtensionCapability> GetRtpHeaderExtensions() 516 const override; 517 void SetRtpHeaderExtensions( 518 std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions); 519 520 private: 521 std::vector<FakeVoiceMediaChannel*> channels_; 522 std::vector<AudioCodec> recv_codecs_; 523 std::vector<AudioCodec> send_codecs_; 524 bool fail_create_channel_; 525 std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions_; 526 527 friend class FakeMediaEngine; 528 }; 529 530 class FakeVideoEngine : public VideoEngineInterface { 531 public: 532 FakeVideoEngine(); 533 bool SetOptions(const VideoOptions& options); 534 VideoMediaChannel* CreateMediaChannel( 535 webrtc::Call* call, 536 const MediaConfig& config, 537 const VideoOptions& options, 538 const webrtc::CryptoOptions& crypto_options, 539 webrtc::VideoBitrateAllocatorFactory* video_bitrate_allocator_factory) 540 override; 541 FakeVideoMediaChannel* GetChannel(size_t index); 542 void UnregisterChannel(VideoMediaChannel* channel); send_codecs()543 std::vector<VideoCodec> send_codecs() const override { 544 return send_codecs(true); 545 } recv_codecs()546 std::vector<VideoCodec> recv_codecs() const override { 547 return recv_codecs(true); 548 } 549 std::vector<VideoCodec> send_codecs(bool include_rtx) const override; 550 std::vector<VideoCodec> recv_codecs(bool include_rtx) const override; 551 void SetSendCodecs(const std::vector<VideoCodec>& codecs); 552 void SetRecvCodecs(const std::vector<VideoCodec>& codecs); 553 bool SetCapture(bool capture); 554 std::vector<webrtc::RtpHeaderExtensionCapability> GetRtpHeaderExtensions() 555 const override; 556 void SetRtpHeaderExtensions( 557 std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions); 558 559 private: 560 std::vector<FakeVideoMediaChannel*> channels_; 561 std::vector<VideoCodec> send_codecs_; 562 std::vector<VideoCodec> recv_codecs_; 563 bool capture_; 564 VideoOptions options_; 565 bool fail_create_channel_; 566 std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions_; 567 568 friend class FakeMediaEngine; 569 }; 570 571 class FakeMediaEngine : public CompositeMediaEngine { 572 public: 573 FakeMediaEngine(); 574 575 ~FakeMediaEngine() override; 576 577 void SetAudioCodecs(const std::vector<AudioCodec>& codecs); 578 void SetAudioRecvCodecs(const std::vector<AudioCodec>& codecs); 579 void SetAudioSendCodecs(const std::vector<AudioCodec>& codecs); 580 void SetVideoCodecs(const std::vector<VideoCodec>& codecs); 581 582 FakeVoiceMediaChannel* GetVoiceChannel(size_t index); 583 FakeVideoMediaChannel* GetVideoChannel(size_t index); 584 585 void set_fail_create_channel(bool fail); 586 587 private: 588 FakeVoiceEngine* const voice_; 589 FakeVideoEngine* const video_; 590 }; 591 592 } // namespace cricket 593 594 #endif // MEDIA_BASE_FAKE_MEDIA_ENGINE_H_ 595