fake_webrtc_call.h (18735B)
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 // This file contains fake implementations, for use in unit tests, of the 12 // following classes: 13 // 14 // webrtc::Call 15 // webrtc::AudioSendStream 16 // webrtc::AudioReceiveStreamInterface 17 // webrtc::VideoSendStream 18 // webrtc::VideoReceiveStreamInterface 19 20 #ifndef MEDIA_ENGINE_FAKE_WEBRTC_CALL_H_ 21 #define MEDIA_ENGINE_FAKE_WEBRTC_CALL_H_ 22 23 #include <cstddef> 24 #include <cstdint> 25 #include <map> 26 #include <memory> 27 #include <optional> 28 #include <string> 29 #include <utility> 30 #include <vector> 31 32 #include "absl/strings/string_view.h" 33 #include "api/adaptation/resource.h" 34 #include "api/array_view.h" 35 #include "api/audio/audio_frame.h" 36 #include "api/audio/audio_mixer.h" 37 #include "api/audio_codecs/audio_format.h" 38 #include "api/crypto/frame_decryptor_interface.h" 39 #include "api/environment/environment.h" 40 #include "api/frame_transformer_interface.h" 41 #include "api/media_types.h" 42 #include "api/rtp_headers.h" 43 #include "api/rtp_parameters.h" 44 #include "api/rtp_sender_interface.h" 45 #include "api/scoped_refptr.h" 46 #include "api/task_queue/task_queue_base.h" 47 #include "api/transport/bitrate_settings.h" 48 #include "api/transport/rtp/rtp_source.h" 49 #include "api/units/time_delta.h" 50 #include "api/units/timestamp.h" 51 #include "api/video/video_frame.h" 52 #include "api/video/video_sink_interface.h" 53 #include "api/video/video_source_interface.h" 54 #include "api/video_codecs/video_codec.h" 55 #include "call/audio_receive_stream.h" 56 #include "call/audio_send_stream.h" 57 #include "call/call.h" 58 #include "call/fake_payload_type_suggester.h" 59 #include "call/flexfec_receive_stream.h" 60 #include "call/packet_receiver.h" 61 #include "call/payload_type.h" 62 #include "call/rtp_transport_controller_send_interface.h" 63 #include "call/test/mock_rtp_transport_controller_send.h" 64 #include "call/video_receive_stream.h" 65 #include "call/video_send_stream.h" 66 #include "modules/rtp_rtcp/include/receive_statistics.h" 67 #include "modules/rtp_rtcp/source/rtp_packet_received.h" 68 #include "rtc_base/buffer.h" 69 #include "rtc_base/copy_on_write_buffer.h" 70 #include "rtc_base/network/sent_packet.h" 71 #include "test/gmock.h" 72 #include "video/config/video_encoder_config.h" 73 74 namespace webrtc { 75 class FakeAudioSendStream final : public AudioSendStream { 76 public: 77 struct TelephoneEvent { 78 int payload_type = -1; 79 int payload_frequency = -1; 80 int event_code = 0; 81 int duration_ms = 0; 82 }; 83 84 explicit FakeAudioSendStream(int id, const AudioSendStream::Config& config); 85 86 int id() const { return id_; } 87 const AudioSendStream::Config& GetConfig() const override; 88 void SetStats(const AudioSendStream::Stats& stats); 89 TelephoneEvent GetLatestTelephoneEvent() const; 90 bool IsSending() const { return sending_; } 91 bool muted() const { return muted_; } 92 93 private: 94 // AudioSendStream implementation. 95 void Reconfigure(const AudioSendStream::Config& config, 96 SetParametersCallback callback) override; 97 void Start() override { sending_ = true; } 98 void Stop() override { sending_ = false; } 99 void SendAudioData(std::unique_ptr<AudioFrame> /* audio_frame */) override {} 100 bool SendTelephoneEvent(int payload_type, 101 int payload_frequency, 102 int event, 103 int duration_ms) override; 104 void SetMuted(bool muted) override; 105 AudioSendStream::Stats GetStats() const override; 106 AudioSendStream::Stats GetStats(bool has_remote_tracks) const override; 107 108 int id_ = -1; 109 TelephoneEvent latest_telephone_event_; 110 AudioSendStream::Config config_; 111 AudioSendStream::Stats stats_; 112 bool sending_ = false; 113 bool muted_ = false; 114 }; 115 116 class FakeAudioReceiveStream final : public AudioReceiveStreamInterface { 117 public: 118 explicit FakeAudioReceiveStream( 119 int id, 120 const AudioReceiveStreamInterface::Config& config); 121 122 int id() const { return id_; } 123 const AudioReceiveStreamInterface::Config& GetConfig() const; 124 void SetStats(const AudioReceiveStreamInterface::Stats& stats); 125 int received_packets() const { return received_packets_; } 126 bool VerifyLastPacket(ArrayView<const uint8_t> data) const; 127 const AudioSinkInterface* sink() const { return sink_; } 128 float gain() const { return gain_; } 129 bool DeliverRtp(ArrayView<const uint8_t> packet, int64_t packet_time_us); 130 bool started() const { return started_; } 131 int base_mininum_playout_delay_ms() const { 132 return base_mininum_playout_delay_ms_; 133 } 134 135 void SetLocalSsrc(uint32_t local_ssrc) { 136 config_.rtp.local_ssrc = local_ssrc; 137 } 138 139 void SetSyncGroup(absl::string_view sync_group) { 140 config_.sync_group = std::string(sync_group); 141 } 142 143 uint32_t remote_ssrc() const override { return config_.rtp.remote_ssrc; } 144 void Start() override { started_ = true; } 145 void Stop() override { started_ = false; } 146 bool IsRunning() const override { return started_; } 147 void SetDepacketizerToDecoderFrameTransformer( 148 scoped_refptr<FrameTransformerInterface> frame_transformer) override; 149 void SetDecoderMap(std::map<int, SdpAudioFormat> decoder_map) override; 150 void SetNackHistory(int history_ms) override; 151 void SetRtcpMode(RtcpMode mode) override; 152 void SetNonSenderRttMeasurement(bool enabled) override; 153 void SetFrameDecryptor( 154 scoped_refptr<FrameDecryptorInterface> frame_decryptor) override; 155 156 AudioReceiveStreamInterface::Stats GetStats( 157 bool get_and_clear_legacy_stats) const override; 158 void SetSink(AudioSinkInterface* sink) override; 159 void SetGain(float gain) override; 160 bool SetBaseMinimumPlayoutDelayMs(int delay_ms) override { 161 base_mininum_playout_delay_ms_ = delay_ms; 162 return true; 163 } 164 int GetBaseMinimumPlayoutDelayMs() const override { 165 return base_mininum_playout_delay_ms_; 166 } 167 std::vector<RtpSource> GetSources() const override { 168 return std::vector<RtpSource>(); 169 } 170 AudioMixer::Source* source() override { 171 // TODO(b/397376626): Add a Fake AudioMixer::Source 172 return nullptr; 173 } 174 175 private: 176 int id_ = -1; 177 AudioReceiveStreamInterface::Config config_; 178 AudioReceiveStreamInterface::Stats stats_; 179 int received_packets_ = 0; 180 AudioSinkInterface* sink_ = nullptr; 181 float gain_ = 1.0f; 182 Buffer last_packet_; 183 bool started_ = false; 184 int base_mininum_playout_delay_ms_ = 0; 185 }; 186 187 class FakeVideoSendStream final : public VideoSendStream, 188 public VideoSinkInterface<VideoFrame> { 189 public: 190 FakeVideoSendStream(const Environment& env, 191 VideoSendStream::Config config, 192 VideoEncoderConfig encoder_config); 193 ~FakeVideoSendStream() override; 194 const VideoSendStream::Config& GetConfig() const; 195 const VideoEncoderConfig& GetEncoderConfig() const; 196 const std::vector<VideoStream>& GetVideoStreams() const; 197 198 bool IsSending() const; 199 bool GetVp8Settings(VideoCodecVP8* settings) const; 200 bool GetVp9Settings(VideoCodecVP9* settings) const; 201 bool GetH264Settings(VideoCodecH264* settings) const; 202 bool GetAv1Settings(VideoCodecAV1* settings) const; 203 204 int GetNumberOfSwappedFrames() const; 205 int GetLastWidth() const; 206 int GetLastHeight() const; 207 int64_t GetLastTimestamp() const; 208 void SetStats(const VideoSendStream::Stats& stats); 209 void SetCsrcs(ArrayView<const uint32_t> csrcs) override; 210 int num_encoder_reconfigurations() const { 211 return num_encoder_reconfigurations_; 212 } 213 214 bool resolution_scaling_enabled() const { 215 return resolution_scaling_enabled_; 216 } 217 bool framerate_scaling_enabled() const { return framerate_scaling_enabled_; } 218 void InjectVideoSinkWants(const VideoSinkWants& wants); 219 220 VideoSourceInterface<VideoFrame>* source() const { return source_; } 221 void GenerateKeyFrame(const std::vector<std::string>& rids); 222 const std::vector<std::string>& GetKeyFramesRequested() const { 223 return keyframes_requested_by_rid_; 224 } 225 226 private: 227 // VideoSinkInterface<VideoFrame> implementation. 228 void OnFrame(const VideoFrame& frame) override; 229 230 // VideoSendStream implementation. 231 void Start() override; 232 void Stop() override; 233 bool started() override { return IsSending(); } 234 void AddAdaptationResource(scoped_refptr<Resource> resource) override; 235 std::vector<scoped_refptr<Resource>> GetAdaptationResources() override; 236 void SetSource(VideoSourceInterface<VideoFrame>* source, 237 const DegradationPreference& degradation_preference) override; 238 VideoSendStream::Stats GetStats() override; 239 240 void ReconfigureVideoEncoder(VideoEncoderConfig config) override; 241 void ReconfigureVideoEncoder(VideoEncoderConfig config, 242 SetParametersCallback callback) override; 243 244 const Environment env_; 245 bool sending_; 246 VideoSendStream::Config config_; 247 VideoEncoderConfig encoder_config_; 248 std::vector<VideoStream> video_streams_; 249 VideoSinkWants sink_wants_; 250 251 bool codec_settings_set_; 252 union CodecSpecificSettings { 253 VideoCodecVP8 vp8; 254 VideoCodecVP9 vp9; 255 VideoCodecH264 h264; 256 VideoCodecAV1 av1; 257 } codec_specific_settings_; 258 bool resolution_scaling_enabled_; 259 bool framerate_scaling_enabled_; 260 VideoSourceInterface<VideoFrame>* source_; 261 int num_swapped_frames_; 262 std::optional<VideoFrame> last_frame_; 263 VideoSendStream::Stats stats_; 264 int num_encoder_reconfigurations_ = 0; 265 std::vector<std::string> keyframes_requested_by_rid_; 266 }; 267 268 class FakeVideoReceiveStream final : public VideoReceiveStreamInterface { 269 public: 270 explicit FakeVideoReceiveStream(VideoReceiveStreamInterface::Config config); 271 272 const VideoReceiveStreamInterface::Config& GetConfig() const; 273 274 bool IsReceiving() const; 275 276 void InjectFrame(const VideoFrame& frame); 277 278 void SetStats(const VideoReceiveStreamInterface::Stats& stats); 279 280 std::vector<RtpSource> GetSources() const override { 281 return std::vector<RtpSource>(); 282 } 283 284 int base_mininum_playout_delay_ms() const { 285 return base_mininum_playout_delay_ms_; 286 } 287 288 void SetLocalSsrc(uint32_t local_ssrc) { 289 config_.rtp.local_ssrc = local_ssrc; 290 } 291 292 void UpdateRtxSsrc(uint32_t ssrc) { config_.rtp.rtx_ssrc = ssrc; } 293 294 void SetFrameDecryptor(scoped_refptr<FrameDecryptorInterface> 295 /* frame_decryptor */) override {} 296 297 void SetDepacketizerToDecoderFrameTransformer( 298 scoped_refptr<FrameTransformerInterface> /* frame_transformer */) 299 override {} 300 301 RecordingState SetAndGetRecordingState( 302 RecordingState /* state */, 303 bool /* generate_key_frame */) override { 304 return RecordingState(); 305 } 306 void GenerateKeyFrame() override {} 307 308 void SetRtcpMode(RtcpMode mode) override { config_.rtp.rtcp_mode = mode; } 309 310 void SetFlexFecProtection(RtpPacketSinkInterface* sink) override { 311 config_.rtp.packet_sink_ = sink; 312 config_.rtp.protected_by_flexfec = (sink != nullptr); 313 } 314 315 void SetLossNotificationEnabled(bool enabled) override { 316 config_.rtp.lntf.enabled = enabled; 317 } 318 319 void SetNackHistory(TimeDelta history) override { 320 config_.rtp.nack.rtp_history_ms = history.ms(); 321 } 322 323 void SetProtectionPayloadTypes(int red_payload_type, 324 int ulpfec_payload_type) override { 325 config_.rtp.red_payload_type = red_payload_type; 326 config_.rtp.ulpfec_payload_type = ulpfec_payload_type; 327 } 328 329 void SetRtcpXr(Config::Rtp::RtcpXr rtcp_xr) override { 330 config_.rtp.rtcp_xr = rtcp_xr; 331 } 332 333 void SetAssociatedPayloadTypes(std::map<int, int> associated_payload_types) { 334 config_.rtp.rtx_associated_payload_types = 335 std::move(associated_payload_types); 336 } 337 338 void Start() override; 339 void Stop() override; 340 341 VideoReceiveStreamInterface::Stats GetStats() const override; 342 343 bool SetBaseMinimumPlayoutDelayMs(int delay_ms) override { 344 base_mininum_playout_delay_ms_ = delay_ms; 345 return true; 346 } 347 348 int GetBaseMinimumPlayoutDelayMs() const override { 349 return base_mininum_playout_delay_ms_; 350 } 351 352 private: 353 VideoReceiveStreamInterface::Config config_; 354 bool receiving_; 355 VideoReceiveStreamInterface::Stats stats_; 356 357 int base_mininum_playout_delay_ms_ = 0; 358 }; 359 360 class FakeFlexfecReceiveStream final : public FlexfecReceiveStream { 361 public: 362 explicit FakeFlexfecReceiveStream(const FlexfecReceiveStream::Config config); 363 364 void SetLocalSsrc(uint32_t local_ssrc) { 365 config_.rtp.local_ssrc = local_ssrc; 366 } 367 368 void SetRtcpMode(RtcpMode mode) override { config_.rtcp_mode = mode; } 369 370 int payload_type() const override { return config_.payload_type; } 371 void SetPayloadType(int payload_type) override { 372 config_.payload_type = payload_type; 373 } 374 375 const FlexfecReceiveStream::Config& GetConfig() const; 376 377 uint32_t remote_ssrc() const { return config_.rtp.remote_ssrc; } 378 379 const ReceiveStatistics* GetStats() const override { return nullptr; } 380 381 private: 382 void OnRtpPacket(const RtpPacketReceived& packet) override; 383 384 FlexfecReceiveStream::Config config_; 385 }; 386 387 class FakeCall final : public Call, public PacketReceiver { 388 public: 389 explicit FakeCall(const Environment& env); 390 FakeCall(const Environment& env, 391 TaskQueueBase* worker_thread, 392 TaskQueueBase* network_thread); 393 ~FakeCall() override; 394 395 PayloadTypeSuggester* GetPayloadTypeSuggester() { return &pt_suggester_; } 396 397 MockRtpTransportControllerSend* GetMockTransportControllerSend() { 398 return &transport_controller_send_; 399 } 400 401 const std::vector<FakeVideoSendStream*>& GetVideoSendStreams(); 402 const std::vector<FakeVideoReceiveStream*>& GetVideoReceiveStreams(); 403 404 const std::vector<FakeAudioSendStream*>& GetAudioSendStreams(); 405 const FakeAudioSendStream* GetAudioSendStream(uint32_t ssrc); 406 const std::vector<FakeAudioReceiveStream*>& GetAudioReceiveStreams(); 407 const FakeAudioReceiveStream* GetAudioReceiveStream(uint32_t ssrc); 408 const FakeVideoReceiveStream* GetVideoReceiveStream(uint32_t ssrc); 409 410 const std::vector<FakeFlexfecReceiveStream*>& GetFlexfecReceiveStreams(); 411 412 SentPacketInfo last_sent_packet() const { return last_sent_packet_; } 413 const RtpPacketReceived& last_received_rtp_packet() const { 414 return last_received_rtp_packet_; 415 } 416 size_t GetDeliveredPacketsForSsrc(uint32_t ssrc) const { 417 auto it = delivered_packets_by_ssrc_.find(ssrc); 418 return it != delivered_packets_by_ssrc_.end() ? it->second : 0u; 419 } 420 421 // This is useful if we care about the last media packet (with id populated) 422 // but not the last ICE packet (with -1 ID). 423 int last_sent_nonnegative_packet_id() const { 424 return last_sent_nonnegative_packet_id_; 425 } 426 427 NetworkState GetNetworkState(MediaType media) const; 428 int GetNumCreatedSendStreams() const; 429 int GetNumCreatedReceiveStreams() const; 430 void SetStats(const Call::Stats& stats); 431 432 void SetClientBitratePreferences( 433 const BitrateSettings& /* preferences */) override {} 434 void SetPreferredRtcpCcAckType( 435 RtcpFeedbackType preferred_rtcp_cc_ack_type) override {} 436 std::optional<int> FeedbackAccordingToRfc8888Count() { return 0; } 437 std::optional<int> FeedbackAccordingToTransportCcCount() { return 0; } 438 439 private: 440 AudioSendStream* CreateAudioSendStream( 441 const AudioSendStream::Config& config) override; 442 void DestroyAudioSendStream(AudioSendStream* send_stream) override; 443 444 AudioReceiveStreamInterface* CreateAudioReceiveStream( 445 const AudioReceiveStreamInterface::Config& config) override; 446 void DestroyAudioReceiveStream( 447 AudioReceiveStreamInterface* receive_stream) override; 448 449 VideoSendStream* CreateVideoSendStream( 450 VideoSendStream::Config config, 451 VideoEncoderConfig encoder_config) override; 452 void DestroyVideoSendStream(VideoSendStream* send_stream) override; 453 454 VideoReceiveStreamInterface* CreateVideoReceiveStream( 455 VideoReceiveStreamInterface::Config config) override; 456 void DestroyVideoReceiveStream( 457 VideoReceiveStreamInterface* receive_stream) override; 458 459 FlexfecReceiveStream* CreateFlexfecReceiveStream( 460 const FlexfecReceiveStream::Config config) override; 461 void DestroyFlexfecReceiveStream( 462 FlexfecReceiveStream* receive_stream) override; 463 464 void AddAdaptationResource(scoped_refptr<Resource> resource) override; 465 466 PacketReceiver* Receiver() override; 467 468 void DeliverRtcpPacket(CopyOnWriteBuffer /* packet */) override {} 469 470 void DeliverRtpPacket( 471 MediaType media_type, 472 RtpPacketReceived packet, 473 OnUndemuxablePacketHandler un_demuxable_packet_handler) override; 474 475 bool DeliverPacketInternal(MediaType media_type, 476 uint32_t ssrc, 477 const CopyOnWriteBuffer& packet, 478 Timestamp arrival_time); 479 480 RtpTransportControllerSendInterface* GetTransportControllerSend() override { 481 return &transport_controller_send_; 482 } 483 484 Call::Stats GetStats() const override; 485 486 TaskQueueBase* network_thread() const override; 487 TaskQueueBase* worker_thread() const override; 488 489 void SignalChannelNetworkState(MediaType media, NetworkState state) override; 490 void OnAudioTransportOverheadChanged( 491 int transport_overhead_per_packet) override; 492 void OnLocalSsrcUpdated(AudioReceiveStreamInterface& stream, 493 uint32_t local_ssrc) override; 494 void OnLocalSsrcUpdated(VideoReceiveStreamInterface& stream, 495 uint32_t local_ssrc) override; 496 void OnLocalSsrcUpdated(FlexfecReceiveStream& stream, 497 uint32_t local_ssrc) override; 498 void OnUpdateSyncGroup(AudioReceiveStreamInterface& stream, 499 absl::string_view sync_group) override; 500 void OnSentPacket(const SentPacketInfo& sent_packet) override; 501 502 const Environment env_; 503 TaskQueueBase* const network_thread_; 504 TaskQueueBase* const worker_thread_; 505 506 ::testing::NiceMock<MockRtpTransportControllerSend> 507 transport_controller_send_; 508 509 NetworkState audio_network_state_; 510 NetworkState video_network_state_; 511 SentPacketInfo last_sent_packet_; 512 RtpPacketReceived last_received_rtp_packet_; 513 int last_sent_nonnegative_packet_id_ = -1; 514 int next_stream_id_ = 665; 515 Call::Stats stats_; 516 std::vector<FakeVideoSendStream*> video_send_streams_; 517 std::vector<FakeAudioSendStream*> audio_send_streams_; 518 std::vector<FakeVideoReceiveStream*> video_receive_streams_; 519 std::vector<FakeAudioReceiveStream*> audio_receive_streams_; 520 std::vector<FakeFlexfecReceiveStream*> flexfec_receive_streams_; 521 std::map<uint32_t, size_t> delivered_packets_by_ssrc_; 522 523 int num_created_send_streams_; 524 int num_created_receive_streams_; 525 526 FakePayloadTypeSuggester pt_suggester_; 527 }; 528 529 } // namespace webrtc 530 531 #endif // MEDIA_ENGINE_FAKE_WEBRTC_CALL_H_