fake_media_engine.h (35400B)
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 <cstddef> 16 #include <cstdint> 17 #include <functional> 18 #include <list> 19 #include <map> 20 #include <memory> 21 #include <optional> 22 #include <set> 23 #include <string> 24 #include <utility> 25 #include <vector> 26 27 #include "absl/algorithm/container.h" 28 #include "absl/base/nullability.h" 29 #include "absl/functional/any_invocable.h" 30 #include "absl/strings/string_view.h" 31 #include "api/audio/audio_device.h" 32 #include "api/audio_codecs/audio_codec_pair_id.h" 33 #include "api/audio_codecs/audio_decoder.h" 34 #include "api/audio_codecs/audio_decoder_factory.h" 35 #include "api/audio_codecs/audio_encoder.h" 36 #include "api/audio_codecs/audio_encoder_factory.h" 37 #include "api/audio_codecs/audio_format.h" 38 #include "api/audio_options.h" 39 #include "api/call/audio_sink.h" 40 #include "api/crypto/crypto_options.h" 41 #include "api/crypto/frame_decryptor_interface.h" 42 #include "api/crypto/frame_encryptor_interface.h" 43 #include "api/environment/environment.h" 44 #include "api/field_trials_view.h" 45 #include "api/frame_transformer_interface.h" 46 #include "api/media_types.h" 47 #include "api/rtc_error.h" 48 #include "api/rtp_headers.h" 49 #include "api/rtp_parameters.h" 50 #include "api/rtp_sender_interface.h" 51 #include "api/scoped_refptr.h" 52 #include "api/task_queue/task_queue_base.h" 53 #include "api/transport/rtp/rtp_source.h" 54 #include "api/video/recordable_encoded_frame.h" 55 #include "api/video/video_bitrate_allocator_factory.h" 56 #include "api/video/video_sink_interface.h" 57 #include "api/video/video_source_interface.h" 58 #include "call/audio_state.h" 59 #include "media/base/audio_source.h" 60 #include "media/base/codec.h" 61 #include "media/base/media_channel.h" 62 #include "media/base/media_channel_impl.h" 63 #include "media/base/media_config.h" 64 #include "media/base/media_engine.h" 65 #include "media/base/rtp_utils.h" 66 #include "media/base/stream_params.h" 67 #include "modules/rtp_rtcp/source/rtp_packet_received.h" 68 #include "rtc_base/async_packet_socket.h" 69 #include "rtc_base/checks.h" 70 #include "rtc_base/copy_on_write_buffer.h" 71 #include "rtc_base/network/sent_packet.h" 72 #include "rtc_base/network_route.h" 73 #include "rtc_base/system/file_wrapper.h" 74 #include "test/create_test_field_trials.h" 75 76 namespace webrtc { 77 78 class FakeMediaEngine; 79 class FakeVideoEngine; 80 class FakeVoiceEngine; 81 82 // A common helper class that handles sending and receiving RTP/RTCP packets. 83 template <class Base> 84 class RtpReceiveChannelHelper : public Base, public MediaChannelUtil { 85 public: 86 explicit RtpReceiveChannelHelper(TaskQueueBase* network_thread) 87 : MediaChannelUtil(network_thread), 88 playout_(false), 89 fail_set_recv_codecs_(false), 90 transport_overhead_per_packet_(0), 91 num_network_route_changes_(0) {} 92 virtual ~RtpReceiveChannelHelper() = default; 93 const std::vector<RtpExtension>& recv_extensions() { 94 return recv_extensions_; 95 } 96 bool playout() const { return playout_; } 97 const std::list<std::string>& rtp_packets() const { return rtp_packets_; } 98 const std::list<std::string>& rtcp_packets() const { return rtcp_packets_; } 99 100 bool SendRtcp(const void* data, size_t len) { 101 CopyOnWriteBuffer packet(reinterpret_cast<const uint8_t*>(data), len, 102 kMaxRtpPacketLen); 103 return Base::SendRtcp(&packet, AsyncSocketPacketOptions()); 104 } 105 106 bool CheckRtp(const void* data, size_t len) { 107 bool success = !rtp_packets_.empty(); 108 if (success) { 109 std::string packet = rtp_packets_.front(); 110 rtp_packets_.pop_front(); 111 success = (packet == std::string(static_cast<const char*>(data), len)); 112 } 113 return success; 114 } 115 bool CheckRtcp(const void* data, size_t len) { 116 bool success = !rtcp_packets_.empty(); 117 if (success) { 118 std::string packet = rtcp_packets_.front(); 119 rtcp_packets_.pop_front(); 120 success = (packet == std::string(static_cast<const char*>(data), len)); 121 } 122 return success; 123 } 124 bool CheckNoRtp() { return rtp_packets_.empty(); } 125 bool CheckNoRtcp() { return rtcp_packets_.empty(); } 126 void set_fail_set_recv_codecs(bool fail) { fail_set_recv_codecs_ = fail; } 127 void ResetUnsignaledRecvStream() override {} 128 std::optional<uint32_t> GetUnsignaledSsrc() const override { 129 return std::nullopt; 130 } 131 void ChooseReceiverReportSsrc( 132 const std::set<uint32_t>& /* choices */) override {} 133 134 virtual bool SetLocalSsrc(const StreamParams& /* sp */) { return true; } 135 void OnDemuxerCriteriaUpdatePending() override {} 136 void OnDemuxerCriteriaUpdateComplete() override {} 137 138 bool AddRecvStream(const StreamParams& sp) override { 139 if (absl::c_linear_search(receive_streams_, sp)) { 140 return false; 141 } 142 receive_streams_.push_back(sp); 143 rtp_receive_parameters_[sp.first_ssrc()] = 144 CreateRtpParametersWithEncodings(sp); 145 return true; 146 } 147 bool RemoveRecvStream(uint32_t ssrc) override { 148 auto parameters_iterator = rtp_receive_parameters_.find(ssrc); 149 if (parameters_iterator != rtp_receive_parameters_.end()) { 150 rtp_receive_parameters_.erase(parameters_iterator); 151 } 152 return RemoveStreamBySsrc(&receive_streams_, ssrc); 153 } 154 155 RtpParameters GetRtpReceiverParameters(uint32_t ssrc) const override { 156 auto parameters_iterator = rtp_receive_parameters_.find(ssrc); 157 if (parameters_iterator != rtp_receive_parameters_.end()) { 158 return parameters_iterator->second; 159 } 160 return RtpParameters(); 161 } 162 RtpParameters GetDefaultRtpReceiveParameters() const override { 163 return RtpParameters(); 164 } 165 166 const std::vector<StreamParams>& recv_streams() const { 167 return receive_streams_; 168 } 169 bool HasRecvStream(uint32_t ssrc) const { 170 return GetStreamBySsrc(receive_streams_, ssrc) != nullptr; 171 } 172 173 const MediaChannelParameters::RtcpParameters& recv_rtcp_parameters() { 174 return recv_rtcp_parameters_; 175 } 176 177 int transport_overhead_per_packet() const { 178 return transport_overhead_per_packet_; 179 } 180 181 NetworkRoute last_network_route() const { return last_network_route_; } 182 int num_network_route_changes() const { return num_network_route_changes_; } 183 void set_num_network_route_changes(int changes) { 184 num_network_route_changes_ = changes; 185 } 186 187 void OnRtcpPacketReceived(CopyOnWriteBuffer* packet, 188 int64_t /* packet_time_us */) { 189 rtcp_packets_.push_back(std::string(packet->cdata<char>(), packet->size())); 190 } 191 192 void SetFrameDecryptor(uint32_t /* ssrc */, 193 scoped_refptr<FrameDecryptorInterface> 194 /* frame_decryptor */) override {} 195 196 void SetDepacketizerToDecoderFrameTransformer( 197 uint32_t /* ssrc */, 198 scoped_refptr<FrameTransformerInterface> /* frame_transformer */) 199 override {} 200 201 void SetInterface(MediaChannelNetworkInterface* iface) override { 202 network_interface_ = iface; 203 MediaChannelUtil::SetInterface(iface); 204 } 205 206 protected: 207 void set_playout(bool playout) { playout_ = playout; } 208 bool SetRecvRtpHeaderExtensions(const std::vector<RtpExtension>& extensions) { 209 recv_extensions_ = extensions; 210 return true; 211 } 212 void set_recv_rtcp_parameters( 213 const MediaChannelParameters::RtcpParameters& params) { 214 recv_rtcp_parameters_ = params; 215 } 216 void OnPacketReceived(const RtpPacketReceived& packet) override { 217 rtp_packets_.push_back( 218 std::string(packet.Buffer().cdata<char>(), packet.size())); 219 } 220 bool fail_set_recv_codecs() const { return fail_set_recv_codecs_; } 221 222 private: 223 bool playout_; 224 std::vector<RtpExtension> recv_extensions_; 225 std::list<std::string> rtp_packets_; 226 std::list<std::string> rtcp_packets_; 227 std::vector<StreamParams> receive_streams_; 228 MediaChannelParameters::RtcpParameters recv_rtcp_parameters_; 229 std::map<uint32_t, RtpParameters> rtp_receive_parameters_; 230 bool fail_set_recv_codecs_; 231 std::string rtcp_cname_; 232 int transport_overhead_per_packet_; 233 NetworkRoute last_network_route_; 234 int num_network_route_changes_; 235 MediaChannelNetworkInterface* network_interface_ = nullptr; 236 }; 237 238 // A common helper class that handles sending and receiving RTP/RTCP packets. 239 template <class Base> 240 class RtpSendChannelHelper : public Base, public MediaChannelUtil { 241 public: 242 explicit RtpSendChannelHelper(TaskQueueBase* network_thread) 243 : MediaChannelUtil(network_thread), 244 sending_(false), 245 fail_set_send_codecs_(false), 246 send_ssrc_(0), 247 ready_to_send_(false), 248 transport_overhead_per_packet_(0), 249 num_network_route_changes_(0) {} 250 virtual ~RtpSendChannelHelper() = default; 251 const std::vector<RtpExtension>& send_extensions() { 252 return send_extensions_; 253 } 254 bool sending() const { return sending_; } 255 const std::list<std::string>& rtp_packets() const { return rtp_packets_; } 256 const std::list<std::string>& rtcp_packets() const { return rtcp_packets_; } 257 258 bool SendPacket(const void* data, 259 size_t len, 260 const AsyncSocketPacketOptions& options) { 261 if (!sending_) { 262 return false; 263 } 264 CopyOnWriteBuffer packet(reinterpret_cast<const uint8_t*>(data), len, 265 kMaxRtpPacketLen); 266 return MediaChannelUtil::SendPacket(&packet, options); 267 } 268 bool SendRtcp(const void* data, size_t len) { 269 CopyOnWriteBuffer packet(reinterpret_cast<const uint8_t*>(data), len, 270 kMaxRtpPacketLen); 271 return MediaChannelUtil::SendRtcp(&packet, AsyncSocketPacketOptions()); 272 } 273 274 bool CheckRtp(const void* data, size_t len) { 275 bool success = !rtp_packets_.empty(); 276 if (success) { 277 std::string packet = rtp_packets_.front(); 278 rtp_packets_.pop_front(); 279 success = (packet == std::string(static_cast<const char*>(data), len)); 280 } 281 return success; 282 } 283 bool CheckRtcp(const void* data, size_t len) { 284 bool success = !rtcp_packets_.empty(); 285 if (success) { 286 std::string packet = rtcp_packets_.front(); 287 rtcp_packets_.pop_front(); 288 success = (packet == std::string(static_cast<const char*>(data), len)); 289 } 290 return success; 291 } 292 bool CheckNoRtp() { return rtp_packets_.empty(); } 293 bool CheckNoRtcp() { return rtcp_packets_.empty(); } 294 void set_fail_set_send_codecs(bool fail) { fail_set_send_codecs_ = fail; } 295 bool AddSendStream(const StreamParams& sp) override { 296 if (absl::c_linear_search(send_streams_, sp)) { 297 return false; 298 } 299 send_streams_.push_back(sp); 300 rtp_send_parameters_[sp.first_ssrc()] = 301 CreateRtpParametersWithEncodings(sp); 302 303 if (ssrc_list_changed_callback_) { 304 std::set<uint32_t> ssrcs_in_use; 305 for (const auto& send_stream : send_streams_) { 306 ssrcs_in_use.insert(send_stream.first_ssrc()); 307 } 308 ssrc_list_changed_callback_(ssrcs_in_use); 309 } 310 311 return true; 312 } 313 bool RemoveSendStream(uint32_t ssrc) override { 314 auto parameters_iterator = rtp_send_parameters_.find(ssrc); 315 if (parameters_iterator != rtp_send_parameters_.end()) { 316 rtp_send_parameters_.erase(parameters_iterator); 317 } 318 return RemoveStreamBySsrc(&send_streams_, ssrc); 319 } 320 void SetSsrcListChangedCallback( 321 absl::AnyInvocable<void(const std::set<uint32_t>&)> callback) override { 322 ssrc_list_changed_callback_ = std::move(callback); 323 } 324 325 void SetExtmapAllowMixed(bool extmap_allow_mixed) override { 326 return MediaChannelUtil::SetExtmapAllowMixed(extmap_allow_mixed); 327 } 328 bool ExtmapAllowMixed() const override { 329 return MediaChannelUtil::ExtmapAllowMixed(); 330 } 331 332 RtpParameters GetRtpSendParameters(uint32_t ssrc) const override { 333 auto parameters_iterator = rtp_send_parameters_.find(ssrc); 334 if (parameters_iterator != rtp_send_parameters_.end()) { 335 // Take header extensions from channel global, not iterated. 336 auto parameters = parameters_iterator->second; 337 parameters.header_extensions = send_extensions_; 338 return parameters; 339 } 340 return RtpParameters(); 341 } 342 RTCError SetRtpSendParameters(uint32_t ssrc, 343 const RtpParameters& parameters, 344 SetParametersCallback callback) override { 345 auto parameters_iterator = rtp_send_parameters_.find(ssrc); 346 if (parameters_iterator != rtp_send_parameters_.end()) { 347 auto result = CheckRtpParametersInvalidModificationAndValues( 348 parameters_iterator->second, parameters, CreateTestFieldTrials()); 349 if (!result.ok()) { 350 return InvokeSetParametersCallback(callback, result); 351 } 352 353 parameters_iterator->second = parameters; 354 355 return InvokeSetParametersCallback(callback, RTCError::OK()); 356 } 357 // Replicate the behavior of the real media channel: return false 358 // when setting parameters for unknown SSRCs. 359 return InvokeSetParametersCallback(callback, 360 RTCError(RTCErrorType::INTERNAL_ERROR)); 361 } 362 363 bool IsStreamMuted(uint32_t ssrc) const { 364 bool ret = muted_streams_.find(ssrc) != muted_streams_.end(); 365 // If |ssrc = 0| check if the first send stream is muted. 366 if (!ret && ssrc == 0 && !send_streams_.empty()) { 367 return muted_streams_.find(send_streams_[0].first_ssrc()) != 368 muted_streams_.end(); 369 } 370 return ret; 371 } 372 const std::vector<StreamParams>& send_streams() const { 373 return send_streams_; 374 } 375 bool HasSendStream(uint32_t ssrc) const { 376 return GetStreamBySsrc(send_streams_, ssrc) != nullptr; 377 } 378 // TODO(perkj): This is to support legacy unit test that only check one 379 // sending stream. 380 uint32_t send_ssrc() const { 381 if (send_streams_.empty()) 382 return 0; 383 return send_streams_[0].first_ssrc(); 384 } 385 386 const MediaChannelParameters::RtcpParameters& send_rtcp_parameters() { 387 return send_rtcp_parameters_; 388 } 389 390 bool ready_to_send() const { return ready_to_send_; } 391 392 int transport_overhead_per_packet() const { 393 return transport_overhead_per_packet_; 394 } 395 396 NetworkRoute last_network_route() const { return last_network_route_; } 397 int num_network_route_changes() const { return num_network_route_changes_; } 398 void set_num_network_route_changes(int changes) { 399 num_network_route_changes_ = changes; 400 } 401 402 void OnRtcpPacketReceived(CopyOnWriteBuffer* packet, 403 int64_t /* packet_time_us */) { 404 rtcp_packets_.push_back(std::string(packet->cdata<char>(), packet->size())); 405 } 406 407 // Stuff that deals with encryptors, transformers and the like 408 void SetFrameEncryptor(uint32_t /* ssrc */, 409 scoped_refptr<FrameEncryptorInterface> 410 /* frame_encryptor */) override {} 411 void SetEncoderToPacketizerFrameTransformer( 412 uint32_t /* ssrc */, 413 scoped_refptr<FrameTransformerInterface> /* frame_transformer */) 414 override {} 415 416 void SetInterface(MediaChannelNetworkInterface* iface) override { 417 network_interface_ = iface; 418 MediaChannelUtil::SetInterface(iface); 419 } 420 bool HasNetworkInterface() const override { 421 return network_interface_ != nullptr; 422 } 423 424 protected: 425 bool MuteStream(uint32_t ssrc, bool mute) { 426 if (!HasSendStream(ssrc) && ssrc != 0) { 427 return false; 428 } 429 if (mute) { 430 muted_streams_.insert(ssrc); 431 } else { 432 muted_streams_.erase(ssrc); 433 } 434 return true; 435 } 436 bool set_sending(bool send) { 437 sending_ = send; 438 return true; 439 } 440 bool SetSendRtpHeaderExtensions(const std::vector<RtpExtension>& extensions) { 441 send_extensions_ = extensions; 442 return true; 443 } 444 void set_send_rtcp_parameters( 445 const MediaChannelParameters::RtcpParameters& params) { 446 send_rtcp_parameters_ = params; 447 } 448 void OnPacketSent(const SentPacketInfo& /* sent_packet */) override {} 449 void OnReadyToSend(bool ready) override { ready_to_send_ = ready; } 450 void OnNetworkRouteChanged(absl::string_view /* transport_name */, 451 const NetworkRoute& network_route) override { 452 last_network_route_ = network_route; 453 ++num_network_route_changes_; 454 transport_overhead_per_packet_ = network_route.packet_overhead; 455 } 456 bool fail_set_send_codecs() const { return fail_set_send_codecs_; } 457 458 private: 459 // TODO(bugs.webrtc.org/12783): This flag is used from more than one thread. 460 // As a workaround for tsan, it's currently std::atomic but that might not 461 // be the appropriate fix. 462 std::atomic<bool> sending_; 463 std::vector<RtpExtension> send_extensions_; 464 std::list<std::string> rtp_packets_; 465 std::list<std::string> rtcp_packets_; 466 std::vector<StreamParams> send_streams_; 467 MediaChannelParameters::RtcpParameters send_rtcp_parameters_; 468 std::set<uint32_t> muted_streams_; 469 std::map<uint32_t, RtpParameters> rtp_send_parameters_; 470 bool fail_set_send_codecs_; 471 uint32_t send_ssrc_; 472 std::string rtcp_cname_; 473 bool ready_to_send_; 474 int transport_overhead_per_packet_; 475 NetworkRoute last_network_route_; 476 int num_network_route_changes_; 477 MediaChannelNetworkInterface* network_interface_ = nullptr; 478 absl::AnyInvocable<void(const std::set<uint32_t>&)> 479 ssrc_list_changed_callback_ = nullptr; 480 }; 481 482 class FakeVoiceMediaReceiveChannel 483 : public RtpReceiveChannelHelper<VoiceMediaReceiveChannelInterface> { 484 public: 485 struct DtmfInfo { 486 DtmfInfo(uint32_t ssrc, int event_code, int duration); 487 uint32_t ssrc; 488 int event_code; 489 int duration; 490 }; 491 FakeVoiceMediaReceiveChannel(const AudioOptions& options, 492 TaskQueueBase* network_thread); 493 virtual ~FakeVoiceMediaReceiveChannel(); 494 495 // Test methods 496 const std::vector<Codec>& recv_codecs() const; 497 const std::vector<DtmfInfo>& dtmf_info_queue() const; 498 const AudioOptions& options() const; 499 int max_bps() const; 500 bool HasSource(uint32_t ssrc) const; 501 502 // Overrides 503 VideoMediaReceiveChannelInterface* AsVideoReceiveChannel() override { 504 return nullptr; 505 } 506 VoiceMediaReceiveChannelInterface* AsVoiceReceiveChannel() override { 507 return this; 508 } 509 MediaType media_type() const override { return MediaType::AUDIO; } 510 511 bool SetReceiverParameters(const AudioReceiverParameters& params) override; 512 void SetPlayout(bool playout) override; 513 514 bool AddRecvStream(const StreamParams& sp) override; 515 bool RemoveRecvStream(uint32_t ssrc) override; 516 517 bool SetOutputVolume(uint32_t ssrc, double volume) override; 518 bool SetDefaultOutputVolume(double volume) override; 519 520 bool GetOutputVolume(uint32_t ssrc, double* volume); 521 522 bool SetBaseMinimumPlayoutDelayMs(uint32_t ssrc, int delay_ms) override; 523 std::optional<int> GetBaseMinimumPlayoutDelayMs(uint32_t ssrc) const override; 524 525 bool GetStats(VoiceMediaReceiveInfo* info, 526 bool get_and_clear_legacy_stats) override; 527 528 void SetRawAudioSink(uint32_t ssrc, 529 std::unique_ptr<AudioSinkInterface> sink) override; 530 void SetDefaultRawAudioSink( 531 std::unique_ptr<AudioSinkInterface> sink) override; 532 533 ::webrtc::RtcpMode RtcpMode() const override { return recv_rtcp_mode_; } 534 void SetRtcpMode(::webrtc::RtcpMode mode) override { recv_rtcp_mode_ = mode; } 535 std::vector<RtpSource> GetSources(uint32_t ssrc) const override; 536 void SetReceiveNackEnabled(bool /* enabled */) override {} 537 void SetReceiveNonSenderRttEnabled(bool /* enabled */) override {} 538 539 private: 540 class VoiceChannelAudioSink : public AudioSource::Sink { 541 public: 542 explicit VoiceChannelAudioSink(AudioSource* source); 543 ~VoiceChannelAudioSink() override; 544 void OnData(const void* audio_data, 545 int bits_per_sample, 546 int sample_rate, 547 size_t number_of_channels, 548 size_t number_of_frames, 549 std::optional<int64_t> absolute_capture_timestamp_ms) override; 550 void OnClose() override; 551 int NumPreferredChannels() const override { return -1; } 552 AudioSource* source() const; 553 554 private: 555 AudioSource* source_; 556 }; 557 558 bool SetRecvCodecs(const std::vector<Codec>& codecs); 559 bool SetMaxSendBandwidth(int bps); 560 bool SetOptions(const AudioOptions& options); 561 562 std::vector<Codec> recv_codecs_; 563 std::map<uint32_t, double> output_scalings_; 564 std::map<uint32_t, int> output_delays_; 565 std::vector<DtmfInfo> dtmf_info_queue_; 566 AudioOptions options_; 567 std::map<uint32_t, std::unique_ptr<VoiceChannelAudioSink>> local_sinks_; 568 std::unique_ptr<AudioSinkInterface> sink_; 569 int max_bps_; 570 ::webrtc::RtcpMode recv_rtcp_mode_ = RtcpMode::kCompound; 571 }; 572 573 class FakeVoiceMediaSendChannel 574 : public RtpSendChannelHelper<VoiceMediaSendChannelInterface> { 575 public: 576 struct DtmfInfo { 577 DtmfInfo(uint32_t ssrc, int event_code, int duration); 578 uint32_t ssrc; 579 int event_code; 580 int duration; 581 }; 582 FakeVoiceMediaSendChannel(const AudioOptions& options, 583 TaskQueueBase* network_thread); 584 ~FakeVoiceMediaSendChannel() override; 585 586 const std::vector<Codec>& send_codecs() const; 587 const std::vector<DtmfInfo>& dtmf_info_queue() const; 588 const AudioOptions& options() const; 589 int max_bps() const; 590 bool HasSource(uint32_t ssrc) const; 591 bool GetOutputVolume(uint32_t ssrc, double* volume); 592 593 // Overrides 594 VideoMediaSendChannelInterface* AsVideoSendChannel() override { 595 return nullptr; 596 } 597 VoiceMediaSendChannelInterface* AsVoiceSendChannel() override { return this; } 598 MediaType media_type() const override { return MediaType::AUDIO; } 599 600 bool SetSenderParameters(const AudioSenderParameter& params) override; 601 void SetSend(bool send) override; 602 bool SetAudioSend(uint32_t ssrc, 603 bool enable, 604 const AudioOptions* options, 605 AudioSource* source) override; 606 607 bool CanInsertDtmf() override; 608 bool InsertDtmf(uint32_t ssrc, int event_code, int duration) override; 609 610 bool SenderNackEnabled() const override { return false; } 611 bool SenderNonSenderRttEnabled() const override { return false; } 612 void SetReceiveNackEnabled(bool /* enabled */) {} 613 void SetReceiveNonSenderRttEnabled(bool /* enabled */) {} 614 bool SendCodecHasNack() const override { return false; } 615 void SetSendCodecChangedCallback( 616 absl::AnyInvocable<void()> /* callback */) override {} 617 std::optional<Codec> GetSendCodec() const override; 618 619 bool GetStats(VoiceMediaSendInfo* stats) override; 620 621 private: 622 class VoiceChannelAudioSink : public AudioSource::Sink { 623 public: 624 explicit VoiceChannelAudioSink(AudioSource* source); 625 ~VoiceChannelAudioSink() override; 626 void OnData(const void* audio_data, 627 int bits_per_sample, 628 int sample_rate, 629 size_t number_of_channels, 630 size_t number_of_frames, 631 std::optional<int64_t> absolute_capture_timestamp_ms) override; 632 void OnClose() override; 633 int NumPreferredChannels() const override { return -1; } 634 AudioSource* source() const; 635 636 private: 637 AudioSource* source_; 638 }; 639 640 bool SetSendCodecs(const std::vector<Codec>& codecs); 641 bool SetMaxSendBandwidth(int bps); 642 bool SetOptions(const AudioOptions& options); 643 bool SetLocalSource(uint32_t ssrc, AudioSource* source); 644 645 std::vector<Codec> send_codecs_; 646 std::map<uint32_t, double> output_scalings_; 647 std::map<uint32_t, int> output_delays_; 648 std::vector<DtmfInfo> dtmf_info_queue_; 649 AudioOptions options_; 650 std::map<uint32_t, std::unique_ptr<VoiceChannelAudioSink>> local_sinks_; 651 int max_bps_; 652 }; 653 654 // A helper function to compare the FakeVoiceMediaChannel::DtmfInfo. 655 bool CompareDtmfInfo(const FakeVoiceMediaSendChannel::DtmfInfo& info, 656 uint32_t ssrc, 657 int event_code, 658 int duration); 659 660 class FakeVideoMediaReceiveChannel 661 : public RtpReceiveChannelHelper<VideoMediaReceiveChannelInterface> { 662 public: 663 FakeVideoMediaReceiveChannel(const VideoOptions& options, 664 TaskQueueBase* network_thread); 665 666 virtual ~FakeVideoMediaReceiveChannel(); 667 668 VideoMediaReceiveChannelInterface* AsVideoReceiveChannel() override { 669 return this; 670 } 671 VoiceMediaReceiveChannelInterface* AsVoiceReceiveChannel() override { 672 return nullptr; 673 } 674 MediaType media_type() const override { return MediaType::VIDEO; } 675 676 const std::vector<Codec>& recv_codecs() const; 677 const std::vector<Codec>& send_codecs() const; 678 bool rendering() const; 679 const VideoOptions& options() const; 680 const std::map<uint32_t, VideoSinkInterface<VideoFrame>*>& sinks() const; 681 int max_bps() const; 682 bool SetReceiverParameters(const VideoReceiverParameters& params) override; 683 684 bool SetSink(uint32_t ssrc, VideoSinkInterface<VideoFrame>* sink) override; 685 void SetDefaultSink(VideoSinkInterface<VideoFrame>* sink) override; 686 bool HasSink(uint32_t ssrc) const; 687 688 void SetReceive(bool /* receive */) override {} 689 690 bool HasSource(uint32_t ssrc) const; 691 bool AddRecvStream(const StreamParams& sp) override; 692 bool RemoveRecvStream(uint32_t ssrc) override; 693 694 std::vector<RtpSource> GetSources(uint32_t ssrc) const override; 695 696 bool SetBaseMinimumPlayoutDelayMs(uint32_t ssrc, int delay_ms) override; 697 std::optional<int> GetBaseMinimumPlayoutDelayMs(uint32_t ssrc) const override; 698 699 void SetRecordableEncodedFrameCallback( 700 uint32_t ssrc, 701 std::function<void(const RecordableEncodedFrame&)> callback) override; 702 void ClearRecordableEncodedFrameCallback(uint32_t ssrc) override; 703 void RequestRecvKeyFrame(uint32_t ssrc) override; 704 void SetReceiverFeedbackParameters( 705 bool /* lntf_enabled */, 706 bool /* nack_enabled */, 707 RtcpMode /* rtcp_mode */, 708 std::optional<int> /* rtx_time */) override {} 709 bool GetStats(VideoMediaReceiveInfo* info) override; 710 711 bool AddDefaultRecvStreamForTesting(const StreamParams& /* sp */) override { 712 RTC_CHECK_NOTREACHED(); 713 return false; 714 } 715 716 private: 717 bool SetRecvCodecs(const std::vector<Codec>& codecs); 718 bool SetSendCodecs(const std::vector<Codec>& codecs); 719 bool SetOptions(const VideoOptions& options); 720 bool SetMaxSendBandwidth(int bps); 721 722 std::vector<Codec> recv_codecs_; 723 std::map<uint32_t, VideoSinkInterface<VideoFrame>*> sinks_; 724 std::map<uint32_t, VideoSourceInterface<VideoFrame>*> sources_; 725 std::map<uint32_t, int> output_delays_; 726 VideoOptions options_; 727 int max_bps_; 728 }; 729 730 class FakeVideoMediaSendChannel 731 : public RtpSendChannelHelper<VideoMediaSendChannelInterface> { 732 public: 733 FakeVideoMediaSendChannel(const VideoOptions& options, 734 TaskQueueBase* network_thread); 735 736 virtual ~FakeVideoMediaSendChannel(); 737 738 VideoMediaSendChannelInterface* AsVideoSendChannel() override { return this; } 739 VoiceMediaSendChannelInterface* AsVoiceSendChannel() override { 740 return nullptr; 741 } 742 MediaType media_type() const override { return MediaType::VIDEO; } 743 744 const std::vector<Codec>& send_codecs() const; 745 const std::vector<Codec>& codecs() const; 746 const VideoOptions& options() const; 747 const std::map<uint32_t, VideoSinkInterface<VideoFrame>*>& sinks() const; 748 int max_bps() const; 749 bool SetSenderParameters(const VideoSenderParameters& params) override; 750 751 std::optional<Codec> GetSendCodec() const override; 752 753 bool SetSend(bool send) override; 754 bool SetVideoSend(uint32_t ssrc, 755 const VideoOptions* options, 756 VideoSourceInterface<VideoFrame>* source) override; 757 758 bool HasSource(uint32_t ssrc) const; 759 760 void FillBitrateInfo(BandwidthEstimationInfo* bwe_info) override; 761 762 void GenerateSendKeyFrame(uint32_t ssrc, 763 const std::vector<std::string>& rids) override; 764 RtcpMode SendCodecRtcpMode() const override { return RtcpMode::kCompound; } 765 void SetSendCodecChangedCallback( 766 absl::AnyInvocable<void()> /* callback */) override {} 767 void SetSsrcListChangedCallback( 768 absl::AnyInvocable<void(const std::set<uint32_t>&)> /* callback */) 769 override {} 770 771 bool SendCodecHasLntf() const override { return false; } 772 bool SendCodecHasNack() const override { return false; } 773 std::optional<int> SendCodecRtxTime() const override { return std::nullopt; } 774 bool GetStats(VideoMediaSendInfo* info) override; 775 776 private: 777 bool SetSendCodecs(const std::vector<Codec>& codecs); 778 bool SetOptions(const VideoOptions& options); 779 bool SetMaxSendBandwidth(int bps); 780 781 std::vector<Codec> send_codecs_; 782 std::map<uint32_t, VideoSourceInterface<VideoFrame>*> sources_; 783 VideoOptions options_; 784 int max_bps_; 785 }; 786 787 class FakeVoiceEngine : public VoiceEngineInterface { 788 public: 789 FakeVoiceEngine(); 790 void Init() override; 791 scoped_refptr<AudioState> GetAudioState() const override; 792 793 std::unique_ptr<VoiceMediaSendChannelInterface> CreateSendChannel( 794 const Environment& env, 795 Call* call, 796 const MediaConfig& config, 797 const AudioOptions& options, 798 const CryptoOptions& crypto_options, 799 AudioCodecPairId codec_pair_id) override; 800 std::unique_ptr<VoiceMediaReceiveChannelInterface> CreateReceiveChannel( 801 const Environment& env, 802 Call* call, 803 const MediaConfig& config, 804 const AudioOptions& options, 805 const CryptoOptions& crypto_options, 806 AudioCodecPairId codec_pair_id) override; 807 808 // TODO(ossu): For proper testing, These should either individually settable 809 // or the voice engine should reference mockable factories. 810 // TODO: https://issues.webrtc.org/360058654 - stop faking codecs here. 811 const std::vector<Codec>& LegacySendCodecs() const override; 812 const std::vector<Codec>& LegacyRecvCodecs() const override; 813 AudioEncoderFactory* encoder_factory() const override { 814 return encoder_factory_.get(); 815 } 816 AudioDecoderFactory* decoder_factory() const override { 817 return decoder_factory_.get(); 818 } 819 void SetCodecs(const std::vector<Codec>& codecs); 820 void SetRecvCodecs(const std::vector<Codec>& codecs); 821 void SetSendCodecs(const std::vector<Codec>& codecs); 822 int GetInputLevel(); 823 bool StartAecDump(FileWrapper file, int64_t max_size_bytes) override; 824 void StopAecDump() override; 825 std::optional<AudioDeviceModule::Stats> GetAudioDeviceStats() override; 826 std::vector<RtpHeaderExtensionCapability> GetRtpHeaderExtensions( 827 const FieldTrialsView* field_trials) const override; 828 void SetRtpHeaderExtensions( 829 std::vector<RtpHeaderExtensionCapability> header_extensions); 830 831 private: 832 class FakeVoiceEncoderFactory : public AudioEncoderFactory { 833 public: 834 explicit FakeVoiceEncoderFactory(FakeVoiceEngine* owner) : owner_(owner) {} 835 std::vector<AudioCodecSpec> GetSupportedEncoders() override { 836 // The reason for this convoluted mapping is because there are 837 // too many tests that expect to push codecs into the fake voice 838 // engine's "send_codecs/recv_codecs" and have them show up later. 839 std::vector<AudioCodecSpec> specs; 840 for (const auto& codec : owner_->send_codecs_) { 841 specs.push_back( 842 AudioCodecSpec{{codec.name, codec.clockrate, codec.channels}, 843 {codec.clockrate, codec.channels, codec.bitrate}}); 844 } 845 return specs; 846 } 847 std::optional<AudioCodecInfo> QueryAudioEncoder( 848 const SdpAudioFormat& format) override { 849 return std::nullopt; 850 } 851 absl_nullable std::unique_ptr<AudioEncoder> Create( 852 const Environment& env, 853 const SdpAudioFormat& format, 854 Options options) override { 855 return nullptr; 856 } 857 FakeVoiceEngine* owner_; 858 }; 859 class FakeVoiceDecoderFactory : public AudioDecoderFactory { 860 public: 861 explicit FakeVoiceDecoderFactory(FakeVoiceEngine* owner) : owner_(owner) {} 862 std::vector<AudioCodecSpec> GetSupportedDecoders() override { 863 // The reason for this convoluted mapping is because there are 864 // too many tests that expect to push codecs into the fake voice 865 // engine's "send_codecs/recv_codecs" and have them show up later. 866 std::vector<AudioCodecSpec> specs; 867 for (const auto& codec : owner_->recv_codecs_) { 868 specs.push_back( 869 AudioCodecSpec{{codec.name, codec.clockrate, codec.channels}, 870 {codec.clockrate, codec.channels, codec.bitrate}}); 871 } 872 return specs; 873 } 874 bool IsSupportedDecoder(const SdpAudioFormat& format) override { 875 return false; 876 } 877 absl_nullable std::unique_ptr<AudioDecoder> Create( 878 const Environment& env, 879 const SdpAudioFormat& format, 880 std::optional<AudioCodecPairId> codec_pair_id) override { 881 return nullptr; 882 } 883 884 private: 885 FakeVoiceEngine* owner_; 886 }; 887 888 std::vector<Codec> recv_codecs_; 889 std::vector<Codec> send_codecs_; 890 scoped_refptr<FakeVoiceEncoderFactory> encoder_factory_; 891 scoped_refptr<FakeVoiceDecoderFactory> decoder_factory_; 892 std::vector<RtpHeaderExtensionCapability> header_extensions_; 893 894 friend class FakeMediaEngine; 895 }; 896 897 class FakeVideoEngine : public VideoEngineInterface { 898 public: 899 FakeVideoEngine(); 900 bool SetOptions(const VideoOptions& options); 901 std::unique_ptr<VideoMediaSendChannelInterface> CreateSendChannel( 902 const Environment& env, 903 Call* call, 904 const MediaConfig& config, 905 const VideoOptions& options, 906 const CryptoOptions& crypto_options, 907 VideoBitrateAllocatorFactory* video_bitrate_allocator_factory) override; 908 std::unique_ptr<VideoMediaReceiveChannelInterface> CreateReceiveChannel( 909 const Environment& env, 910 Call* call, 911 const MediaConfig& config, 912 const VideoOptions& options, 913 const CryptoOptions& crypto_options) override; 914 FakeVideoMediaSendChannel* GetSendChannel(size_t index); 915 FakeVideoMediaReceiveChannel* GetReceiveChannel(size_t index); 916 917 std::vector<Codec> LegacySendCodecs() const override { 918 return LegacySendCodecs(true); 919 } 920 std::vector<Codec> LegacyRecvCodecs() const override { 921 return LegacyRecvCodecs(true); 922 } 923 std::vector<Codec> LegacySendCodecs(bool include_rtx) const override; 924 std::vector<Codec> LegacyRecvCodecs(bool include_rtx) const override; 925 void SetSendCodecs(const std::vector<Codec>& codecs); 926 void SetRecvCodecs(const std::vector<Codec>& codecs); 927 bool SetCapture(bool capture); 928 std::vector<RtpHeaderExtensionCapability> GetRtpHeaderExtensions( 929 const FieldTrialsView* field_trials) const override; 930 void SetRtpHeaderExtensions( 931 std::vector<RtpHeaderExtensionCapability> header_extensions); 932 933 private: 934 std::vector<Codec> send_codecs_; 935 std::vector<Codec> recv_codecs_; 936 bool capture_; 937 VideoOptions options_; 938 std::vector<RtpHeaderExtensionCapability> header_extensions_; 939 940 friend class FakeMediaEngine; 941 }; 942 943 class FakeMediaEngine : public CompositeMediaEngine { 944 public: 945 FakeMediaEngine(); 946 947 ~FakeMediaEngine() override; 948 949 void SetAudioCodecs(const std::vector<Codec>& codecs); 950 void SetAudioRecvCodecs(const std::vector<Codec>& codecs); 951 void SetAudioSendCodecs(const std::vector<Codec>& codecs); 952 void SetVideoCodecs(const std::vector<Codec>& codecs); 953 void SetVideoRecvCodecs(const std::vector<Codec>& codecs); 954 void SetVideoSendCodecs(const std::vector<Codec>& codecs); 955 956 FakeVoiceEngine* fake_voice_engine() { return voice_; } 957 FakeVideoEngine* fake_video_engine() { return video_; } 958 959 private: 960 FakeVoiceEngine* const voice_; 961 FakeVideoEngine* const video_; 962 }; 963 964 } // namespace webrtc 965 966 967 #endif // MEDIA_BASE_FAKE_MEDIA_ENGINE_H_