webrtc/modules/rtp_rtcp/source/rtp_receiver.h

/*
 *  Copyright (c) 2011 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_SOURCE_RTP_RECEIVER_H_
#define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_RECEIVER_H_

#include "typedefs.h"
#include "rtp_utility.h"

#include "rtp_rtcp.h"
#include "rtp_receiver_audio.h"
#include "rtp_receiver_video.h"
#include "rtcp_receiver_help.h"
#include "Bitrate.h"

namespace webrtc {
class RtpRtcpFeedback;
class Trace;

class RTPReceiver : public RTPReceiverAudio, public RTPReceiverVideo, public Bitrate
{
public:
    RTPReceiver(const WebRtc_Word32 id,
                const bool audio,
                ModuleRtpRtcpPrivate& callback);

    virtual ~RTPReceiver();

    virtual void ChangeUniqueId(const WebRtc_Word32 id);

    WebRtc_Word32 Init();

    RtpVideoCodecTypes VideoCodecType() const;
    WebRtc_UWord32 MaxConfiguredBitrate() const;

    WebRtc_Word32 SetPacketTimeout(const WebRtc_UWord32 timeoutMS);
    void PacketTimeout();

    void ProcessDeadOrAlive(const bool RTCPalive, const WebRtc_UWord32 now);

    void ProcessBitrate();

    WebRtc_Word32 RegisterIncomingDataCallback(RtpData* incomingDataCallback);
    WebRtc_Word32 RegisterIncomingRTPCallback(RtpFeedback* incomingMessagesCallback);

    WebRtc_Word32 RegisterReceivePayload( const WebRtc_Word8 payloadName[RTP_PAYLOAD_NAME_SIZE],
                                        const WebRtc_Word8 payloadType,
                                        const WebRtc_UWord32 frequency,
                                        const WebRtc_UWord8 channels,
                                        const WebRtc_UWord32 rate);

    WebRtc_Word32 DeRegisterReceivePayload(const WebRtc_Word8 payloadType);

    WebRtc_Word32 ReceivePayloadType(const WebRtc_Word8 payloadName[RTP_PAYLOAD_NAME_SIZE],
                                   const WebRtc_UWord32 frequency,
                                   const WebRtc_UWord8 channels,
                                   WebRtc_Word8* payloadType,
                                   const WebRtc_UWord32 rate) const;

    WebRtc_Word32 ReceivePayload(const WebRtc_Word8 payloadType,
                               WebRtc_Word8 payloadName[RTP_PAYLOAD_NAME_SIZE],
                               WebRtc_UWord32* frequency,
                               WebRtc_UWord8* channels,
                               WebRtc_UWord32* rate) const;

    WebRtc_Word32 RemotePayload(WebRtc_Word8 payloadName[RTP_PAYLOAD_NAME_SIZE],
                              WebRtc_Word8* payloadType,
                              WebRtc_UWord32* frequency,
                              WebRtc_UWord8* channels) const;

    WebRtc_Word32 IncomingRTPPacket(WebRtcRTPHeader* rtpheader,
                                    const WebRtc_UWord8* incomingRtpPacket,
                                    const WebRtc_UWord16 incomingRtpPacketLengt);

    NACKMethod NACK() const ;

    // Turn negative acknowledgement requests on/off
    WebRtc_Word32 SetNACKStatus(const NACKMethod method);


    // last received
    virtual WebRtc_UWord32 TimeStamp() const;
    virtual WebRtc_UWord16 SequenceNumber() const;

    WebRtc_Word32 EstimatedRemoteTimeStamp(WebRtc_UWord32& timestamp) const;

    WebRtc_UWord32 SSRC() const;

    WebRtc_Word32 CSRCs( WebRtc_UWord32 arrOfCSRC[kRtpCsrcSize]) const;

    WebRtc_Word32 Energy( WebRtc_UWord8 arrOfEnergy[kRtpCsrcSize]) const;

    // get the currently configured SSRC filter
    WebRtc_Word32 SSRCFilter(WebRtc_UWord32& allowedSSRC) const;

    // set a SSRC to be used as a filter for incoming RTP streams
    WebRtc_Word32 SetSSRCFilter(const bool enable, const WebRtc_UWord32 allowedSSRC);

    WebRtc_Word32 Statistics(WebRtc_UWord8  *fraction_lost,
                           WebRtc_UWord32 *cum_lost,
                           WebRtc_UWord32 *ext_max,
                           WebRtc_UWord32 *jitter,               // will be moved from JB
                           WebRtc_UWord32 *max_jitter,
                           bool reset = false) const;

    WebRtc_Word32 Statistics(WebRtc_UWord8  *fraction_lost,
                           WebRtc_UWord32 *cum_lost,
                           WebRtc_UWord32 *ext_max,
                           WebRtc_UWord32 *jitter,               // will be moved from JB
                           WebRtc_UWord32 *max_jitter,
                           WebRtc_Word32 *missing,
                           bool reset = false) const;

    WebRtc_Word32 DataCounters(WebRtc_UWord32 *bytesReceived,
                             WebRtc_UWord32 *packetsReceived) const;

    WebRtc_Word32 ResetStatistics();

    WebRtc_Word32 ResetDataCounters();

    WebRtc_UWord16 PacketOHReceived() const;

    WebRtc_UWord32 PacketCountReceived() const;

    WebRtc_UWord32 ByteCountReceived() const;

    virtual WebRtc_UWord32 PayloadTypeToPayload(const WebRtc_UWord8 payloadType,
                                              ModuleRTPUtility::Payload*& payload) const;

protected:
    virtual WebRtc_Word32 CallbackOfReceivedPayloadData(const WebRtc_UWord8* payloadData,
                                                      const WebRtc_UWord16 payloadSize,
                                                      const WebRtcRTPHeader* rtpHeader);

    virtual bool RetransmitOfOldPacket(const WebRtc_UWord16 sequenceNumber,
                                       const WebRtc_UWord32 rtpTimeStamp) const;


    void UpdateStatistics(const WebRtcRTPHeader* rtpHeader,
                          const WebRtc_UWord16 bytes,
                          const bool oldPacket);

    virtual WebRtc_Word8 REDPayloadType() const;

private:
    // Is RED configured with payload type payloadType
    bool REDPayloadType(const WebRtc_Word8 payloadType) const;

    bool InOrderPacket(const WebRtc_UWord16 sequenceNumber) const;

    void CheckSSRCChanged(const WebRtcRTPHeader* rtpHeader);
    void CheckCSRC(const WebRtcRTPHeader* rtpHeader);
    WebRtc_Word32 CheckPayloadChanged(const WebRtcRTPHeader* rtpHeader,
                                    const WebRtc_Word8 firstPayloadByte,
                                    bool& isRED,
                                    ModuleRTPUtility::AudioPayload& audioSpecific,
                                    ModuleRTPUtility::VideoPayload& videoSpecific);

    void UpdateNACKBitRate(WebRtc_Word32 bytes, WebRtc_UWord32 now);
    bool ProcessNACKBitRate(WebRtc_UWord32 now);

private:
    WebRtc_Word32             _id;
    const bool              _audio;

    CriticalSectionWrapper&    _criticalSectionCbs;
    ModuleRtpRtcpPrivate&   _cbPrivateFeedback;
    RtpFeedback*        _cbRtpFeedback;
    RtpData*            _cbRtpData;

    CriticalSectionWrapper&    _criticalSectionRTPReceiver;
    mutable WebRtc_UWord32    _lastReceiveTime;
    WebRtc_UWord16            _lastReceivedPayloadLength;
    WebRtc_Word8              _lastReceivedPayloadType;
    WebRtc_Word8              _lastReceivedMediaPayloadType;

    ModuleRTPUtility::AudioPayload _lastReceivedAudioSpecific;
    ModuleRTPUtility::VideoPayload _lastReceivedVideoSpecific;

    WebRtc_UWord32            _packetTimeOutMS;

    WebRtc_Word8              _redPayloadType;

    //
    MapWrapper                    _payloadTypeMap;

    // SSRCs
    WebRtc_UWord32            _SSRC;
    WebRtc_UWord8             _numCSRCs;
    WebRtc_UWord32            _currentRemoteCSRC[kRtpCsrcSize];
    WebRtc_UWord8             _numEnergy;
    WebRtc_UWord8             _currentRemoteEnergy[kRtpCsrcSize];

    bool                    _useSSRCFilter;
    WebRtc_UWord32            _SSRCFilter;

    // stats on received RTP packets
    WebRtc_UWord32            _jitterQ4;
    mutable WebRtc_UWord32    _jitterMaxQ4;
    mutable WebRtc_UWord32    _cumulativeLoss;

    WebRtc_UWord32            _localTimeLastReceivedTimestamp;
    WebRtc_UWord32            _lastReceivedTimestamp;
    WebRtc_UWord16            _lastReceivedSequenceNumber;
    WebRtc_UWord16            _receivedSeqFirst;
    WebRtc_UWord16            _receivedSeqMax;
    WebRtc_UWord16            _receivedSeqWraps;

    // current counter values
    WebRtc_UWord16            _receivedPacketOH;
    WebRtc_UWord32            _receivedByteCount;
    WebRtc_UWord32            _receivedOldPacketCount;
    WebRtc_UWord32            _receivedInorderPacketCount;

    // counter values when we sent the last report
    mutable WebRtc_UWord32    _lastReportInorderPackets;
    mutable WebRtc_UWord32    _lastReportOldPackets;
    mutable WebRtc_UWord16    _lastReportSeqMax;
    mutable WebRtc_UWord8     _lastReportFractionLost;
    mutable WebRtc_UWord32    _lastReportCumulativeLost;  // 24 bits valid
    mutable WebRtc_UWord32    _lastReportExtendedHighSeqNum;
    mutable WebRtc_UWord32    _lastReportJitter;

    // NACK
    NACKMethod          _nackMethod;
};
} // namespace webrtc

#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_RECEIVER_H_