mirror of
https://github.com/mollyim/webrtc.git
synced 2025-05-13 22:00:47 +01:00
c33c0fcbf7
Moving the module process thread responsible for running the pacer and the send side congestion controller to RtpTransportControllerSend since it already owns the pacer and the congestion controller. They are also moved to a common thread rather than using two separate threads. As part of the move, the remote bitrate estimator has been moved to the common process thread in the Call class. Previously it was run on the removed pacer thread. Bug: webrtc:8415 Change-Id: I4322eef30d8b97b9611f33af7e560703b710d232 Reviewed-on: https://webrtc-review.googlesource.com/55700 Reviewed-by: Niels Moller <nisse@webrtc.org> Commit-Queue: Sebastian Jansson <srte@webrtc.org> Cr-Commit-Position: refs/heads/master@{#22166}
116 lines
4.7 KiB
C++
116 lines
4.7 KiB
C++
/*
|
|
* Copyright (c) 2017 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_RTP_TRANSPORT_CONTROLLER_SEND_INTERFACE_H_
|
|
#define CALL_RTP_TRANSPORT_CONTROLLER_SEND_INTERFACE_H_
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
|
|
#include <string>
|
|
|
|
#include "api/optional.h"
|
|
#include "call/bitrate_constraints.h"
|
|
|
|
namespace rtc {
|
|
struct SentPacket;
|
|
struct NetworkRoute;
|
|
} // namespace rtc
|
|
namespace webrtc {
|
|
|
|
class CallStatsObserver;
|
|
class NetworkChangedObserver;
|
|
class Module;
|
|
class PacedSender;
|
|
class PacketFeedbackObserver;
|
|
class PacketRouter;
|
|
class RateLimiter;
|
|
class RtcpBandwidthObserver;
|
|
class RtpPacketSender;
|
|
struct RtpKeepAliveConfig;
|
|
class TransportFeedbackObserver;
|
|
|
|
// An RtpTransportController should own everything related to the RTP
|
|
// transport to/from a remote endpoint. We should have separate
|
|
// interfaces for send and receive side, even if they are implemented
|
|
// by the same class. This is an ongoing refactoring project. At some
|
|
// point, this class should be promoted to a public api under
|
|
// webrtc/api/rtp/.
|
|
//
|
|
// For a start, this object is just a collection of the objects needed
|
|
// by the VideoSendStream constructor. The plan is to move ownership
|
|
// of all RTP-related objects here, and add methods to create per-ssrc
|
|
// objects which would then be passed to VideoSendStream. Eventually,
|
|
// direct accessors like packet_router() should be removed.
|
|
//
|
|
// This should also have a reference to the underlying
|
|
// webrtc::Transport(s). Currently, webrtc::Transport is implemented by
|
|
// WebRtcVideoChannel and WebRtcVoiceMediaChannel, and owned by
|
|
// WebrtcSession. Video and audio always uses different transport
|
|
// objects, even in the common case where they are bundled over the
|
|
// same underlying transport.
|
|
//
|
|
// Extracting the logic of the webrtc::Transport from BaseChannel and
|
|
// subclasses into a separate class seems to be a prerequesite for
|
|
// moving the transport here.
|
|
class RtpTransportControllerSendInterface {
|
|
public:
|
|
virtual ~RtpTransportControllerSendInterface() {}
|
|
virtual PacketRouter* packet_router() = 0;
|
|
virtual TransportFeedbackObserver* transport_feedback_observer() = 0;
|
|
|
|
virtual RtpPacketSender* packet_sender() = 0;
|
|
virtual const RtpKeepAliveConfig& keepalive_config() const = 0;
|
|
|
|
// SetAllocatedSendBitrateLimits sets bitrates limits imposed by send codec
|
|
// settings.
|
|
// |min_send_bitrate_bps| is the total minimum send bitrate required by all
|
|
// sending streams. This is the minimum bitrate the PacedSender will use.
|
|
// Note that SendSideCongestionController::OnNetworkChanged can still be
|
|
// called with a lower bitrate estimate. |max_padding_bitrate_bps| is the max
|
|
// bitrate the send streams request for padding. This can be higher than the
|
|
// current network estimate and tells the PacedSender how much it should max
|
|
// pad unless there is real packets to send.
|
|
virtual void SetAllocatedSendBitrateLimits(int min_send_bitrate_bps,
|
|
int max_padding_bitrate_bps) = 0;
|
|
|
|
virtual void SetPacingFactor(float pacing_factor) = 0;
|
|
virtual void SetQueueTimeLimit(int limit_ms) = 0;
|
|
|
|
virtual CallStatsObserver* GetCallStatsObserver() = 0;
|
|
|
|
virtual void RegisterPacketFeedbackObserver(
|
|
PacketFeedbackObserver* observer) = 0;
|
|
virtual void DeRegisterPacketFeedbackObserver(
|
|
PacketFeedbackObserver* observer) = 0;
|
|
virtual void RegisterNetworkObserver(NetworkChangedObserver* observer) = 0;
|
|
virtual void DeRegisterNetworkObserver(NetworkChangedObserver* observer) = 0;
|
|
virtual void OnNetworkRouteChanged(
|
|
const std::string& transport_name,
|
|
const rtc::NetworkRoute& network_route) = 0;
|
|
virtual void OnNetworkAvailability(bool network_available) = 0;
|
|
virtual void SetTransportOverhead(
|
|
size_t transport_overhead_bytes_per_packet) = 0;
|
|
virtual RtcpBandwidthObserver* GetBandwidthObserver() = 0;
|
|
virtual bool AvailableBandwidth(uint32_t* bandwidth) const = 0;
|
|
virtual int64_t GetPacerQueuingDelayMs() const = 0;
|
|
virtual int64_t GetFirstPacketTimeMs() const = 0;
|
|
virtual RateLimiter* GetRetransmissionRateLimiter() = 0;
|
|
virtual void EnablePeriodicAlrProbing(bool enable) = 0;
|
|
virtual void OnSentPacket(const rtc::SentPacket& sent_packet) = 0;
|
|
|
|
virtual void SetSdpBitrateParameters(
|
|
const BitrateConstraints& constraints) = 0;
|
|
virtual void SetClientBitratePreferences(
|
|
const BitrateConstraintsMask& preferences) = 0;
|
|
};
|
|
|
|
} // namespace webrtc
|
|
|
|
#endif // CALL_RTP_TRANSPORT_CONTROLLER_SEND_INTERFACE_H_
|