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