blob: 4fb50d1bdef81ec185dbb705dd756eced3f2fdee [file] [log] [blame]
/*
* Copyright (c) 2012 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 WEBRTC_MODULES_RTP_RTCP_INCLUDE_RTP_RTCP_H_
#define WEBRTC_MODULES_RTP_RTCP_INCLUDE_RTP_RTCP_H_
#include <set>
#include <string>
#include <utility>
#include <vector>
#include "webrtc/api/optional.h"
#include "webrtc/common_types.h"
#include "webrtc/modules/include/module.h"
#include "webrtc/modules/rtp_rtcp/include/flexfec_sender.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "webrtc/rtc_base/constructormagic.h"
#include "webrtc/rtc_base/deprecation.h"
namespace webrtc {
// Forward declarations.
class OverheadObserver;
class RateLimiter;
class ReceiveStatisticsProvider;
class RemoteBitrateEstimator;
class RtcEventLog;
class RtpReceiver;
class Transport;
class VideoBitrateAllocationObserver;
RTPExtensionType StringToRtpExtensionType(const std::string& extension);
namespace rtcp {
class TransportFeedback;
}
class RtpRtcp : public Module {
public:
struct Configuration {
Configuration();
// True for a audio version of the RTP/RTCP module object false will create
// a video version.
bool audio = false;
bool receiver_only = false;
// The clock to use to read time. If nullptr then system clock will be used.
Clock* clock = nullptr;
ReceiveStatisticsProvider* receive_statistics = nullptr;
// Transport object that will be called when packets are ready to be sent
// out on the network.
Transport* outgoing_transport = nullptr;
// Called when the receiver request a intra frame.
RtcpIntraFrameObserver* intra_frame_callback = nullptr;
// Called when we receive a changed estimate from the receiver of out
// stream.
RtcpBandwidthObserver* bandwidth_callback = nullptr;
TransportFeedbackObserver* transport_feedback_callback = nullptr;
VideoBitrateAllocationObserver* bitrate_allocation_observer = nullptr;
RtcpRttStats* rtt_stats = nullptr;
RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer = nullptr;
// Estimates the bandwidth available for a set of streams from the same
// client.
RemoteBitrateEstimator* remote_bitrate_estimator = nullptr;
// Spread any bursts of packets into smaller bursts to minimize packet loss.
RtpPacketSender* paced_sender = nullptr;
// Generate FlexFEC packets.
// TODO(brandtr): Remove when FlexfecSender is wired up to PacedSender.
FlexfecSender* flexfec_sender = nullptr;
TransportSequenceNumberAllocator* transport_sequence_number_allocator =
nullptr;
BitrateStatisticsObserver* send_bitrate_observer = nullptr;
FrameCountObserver* send_frame_count_observer = nullptr;
SendSideDelayObserver* send_side_delay_observer = nullptr;
RtcEventLog* event_log = nullptr;
SendPacketObserver* send_packet_observer = nullptr;
RateLimiter* retransmission_rate_limiter = nullptr;
OverheadObserver* overhead_observer = nullptr;
RtpKeepAliveConfig keepalive_config;
private:
RTC_DISALLOW_COPY_AND_ASSIGN(Configuration);
};
// Create a RTP/RTCP module object using the system clock.
// |configuration| - Configuration of the RTP/RTCP module.
static RtpRtcp* CreateRtpRtcp(const RtpRtcp::Configuration& configuration);
// **************************************************************************
// Receiver functions
// **************************************************************************
virtual void IncomingRtcpPacket(const uint8_t* incoming_packet,
size_t incoming_packet_length) = 0;
virtual void SetRemoteSSRC(uint32_t ssrc) = 0;
// **************************************************************************
// Sender
// **************************************************************************
// TODO(nisse): Deprecated. Kept temporarily, as an alias for the
// new function which has slighly different semantics. Delete as
// soon as known applications are updated.
virtual int32_t SetMaxTransferUnit(uint16_t size) {
SetMaxRtpPacketSize(size);
return 0;
}
// Sets the maximum size of an RTP packet, including RTP headers.
virtual void SetMaxRtpPacketSize(size_t size) = 0;
// Returns max RTP packet size. Takes into account RTP headers and
// FEC/ULP/RED overhead (when FEC is enabled).
virtual size_t MaxRtpPacketSize() const = 0;
// Sets codec name and payload type. Returns -1 on failure else 0.
virtual int32_t RegisterSendPayload(const CodecInst& voice_codec) = 0;
// Sets codec name and payload type. Return -1 on failure else 0.
virtual int32_t RegisterSendPayload(const VideoCodec& video_codec) = 0;
virtual void RegisterVideoSendPayload(int payload_type,
const char* payload_name) = 0;
// Unregisters a send payload.
// |payload_type| - payload type of codec
// Returns -1 on failure else 0.
virtual int32_t DeRegisterSendPayload(int8_t payload_type) = 0;
// (De)registers RTP header extension type and id.
// Returns -1 on failure else 0.
virtual int32_t RegisterSendRtpHeaderExtension(RTPExtensionType type,
uint8_t id) = 0;
virtual int32_t DeregisterSendRtpHeaderExtension(RTPExtensionType type) = 0;
virtual bool HasBweExtensions() const = 0;
// Returns start timestamp.
virtual uint32_t StartTimestamp() const = 0;
// Sets start timestamp. Start timestamp is set to a random value if this
// function is never called.
virtual void SetStartTimestamp(uint32_t timestamp) = 0;
// Returns SequenceNumber.
virtual uint16_t SequenceNumber() const = 0;
// Sets SequenceNumber, default is a random number.
virtual void SetSequenceNumber(uint16_t seq) = 0;
virtual void SetRtpState(const RtpState& rtp_state) = 0;
virtual void SetRtxState(const RtpState& rtp_state) = 0;
virtual RtpState GetRtpState() const = 0;
virtual RtpState GetRtxState() const = 0;
// Returns SSRC.
virtual uint32_t SSRC() const = 0;
// Sets SSRC, default is a random number.
virtual void SetSSRC(uint32_t ssrc) = 0;
// Sets CSRC.
// |csrcs| - vector of CSRCs
virtual void SetCsrcs(const std::vector<uint32_t>& csrcs) = 0;
// Turns on/off sending RTX (RFC 4588). The modes can be set as a combination
// of values of the enumerator RtxMode.
virtual void SetRtxSendStatus(int modes) = 0;
// Returns status of sending RTX (RFC 4588). The returned value can be
// a combination of values of the enumerator RtxMode.
virtual int RtxSendStatus() const = 0;
// Sets the SSRC to use when sending RTX packets. This doesn't enable RTX,
// only the SSRC is set.
virtual void SetRtxSsrc(uint32_t ssrc) = 0;
// Sets the payload type to use when sending RTX packets. Note that this
// doesn't enable RTX, only the payload type is set.
virtual void SetRtxSendPayloadType(int payload_type,
int associated_payload_type) = 0;
// Returns the FlexFEC SSRC, if there is one.
virtual rtc::Optional<uint32_t> FlexfecSsrc() const = 0;
// Sets sending status. Sends kRtcpByeCode when going from true to false.
// Returns -1 on failure else 0.
virtual int32_t SetSendingStatus(bool sending) = 0;
// Returns current sending status.
virtual bool Sending() const = 0;
// Starts/Stops media packets. On by default.
virtual void SetSendingMediaStatus(bool sending) = 0;
// Returns current media sending status.
virtual bool SendingMedia() const = 0;
// Returns current bitrate in Kbit/s.
virtual void BitrateSent(uint32_t* total_rate,
uint32_t* video_rate,
uint32_t* fec_rate,
uint32_t* nack_rate) const = 0;
// Used by the codec module to deliver a video or audio frame for
// packetization.
// |frame_type| - type of frame to send
// |payload_type| - payload type of frame to send
// |timestamp| - timestamp of frame to send
// |payload_data| - payload buffer of frame to send
// |payload_size| - size of payload buffer to send
// |fragmentation| - fragmentation offset data for fragmented frames such
// as layers or RED
// |transport_frame_id_out| - set to RTP timestamp.
// Returns true on success.
virtual bool SendOutgoingData(FrameType frame_type,
int8_t payload_type,
uint32_t timestamp,
int64_t capture_time_ms,
const uint8_t* payload_data,
size_t payload_size,
const RTPFragmentationHeader* fragmentation,
const RTPVideoHeader* rtp_video_header,
uint32_t* transport_frame_id_out) = 0;
virtual bool TimeToSendPacket(uint32_t ssrc,
uint16_t sequence_number,
int64_t capture_time_ms,
bool retransmission,
const PacedPacketInfo& pacing_info) = 0;
virtual size_t TimeToSendPadding(size_t bytes,
const PacedPacketInfo& pacing_info) = 0;
// Called on generation of new statistics after an RTP send.
virtual void RegisterSendChannelRtpStatisticsCallback(
StreamDataCountersCallback* callback) = 0;
virtual StreamDataCountersCallback* GetSendChannelRtpStatisticsCallback()
const = 0;
// **************************************************************************
// RTCP
// **************************************************************************
// Returns RTCP status.
virtual RtcpMode RTCP() const = 0;
// Sets RTCP status i.e on(compound or non-compound)/off.
// |method| - RTCP method to use.
virtual void SetRTCPStatus(RtcpMode method) = 0;
// Sets RTCP CName (i.e unique identifier).
// Returns -1 on failure else 0.
virtual int32_t SetCNAME(const char* cname) = 0;
// Returns remote CName.
// Returns -1 on failure else 0.
virtual int32_t RemoteCNAME(uint32_t remote_ssrc,
char cname[RTCP_CNAME_SIZE]) const = 0;
// Returns remote NTP.
// Returns -1 on failure else 0.
virtual int32_t RemoteNTP(uint32_t* received_ntp_secs,
uint32_t* received_ntp_frac,
uint32_t* rtcp_arrival_time_secs,
uint32_t* rtcp_arrival_time_frac,
uint32_t* rtcp_timestamp) const = 0;
// Returns -1 on failure else 0.
virtual int32_t AddMixedCNAME(uint32_t ssrc, const char* cname) = 0;
// Returns -1 on failure else 0.
virtual int32_t RemoveMixedCNAME(uint32_t ssrc) = 0;
// Returns current RTT (round-trip time) estimate.
// Returns -1 on failure else 0.
virtual int32_t RTT(uint32_t remote_ssrc,
int64_t* rtt,
int64_t* avg_rtt,
int64_t* min_rtt,
int64_t* max_rtt) const = 0;
// Forces a send of a RTCP packet. Periodic SR and RR are triggered via the
// process function.
// Returns -1 on failure else 0.
virtual int32_t SendRTCP(RTCPPacketType rtcp_packet_type) = 0;
// Forces a send of a RTCP packet with more than one packet type.
// periodic SR and RR are triggered via the process function
// Returns -1 on failure else 0.
virtual int32_t SendCompoundRTCP(
const std::set<RTCPPacketType>& rtcp_packet_types) = 0;
// Returns statistics of the amount of data sent.
// Returns -1 on failure else 0.
virtual int32_t DataCountersRTP(size_t* bytes_sent,
uint32_t* packets_sent) const = 0;
// Returns send statistics for the RTP and RTX stream.
virtual void GetSendStreamDataCounters(
StreamDataCounters* rtp_counters,
StreamDataCounters* rtx_counters) const = 0;
// Returns packet loss statistics for the RTP stream.
virtual void GetRtpPacketLossStats(
bool outgoing,
uint32_t ssrc,
struct RtpPacketLossStats* loss_stats) const = 0;
// Returns received RTCP report block.
// Returns -1 on failure else 0.
virtual int32_t RemoteRTCPStat(
std::vector<RTCPReportBlock>* receive_blocks) const = 0;
// (APP) Sets application specific data.
// Returns -1 on failure else 0.
virtual int32_t SetRTCPApplicationSpecificData(uint8_t sub_type,
uint32_t name,
const uint8_t* data,
uint16_t length) = 0;
// (XR) Sets VOIP metric.
// Returns -1 on failure else 0.
virtual int32_t SetRTCPVoIPMetrics(const RTCPVoIPMetric* VoIPMetric) = 0;
// (XR) Sets Receiver Reference Time Report (RTTR) status.
virtual void SetRtcpXrRrtrStatus(bool enable) = 0;
// Returns current Receiver Reference Time Report (RTTR) status.
virtual bool RtcpXrRrtrStatus() const = 0;
// (REMB) Receiver Estimated Max Bitrate.
virtual bool REMB() const = 0;
virtual void SetREMBStatus(bool enable) = 0;
virtual void SetREMBData(uint32_t bitrate,
const std::vector<uint32_t>& ssrcs) = 0;
// (TMMBR) Temporary Max Media Bit Rate
virtual bool TMMBR() const = 0;
virtual void SetTMMBRStatus(bool enable) = 0;
// (NACK)
// TODO(holmer): Propagate this API to VideoEngine.
// Returns the currently configured selective retransmission settings.
virtual int SelectiveRetransmissions() const = 0;
// TODO(holmer): Propagate this API to VideoEngine.
// Sets the selective retransmission settings, which will decide which
// packets will be retransmitted if NACKed. Settings are constructed by
// combining the constants in enum RetransmissionMode with bitwise OR.
// All packets are retransmitted if kRetransmitAllPackets is set, while no
// packets are retransmitted if kRetransmitOff is set.
// By default all packets except FEC packets are retransmitted. For VP8
// with temporal scalability only base layer packets are retransmitted.
// Returns -1 on failure, otherwise 0.
virtual int SetSelectiveRetransmissions(uint8_t settings) = 0;
// Sends a Negative acknowledgement packet.
// Returns -1 on failure else 0.
// TODO(philipel): Deprecate this and start using SendNack instead, mostly
// because we want a function that actually send NACK for the specified
// packets.
virtual int32_t SendNACK(const uint16_t* nack_list, uint16_t size) = 0;
// Sends NACK for the packets specified.
// Note: This assumes the caller keeps track of timing and doesn't rely on
// the RTP module to do this.
virtual void SendNack(const std::vector<uint16_t>& sequence_numbers) = 0;
// Store the sent packets, needed to answer to a Negative acknowledgment
// requests.
virtual void SetStorePacketsStatus(bool enable, uint16_t numberToStore) = 0;
// Returns true if the module is configured to store packets.
virtual bool StorePackets() const = 0;
// Called on receipt of RTCP report block from remote side.
virtual void RegisterRtcpStatisticsCallback(
RtcpStatisticsCallback* callback) = 0;
virtual RtcpStatisticsCallback* GetRtcpStatisticsCallback() = 0;
// BWE feedback packets.
virtual bool SendFeedbackPacket(const rtcp::TransportFeedback& packet) = 0;
virtual void SetVideoBitrateAllocation(const BitrateAllocation& bitrate) = 0;
// **************************************************************************
// Audio
// **************************************************************************
// Sends a TelephoneEvent tone using RFC 2833 (4733).
// Returns -1 on failure else 0.
virtual int32_t SendTelephoneEventOutband(uint8_t key,
uint16_t time_ms,
uint8_t level) = 0;
// Store the audio level in dBov for header-extension-for-audio-level-
// indication.
// This API shall be called before transmision of an RTP packet to ensure
// that the |level| part of the extended RTP header is updated.
// return -1 on failure else 0.
virtual int32_t SetAudioLevel(uint8_t level_dbov) = 0;
// **************************************************************************
// Video
// **************************************************************************
// Set RED and ULPFEC payload types. A payload type of -1 means that the
// corresponding feature is turned off. Note that we DO NOT support enabling
// ULPFEC without enabling RED. However, we DO support enabling RED without
// enabling ULPFEC. This is due to an RED/RTX workaround, where the receiver
// assumes that RTX packets carry RED if RED has been configured in the SDP,
// regardless of what RTX payload type mapping was negotiated in the SDP.
// TODO(brandtr): Update this comment when we have removed the RED/RTX
// send-side workaround, i.e., when we do not support enabling RED without
// enabling ULPFEC.
virtual void SetUlpfecConfig(int red_payload_type,
int ulpfec_payload_type) = 0;
// Set FEC rates, max frames before FEC is sent, and type of FEC masks.
// Returns false on failure.
virtual bool SetFecParameters(const FecProtectionParams& delta_params,
const FecProtectionParams& key_params) = 0;
// Deprecated version of member function above.
RTC_DEPRECATED
int32_t SetFecParameters(const FecProtectionParams* delta_params,
const FecProtectionParams* key_params);
// Set method for requestion a new key frame.
// Returns -1 on failure else 0.
virtual int32_t SetKeyFrameRequestMethod(KeyFrameRequestMethod method) = 0;
// Sends a request for a keyframe.
// Returns -1 on failure else 0.
virtual int32_t RequestKeyFrame() = 0;
};
} // namespace webrtc
#endif // WEBRTC_MODULES_RTP_RTCP_INCLUDE_RTP_RTCP_H_