src/third_party/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h

   1 /*
   2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #ifndef WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_RTCP_H_
  12 #define WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_RTCP_H_
  13
  14 #include <vector>
  15
  16 #include "webrtc/modules/interface/module.h"
  17 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
  18
  19 namespace webrtc {
  20 // Forward declarations.
  21 class PacedSender;
  22 class ReceiveStatistics;
  23 class RemoteBitrateEstimator;
  24 class RtpReceiver;
  25 class Transport;
  26
  27 class RtpRtcp : public Module {
  28  public:
  29   struct Configuration {
  30     Configuration();
  31
  32    /*  id                   - Unique identifier of this RTP/RTCP module object
  33     *  audio                - True for a audio version of the RTP/RTCP module
  34     *                         object false will create a video version
  35     *  clock                - The clock to use to read time. If NULL object
  36     *                         will be using the system clock.
  37     *  incoming_data        - Callback object that will receive the incoming
  38     *                         data. May not be NULL; default callback will do
  39     *                         nothing.
  40     *  incoming_messages    - Callback object that will receive the incoming
  41     *                         RTP messages. May not be NULL; default callback
  42     *                         will do nothing.
  43     *  outgoing_transport   - Transport object that will be called when packets
  44     *                         are ready to be sent out on the network
  45     *  rtcp_feedback        - Callback object that will receive the incoming
  46     *                         RTCP messages.
  47     *  intra_frame_callback - Called when the receiver request a intra frame.
  48     *  bandwidth_callback   - Called when we receive a changed estimate from
  49     *                         the receiver of out stream.
  50     *  audio_messages       - Telehone events. May not be NULL; default callback
  51     *                         will do nothing.
  52     *  remote_bitrate_estimator - Estimates the bandwidth available for a set of
  53     *                             streams from the same client.
  54     *  paced_sender             - Spread any bursts of packets into smaller
  55     *                             bursts to minimize packet loss.
  56     */
  57     int32_t id;
  58     bool audio;
  59     Clock* clock;
  60     RtpRtcp* default_module;
  61     ReceiveStatistics* receive_statistics;
  62     Transport* outgoing_transport;
  63     RtcpFeedback* rtcp_feedback;
  64     RtcpIntraFrameObserver* intra_frame_callback;
  65     RtcpBandwidthObserver* bandwidth_callback;
  66     RtcpRttStats* rtt_stats;
  67     RtpAudioFeedback* audio_messages;
  68     RemoteBitrateEstimator* remote_bitrate_estimator;
  69     PacedSender* paced_sender;
  70   };
  71
  72   /*
  73    *   Create a RTP/RTCP module object using the system clock.
  74    *
  75    *   configuration  - Configuration of the RTP/RTCP module.
  76    */
  77   static RtpRtcp* CreateRtpRtcp(const RtpRtcp::Configuration& configuration);
  78
  79   /**************************************************************************
  80    *
  81    *   Receiver functions
  82    *
  83    ***************************************************************************/
  84
  85     virtual int32_t IncomingRtcpPacket(const uint8_t* incoming_packet,
  86                                        uint16_t incoming_packet_length) = 0;
  87
  88     virtual void SetRemoteSSRC(const uint32_t ssrc) = 0;
  89
  90     /**************************************************************************
  91     *
  92     *   Sender
  93     *
  94     ***************************************************************************/
  95
  96     /*
  97     *   set MTU
  98     *
  99     *   size    -  Max transfer unit in bytes, default is 1500
 100     *
 101     *   return -1 on failure else 0
 102     */
 103     virtual int32_t SetMaxTransferUnit(const uint16_t size) = 0;
 104
 105     /*
 106     *   set transtport overhead
 107     *   default is IPv4 and UDP with no encryption
 108     *
 109     *   TCP                     - true for TCP false UDP
 110     *   IPv6                    - true for IP version 6 false for version 4
 111     *   authenticationOverhead  - number of bytes to leave for an
 112     *                             authentication header
 113     *
 114     *   return -1 on failure else 0
 115     */
 116     virtual int32_t SetTransportOverhead(
 117         const bool TCP,
 118         const bool IPV6,
 119         const uint8_t authenticationOverhead = 0) = 0;
 120
 121     /*
 122     *   Get max payload length
 123     *
 124     *   A combination of the configuration MaxTransferUnit and
 125     *   TransportOverhead.
 126     *   Does not account FEC/ULP/RED overhead if FEC is enabled.
 127     *   Does not account for RTP headers
 128     */
 129     virtual uint16_t MaxPayloadLength() const = 0;
 130
 131     /*
 132     *   Get max data payload length
 133     *
 134     *   A combination of the configuration MaxTransferUnit, headers and
 135     *   TransportOverhead.
 136     *   Takes into account FEC/ULP/RED overhead if FEC is enabled.
 137     *   Takes into account RTP headers
 138     */
 139     virtual uint16_t MaxDataPayloadLength() const = 0;
 140
 141     /*
 142     *   set codec name and payload type
 143     *
 144     *   return -1 on failure else 0
 145     */
 146     virtual int32_t RegisterSendPayload(
 147         const CodecInst& voiceCodec) = 0;
 148
 149     /*
 150     *   set codec name and payload type
 151     *
 152     *   return -1 on failure else 0
 153     */
 154     virtual int32_t RegisterSendPayload(
 155         const VideoCodec& videoCodec) = 0;
 156
 157     /*
 158     *   Unregister a send payload
 159     *
 160     *   payloadType - payload type of codec
 161     *
 162     *   return -1 on failure else 0
 163     */
 164     virtual int32_t DeRegisterSendPayload(
 165         const int8_t payloadType) = 0;
 166
 167    /*
 168     *   (De)register RTP header extension type and id.
 169     *
 170     *   return -1 on failure else 0
 171     */
 172     virtual int32_t RegisterSendRtpHeaderExtension(
 173         const RTPExtensionType type,
 174         const uint8_t id) = 0;
 175
 176     virtual int32_t DeregisterSendRtpHeaderExtension(
 177         const RTPExtensionType type) = 0;
 178
 179     /*
 180     *   get start timestamp
 181     */
 182     virtual uint32_t StartTimestamp() const = 0;
 183
 184     /*
 185     *   configure start timestamp, default is a random number
 186     *
 187     *   timestamp   - start timestamp
 188     *
 189     *   return -1 on failure else 0
 190     */
 191     virtual int32_t SetStartTimestamp(
 192         const uint32_t timestamp) = 0;
 193
 194     /*
 195     *   Get SequenceNumber
 196     */
 197     virtual uint16_t SequenceNumber() const = 0;
 198
 199     /*
 200     *   Set SequenceNumber, default is a random number
 201     *
 202     *   return -1 on failure else 0
 203     */
 204     virtual int32_t SetSequenceNumber(const uint16_t seq) = 0;
 205
 206     /*
 207     *   Get SSRC
 208     */
 209     virtual uint32_t SSRC() const = 0;
 210
 211     /*
 212     *   configure SSRC, default is a random number
 213     *
 214     *   return -1 on failure else 0
 215     */
 216     virtual int32_t SetSSRC(const uint32_t ssrc) = 0;
 217
 218     /*
 219     *   Get CSRC
 220     *
 221     *   arrOfCSRC   - array of CSRCs
 222     *
 223     *   return -1 on failure else number of valid entries in the array
 224     */
 225     virtual int32_t CSRCs(
 226         uint32_t arrOfCSRC[kRtpCsrcSize]) const = 0;
 227
 228     /*
 229     *   Set CSRC
 230     *
 231     *   arrOfCSRC   - array of CSRCs
 232     *   arrLength   - number of valid entries in the array
 233     *
 234     *   return -1 on failure else 0
 235     */
 236     virtual int32_t SetCSRCs(
 237         const uint32_t arrOfCSRC[kRtpCsrcSize],
 238         const uint8_t arrLength) = 0;
 239
 240     /*
 241     *   includes CSRCs in RTP header if enabled
 242     *
 243     *   include CSRC - on/off
 244     *
 245     *    default:on
 246     *
 247     *   return -1 on failure else 0
 248     */
 249     virtual int32_t SetCSRCStatus(const bool include) = 0;
 250
 251     /*
 252     * Turn on/off sending RTX (RFC 4588) on a specific SSRC.
 253     */
 254     virtual int32_t SetRTXSendStatus(int modes, bool set_ssrc,
 255                                      uint32_t ssrc) = 0;
 256
 257     // Sets the payload type to use when sending RTX packets. Note that this
 258     // doesn't enable RTX, only the payload type is set.
 259     virtual void SetRtxSendPayloadType(int payload_type) = 0;
 260
 261     /*
 262     * Get status of sending RTX (RFC 4588) on a specific SSRC.
 263     */
 264     virtual int32_t RTXSendStatus(int* modes, uint32_t* ssrc,
 265                                   int* payloadType) const = 0;
 266
 267     /*
 268     *   sends kRtcpByeCode when going from true to false
 269     *
 270     *   sending - on/off
 271     *
 272     *   return -1 on failure else 0
 273     */
 274     virtual int32_t SetSendingStatus(const bool sending) = 0;
 275
 276     /*
 277     *   get send status
 278     */
 279     virtual bool Sending() const = 0;
 280
 281     /*
 282     *   Starts/Stops media packets, on by default
 283     *
 284     *   sending - on/off
 285     *
 286     *   return -1 on failure else 0
 287     */
 288     virtual int32_t SetSendingMediaStatus(const bool sending) = 0;
 289
 290     /*
 291     *   get send status
 292     */
 293     virtual bool SendingMedia() const = 0;
 294
 295     /*
 296     *   get sent bitrate in Kbit/s
 297     */
 298     virtual void BitrateSent(uint32_t* totalRate,
 299                              uint32_t* videoRate,
 300                              uint32_t* fecRate,
 301                              uint32_t* nackRate) const = 0;
 302
 303     /*
 304     *   Called on any new send bitrate estimate.
 305     */
 306     virtual void RegisterVideoBitrateObserver(
 307         BitrateStatisticsObserver* observer) = 0;
 308     virtual BitrateStatisticsObserver* GetVideoBitrateObserver() const = 0;
 309
 310     /*
 311     *   Used by the codec module to deliver a video or audio frame for
 312     *   packetization.
 313     *
 314     *   frameType       - type of frame to send
 315     *   payloadType     - payload type of frame to send
 316     *   timestamp       - timestamp of frame to send
 317     *   payloadData     - payload buffer of frame to send
 318     *   payloadSize     - size of payload buffer to send
 319     *   fragmentation   - fragmentation offset data for fragmented frames such
 320     *                     as layers or RED
 321     *
 322     *   return -1 on failure else 0
 323     */
 324     virtual int32_t SendOutgoingData(
 325         const FrameType frameType,
 326         const int8_t payloadType,
 327         const uint32_t timeStamp,
 328         int64_t capture_time_ms,
 329         const uint8_t* payloadData,
 330         const uint32_t payloadSize,
 331         const RTPFragmentationHeader* fragmentation = NULL,
 332         const RTPVideoHeader* rtpVideoHdr = NULL) = 0;
 333
 334     virtual bool TimeToSendPacket(uint32_t ssrc,
 335                                   uint16_t sequence_number,
 336                                   int64_t capture_time_ms,
 337                                   bool retransmission) = 0;
 338
 339     virtual int TimeToSendPadding(int bytes) = 0;
 340
 341     virtual void RegisterSendFrameCountObserver(
 342         FrameCountObserver* observer) = 0;
 343     virtual FrameCountObserver* GetSendFrameCountObserver() const = 0;
 344
 345     virtual bool GetSendSideDelay(int* avg_send_delay_ms,
 346                                   int* max_send_delay_ms) const = 0;
 347
 348     // Called on generation of new statistics after an RTP send.
 349     virtual void RegisterSendChannelRtpStatisticsCallback(
 350         StreamDataCountersCallback* callback) = 0;
 351     virtual StreamDataCountersCallback*
 352         GetSendChannelRtpStatisticsCallback() const = 0;
 353
 354     /**************************************************************************
 355     *
 356     *   RTCP
 357     *
 358     ***************************************************************************/
 359
 360     /*
 361     *    Get RTCP status
 362     */
 363     virtual RTCPMethod RTCP() const = 0;
 364
 365     /*
 366     *   configure RTCP status i.e on(compound or non- compound)/off
 367     *
 368     *   method  - RTCP method to use
 369     *
 370     *   return -1 on failure else 0
 371     */
 372     virtual int32_t SetRTCPStatus(const RTCPMethod method) = 0;
 373
 374     /*
 375     *   Set RTCP CName (i.e unique identifier)
 376     *
 377     *   return -1 on failure else 0
 378     */
 379     virtual int32_t SetCNAME(const char cName[RTCP_CNAME_SIZE]) = 0;
 380
 381     /*
 382     *   Get RTCP CName (i.e unique identifier)
 383     *
 384     *   return -1 on failure else 0
 385     */
 386     virtual int32_t CNAME(char cName[RTCP_CNAME_SIZE]) = 0;
 387
 388     /*
 389     *   Get remote CName
 390     *
 391     *   return -1 on failure else 0
 392     */
 393     virtual int32_t RemoteCNAME(
 394         const uint32_t remoteSSRC,
 395         char cName[RTCP_CNAME_SIZE]) const = 0;
 396
 397     /*
 398     *   Get remote NTP
 399     *
 400     *   return -1 on failure else 0
 401     */
 402     virtual int32_t RemoteNTP(
 403         uint32_t *ReceivedNTPsecs,
 404         uint32_t *ReceivedNTPfrac,
 405         uint32_t *RTCPArrivalTimeSecs,
 406         uint32_t *RTCPArrivalTimeFrac,
 407         uint32_t *rtcp_timestamp) const  = 0;
 408
 409     /*
 410     *   AddMixedCNAME
 411     *
 412     *   return -1 on failure else 0
 413     */
 414     virtual int32_t AddMixedCNAME(
 415         const uint32_t SSRC,
 416         const char cName[RTCP_CNAME_SIZE]) = 0;
 417
 418     /*
 419     *   RemoveMixedCNAME
 420     *
 421     *   return -1 on failure else 0
 422     */
 423     virtual int32_t RemoveMixedCNAME(const uint32_t SSRC) = 0;
 424
 425     /*
 426     *   Get RoundTripTime
 427     *
 428     *   return -1 on failure else 0
 429     */
 430     virtual int32_t RTT(const uint32_t remoteSSRC,
 431                         uint16_t* RTT,
 432                         uint16_t* avgRTT,
 433                         uint16_t* minRTT,
 434                         uint16_t* maxRTT) const = 0 ;
 435
 436     /*
 437     *   Reset RoundTripTime statistics
 438     *
 439     *   return -1 on failure else 0
 440     */
 441     virtual int32_t ResetRTT(const uint32_t remoteSSRC)= 0 ;
 442
 443     /*
 444     *   Force a send of a RTCP packet
 445     *   normal SR and RR are triggered via the process function
 446     *
 447     *   return -1 on failure else 0
 448     */
 449     virtual int32_t SendRTCP(
 450         uint32_t rtcpPacketType = kRtcpReport) = 0;
 451
 452     /*
 453     *    Good state of RTP receiver inform sender
 454     */
 455     virtual int32_t SendRTCPReferencePictureSelection(
 456         const uint64_t pictureID) = 0;
 457
 458     /*
 459     *    Send a RTCP Slice Loss Indication (SLI)
 460     *    6 least significant bits of pictureID
 461     */
 462     virtual int32_t SendRTCPSliceLossIndication(
 463         const uint8_t pictureID) = 0;
 464
 465     /*
 466     *   Reset RTP data counters for the sending side
 467     *
 468     *   return -1 on failure else 0
 469     */
 470     virtual int32_t ResetSendDataCountersRTP() = 0;
 471
 472     /*
 473     *   statistics of the amount of data sent and received
 474     *
 475     *   return -1 on failure else 0
 476     */
 477     virtual int32_t DataCountersRTP(
 478         uint32_t* bytesSent,
 479         uint32_t* packetsSent) const = 0;
 480     /*
 481     *   Get received RTCP sender info
 482     *
 483     *   return -1 on failure else 0
 484     */
 485     virtual int32_t RemoteRTCPStat(RTCPSenderInfo* senderInfo) = 0;
 486
 487     /*
 488     *   Get received RTCP report block
 489     *
 490     *   return -1 on failure else 0
 491     */
 492     virtual int32_t RemoteRTCPStat(
 493         std::vector<RTCPReportBlock>* receiveBlocks) const = 0;
 494     /*
 495     *   Set received RTCP report block
 496     *
 497     *   return -1 on failure else 0
 498     */
 499     virtual int32_t AddRTCPReportBlock(
 500         const uint32_t SSRC,
 501         const RTCPReportBlock* receiveBlock) = 0;
 502
 503     /*
 504     *   RemoveRTCPReportBlock
 505     *
 506     *   return -1 on failure else 0
 507     */
 508     virtual int32_t RemoveRTCPReportBlock(const uint32_t SSRC) = 0;
 509
 510     /*
 511     *   (APP) Application specific data
 512     *
 513     *   return -1 on failure else 0
 514     */
 515     virtual int32_t SetRTCPApplicationSpecificData(
 516         const uint8_t subType,
 517         const uint32_t name,
 518         const uint8_t* data,
 519         const uint16_t length) = 0;
 520     /*
 521     *   (XR) VOIP metric
 522     *
 523     *   return -1 on failure else 0
 524     */
 525     virtual int32_t SetRTCPVoIPMetrics(
 526         const RTCPVoIPMetric* VoIPMetric) = 0;
 527
 528     /*
 529     *   (XR) Receiver Reference Time Report
 530     */
 531     virtual void SetRtcpXrRrtrStatus(bool enable) = 0;
 532
 533     virtual bool RtcpXrRrtrStatus() const = 0;
 534
 535     /*
 536     *  (REMB) Receiver Estimated Max Bitrate
 537     */
 538     virtual bool REMB() const = 0;
 539
 540     virtual int32_t SetREMBStatus(const bool enable) = 0;
 541
 542     virtual int32_t SetREMBData(const uint32_t bitrate,
 543                                 const uint8_t numberOfSSRC,
 544                                 const uint32_t* SSRC) = 0;
 545
 546     /*
 547     *   (IJ) Extended jitter report.
 548     */
 549     virtual bool IJ() const = 0;
 550
 551     virtual int32_t SetIJStatus(const bool enable) = 0;
 552
 553     /*
 554     *   (TMMBR) Temporary Max Media Bit Rate
 555     */
 556     virtual bool TMMBR() const = 0;
 557
 558     /*
 559     *
 560     *   return -1 on failure else 0
 561     */
 562     virtual int32_t SetTMMBRStatus(const bool enable) = 0;
 563
 564     /*
 565     *   (NACK)
 566     */
 567
 568     /*
 569      *  TODO(holmer): Propagate this API to VideoEngine.
 570      *  Returns the currently configured selective retransmission settings.
 571      */
 572     virtual int SelectiveRetransmissions() const = 0;
 573
 574     /*
 575      *  TODO(holmer): Propagate this API to VideoEngine.
 576      *  Sets the selective retransmission settings, which will decide which
 577      *  packets will be retransmitted if NACKed. Settings are constructed by
 578      *  combining the constants in enum RetransmissionMode with bitwise OR.
 579      *  All packets are retransmitted if kRetransmitAllPackets is set, while no
 580      *  packets are retransmitted if kRetransmitOff is set.
 581      *  By default all packets except FEC packets are retransmitted. For VP8
 582      *  with temporal scalability only base layer packets are retransmitted.
 583      *
 584      *  Returns -1 on failure, otherwise 0.
 585      */
 586     virtual int SetSelectiveRetransmissions(uint8_t settings) = 0;
 587
 588     /*
 589     *   Send a Negative acknowledgement packet
 590     *
 591     *   return -1 on failure else 0
 592     */
 593     virtual int32_t SendNACK(const uint16_t* nackList,
 594                              const uint16_t size) = 0;
 595
 596     /*
 597     *   Store the sent packets, needed to answer to a Negative acknowledgement
 598     *   requests
 599     *
 600     *   return -1 on failure else 0
 601     */
 602     virtual int32_t SetStorePacketsStatus(
 603         const bool enable,
 604         const uint16_t numberToStore) = 0;
 605
 606     // Returns true if the module is configured to store packets.
 607     virtual bool StorePackets() const = 0;
 608
 609     // Called on receipt of RTCP report block from remote side.
 610     virtual void RegisterSendChannelRtcpStatisticsCallback(
 611         RtcpStatisticsCallback* callback) = 0;
 612     virtual RtcpStatisticsCallback*
 613         GetSendChannelRtcpStatisticsCallback() = 0;
 614
 615     /**************************************************************************
 616     *
 617     *   Audio
 618     *
 619     ***************************************************************************/
 620
 621     /*
 622     *   set audio packet size, used to determine when it's time to send a DTMF
 623     *   packet in silence (CNG)
 624     *
 625     *   return -1 on failure else 0
 626     */
 627     virtual int32_t SetAudioPacketSize(
 628         const uint16_t packetSizeSamples) = 0;
 629
 630     /*
 631     *   SendTelephoneEventActive
 632     *
 633     *   return true if we currently send a telephone event and 100 ms after an
 634     *   event is sent used to prevent the telephone event tone to be recorded
 635     *   by the microphone and send inband just after the tone has ended.
 636     */
 637     virtual bool SendTelephoneEventActive(
 638         int8_t& telephoneEvent) const = 0;
 639
 640     /*
 641     *   Send a TelephoneEvent tone using RFC 2833 (4733)
 642     *
 643     *   return -1 on failure else 0
 644     */
 645     virtual int32_t SendTelephoneEventOutband(
 646         const uint8_t key,
 647         const uint16_t time_ms,
 648         const uint8_t level) = 0;
 649
 650     /*
 651     *   Set payload type for Redundant Audio Data RFC 2198
 652     *
 653     *   return -1 on failure else 0
 654     */
 655     virtual int32_t SetSendREDPayloadType(
 656         const int8_t payloadType) = 0;
 657
 658     /*
 659     *   Get payload type for Redundant Audio Data RFC 2198
 660     *
 661     *   return -1 on failure else 0
 662     */
 663      virtual int32_t SendREDPayloadType(
 664          int8_t& payloadType) const = 0;
 665
 666      /*
 667      * Set status and ID for header-extension-for-audio-level-indication.
 668      * See http://tools.ietf.org/html/rfc6464 for more details.
 669      *
 670      * return -1 on failure else 0
 671      */
 672      virtual int32_t SetRTPAudioLevelIndicationStatus(
 673          const bool enable,
 674          const uint8_t ID) = 0;
 675
 676      /*
 677      * Get status and ID for header-extension-for-audio-level-indication.
 678      *
 679      * return -1 on failure else 0
 680      */
 681      virtual int32_t GetRTPAudioLevelIndicationStatus(
 682          bool& enable,
 683          uint8_t& ID) const = 0;
 684
 685      /*
 686      * Store the audio level in dBov for header-extension-for-audio-level-
 687      * indication.
 688      * This API shall be called before transmision of an RTP packet to ensure
 689      * that the |level| part of the extended RTP header is updated.
 690      *
 691      * return -1 on failure else 0.
 692      */
 693      virtual int32_t SetAudioLevel(const uint8_t level_dBov) = 0;
 694
 695     /**************************************************************************
 696     *
 697     *   Video
 698     *
 699     ***************************************************************************/
 700
 701     /*
 702     *   Set the estimated camera delay in MS
 703     *
 704     *   return -1 on failure else 0
 705     */
 706     virtual int32_t SetCameraDelay(const int32_t delayMS) = 0;
 707
 708     /*
 709     *   Set the target send bitrate
 710     */
 711     virtual void SetTargetSendBitrate(
 712         const std::vector<uint32_t>& stream_bitrates) = 0;
 713
 714     /*
 715     *   Turn on/off generic FEC
 716     *
 717     *   return -1 on failure else 0
 718     */
 719     virtual int32_t SetGenericFECStatus(
 720         const bool enable,
 721         const uint8_t payloadTypeRED,
 722         const uint8_t payloadTypeFEC) = 0;
 723
 724     /*
 725     *   Get generic FEC setting
 726     *
 727     *   return -1 on failure else 0
 728     */
 729     virtual int32_t GenericFECStatus(bool& enable,
 730                                      uint8_t& payloadTypeRED,
 731                                      uint8_t& payloadTypeFEC) = 0;
 732
 733
 734     virtual int32_t SetFecParameters(
 735         const FecProtectionParams* delta_params,
 736         const FecProtectionParams* key_params) = 0;
 737
 738     /*
 739     *   Set method for requestion a new key frame
 740     *
 741     *   return -1 on failure else 0
 742     */
 743     virtual int32_t SetKeyFrameRequestMethod(
 744         const KeyFrameRequestMethod method) = 0;
 745
 746     /*
 747     *   send a request for a keyframe
 748     *
 749     *   return -1 on failure else 0
 750     */
 751     virtual int32_t RequestKeyFrame() = 0;
 752 };
 753 }  // namespace webrtc
 754 #endif // WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_RTCP_H_