diff options
Diffstat (limited to 'third_party/libwebrtc/webrtc/media/engine/fakewebrtccall.h')
| -rw-r--r-- | third_party/libwebrtc/webrtc/media/engine/fakewebrtccall.h | 333 |
1 files changed, 333 insertions, 0 deletions
diff --git a/third_party/libwebrtc/webrtc/media/engine/fakewebrtccall.h b/third_party/libwebrtc/webrtc/media/engine/fakewebrtccall.h new file mode 100644 index 0000000000..e598e9014a --- /dev/null +++ b/third_party/libwebrtc/webrtc/media/engine/fakewebrtccall.h @@ -0,0 +1,333 @@ +/* + * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +// This file contains fake implementations, for use in unit tests, of the +// following classes: +// +// webrtc::Call +// webrtc::AudioSendStream +// webrtc::AudioReceiveStream +// webrtc::VideoSendStream +// webrtc::VideoReceiveStream + +#ifndef MEDIA_ENGINE_FAKEWEBRTCCALL_H_ +#define MEDIA_ENGINE_FAKEWEBRTCCALL_H_ + +#include <memory> +#include <string> +#include <vector> + +#include "api/video/video_frame.h" +#include "call/audio_receive_stream.h" +#include "call/audio_send_stream.h" +#include "call/call.h" +#include "call/flexfec_receive_stream.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" +#include "rtc_base/buffer.h" +#include "call/video_receive_stream.h" +#include "call/video_send_stream.h" + +namespace cricket { +class FakeAudioSendStream final : public webrtc::AudioSendStream { + public: + struct TelephoneEvent { + int payload_type = -1; + int payload_frequency = -1; + int event_code = 0; + int duration_ms = 0; + }; + + explicit FakeAudioSendStream( + int id, const webrtc::AudioSendStream::Config& config); + + int id() const { return id_; } + const webrtc::AudioSendStream::Config& GetConfig() const override; + void SetStats(const webrtc::AudioSendStream::Stats& stats); + TelephoneEvent GetLatestTelephoneEvent() const; + bool IsSending() const { return sending_; } + bool muted() const { return muted_; } + + private: + // webrtc::AudioSendStream implementation. + void Reconfigure(const webrtc::AudioSendStream::Config& config) override; + + void Start() override { sending_ = true; } + void Stop() override { sending_ = false; } + + bool SendTelephoneEvent(int payload_type, int payload_frequency, int event, + int duration_ms) override; + void SetMuted(bool muted) override; + webrtc::AudioSendStream::Stats GetStats() const override; + webrtc::AudioSendStream::Stats GetStats( + bool has_remote_tracks) const override; + + int id_ = -1; + TelephoneEvent latest_telephone_event_; + webrtc::AudioSendStream::Config config_; + webrtc::AudioSendStream::Stats stats_; + bool sending_ = false; + bool muted_ = false; +}; + +class FakeAudioReceiveStream final : public webrtc::AudioReceiveStream { + public: + explicit FakeAudioReceiveStream( + int id, const webrtc::AudioReceiveStream::Config& config); + + int id() const { return id_; } + const webrtc::AudioReceiveStream::Config& GetConfig() const; + void SetStats(const webrtc::AudioReceiveStream::Stats& stats); + int received_packets() const { return received_packets_; } + bool VerifyLastPacket(const uint8_t* data, size_t length) const; + const webrtc::AudioSinkInterface* sink() const { return sink_.get(); } + float gain() const { return gain_; } + bool DeliverRtp(const uint8_t* packet, + size_t length, + const webrtc::PacketTime& packet_time); + bool started() const { return started_; } + + private: + // webrtc::AudioReceiveStream implementation. + void Start() override { started_ = true; } + void Stop() override { started_ = false; } + + webrtc::AudioReceiveStream::Stats GetStats() const override; + int GetOutputLevel() const override { return 0; } + void SetSink(std::unique_ptr<webrtc::AudioSinkInterface> sink) override; + void SetGain(float gain) override; + std::vector<webrtc::RtpSource> GetSources() const override { + return std::vector<webrtc::RtpSource>(); + } + + int id_ = -1; + webrtc::AudioReceiveStream::Config config_; + webrtc::AudioReceiveStream::Stats stats_; + int received_packets_ = 0; + std::unique_ptr<webrtc::AudioSinkInterface> sink_; + float gain_ = 1.0f; + rtc::Buffer last_packet_; + bool started_ = false; +}; + +class FakeVideoSendStream final + : public webrtc::VideoSendStream, + public rtc::VideoSinkInterface<webrtc::VideoFrame> { + public: + FakeVideoSendStream(webrtc::VideoSendStream::Config config, + webrtc::VideoEncoderConfig encoder_config); + ~FakeVideoSendStream() override; + const webrtc::VideoSendStream::Config& GetConfig() const; + const webrtc::VideoEncoderConfig& GetEncoderConfig() const; + const std::vector<webrtc::VideoStream>& GetVideoStreams() const; + + bool IsSending() const; + bool GetVp8Settings(webrtc::VideoCodecVP8* settings) const; + bool GetVp9Settings(webrtc::VideoCodecVP9* settings) const; + + int GetNumberOfSwappedFrames() const; + int GetLastWidth() const; + int GetLastHeight() const; + int64_t GetLastTimestamp() const; + void SetStats(const webrtc::VideoSendStream::Stats& stats); + int num_encoder_reconfigurations() const { + return num_encoder_reconfigurations_; + } + + void EnableEncodedFrameRecording(const std::vector<rtc::PlatformFile>& files, + size_t byte_limit) override; + + bool resolution_scaling_enabled() const { + return resolution_scaling_enabled_; + } + bool framerate_scaling_enabled() const { return framerate_scaling_enabled_; } + void InjectVideoSinkWants(const rtc::VideoSinkWants& wants); + + rtc::VideoSourceInterface<webrtc::VideoFrame>* source() const { + return source_; + } + + private: + // rtc::VideoSinkInterface<VideoFrame> implementation. + void OnFrame(const webrtc::VideoFrame& frame) override; + + // webrtc::VideoSendStream implementation. + void Start() override; + void Stop() override; + void SetSource(rtc::VideoSourceInterface<webrtc::VideoFrame>* source, + const webrtc::VideoSendStream::DegradationPreference& + degradation_preference) override; + webrtc::VideoSendStream::Stats GetStats() override; + void ReconfigureVideoEncoder(webrtc::VideoEncoderConfig config) override; + + bool sending_; + webrtc::VideoSendStream::Config config_; + webrtc::VideoEncoderConfig encoder_config_; + std::vector<webrtc::VideoStream> video_streams_; + rtc::VideoSinkWants sink_wants_; + + bool codec_settings_set_; + union VpxSettings { + webrtc::VideoCodecVP8 vp8; + webrtc::VideoCodecVP9 vp9; + } vpx_settings_; + bool resolution_scaling_enabled_; + bool framerate_scaling_enabled_; + rtc::VideoSourceInterface<webrtc::VideoFrame>* source_; + int num_swapped_frames_; + rtc::Optional<webrtc::VideoFrame> last_frame_; + webrtc::VideoSendStream::Stats stats_; + int num_encoder_reconfigurations_ = 0; +}; + +class FakeVideoReceiveStream final : public webrtc::VideoReceiveStream { + public: + explicit FakeVideoReceiveStream(webrtc::VideoReceiveStream::Config config); + + const webrtc::VideoReceiveStream::Config& GetConfig() const; + + bool IsReceiving() const; + + void InjectFrame(const webrtc::VideoFrame& frame); + + void SetStats(const webrtc::VideoReceiveStream::Stats& stats); + + void EnableEncodedFrameRecording(rtc::PlatformFile file, + size_t byte_limit) override; + + void AddSecondarySink(webrtc::RtpPacketSinkInterface* sink) override; + void RemoveSecondarySink(const webrtc::RtpPacketSinkInterface* sink) override; + + private: + // webrtc::VideoReceiveStream implementation. + void Start() override; + void Stop() override; + + webrtc::VideoReceiveStream::Stats GetStats() const override; + + webrtc::VideoReceiveStream::Config config_; + bool receiving_; + webrtc::VideoReceiveStream::Stats stats_; +}; + +class FakeFlexfecReceiveStream final : public webrtc::FlexfecReceiveStream { + public: + explicit FakeFlexfecReceiveStream( + const webrtc::FlexfecReceiveStream::Config& config); + + const webrtc::FlexfecReceiveStream::Config& GetConfig() const override; + + private: + webrtc::FlexfecReceiveStream::Stats GetStats() const override; + + void OnRtpPacket(const webrtc::RtpPacketReceived& packet) override; + + webrtc::FlexfecReceiveStream::Config config_; +}; + +class FakeCall final : public webrtc::Call, public webrtc::PacketReceiver { + public: + explicit FakeCall(const webrtc::Call::Config& config); + ~FakeCall() override; + + webrtc::Call::Config GetConfig() const; + const std::vector<FakeVideoSendStream*>& GetVideoSendStreams(); + const std::vector<FakeVideoReceiveStream*>& GetVideoReceiveStreams(); + + const std::vector<FakeAudioSendStream*>& GetAudioSendStreams(); + const FakeAudioSendStream* GetAudioSendStream(uint32_t ssrc); + const std::vector<FakeAudioReceiveStream*>& GetAudioReceiveStreams(); + const FakeAudioReceiveStream* GetAudioReceiveStream(uint32_t ssrc); + + const std::vector<FakeFlexfecReceiveStream*>& GetFlexfecReceiveStreams(); + + rtc::SentPacket last_sent_packet() const { return last_sent_packet_; } + + // This is useful if we care about the last media packet (with id populated) + // but not the last ICE packet (with -1 ID). + int last_sent_nonnegative_packet_id() const { + return last_sent_nonnegative_packet_id_; + } + + webrtc::NetworkState GetNetworkState(webrtc::MediaType media) const; + int GetNumCreatedSendStreams() const; + int GetNumCreatedReceiveStreams() const; + void SetStats(const webrtc::Call::Stats& stats); + + private: + webrtc::AudioSendStream* CreateAudioSendStream( + const webrtc::AudioSendStream::Config& config) override; + void DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) override; + + webrtc::AudioReceiveStream* CreateAudioReceiveStream( + const webrtc::AudioReceiveStream::Config& config) override; + void DestroyAudioReceiveStream( + webrtc::AudioReceiveStream* receive_stream) override; + + webrtc::VideoSendStream* CreateVideoSendStream( + webrtc::VideoSendStream::Config config, + webrtc::VideoEncoderConfig encoder_config) override; + void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override; + + webrtc::VideoReceiveStream* CreateVideoReceiveStream( + webrtc::VideoReceiveStream::Config config) override; + void DestroyVideoReceiveStream( + webrtc::VideoReceiveStream* receive_stream) override; + + webrtc::FlexfecReceiveStream* CreateFlexfecReceiveStream( + const webrtc::FlexfecReceiveStream::Config& config) override; + void DestroyFlexfecReceiveStream( + webrtc::FlexfecReceiveStream* receive_stream) override; + + webrtc::PacketReceiver* Receiver() override; + + DeliveryStatus DeliverPacket(webrtc::MediaType media_type, + const uint8_t* packet, + size_t length, + const webrtc::PacketTime& packet_time) override; + + webrtc::Call::Stats GetStats() const override; + + void SetBitrateConfig( + const webrtc::Call::Config::BitrateConfig& bitrate_config) override; + void SetBitrateConfigMask( + const webrtc::Call::Config::BitrateConfigMask& mask) override; + void SetBitrateAllocationStrategy( + std::unique_ptr<rtc::BitrateAllocationStrategy> + bitrate_allocation_strategy) override; + void OnNetworkRouteChanged(const std::string& transport_name, + const rtc::NetworkRoute& network_route) override {} + void SignalChannelNetworkState(webrtc::MediaType media, + webrtc::NetworkState state) override; + void OnTransportOverheadChanged(webrtc::MediaType media, + int transport_overhead_per_packet) override; + void OnSentPacket(const rtc::SentPacket& sent_packet) override; + + webrtc::Call::Config config_; + webrtc::NetworkState audio_network_state_; + webrtc::NetworkState video_network_state_; + rtc::SentPacket last_sent_packet_; + int last_sent_nonnegative_packet_id_ = -1; + int next_stream_id_ = 665; + webrtc::Call::Stats stats_; + std::vector<FakeVideoSendStream*> video_send_streams_; + std::vector<FakeAudioSendStream*> audio_send_streams_; + std::vector<FakeVideoReceiveStream*> video_receive_streams_; + std::vector<FakeAudioReceiveStream*> audio_receive_streams_; + std::vector<FakeFlexfecReceiveStream*> flexfec_receive_streams_; + + int num_created_send_streams_; + int num_created_receive_streams_; + + int audio_transport_overhead_; + int video_transport_overhead_; +}; + +} // namespace cricket +#endif // MEDIA_ENGINE_FAKEWEBRTCCALL_H_ |