ef92755780
This makes it easier to disable RTX by filtering out the RTX codec during call setup/signaling, and won't require that also the SSRCs are filtered out. BUG=1811 R=mflodman@webrtc.org, pbos@webrtc.org Review URL: https://webrtc-codereview.appspot.com/15629005 git-svn-id: http://webrtc.googlecode.com/svn/trunk@6335 4adac7df-926f-26a2-2b94-8c16560cd09d
747 lines
21 KiB
C++
747 lines
21 KiB
C++
/*
|
|
* 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_INTERFACE_RTP_RTCP_H_
|
|
#define WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_RTCP_H_
|
|
|
|
#include <vector>
|
|
|
|
#include "webrtc/modules/interface/module.h"
|
|
#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
|
|
|
|
namespace webrtc {
|
|
// Forward declarations.
|
|
class PacedSender;
|
|
class ReceiveStatistics;
|
|
class RemoteBitrateEstimator;
|
|
class RtpReceiver;
|
|
class Transport;
|
|
|
|
class RtpRtcp : public Module {
|
|
public:
|
|
struct Configuration {
|
|
Configuration();
|
|
|
|
/* id - Unique identifier of this RTP/RTCP module object
|
|
* audio - True for a audio version of the RTP/RTCP module
|
|
* object false will create a video version
|
|
* clock - The clock to use to read time. If NULL object
|
|
* will be using the system clock.
|
|
* incoming_data - Callback object that will receive the incoming
|
|
* data. May not be NULL; default callback will do
|
|
* nothing.
|
|
* incoming_messages - Callback object that will receive the incoming
|
|
* RTP messages. May not be NULL; default callback
|
|
* will do nothing.
|
|
* outgoing_transport - Transport object that will be called when packets
|
|
* are ready to be sent out on the network
|
|
* rtcp_feedback - Callback object that will receive the incoming
|
|
* RTCP messages.
|
|
* intra_frame_callback - Called when the receiver request a intra frame.
|
|
* bandwidth_callback - Called when we receive a changed estimate from
|
|
* the receiver of out stream.
|
|
* audio_messages - Telehone events. May not be NULL; default callback
|
|
* will do nothing.
|
|
* remote_bitrate_estimator - Estimates the bandwidth available for a set of
|
|
* streams from the same client.
|
|
* paced_sender - Spread any bursts of packets into smaller
|
|
* bursts to minimize packet loss.
|
|
*/
|
|
int32_t id;
|
|
bool audio;
|
|
Clock* clock;
|
|
RtpRtcp* default_module;
|
|
ReceiveStatistics* receive_statistics;
|
|
Transport* outgoing_transport;
|
|
RtcpFeedback* rtcp_feedback;
|
|
RtcpIntraFrameObserver* intra_frame_callback;
|
|
RtcpBandwidthObserver* bandwidth_callback;
|
|
RtcpRttStats* rtt_stats;
|
|
RtpAudioFeedback* audio_messages;
|
|
RemoteBitrateEstimator* remote_bitrate_estimator;
|
|
PacedSender* paced_sender;
|
|
};
|
|
|
|
/*
|
|
* 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 int32_t IncomingRtcpPacket(const uint8_t* incoming_packet,
|
|
uint16_t incoming_packet_length) = 0;
|
|
|
|
virtual void SetRemoteSSRC(const uint32_t ssrc) = 0;
|
|
|
|
/**************************************************************************
|
|
*
|
|
* Sender
|
|
*
|
|
***************************************************************************/
|
|
|
|
/*
|
|
* set MTU
|
|
*
|
|
* size - Max transfer unit in bytes, default is 1500
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetMaxTransferUnit(const uint16_t size) = 0;
|
|
|
|
/*
|
|
* set transtport overhead
|
|
* default is IPv4 and UDP with no encryption
|
|
*
|
|
* TCP - true for TCP false UDP
|
|
* IPv6 - true for IP version 6 false for version 4
|
|
* authenticationOverhead - number of bytes to leave for an
|
|
* authentication header
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetTransportOverhead(
|
|
const bool TCP,
|
|
const bool IPV6,
|
|
const uint8_t authenticationOverhead = 0) = 0;
|
|
|
|
/*
|
|
* Get max payload length
|
|
*
|
|
* A combination of the configuration MaxTransferUnit and
|
|
* TransportOverhead.
|
|
* Does not account FEC/ULP/RED overhead if FEC is enabled.
|
|
* Does not account for RTP headers
|
|
*/
|
|
virtual uint16_t MaxPayloadLength() const = 0;
|
|
|
|
/*
|
|
* Get max data payload length
|
|
*
|
|
* A combination of the configuration MaxTransferUnit, headers and
|
|
* TransportOverhead.
|
|
* Takes into account FEC/ULP/RED overhead if FEC is enabled.
|
|
* Takes into account RTP headers
|
|
*/
|
|
virtual uint16_t MaxDataPayloadLength() const = 0;
|
|
|
|
/*
|
|
* set codec name and payload type
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t RegisterSendPayload(
|
|
const CodecInst& voiceCodec) = 0;
|
|
|
|
/*
|
|
* set codec name and payload type
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t RegisterSendPayload(
|
|
const VideoCodec& videoCodec) = 0;
|
|
|
|
/*
|
|
* Unregister a send payload
|
|
*
|
|
* payloadType - payload type of codec
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t DeRegisterSendPayload(
|
|
const int8_t payloadType) = 0;
|
|
|
|
/*
|
|
* (De)register RTP header extension type and id.
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t RegisterSendRtpHeaderExtension(
|
|
const RTPExtensionType type,
|
|
const uint8_t id) = 0;
|
|
|
|
virtual int32_t DeregisterSendRtpHeaderExtension(
|
|
const RTPExtensionType type) = 0;
|
|
|
|
/*
|
|
* get start timestamp
|
|
*/
|
|
virtual uint32_t StartTimestamp() const = 0;
|
|
|
|
/*
|
|
* configure start timestamp, default is a random number
|
|
*
|
|
* timestamp - start timestamp
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetStartTimestamp(
|
|
const uint32_t timestamp) = 0;
|
|
|
|
/*
|
|
* Get SequenceNumber
|
|
*/
|
|
virtual uint16_t SequenceNumber() const = 0;
|
|
|
|
/*
|
|
* Set SequenceNumber, default is a random number
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetSequenceNumber(const uint16_t seq) = 0;
|
|
|
|
/*
|
|
* Get SSRC
|
|
*/
|
|
virtual uint32_t SSRC() const = 0;
|
|
|
|
/*
|
|
* configure SSRC, default is a random number
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual void SetSSRC(const uint32_t ssrc) = 0;
|
|
|
|
/*
|
|
* Get CSRC
|
|
*
|
|
* arrOfCSRC - array of CSRCs
|
|
*
|
|
* return -1 on failure else number of valid entries in the array
|
|
*/
|
|
virtual int32_t CSRCs(
|
|
uint32_t arrOfCSRC[kRtpCsrcSize]) const = 0;
|
|
|
|
/*
|
|
* Set CSRC
|
|
*
|
|
* arrOfCSRC - array of CSRCs
|
|
* arrLength - number of valid entries in the array
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetCSRCs(
|
|
const uint32_t arrOfCSRC[kRtpCsrcSize],
|
|
const uint8_t arrLength) = 0;
|
|
|
|
/*
|
|
* includes CSRCs in RTP header if enabled
|
|
*
|
|
* include CSRC - on/off
|
|
*
|
|
* default:on
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetCSRCStatus(const bool include) = 0;
|
|
|
|
/*
|
|
* Turn 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;
|
|
|
|
// 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) = 0;
|
|
|
|
/*
|
|
* Get status of sending RTX (RFC 4588) on a specific SSRC.
|
|
*/
|
|
virtual void RTXSendStatus(int* modes, uint32_t* ssrc,
|
|
int* payloadType) const = 0;
|
|
|
|
/*
|
|
* sends kRtcpByeCode when going from true to false
|
|
*
|
|
* sending - on/off
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetSendingStatus(const bool sending) = 0;
|
|
|
|
/*
|
|
* get send status
|
|
*/
|
|
virtual bool Sending() const = 0;
|
|
|
|
/*
|
|
* Starts/Stops media packets, on by default
|
|
*
|
|
* sending - on/off
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetSendingMediaStatus(const bool sending) = 0;
|
|
|
|
/*
|
|
* get send status
|
|
*/
|
|
virtual bool SendingMedia() const = 0;
|
|
|
|
/*
|
|
* get sent bitrate in Kbit/s
|
|
*/
|
|
virtual void BitrateSent(uint32_t* totalRate,
|
|
uint32_t* videoRate,
|
|
uint32_t* fecRate,
|
|
uint32_t* nackRate) const = 0;
|
|
|
|
/*
|
|
* Called on any new send bitrate estimate.
|
|
*/
|
|
virtual void RegisterVideoBitrateObserver(
|
|
BitrateStatisticsObserver* observer) = 0;
|
|
virtual BitrateStatisticsObserver* GetVideoBitrateObserver() const = 0;
|
|
|
|
/*
|
|
* Used by the codec module to deliver a video or audio frame for
|
|
* packetization.
|
|
*
|
|
* frameType - type of frame to send
|
|
* payloadType - payload type of frame to send
|
|
* timestamp - timestamp of frame to send
|
|
* payloadData - payload buffer of frame to send
|
|
* payloadSize - size of payload buffer to send
|
|
* fragmentation - fragmentation offset data for fragmented frames such
|
|
* as layers or RED
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SendOutgoingData(
|
|
const FrameType frameType,
|
|
const int8_t payloadType,
|
|
const uint32_t timeStamp,
|
|
int64_t capture_time_ms,
|
|
const uint8_t* payloadData,
|
|
const uint32_t payloadSize,
|
|
const RTPFragmentationHeader* fragmentation = NULL,
|
|
const RTPVideoHeader* rtpVideoHdr = NULL) = 0;
|
|
|
|
virtual bool TimeToSendPacket(uint32_t ssrc,
|
|
uint16_t sequence_number,
|
|
int64_t capture_time_ms,
|
|
bool retransmission) = 0;
|
|
|
|
virtual int TimeToSendPadding(int bytes) = 0;
|
|
|
|
virtual void RegisterSendFrameCountObserver(
|
|
FrameCountObserver* observer) = 0;
|
|
virtual FrameCountObserver* GetSendFrameCountObserver() const = 0;
|
|
|
|
virtual bool GetSendSideDelay(int* avg_send_delay_ms,
|
|
int* max_send_delay_ms) const = 0;
|
|
|
|
// Called on generation of new statistics after an RTP send.
|
|
virtual void RegisterSendChannelRtpStatisticsCallback(
|
|
StreamDataCountersCallback* callback) = 0;
|
|
virtual StreamDataCountersCallback*
|
|
GetSendChannelRtpStatisticsCallback() const = 0;
|
|
|
|
/**************************************************************************
|
|
*
|
|
* RTCP
|
|
*
|
|
***************************************************************************/
|
|
|
|
/*
|
|
* Get RTCP status
|
|
*/
|
|
virtual RTCPMethod RTCP() const = 0;
|
|
|
|
/*
|
|
* configure RTCP status i.e on(compound or non- compound)/off
|
|
*
|
|
* method - RTCP method to use
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetRTCPStatus(const RTCPMethod method) = 0;
|
|
|
|
/*
|
|
* Set RTCP CName (i.e unique identifier)
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetCNAME(const char cName[RTCP_CNAME_SIZE]) = 0;
|
|
|
|
/*
|
|
* Get RTCP CName (i.e unique identifier)
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t CNAME(char cName[RTCP_CNAME_SIZE]) = 0;
|
|
|
|
/*
|
|
* Get remote CName
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t RemoteCNAME(
|
|
const uint32_t remoteSSRC,
|
|
char cName[RTCP_CNAME_SIZE]) const = 0;
|
|
|
|
/*
|
|
* Get remote NTP
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t RemoteNTP(
|
|
uint32_t *ReceivedNTPsecs,
|
|
uint32_t *ReceivedNTPfrac,
|
|
uint32_t *RTCPArrivalTimeSecs,
|
|
uint32_t *RTCPArrivalTimeFrac,
|
|
uint32_t *rtcp_timestamp) const = 0;
|
|
|
|
/*
|
|
* AddMixedCNAME
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t AddMixedCNAME(
|
|
const uint32_t SSRC,
|
|
const char cName[RTCP_CNAME_SIZE]) = 0;
|
|
|
|
/*
|
|
* RemoveMixedCNAME
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t RemoveMixedCNAME(const uint32_t SSRC) = 0;
|
|
|
|
/*
|
|
* Get RoundTripTime
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t RTT(const uint32_t remoteSSRC,
|
|
uint16_t* RTT,
|
|
uint16_t* avgRTT,
|
|
uint16_t* minRTT,
|
|
uint16_t* maxRTT) const = 0 ;
|
|
|
|
/*
|
|
* Reset RoundTripTime statistics
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t ResetRTT(const uint32_t remoteSSRC)= 0 ;
|
|
|
|
/*
|
|
* Force a send of a RTCP packet
|
|
* normal SR and RR are triggered via the process function
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SendRTCP(
|
|
uint32_t rtcpPacketType = kRtcpReport) = 0;
|
|
|
|
/*
|
|
* Good state of RTP receiver inform sender
|
|
*/
|
|
virtual int32_t SendRTCPReferencePictureSelection(
|
|
const uint64_t pictureID) = 0;
|
|
|
|
/*
|
|
* Send a RTCP Slice Loss Indication (SLI)
|
|
* 6 least significant bits of pictureID
|
|
*/
|
|
virtual int32_t SendRTCPSliceLossIndication(
|
|
const uint8_t pictureID) = 0;
|
|
|
|
/*
|
|
* Reset RTP data counters for the sending side
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t ResetSendDataCountersRTP() = 0;
|
|
|
|
/*
|
|
* statistics of the amount of data sent and received
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t DataCountersRTP(
|
|
uint32_t* bytesSent,
|
|
uint32_t* packetsSent) const = 0;
|
|
/*
|
|
* Get received RTCP sender info
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t RemoteRTCPStat(RTCPSenderInfo* senderInfo) = 0;
|
|
|
|
/*
|
|
* Get received RTCP report block
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t RemoteRTCPStat(
|
|
std::vector<RTCPReportBlock>* receiveBlocks) const = 0;
|
|
/*
|
|
* Set received RTCP report block
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t AddRTCPReportBlock(
|
|
const uint32_t SSRC,
|
|
const RTCPReportBlock* receiveBlock) = 0;
|
|
|
|
/*
|
|
* RemoveRTCPReportBlock
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t RemoveRTCPReportBlock(const uint32_t SSRC) = 0;
|
|
|
|
/*
|
|
* Get number of sent and received RTCP packet types.
|
|
*/
|
|
virtual void GetRtcpPacketTypeCounters(
|
|
RtcpPacketTypeCounter* packets_sent,
|
|
RtcpPacketTypeCounter* packets_received) const = 0;
|
|
|
|
/*
|
|
* (APP) Application specific data
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetRTCPApplicationSpecificData(
|
|
const uint8_t subType,
|
|
const uint32_t name,
|
|
const uint8_t* data,
|
|
const uint16_t length) = 0;
|
|
/*
|
|
* (XR) VOIP metric
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetRTCPVoIPMetrics(
|
|
const RTCPVoIPMetric* VoIPMetric) = 0;
|
|
|
|
/*
|
|
* (XR) Receiver Reference Time Report
|
|
*/
|
|
virtual void SetRtcpXrRrtrStatus(bool enable) = 0;
|
|
|
|
virtual bool RtcpXrRrtrStatus() const = 0;
|
|
|
|
/*
|
|
* (REMB) Receiver Estimated Max Bitrate
|
|
*/
|
|
virtual bool REMB() const = 0;
|
|
|
|
virtual int32_t SetREMBStatus(const bool enable) = 0;
|
|
|
|
virtual int32_t SetREMBData(const uint32_t bitrate,
|
|
const uint8_t numberOfSSRC,
|
|
const uint32_t* SSRC) = 0;
|
|
|
|
/*
|
|
* (IJ) Extended jitter report.
|
|
*/
|
|
virtual bool IJ() const = 0;
|
|
|
|
virtual int32_t SetIJStatus(const bool enable) = 0;
|
|
|
|
/*
|
|
* (TMMBR) Temporary Max Media Bit Rate
|
|
*/
|
|
virtual bool TMMBR() const = 0;
|
|
|
|
/*
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetTMMBRStatus(const 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;
|
|
|
|
/*
|
|
* Send a Negative acknowledgement packet
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SendNACK(const uint16_t* nackList,
|
|
const uint16_t size) = 0;
|
|
|
|
/*
|
|
* Store the sent packets, needed to answer to a Negative acknowledgement
|
|
* requests
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetStorePacketsStatus(
|
|
const bool enable,
|
|
const 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 RegisterSendChannelRtcpStatisticsCallback(
|
|
RtcpStatisticsCallback* callback) = 0;
|
|
virtual RtcpStatisticsCallback*
|
|
GetSendChannelRtcpStatisticsCallback() = 0;
|
|
|
|
/**************************************************************************
|
|
*
|
|
* Audio
|
|
*
|
|
***************************************************************************/
|
|
|
|
/*
|
|
* set audio packet size, used to determine when it's time to send a DTMF
|
|
* packet in silence (CNG)
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetAudioPacketSize(
|
|
const uint16_t packetSizeSamples) = 0;
|
|
|
|
/*
|
|
* SendTelephoneEventActive
|
|
*
|
|
* return true if we currently send a telephone event and 100 ms after an
|
|
* event is sent used to prevent the telephone event tone to be recorded
|
|
* by the microphone and send inband just after the tone has ended.
|
|
*/
|
|
virtual bool SendTelephoneEventActive(
|
|
int8_t& telephoneEvent) const = 0;
|
|
|
|
/*
|
|
* Send a TelephoneEvent tone using RFC 2833 (4733)
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SendTelephoneEventOutband(
|
|
const uint8_t key,
|
|
const uint16_t time_ms,
|
|
const uint8_t level) = 0;
|
|
|
|
/*
|
|
* Set payload type for Redundant Audio Data RFC 2198
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetSendREDPayloadType(
|
|
const int8_t payloadType) = 0;
|
|
|
|
/*
|
|
* Get payload type for Redundant Audio Data RFC 2198
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SendREDPayloadType(
|
|
int8_t& payloadType) const = 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(const uint8_t level_dBov) = 0;
|
|
|
|
/**************************************************************************
|
|
*
|
|
* Video
|
|
*
|
|
***************************************************************************/
|
|
|
|
/*
|
|
* Set the estimated camera delay in MS
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetCameraDelay(const int32_t delayMS) = 0;
|
|
|
|
/*
|
|
* Set the target send bitrate
|
|
*/
|
|
virtual void SetTargetSendBitrate(
|
|
const std::vector<uint32_t>& stream_bitrates) = 0;
|
|
|
|
/*
|
|
* Turn on/off generic FEC
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetGenericFECStatus(
|
|
const bool enable,
|
|
const uint8_t payloadTypeRED,
|
|
const uint8_t payloadTypeFEC) = 0;
|
|
|
|
/*
|
|
* Get generic FEC setting
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t GenericFECStatus(bool& enable,
|
|
uint8_t& payloadTypeRED,
|
|
uint8_t& payloadTypeFEC) = 0;
|
|
|
|
|
|
virtual int32_t SetFecParameters(
|
|
const FecProtectionParams* delta_params,
|
|
const FecProtectionParams* key_params) = 0;
|
|
|
|
/*
|
|
* Set method for requestion a new key frame
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t SetKeyFrameRequestMethod(
|
|
const KeyFrameRequestMethod method) = 0;
|
|
|
|
/*
|
|
* send a request for a keyframe
|
|
*
|
|
* return -1 on failure else 0
|
|
*/
|
|
virtual int32_t RequestKeyFrame() = 0;
|
|
};
|
|
} // namespace webrtc
|
|
#endif // WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_RTCP_H_
|