mirror of
https://github.com/mollyim/webrtc.git
synced 2025-05-13 22:00:47 +01:00
78a7138600
There aren't any tests for this and the code isn't currently active except for the fact that it adds complexity to the Call class, synchronization into the active code path and makes future improvements to the class more complex or impossible. Bug: webrtc:9719 Change-Id: Ia41af0b2186b8a36ca70a07858990b6af7f3a5c3 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/148078 Commit-Queue: Tommi <tommi@webrtc.org> Reviewed-by: Magnus Flodman <mflodman@webrtc.org> Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org> Cr-Commit-Position: refs/heads/master@{#28807}
124 lines
4.6 KiB
C++
124 lines
4.6 KiB
C++
/*
|
|
* Copyright (c) 2013 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 CALL_CALL_H_
|
|
#define CALL_CALL_H_
|
|
|
|
#include <algorithm>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "api/media_types.h"
|
|
#include "call/audio_receive_stream.h"
|
|
#include "call/audio_send_stream.h"
|
|
#include "call/call_config.h"
|
|
#include "call/flexfec_receive_stream.h"
|
|
#include "call/packet_receiver.h"
|
|
#include "call/rtp_transport_controller_send_interface.h"
|
|
#include "call/video_receive_stream.h"
|
|
#include "call/video_send_stream.h"
|
|
#include "modules/utility/include/process_thread.h"
|
|
#include "rtc_base/copy_on_write_buffer.h"
|
|
#include "rtc_base/network/sent_packet.h"
|
|
#include "rtc_base/network_route.h"
|
|
|
|
namespace webrtc {
|
|
|
|
// A Call instance can contain several send and/or receive streams. All streams
|
|
// are assumed to have the same remote endpoint and will share bitrate estimates
|
|
// etc.
|
|
class Call {
|
|
public:
|
|
using Config = CallConfig;
|
|
|
|
struct Stats {
|
|
std::string ToString(int64_t time_ms) const;
|
|
|
|
int send_bandwidth_bps = 0; // Estimated available send bandwidth.
|
|
int max_padding_bitrate_bps = 0; // Cumulative configured max padding.
|
|
int recv_bandwidth_bps = 0; // Estimated available receive bandwidth.
|
|
int64_t pacer_delay_ms = 0;
|
|
int64_t rtt_ms = -1;
|
|
};
|
|
|
|
static Call* Create(const Call::Config& config);
|
|
static Call* Create(const Call::Config& config,
|
|
Clock* clock,
|
|
std::unique_ptr<ProcessThread> call_thread,
|
|
std::unique_ptr<ProcessThread> pacer_thread);
|
|
|
|
virtual AudioSendStream* CreateAudioSendStream(
|
|
const AudioSendStream::Config& config) = 0;
|
|
|
|
virtual void DestroyAudioSendStream(AudioSendStream* send_stream) = 0;
|
|
|
|
virtual AudioReceiveStream* CreateAudioReceiveStream(
|
|
const AudioReceiveStream::Config& config) = 0;
|
|
virtual void DestroyAudioReceiveStream(
|
|
AudioReceiveStream* receive_stream) = 0;
|
|
|
|
virtual VideoSendStream* CreateVideoSendStream(
|
|
VideoSendStream::Config config,
|
|
VideoEncoderConfig encoder_config) = 0;
|
|
virtual VideoSendStream* CreateVideoSendStream(
|
|
VideoSendStream::Config config,
|
|
VideoEncoderConfig encoder_config,
|
|
std::unique_ptr<FecController> fec_controller);
|
|
virtual void DestroyVideoSendStream(VideoSendStream* send_stream) = 0;
|
|
|
|
virtual VideoReceiveStream* CreateVideoReceiveStream(
|
|
VideoReceiveStream::Config configuration) = 0;
|
|
virtual void DestroyVideoReceiveStream(
|
|
VideoReceiveStream* receive_stream) = 0;
|
|
|
|
// In order for a created VideoReceiveStream to be aware that it is
|
|
// protected by a FlexfecReceiveStream, the latter should be created before
|
|
// the former.
|
|
virtual FlexfecReceiveStream* CreateFlexfecReceiveStream(
|
|
const FlexfecReceiveStream::Config& config) = 0;
|
|
virtual void DestroyFlexfecReceiveStream(
|
|
FlexfecReceiveStream* receive_stream) = 0;
|
|
|
|
// All received RTP and RTCP packets for the call should be inserted to this
|
|
// PacketReceiver. The PacketReceiver pointer is valid as long as the
|
|
// Call instance exists.
|
|
virtual PacketReceiver* Receiver() = 0;
|
|
|
|
// This is used to access the transport controller send instance owned by
|
|
// Call. The send transport controller is currently owned by Call for legacy
|
|
// reasons. (for instance variants of call tests are built on this assumtion)
|
|
// TODO(srte): Move ownership of transport controller send out of Call and
|
|
// remove this method interface.
|
|
virtual RtpTransportControllerSendInterface* GetTransportControllerSend() = 0;
|
|
|
|
// Returns the call statistics, such as estimated send and receive bandwidth,
|
|
// pacing delay, etc.
|
|
virtual Stats GetStats() const = 0;
|
|
|
|
// TODO(skvlad): When the unbundled case with multiple streams for the same
|
|
// media type going over different networks is supported, track the state
|
|
// for each stream separately. Right now it's global per media type.
|
|
virtual void SignalChannelNetworkState(MediaType media,
|
|
NetworkState state) = 0;
|
|
|
|
virtual void OnAudioTransportOverheadChanged(
|
|
int transport_overhead_per_packet) = 0;
|
|
|
|
virtual void OnSentPacket(const rtc::SentPacket& sent_packet) = 0;
|
|
|
|
virtual void SetClientBitratePreferences(
|
|
const BitrateSettings& preferences) = 0;
|
|
|
|
virtual ~Call() {}
|
|
};
|
|
|
|
} // namespace webrtc
|
|
|
|
#endif // CALL_CALL_H_
|