blob: fe39bd87becec320999bd6bb65e6524234411b05 [file] [log] [blame]
/*
* Copyright 2018 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.
*/
#ifndef TEST_SCENARIO_CALL_CLIENT_H_
#define TEST_SCENARIO_CALL_CLIENT_H_
#include <memory>
#include <string>
#include <vector>
#include "call/call.h"
#include "logging/rtc_event_log/rtc_event_log.h"
#include "modules/audio_device/include/test_audio_device.h"
#include "modules/congestion_controller/test/controller_printer.h"
#include "modules/rtp_rtcp/include/rtp_header_parser.h"
#include "rtc_base/constructormagic.h"
#include "test/scenario/column_printer.h"
#include "test/scenario/network_node.h"
#include "test/scenario/scenario_config.h"
namespace webrtc {
namespace test {
class LoggingNetworkControllerFactory
: public NetworkControllerFactoryInterface {
public:
LoggingNetworkControllerFactory(std::string filename,
TransportControllerConfig config);
RTC_DISALLOW_COPY_AND_ASSIGN(LoggingNetworkControllerFactory);
~LoggingNetworkControllerFactory();
std::unique_ptr<NetworkControllerInterface> Create(
NetworkControllerConfig config) override;
TimeDelta GetProcessInterval() const override;
// TODO(srte): Consider using the Columnprinter interface for this.
void LogCongestionControllerStats(Timestamp at_time);
RtcEventLog* GetEventLog() const;
private:
std::unique_ptr<RtcEventLog> event_log_;
std::unique_ptr<NetworkControllerFactoryInterface> cc_factory_;
std::unique_ptr<ControlStatePrinter> cc_printer_;
FILE* cc_out_ = nullptr;
};
struct CallClientFakeAudio {
rtc::scoped_refptr<AudioProcessing> apm;
rtc::scoped_refptr<TestAudioDeviceModule> fake_audio_device;
rtc::scoped_refptr<AudioState> audio_state;
};
// CallClient represents a participant in a call scenario. It is created by the
// Scenario class and is used as sender and receiver when setting up a media
// stream session.
class CallClient : public NetworkReceiverInterface {
public:
CallClient(Clock* clock, std::string log_filename, CallClientConfig config);
RTC_DISALLOW_COPY_AND_ASSIGN(CallClient);
~CallClient();
ColumnPrinter StatsPrinter();
Call::Stats GetStats();
DataRate send_bandwidth() {
return DataRate::bps(GetStats().send_bandwidth_bps);
}
bool TryDeliverPacket(rtc::CopyOnWriteBuffer packet,
uint64_t receiver,
Timestamp at_time) override;
private:
friend class Scenario;
friend class CallClientPair;
friend class SendVideoStream;
friend class VideoStreamPair;
friend class ReceiveVideoStream;
friend class SendAudioStream;
friend class ReceiveAudioStream;
friend class AudioStreamPair;
friend class NetworkNodeTransport;
uint32_t GetNextVideoSsrc();
uint32_t GetNextAudioSsrc();
uint32_t GetNextRtxSsrc();
std::string GetNextPriorityId();
Clock* clock_;
LoggingNetworkControllerFactory network_controller_factory_;
CallClientFakeAudio fake_audio_setup_;
std::unique_ptr<Call> call_;
NetworkNodeTransport transport_;
RtpHeaderParser* const header_parser_;
std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory_;
// Stores the configured overhead per known incomming route. This is used to
// subtract the overhead before processing.
std::map<uint64_t, DataSize> route_overhead_;
int next_video_ssrc_index_ = 0;
int next_rtx_ssrc_index_ = 0;
int next_audio_ssrc_index_ = 0;
int next_priority_index_ = 0;
std::map<uint32_t, MediaType> ssrc_media_types_;
};
class CallClientPair {
public:
RTC_DISALLOW_COPY_AND_ASSIGN(CallClientPair);
~CallClientPair();
CallClient* first() { return first_; }
CallClient* second() { return second_; }
std::pair<CallClient*, CallClient*> forward() { return {first(), second()}; }
std::pair<CallClient*, CallClient*> reverse() { return {second(), first()}; }
private:
friend class Scenario;
CallClientPair(CallClient* first, CallClient* second)
: first_(first), second_(second) {}
CallClient* const first_;
CallClient* const second_;
};
} // namespace test
} // namespace webrtc
#endif // TEST_SCENARIO_CALL_CLIENT_H_