fake_webrtc_call.cc (23783B)
1 /* 2 * Copyright (c) 2015 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/engine/fake_webrtc_call.h" 12 13 #include <cstddef> 14 #include <cstdint> 15 #include <map> 16 #include <string> 17 #include <utility> 18 #include <vector> 19 20 #include "absl/algorithm/container.h" 21 #include "absl/strings/string_view.h" 22 #include "api/adaptation/resource.h" 23 #include "api/array_view.h" 24 #include "api/audio_codecs/audio_format.h" 25 #include "api/call/audio_sink.h" 26 #include "api/crypto/frame_decryptor_interface.h" 27 #include "api/environment/environment.h" 28 #include "api/frame_transformer_interface.h" 29 #include "api/make_ref_counted.h" 30 #include "api/media_types.h" 31 #include "api/rtc_error.h" 32 #include "api/rtp_headers.h" 33 #include "api/rtp_parameters.h" 34 #include "api/rtp_sender_interface.h" 35 #include "api/scoped_refptr.h" 36 #include "api/task_queue/task_queue_base.h" 37 #include "api/units/timestamp.h" 38 #include "api/video/video_source_interface.h" 39 #include "api/video_codecs/video_codec.h" 40 #include "api/video_codecs/video_encoder.h" 41 #include "call/audio_receive_stream.h" 42 #include "call/audio_send_stream.h" 43 #include "call/call.h" 44 #include "call/flexfec_receive_stream.h" 45 #include "call/packet_receiver.h" 46 #include "call/video_receive_stream.h" 47 #include "call/video_send_stream.h" 48 #include "media/base/media_channel.h" 49 #include "modules/rtp_rtcp/source/rtp_packet_received.h" 50 #include "rtc_base/buffer.h" 51 #include "rtc_base/checks.h" 52 #include "rtc_base/copy_on_write_buffer.h" 53 #include "rtc_base/network/sent_packet.h" 54 #include "rtc_base/thread.h" 55 #include "test/gtest.h" 56 #include "video/config/encoder_stream_factory.h" 57 #include "video/config/video_encoder_config.h" 58 59 namespace webrtc { 60 61 62 FakeAudioSendStream::FakeAudioSendStream(int id, 63 const AudioSendStream::Config& config) 64 : id_(id), config_(config) {} 65 66 void FakeAudioSendStream::Reconfigure(const AudioSendStream::Config& config, 67 SetParametersCallback callback) { 68 config_ = config; 69 InvokeSetParametersCallback(callback, RTCError::OK()); 70 } 71 72 const AudioSendStream::Config& FakeAudioSendStream::GetConfig() const { 73 return config_; 74 } 75 76 void FakeAudioSendStream::SetStats(const AudioSendStream::Stats& stats) { 77 stats_ = stats; 78 } 79 80 FakeAudioSendStream::TelephoneEvent 81 FakeAudioSendStream::GetLatestTelephoneEvent() const { 82 return latest_telephone_event_; 83 } 84 85 bool FakeAudioSendStream::SendTelephoneEvent(int payload_type, 86 int payload_frequency, 87 int event, 88 int duration_ms) { 89 latest_telephone_event_.payload_type = payload_type; 90 latest_telephone_event_.payload_frequency = payload_frequency; 91 latest_telephone_event_.event_code = event; 92 latest_telephone_event_.duration_ms = duration_ms; 93 return true; 94 } 95 96 void FakeAudioSendStream::SetMuted(bool muted) { 97 muted_ = muted; 98 } 99 100 AudioSendStream::Stats FakeAudioSendStream::GetStats() const { 101 return stats_; 102 } 103 104 AudioSendStream::Stats FakeAudioSendStream::GetStats( 105 bool /*has_remote_tracks*/) const { 106 return stats_; 107 } 108 109 FakeAudioReceiveStream::FakeAudioReceiveStream( 110 int id, 111 const AudioReceiveStreamInterface::Config& config) 112 : id_(id), config_(config) {} 113 114 const AudioReceiveStreamInterface::Config& FakeAudioReceiveStream::GetConfig() 115 const { 116 return config_; 117 } 118 119 void FakeAudioReceiveStream::SetStats( 120 const AudioReceiveStreamInterface::Stats& stats) { 121 stats_ = stats; 122 } 123 124 bool FakeAudioReceiveStream::VerifyLastPacket( 125 ArrayView<const uint8_t> data) const { 126 return last_packet_ == Buffer(data.data(), data.size()); 127 } 128 129 bool FakeAudioReceiveStream::DeliverRtp(ArrayView<const uint8_t> packet, 130 int64_t /* packet_time_us */) { 131 ++received_packets_; 132 last_packet_.SetData(packet); 133 return true; 134 } 135 136 void FakeAudioReceiveStream::SetDepacketizerToDecoderFrameTransformer( 137 scoped_refptr<FrameTransformerInterface> frame_transformer) { 138 config_.frame_transformer = std::move(frame_transformer); 139 } 140 141 void FakeAudioReceiveStream::SetDecoderMap( 142 std::map<int, SdpAudioFormat> decoder_map) { 143 config_.decoder_map = std::move(decoder_map); 144 } 145 146 void FakeAudioReceiveStream::SetNackHistory(int history_ms) { 147 config_.rtp.nack.rtp_history_ms = history_ms; 148 } 149 150 void FakeAudioReceiveStream::SetRtcpMode(RtcpMode mode) { 151 config_.rtp.rtcp_mode = mode; 152 } 153 154 void FakeAudioReceiveStream::SetNonSenderRttMeasurement(bool enabled) { 155 config_.enable_non_sender_rtt = enabled; 156 } 157 158 void FakeAudioReceiveStream::SetFrameDecryptor( 159 scoped_refptr<FrameDecryptorInterface> frame_decryptor) { 160 config_.frame_decryptor = std::move(frame_decryptor); 161 } 162 163 AudioReceiveStreamInterface::Stats FakeAudioReceiveStream::GetStats( 164 bool /* get_and_clear_legacy_stats */) const { 165 return stats_; 166 } 167 168 void FakeAudioReceiveStream::SetSink(AudioSinkInterface* sink) { 169 sink_ = sink; 170 } 171 172 void FakeAudioReceiveStream::SetGain(float gain) { 173 gain_ = gain; 174 } 175 176 FakeVideoSendStream::FakeVideoSendStream(const Environment& env, 177 VideoSendStream::Config config, 178 VideoEncoderConfig encoder_config) 179 : env_(env), 180 sending_(false), 181 config_(std::move(config)), 182 codec_settings_set_(false), 183 resolution_scaling_enabled_(false), 184 framerate_scaling_enabled_(false), 185 source_(nullptr), 186 num_swapped_frames_(0) { 187 RTC_DCHECK(config_.encoder_settings.encoder_factory != nullptr); 188 RTC_DCHECK(config_.encoder_settings.bitrate_allocator_factory != nullptr); 189 ReconfigureVideoEncoder(std::move(encoder_config)); 190 } 191 192 FakeVideoSendStream::~FakeVideoSendStream() { 193 if (source_) 194 source_->RemoveSink(this); 195 } 196 197 const VideoSendStream::Config& FakeVideoSendStream::GetConfig() const { 198 return config_; 199 } 200 201 const VideoEncoderConfig& FakeVideoSendStream::GetEncoderConfig() const { 202 return encoder_config_; 203 } 204 205 const std::vector<VideoStream>& FakeVideoSendStream::GetVideoStreams() const { 206 return video_streams_; 207 } 208 209 bool FakeVideoSendStream::IsSending() const { 210 return sending_; 211 } 212 213 bool FakeVideoSendStream::GetVp8Settings(VideoCodecVP8* settings) const { 214 if (!codec_settings_set_) { 215 return false; 216 } 217 218 *settings = codec_specific_settings_.vp8; 219 return true; 220 } 221 222 bool FakeVideoSendStream::GetVp9Settings(VideoCodecVP9* settings) const { 223 if (!codec_settings_set_) { 224 return false; 225 } 226 227 *settings = codec_specific_settings_.vp9; 228 return true; 229 } 230 231 bool FakeVideoSendStream::GetH264Settings(VideoCodecH264* settings) const { 232 if (!codec_settings_set_) { 233 return false; 234 } 235 236 *settings = codec_specific_settings_.h264; 237 return true; 238 } 239 240 bool FakeVideoSendStream::GetAv1Settings(VideoCodecAV1* settings) const { 241 if (!codec_settings_set_) { 242 return false; 243 } 244 245 *settings = codec_specific_settings_.av1; 246 return true; 247 } 248 249 int FakeVideoSendStream::GetNumberOfSwappedFrames() const { 250 return num_swapped_frames_; 251 } 252 253 int FakeVideoSendStream::GetLastWidth() const { 254 return last_frame_->width(); 255 } 256 257 int FakeVideoSendStream::GetLastHeight() const { 258 return last_frame_->height(); 259 } 260 261 int64_t FakeVideoSendStream::GetLastTimestamp() const { 262 RTC_DCHECK(last_frame_->ntp_time_ms() == 0); 263 return last_frame_->render_time_ms(); 264 } 265 266 void FakeVideoSendStream::OnFrame(const VideoFrame& frame) { 267 ++num_swapped_frames_; 268 if (!last_frame_ || frame.width() != last_frame_->width() || 269 frame.height() != last_frame_->height() || 270 frame.rotation() != last_frame_->rotation()) { 271 if (encoder_config_.video_stream_factory) { 272 // Note: only tests set their own EncoderStreamFactory... 273 video_streams_ = 274 encoder_config_.video_stream_factory->CreateEncoderStreams( 275 env_.field_trials(), frame.width(), frame.height(), 276 encoder_config_); 277 } else { 278 VideoEncoder::EncoderInfo encoder_info; 279 auto factory = make_ref_counted<EncoderStreamFactory>(encoder_info); 280 281 video_streams_ = factory->CreateEncoderStreams( 282 env_.field_trials(), frame.width(), frame.height(), encoder_config_); 283 } 284 } 285 last_frame_ = frame; 286 } 287 288 void FakeVideoSendStream::SetStats(const VideoSendStream::Stats& stats) { 289 stats_ = stats; 290 } 291 292 VideoSendStream::Stats FakeVideoSendStream::GetStats() { 293 return stats_; 294 } 295 296 void FakeVideoSendStream::SetCsrcs(ArrayView<const uint32_t> csrcs) {} 297 298 void FakeVideoSendStream::ReconfigureVideoEncoder(VideoEncoderConfig config) { 299 ReconfigureVideoEncoder(std::move(config), nullptr); 300 } 301 302 void FakeVideoSendStream::ReconfigureVideoEncoder( 303 VideoEncoderConfig config, 304 SetParametersCallback callback) { 305 int width, height; 306 if (last_frame_) { 307 width = last_frame_->width(); 308 height = last_frame_->height(); 309 } else { 310 width = height = 0; 311 } 312 if (config.video_stream_factory) { 313 // Note: only tests set their own EncoderStreamFactory... 314 video_streams_ = config.video_stream_factory->CreateEncoderStreams( 315 env_.field_trials(), width, height, config); 316 } else { 317 VideoEncoder::EncoderInfo encoder_info; 318 auto factory = make_ref_counted<EncoderStreamFactory>(encoder_info); 319 320 video_streams_ = factory->CreateEncoderStreams(env_.field_trials(), width, 321 height, config); 322 } 323 324 if (config.encoder_specific_settings != nullptr) { 325 const unsigned char num_temporal_layers = static_cast<unsigned char>( 326 video_streams_.back().num_temporal_layers.value_or(1)); 327 if (config_.rtp.payload_name == "VP8") { 328 config.encoder_specific_settings->FillVideoCodecVp8( 329 &codec_specific_settings_.vp8); 330 if (!video_streams_.empty()) { 331 codec_specific_settings_.vp8.numberOfTemporalLayers = 332 num_temporal_layers; 333 } 334 } else if (config_.rtp.payload_name == "VP9") { 335 config.encoder_specific_settings->FillVideoCodecVp9( 336 &codec_specific_settings_.vp9); 337 if (!video_streams_.empty()) { 338 codec_specific_settings_.vp9.numberOfTemporalLayers = 339 num_temporal_layers; 340 } 341 } else if (config_.rtp.payload_name == "H264") { 342 codec_specific_settings_.h264.numberOfTemporalLayers = 343 num_temporal_layers; 344 } else if (config_.rtp.payload_name == "AV1") { 345 config.encoder_specific_settings->FillVideoCodecAv1( 346 &codec_specific_settings_.av1); 347 } else { 348 ADD_FAILURE() << "Unsupported encoder payload: " 349 << config_.rtp.payload_name; 350 } 351 } 352 codec_settings_set_ = config.encoder_specific_settings != nullptr; 353 encoder_config_ = std::move(config); 354 ++num_encoder_reconfigurations_; 355 InvokeSetParametersCallback(callback, RTCError::OK()); 356 } 357 358 void FakeVideoSendStream::Start() { 359 sending_ = true; 360 } 361 362 void FakeVideoSendStream::Stop() { 363 sending_ = false; 364 } 365 366 void FakeVideoSendStream::AddAdaptationResource( 367 scoped_refptr<Resource> /* resource */) {} 368 369 std::vector<scoped_refptr<Resource>> 370 FakeVideoSendStream::GetAdaptationResources() { 371 return {}; 372 } 373 374 void FakeVideoSendStream::SetSource( 375 VideoSourceInterface<VideoFrame>* source, 376 const DegradationPreference& degradation_preference) { 377 if (source_) 378 source_->RemoveSink(this); 379 source_ = source; 380 switch (degradation_preference) { 381 case DegradationPreference::MAINTAIN_FRAMERATE: 382 resolution_scaling_enabled_ = true; 383 framerate_scaling_enabled_ = false; 384 break; 385 case DegradationPreference::MAINTAIN_RESOLUTION: 386 resolution_scaling_enabled_ = false; 387 framerate_scaling_enabled_ = true; 388 break; 389 case DegradationPreference::BALANCED: 390 resolution_scaling_enabled_ = true; 391 framerate_scaling_enabled_ = true; 392 break; 393 case DegradationPreference::DISABLED: 394 resolution_scaling_enabled_ = false; 395 framerate_scaling_enabled_ = false; 396 break; 397 } 398 if (source) 399 source->AddOrUpdateSink( 400 this, resolution_scaling_enabled_ ? sink_wants_ : VideoSinkWants()); 401 } 402 403 void FakeVideoSendStream::GenerateKeyFrame( 404 const std::vector<std::string>& rids) { 405 keyframes_requested_by_rid_ = rids; 406 } 407 408 void FakeVideoSendStream::InjectVideoSinkWants(const VideoSinkWants& wants) { 409 sink_wants_ = wants; 410 source_->AddOrUpdateSink(this, wants); 411 } 412 413 FakeVideoReceiveStream::FakeVideoReceiveStream( 414 VideoReceiveStreamInterface::Config config) 415 : config_(std::move(config)), receiving_(false) {} 416 417 const VideoReceiveStreamInterface::Config& FakeVideoReceiveStream::GetConfig() 418 const { 419 return config_; 420 } 421 422 bool FakeVideoReceiveStream::IsReceiving() const { 423 return receiving_; 424 } 425 426 void FakeVideoReceiveStream::InjectFrame(const VideoFrame& frame) { 427 config_.renderer->OnFrame(frame); 428 } 429 430 VideoReceiveStreamInterface::Stats FakeVideoReceiveStream::GetStats() const { 431 return stats_; 432 } 433 434 void FakeVideoReceiveStream::Start() { 435 receiving_ = true; 436 } 437 438 void FakeVideoReceiveStream::Stop() { 439 receiving_ = false; 440 } 441 442 void FakeVideoReceiveStream::SetStats( 443 const VideoReceiveStreamInterface::Stats& stats) { 444 stats_ = stats; 445 } 446 447 FakeFlexfecReceiveStream::FakeFlexfecReceiveStream( 448 const FlexfecReceiveStream::Config config) 449 : config_(std::move(config)) {} 450 451 const FlexfecReceiveStream::Config& FakeFlexfecReceiveStream::GetConfig() 452 const { 453 return config_; 454 } 455 456 void FakeFlexfecReceiveStream::OnRtpPacket(const RtpPacketReceived&) { 457 RTC_DCHECK_NOTREACHED() << "Not implemented."; 458 } 459 460 FakeCall::FakeCall(const Environment& env) 461 : FakeCall(env, Thread::Current(), Thread::Current()) {} 462 463 FakeCall::FakeCall(const Environment& env, 464 TaskQueueBase* worker_thread, 465 TaskQueueBase* network_thread) 466 : env_(env), 467 network_thread_(network_thread), 468 worker_thread_(worker_thread), 469 audio_network_state_(kNetworkUp), 470 video_network_state_(kNetworkUp), 471 num_created_send_streams_(0), 472 num_created_receive_streams_(0) {} 473 474 FakeCall::~FakeCall() { 475 EXPECT_EQ(0u, video_send_streams_.size()); 476 EXPECT_EQ(0u, audio_send_streams_.size()); 477 EXPECT_EQ(0u, video_receive_streams_.size()); 478 EXPECT_EQ(0u, audio_receive_streams_.size()); 479 } 480 481 const std::vector<FakeVideoSendStream*>& FakeCall::GetVideoSendStreams() { 482 return video_send_streams_; 483 } 484 485 const std::vector<FakeVideoReceiveStream*>& FakeCall::GetVideoReceiveStreams() { 486 return video_receive_streams_; 487 } 488 489 const FakeVideoReceiveStream* FakeCall::GetVideoReceiveStream(uint32_t ssrc) { 490 for (const auto* p : GetVideoReceiveStreams()) { 491 if (p->GetConfig().rtp.remote_ssrc == ssrc) { 492 return p; 493 } 494 } 495 return nullptr; 496 } 497 498 const std::vector<FakeAudioSendStream*>& FakeCall::GetAudioSendStreams() { 499 return audio_send_streams_; 500 } 501 502 const FakeAudioSendStream* FakeCall::GetAudioSendStream(uint32_t ssrc) { 503 for (const auto* p : GetAudioSendStreams()) { 504 if (p->GetConfig().rtp.ssrc == ssrc) { 505 return p; 506 } 507 } 508 return nullptr; 509 } 510 511 const std::vector<FakeAudioReceiveStream*>& FakeCall::GetAudioReceiveStreams() { 512 return audio_receive_streams_; 513 } 514 515 const FakeAudioReceiveStream* FakeCall::GetAudioReceiveStream(uint32_t ssrc) { 516 for (const auto* p : GetAudioReceiveStreams()) { 517 if (p->GetConfig().rtp.remote_ssrc == ssrc) { 518 return p; 519 } 520 } 521 return nullptr; 522 } 523 524 const std::vector<FakeFlexfecReceiveStream*>& 525 FakeCall::GetFlexfecReceiveStreams() { 526 return flexfec_receive_streams_; 527 } 528 529 NetworkState FakeCall::GetNetworkState(MediaType media) const { 530 switch (media) { 531 case MediaType::AUDIO: 532 return audio_network_state_; 533 case MediaType::VIDEO: 534 return video_network_state_; 535 case MediaType::DATA: 536 case MediaType::ANY: 537 case MediaType::UNSUPPORTED: 538 ADD_FAILURE() << "GetNetworkState called with unknown parameter."; 539 return kNetworkDown; 540 } 541 // Even though all the values for the enum class are listed above,the compiler 542 // will emit a warning as the method may be called with a value outside of the 543 // valid enum range, unless this case is also handled. 544 ADD_FAILURE() << "GetNetworkState called with unknown parameter."; 545 return kNetworkDown; 546 } 547 548 AudioSendStream* FakeCall::CreateAudioSendStream( 549 const AudioSendStream::Config& config) { 550 FakeAudioSendStream* fake_stream = 551 new FakeAudioSendStream(next_stream_id_++, config); 552 audio_send_streams_.push_back(fake_stream); 553 ++num_created_send_streams_; 554 return fake_stream; 555 } 556 557 void FakeCall::DestroyAudioSendStream(AudioSendStream* send_stream) { 558 auto it = absl::c_find(audio_send_streams_, 559 static_cast<FakeAudioSendStream*>(send_stream)); 560 if (it == audio_send_streams_.end()) { 561 ADD_FAILURE() << "DestroyAudioSendStream called with unknown parameter."; 562 } else { 563 delete *it; 564 audio_send_streams_.erase(it); 565 } 566 } 567 568 AudioReceiveStreamInterface* FakeCall::CreateAudioReceiveStream( 569 const AudioReceiveStreamInterface::Config& config) { 570 audio_receive_streams_.push_back( 571 new FakeAudioReceiveStream(next_stream_id_++, config)); 572 ++num_created_receive_streams_; 573 return audio_receive_streams_.back(); 574 } 575 576 void FakeCall::DestroyAudioReceiveStream( 577 AudioReceiveStreamInterface* receive_stream) { 578 auto it = absl::c_find(audio_receive_streams_, 579 static_cast<FakeAudioReceiveStream*>(receive_stream)); 580 if (it == audio_receive_streams_.end()) { 581 ADD_FAILURE() << "DestroyAudioReceiveStream called with unknown parameter."; 582 } else { 583 delete *it; 584 audio_receive_streams_.erase(it); 585 } 586 } 587 588 VideoSendStream* FakeCall::CreateVideoSendStream( 589 VideoSendStream::Config config, 590 VideoEncoderConfig encoder_config) { 591 FakeVideoSendStream* fake_stream = new FakeVideoSendStream( 592 env_, std::move(config), std::move(encoder_config)); 593 video_send_streams_.push_back(fake_stream); 594 ++num_created_send_streams_; 595 return fake_stream; 596 } 597 598 void FakeCall::DestroyVideoSendStream(VideoSendStream* send_stream) { 599 auto it = absl::c_find(video_send_streams_, 600 static_cast<FakeVideoSendStream*>(send_stream)); 601 if (it == video_send_streams_.end()) { 602 ADD_FAILURE() << "DestroyVideoSendStream called with unknown parameter."; 603 } else { 604 delete *it; 605 video_send_streams_.erase(it); 606 } 607 } 608 609 VideoReceiveStreamInterface* FakeCall::CreateVideoReceiveStream( 610 VideoReceiveStreamInterface::Config config) { 611 video_receive_streams_.push_back( 612 new FakeVideoReceiveStream(std::move(config))); 613 ++num_created_receive_streams_; 614 return video_receive_streams_.back(); 615 } 616 617 void FakeCall::DestroyVideoReceiveStream( 618 VideoReceiveStreamInterface* receive_stream) { 619 auto it = absl::c_find(video_receive_streams_, 620 static_cast<FakeVideoReceiveStream*>(receive_stream)); 621 if (it == video_receive_streams_.end()) { 622 ADD_FAILURE() << "DestroyVideoReceiveStream called with unknown parameter."; 623 } else { 624 delete *it; 625 video_receive_streams_.erase(it); 626 } 627 } 628 629 FlexfecReceiveStream* FakeCall::CreateFlexfecReceiveStream( 630 const FlexfecReceiveStream::Config config) { 631 FakeFlexfecReceiveStream* fake_stream = 632 new FakeFlexfecReceiveStream(std::move(config)); 633 flexfec_receive_streams_.push_back(fake_stream); 634 ++num_created_receive_streams_; 635 return fake_stream; 636 } 637 638 void FakeCall::DestroyFlexfecReceiveStream( 639 FlexfecReceiveStream* receive_stream) { 640 auto it = 641 absl::c_find(flexfec_receive_streams_, 642 static_cast<FakeFlexfecReceiveStream*>(receive_stream)); 643 if (it == flexfec_receive_streams_.end()) { 644 ADD_FAILURE() 645 << "DestroyFlexfecReceiveStream called with unknown parameter."; 646 } else { 647 delete *it; 648 flexfec_receive_streams_.erase(it); 649 } 650 } 651 652 void FakeCall::AddAdaptationResource(scoped_refptr<Resource> /* resource */) {} 653 654 PacketReceiver* FakeCall::Receiver() { 655 return this; 656 } 657 658 void FakeCall::DeliverRtpPacket( 659 MediaType media_type, 660 RtpPacketReceived packet, 661 OnUndemuxablePacketHandler undemuxable_packet_handler) { 662 if (!DeliverPacketInternal(media_type, packet.Ssrc(), packet.Buffer(), 663 packet.arrival_time())) { 664 if (undemuxable_packet_handler(packet)) { 665 DeliverPacketInternal(media_type, packet.Ssrc(), packet.Buffer(), 666 packet.arrival_time()); 667 } 668 } 669 last_received_rtp_packet_ = packet; 670 } 671 672 bool FakeCall::DeliverPacketInternal(MediaType media_type, 673 uint32_t ssrc, 674 const CopyOnWriteBuffer& packet, 675 Timestamp arrival_time) { 676 EXPECT_GE(packet.size(), 12u); 677 RTC_DCHECK(arrival_time.IsFinite()); 678 RTC_DCHECK(media_type == MediaType::AUDIO || media_type == MediaType::VIDEO); 679 680 if (media_type == MediaType::VIDEO) { 681 for (auto receiver : video_receive_streams_) { 682 if (receiver->GetConfig().rtp.remote_ssrc == ssrc || 683 receiver->GetConfig().rtp.rtx_ssrc == ssrc) { 684 ++delivered_packets_by_ssrc_[ssrc]; 685 return true; 686 } 687 } 688 } 689 if (media_type == MediaType::AUDIO) { 690 for (auto receiver : audio_receive_streams_) { 691 if (receiver->GetConfig().rtp.remote_ssrc == ssrc) { 692 receiver->DeliverRtp(packet, arrival_time.us()); 693 ++delivered_packets_by_ssrc_[ssrc]; 694 return true; 695 } 696 } 697 } 698 return false; 699 } 700 701 void FakeCall::SetStats(const Call::Stats& stats) { 702 stats_ = stats; 703 } 704 705 int FakeCall::GetNumCreatedSendStreams() const { 706 return num_created_send_streams_; 707 } 708 709 int FakeCall::GetNumCreatedReceiveStreams() const { 710 return num_created_receive_streams_; 711 } 712 713 Call::Stats FakeCall::GetStats() const { 714 return stats_; 715 } 716 717 TaskQueueBase* FakeCall::network_thread() const { 718 return network_thread_; 719 } 720 721 TaskQueueBase* FakeCall::worker_thread() const { 722 return worker_thread_; 723 } 724 725 void FakeCall::SignalChannelNetworkState(MediaType media, NetworkState state) { 726 switch (media) { 727 case MediaType::AUDIO: 728 audio_network_state_ = state; 729 break; 730 case MediaType::VIDEO: 731 video_network_state_ = state; 732 break; 733 case MediaType::DATA: 734 case MediaType::ANY: 735 case MediaType::UNSUPPORTED: 736 ADD_FAILURE() 737 << "SignalChannelNetworkState called with unknown parameter."; 738 } 739 } 740 741 void FakeCall::OnAudioTransportOverheadChanged( 742 int /* transport_overhead_per_packet */) {} 743 744 void FakeCall::OnLocalSsrcUpdated(AudioReceiveStreamInterface& stream, 745 uint32_t local_ssrc) { 746 auto& fake_stream = static_cast<FakeAudioReceiveStream&>(stream); 747 fake_stream.SetLocalSsrc(local_ssrc); 748 } 749 750 void FakeCall::OnLocalSsrcUpdated(VideoReceiveStreamInterface& stream, 751 uint32_t local_ssrc) { 752 auto& fake_stream = static_cast<FakeVideoReceiveStream&>(stream); 753 fake_stream.SetLocalSsrc(local_ssrc); 754 } 755 756 void FakeCall::OnLocalSsrcUpdated(FlexfecReceiveStream& stream, 757 uint32_t local_ssrc) { 758 auto& fake_stream = static_cast<FakeFlexfecReceiveStream&>(stream); 759 fake_stream.SetLocalSsrc(local_ssrc); 760 } 761 762 void FakeCall::OnUpdateSyncGroup(AudioReceiveStreamInterface& stream, 763 absl::string_view sync_group) { 764 auto& fake_stream = static_cast<FakeAudioReceiveStream&>(stream); 765 fake_stream.SetSyncGroup(sync_group); 766 } 767 768 void FakeCall::OnSentPacket(const SentPacketInfo& sent_packet) { 769 last_sent_packet_ = sent_packet; 770 if (sent_packet.packet_id >= 0) { 771 last_sent_nonnegative_packet_id_ = sent_packet.packet_id; 772 } 773 } 774 775 } // namespace webrtc