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::AudioReceiveStream 17 // webrtc::VideoSendStream 18 // webrtc::VideoReceiveStream 19 20 #ifndef MEDIA_ENGINE_FAKE_WEBRTC_CALL_H_ 21 #define MEDIA_ENGINE_FAKE_WEBRTC_CALL_H_ 22 23 #include <memory> 24 #include <string> 25 #include <vector> 26 27 #include "api/video/video_frame.h" 28 #include "call/audio_receive_stream.h" 29 #include "call/audio_send_stream.h" 30 #include "call/call.h" 31 #include "call/flexfec_receive_stream.h" 32 #include "call/test/mock_rtp_transport_controller_send.h" 33 #include "call/video_receive_stream.h" 34 #include "call/video_send_stream.h" 35 #include "modules/rtp_rtcp/source/rtp_packet_received.h" 36 #include "rtc_base/buffer.h" 37 38 namespace cricket { 39 class FakeAudioSendStream final : public webrtc::AudioSendStream { 40 public: 41 struct TelephoneEvent { 42 int payload_type = -1; 43 int payload_frequency = -1; 44 int event_code = 0; 45 int duration_ms = 0; 46 }; 47 48 explicit FakeAudioSendStream(int id, 49 const webrtc::AudioSendStream::Config& config); 50 id()51 int id() const { return id_; } 52 const webrtc::AudioSendStream::Config& GetConfig() const override; 53 void SetStats(const webrtc::AudioSendStream::Stats& stats); 54 TelephoneEvent GetLatestTelephoneEvent() const; IsSending()55 bool IsSending() const { return sending_; } muted()56 bool muted() const { return muted_; } 57 58 private: 59 // webrtc::AudioSendStream implementation. 60 void Reconfigure(const webrtc::AudioSendStream::Config& config) override; Start()61 void Start() override { sending_ = true; } Stop()62 void Stop() override { sending_ = false; } SendAudioData(std::unique_ptr<webrtc::AudioFrame> audio_frame)63 void SendAudioData(std::unique_ptr<webrtc::AudioFrame> audio_frame) override { 64 } 65 bool SendTelephoneEvent(int payload_type, 66 int payload_frequency, 67 int event, 68 int duration_ms) override; 69 void SetMuted(bool muted) override; 70 webrtc::AudioSendStream::Stats GetStats() const override; 71 webrtc::AudioSendStream::Stats GetStats( 72 bool has_remote_tracks) const override; 73 74 int id_ = -1; 75 TelephoneEvent latest_telephone_event_; 76 webrtc::AudioSendStream::Config config_; 77 webrtc::AudioSendStream::Stats stats_; 78 bool sending_ = false; 79 bool muted_ = false; 80 }; 81 82 class FakeAudioReceiveStream final : public webrtc::AudioReceiveStream { 83 public: 84 explicit FakeAudioReceiveStream( 85 int id, 86 const webrtc::AudioReceiveStream::Config& config); 87 id()88 int id() const { return id_; } 89 const webrtc::AudioReceiveStream::Config& GetConfig() const; 90 void SetStats(const webrtc::AudioReceiveStream::Stats& stats); received_packets()91 int received_packets() const { return received_packets_; } 92 bool VerifyLastPacket(const uint8_t* data, size_t length) const; sink()93 const webrtc::AudioSinkInterface* sink() const { return sink_; } gain()94 float gain() const { return gain_; } 95 bool DeliverRtp(const uint8_t* packet, size_t length, int64_t packet_time_us); started()96 bool started() const { return started_; } base_mininum_playout_delay_ms()97 int base_mininum_playout_delay_ms() const { 98 return base_mininum_playout_delay_ms_; 99 } 100 101 private: 102 // webrtc::AudioReceiveStream implementation. 103 void Reconfigure(const webrtc::AudioReceiveStream::Config& config) override; Start()104 void Start() override { started_ = true; } Stop()105 void Stop() override { started_ = false; } 106 107 webrtc::AudioReceiveStream::Stats GetStats() const override; 108 void SetSink(webrtc::AudioSinkInterface* sink) override; 109 void SetGain(float gain) override; SetBaseMinimumPlayoutDelayMs(int delay_ms)110 bool SetBaseMinimumPlayoutDelayMs(int delay_ms) override { 111 base_mininum_playout_delay_ms_ = delay_ms; 112 return true; 113 } GetBaseMinimumPlayoutDelayMs()114 int GetBaseMinimumPlayoutDelayMs() const override { 115 return base_mininum_playout_delay_ms_; 116 } GetSources()117 std::vector<webrtc::RtpSource> GetSources() const override { 118 return std::vector<webrtc::RtpSource>(); 119 } 120 121 int id_ = -1; 122 webrtc::AudioReceiveStream::Config config_; 123 webrtc::AudioReceiveStream::Stats stats_; 124 int received_packets_ = 0; 125 webrtc::AudioSinkInterface* sink_ = nullptr; 126 float gain_ = 1.0f; 127 rtc::Buffer last_packet_; 128 bool started_ = false; 129 int base_mininum_playout_delay_ms_ = 0; 130 }; 131 132 class FakeVideoSendStream final 133 : public webrtc::VideoSendStream, 134 public rtc::VideoSinkInterface<webrtc::VideoFrame> { 135 public: 136 FakeVideoSendStream(webrtc::VideoSendStream::Config config, 137 webrtc::VideoEncoderConfig encoder_config); 138 ~FakeVideoSendStream() override; 139 const webrtc::VideoSendStream::Config& GetConfig() const; 140 const webrtc::VideoEncoderConfig& GetEncoderConfig() const; 141 const std::vector<webrtc::VideoStream>& GetVideoStreams() const; 142 143 bool IsSending() const; 144 bool GetVp8Settings(webrtc::VideoCodecVP8* settings) const; 145 bool GetVp9Settings(webrtc::VideoCodecVP9* settings) const; 146 bool GetH264Settings(webrtc::VideoCodecH264* settings) const; 147 148 int GetNumberOfSwappedFrames() const; 149 int GetLastWidth() const; 150 int GetLastHeight() const; 151 int64_t GetLastTimestamp() const; 152 void SetStats(const webrtc::VideoSendStream::Stats& stats); num_encoder_reconfigurations()153 int num_encoder_reconfigurations() const { 154 return num_encoder_reconfigurations_; 155 } 156 resolution_scaling_enabled()157 bool resolution_scaling_enabled() const { 158 return resolution_scaling_enabled_; 159 } framerate_scaling_enabled()160 bool framerate_scaling_enabled() const { return framerate_scaling_enabled_; } 161 void InjectVideoSinkWants(const rtc::VideoSinkWants& wants); 162 source()163 rtc::VideoSourceInterface<webrtc::VideoFrame>* source() const { 164 return source_; 165 } 166 167 private: 168 // rtc::VideoSinkInterface<VideoFrame> implementation. 169 void OnFrame(const webrtc::VideoFrame& frame) override; 170 171 // webrtc::VideoSendStream implementation. 172 void UpdateActiveSimulcastLayers( 173 const std::vector<bool> active_layers) override; 174 void Start() override; 175 void Stop() override; 176 void SetSource( 177 rtc::VideoSourceInterface<webrtc::VideoFrame>* source, 178 const webrtc::DegradationPreference& degradation_preference) override; 179 webrtc::VideoSendStream::Stats GetStats() override; 180 void ReconfigureVideoEncoder(webrtc::VideoEncoderConfig config) override; 181 182 bool sending_; 183 webrtc::VideoSendStream::Config config_; 184 webrtc::VideoEncoderConfig encoder_config_; 185 std::vector<webrtc::VideoStream> video_streams_; 186 rtc::VideoSinkWants sink_wants_; 187 188 bool codec_settings_set_; 189 union CodecSpecificSettings { 190 webrtc::VideoCodecVP8 vp8; 191 webrtc::VideoCodecVP9 vp9; 192 webrtc::VideoCodecH264 h264; 193 } codec_specific_settings_; 194 bool resolution_scaling_enabled_; 195 bool framerate_scaling_enabled_; 196 rtc::VideoSourceInterface<webrtc::VideoFrame>* source_; 197 int num_swapped_frames_; 198 absl::optional<webrtc::VideoFrame> last_frame_; 199 webrtc::VideoSendStream::Stats stats_; 200 int num_encoder_reconfigurations_ = 0; 201 }; 202 203 class FakeVideoReceiveStream final : public webrtc::VideoReceiveStream { 204 public: 205 explicit FakeVideoReceiveStream(webrtc::VideoReceiveStream::Config config); 206 207 const webrtc::VideoReceiveStream::Config& GetConfig() const; 208 209 bool IsReceiving() const; 210 211 void InjectFrame(const webrtc::VideoFrame& frame); 212 213 void SetStats(const webrtc::VideoReceiveStream::Stats& stats); 214 215 void AddSecondarySink(webrtc::RtpPacketSinkInterface* sink) override; 216 void RemoveSecondarySink(const webrtc::RtpPacketSinkInterface* sink) override; 217 218 int GetNumAddedSecondarySinks() const; 219 int GetNumRemovedSecondarySinks() const; 220 GetSources()221 std::vector<webrtc::RtpSource> GetSources() const override { 222 return std::vector<webrtc::RtpSource>(); 223 } 224 base_mininum_playout_delay_ms()225 int base_mininum_playout_delay_ms() const { 226 return base_mininum_playout_delay_ms_; 227 } 228 SetFrameDecryptor(rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor)229 void SetFrameDecryptor(rtc::scoped_refptr<webrtc::FrameDecryptorInterface> 230 frame_decryptor) override {} 231 SetDepacketizerToDecoderFrameTransformer(rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)232 void SetDepacketizerToDecoderFrameTransformer( 233 rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) 234 override {} 235 SetAndGetRecordingState(RecordingState state,bool generate_key_frame)236 RecordingState SetAndGetRecordingState(RecordingState state, 237 bool generate_key_frame) override { 238 return RecordingState(); 239 } GenerateKeyFrame()240 void GenerateKeyFrame() override {} 241 242 private: 243 // webrtc::VideoReceiveStream implementation. 244 void Start() override; 245 void Stop() override; 246 247 webrtc::VideoReceiveStream::Stats GetStats() const override; 248 SetBaseMinimumPlayoutDelayMs(int delay_ms)249 bool SetBaseMinimumPlayoutDelayMs(int delay_ms) override { 250 base_mininum_playout_delay_ms_ = delay_ms; 251 return true; 252 } 253 GetBaseMinimumPlayoutDelayMs()254 int GetBaseMinimumPlayoutDelayMs() const override { 255 return base_mininum_playout_delay_ms_; 256 } 257 258 webrtc::VideoReceiveStream::Config config_; 259 bool receiving_; 260 webrtc::VideoReceiveStream::Stats stats_; 261 262 int base_mininum_playout_delay_ms_ = 0; 263 264 int num_added_secondary_sinks_; 265 int num_removed_secondary_sinks_; 266 }; 267 268 class FakeFlexfecReceiveStream final : public webrtc::FlexfecReceiveStream { 269 public: 270 explicit FakeFlexfecReceiveStream( 271 const webrtc::FlexfecReceiveStream::Config& config); 272 273 const webrtc::FlexfecReceiveStream::Config& GetConfig() const override; 274 275 private: 276 webrtc::FlexfecReceiveStream::Stats GetStats() const override; 277 278 void OnRtpPacket(const webrtc::RtpPacketReceived& packet) override; 279 280 webrtc::FlexfecReceiveStream::Config config_; 281 }; 282 283 class FakeCall final : public webrtc::Call, public webrtc::PacketReceiver { 284 public: 285 FakeCall(); 286 ~FakeCall() override; 287 GetMockTransportControllerSend()288 webrtc::MockRtpTransportControllerSend* GetMockTransportControllerSend() { 289 return &transport_controller_send_; 290 } 291 292 const std::vector<FakeVideoSendStream*>& GetVideoSendStreams(); 293 const std::vector<FakeVideoReceiveStream*>& GetVideoReceiveStreams(); 294 295 const std::vector<FakeAudioSendStream*>& GetAudioSendStreams(); 296 const FakeAudioSendStream* GetAudioSendStream(uint32_t ssrc); 297 const std::vector<FakeAudioReceiveStream*>& GetAudioReceiveStreams(); 298 const FakeAudioReceiveStream* GetAudioReceiveStream(uint32_t ssrc); 299 const FakeVideoReceiveStream* GetVideoReceiveStream(uint32_t ssrc); 300 301 const std::vector<FakeFlexfecReceiveStream*>& GetFlexfecReceiveStreams(); 302 last_sent_packet()303 rtc::SentPacket last_sent_packet() const { return last_sent_packet_; } 304 305 // This is useful if we care about the last media packet (with id populated) 306 // but not the last ICE packet (with -1 ID). last_sent_nonnegative_packet_id()307 int last_sent_nonnegative_packet_id() const { 308 return last_sent_nonnegative_packet_id_; 309 } 310 311 webrtc::NetworkState GetNetworkState(webrtc::MediaType media) const; 312 int GetNumCreatedSendStreams() const; 313 int GetNumCreatedReceiveStreams() const; 314 void SetStats(const webrtc::Call::Stats& stats); 315 SetClientBitratePreferences(const webrtc::BitrateSettings & preferences)316 void SetClientBitratePreferences( 317 const webrtc::BitrateSettings& preferences) override {} 318 319 private: 320 webrtc::AudioSendStream* CreateAudioSendStream( 321 const webrtc::AudioSendStream::Config& config) override; 322 void DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) override; 323 324 webrtc::AudioReceiveStream* CreateAudioReceiveStream( 325 const webrtc::AudioReceiveStream::Config& config) override; 326 void DestroyAudioReceiveStream( 327 webrtc::AudioReceiveStream* receive_stream) override; 328 329 webrtc::VideoSendStream* CreateVideoSendStream( 330 webrtc::VideoSendStream::Config config, 331 webrtc::VideoEncoderConfig encoder_config) override; 332 void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override; 333 334 webrtc::VideoReceiveStream* CreateVideoReceiveStream( 335 webrtc::VideoReceiveStream::Config config) override; 336 void DestroyVideoReceiveStream( 337 webrtc::VideoReceiveStream* receive_stream) override; 338 339 webrtc::FlexfecReceiveStream* CreateFlexfecReceiveStream( 340 const webrtc::FlexfecReceiveStream::Config& config) override; 341 void DestroyFlexfecReceiveStream( 342 webrtc::FlexfecReceiveStream* receive_stream) override; 343 344 webrtc::PacketReceiver* Receiver() override; 345 346 DeliveryStatus DeliverPacket(webrtc::MediaType media_type, 347 rtc::CopyOnWriteBuffer packet, 348 int64_t packet_time_us) override; 349 GetTransportControllerSend()350 webrtc::RtpTransportControllerSendInterface* GetTransportControllerSend() 351 override { 352 return &transport_controller_send_; 353 } 354 355 webrtc::Call::Stats GetStats() const override; 356 357 void SignalChannelNetworkState(webrtc::MediaType media, 358 webrtc::NetworkState state) override; 359 void OnAudioTransportOverheadChanged( 360 int transport_overhead_per_packet) override; 361 void OnSentPacket(const rtc::SentPacket& sent_packet) override; 362 363 ::testing::NiceMock<webrtc::MockRtpTransportControllerSend> 364 transport_controller_send_; 365 366 webrtc::NetworkState audio_network_state_; 367 webrtc::NetworkState video_network_state_; 368 rtc::SentPacket last_sent_packet_; 369 int last_sent_nonnegative_packet_id_ = -1; 370 int next_stream_id_ = 665; 371 webrtc::Call::Stats stats_; 372 std::vector<FakeVideoSendStream*> video_send_streams_; 373 std::vector<FakeAudioSendStream*> audio_send_streams_; 374 std::vector<FakeVideoReceiveStream*> video_receive_streams_; 375 std::vector<FakeAudioReceiveStream*> audio_receive_streams_; 376 std::vector<FakeFlexfecReceiveStream*> flexfec_receive_streams_; 377 378 int num_created_send_streams_; 379 int num_created_receive_streams_; 380 }; 381 382 } // namespace cricket 383 #endif // MEDIA_ENGINE_FAKE_WEBRTC_CALL_H_ 384