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