text: /*
   *  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; }
    void SendAudioData(std::unique_ptr<webrtc::AudioFrame> audio_frame) override {
    }
    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_; }
    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 Reconfigure(const webrtc::AudioReceiveStream::Config& config) override;
    void Start() override { started_ = true; }
    void Stop() override { started_ = false; }
  
    webrtc::AudioReceiveStream::Stats GetStats() const override;
    int GetOutputLevel() const override { return 0; }
    void SetSink(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;
    webrtc::AudioSinkInterface* sink_ = nullptr;
    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,
                                 rtc::CopyOnWriteBuffer packet,
                                 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_
  