cqueue.h

Go to the documentation of this file.

// Copyright (C) 2001-2015 Federico Montesino Pouzols <fedemp@altern.org>.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GNU ccRTP.  If not, see <http://www.gnu.org/licenses/>.
//
// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// This exception applies only to the code released under the name GNU
// ccRTP.  If you copy code from other releases into a copy of GNU
// ccRTP, as the General Public License permits, the exception does
// not apply to the code that you add in this way.  To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
//
// If you write modifications of your own for GNU ccRTP, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.
//

 
#ifndef CCXX_RTP_CQUEUE_H_
#define CCXX_RTP_CQUEUE_H_
 
#include <ccrtp/ioqueue.h>
#include <ccrtp/CryptoContextCtrl.h>
#include <list>
 
NAMESPACE_COMMONCPP


class __EXPORT QueueRTCPManager : public RTPDataQueue,
    protected RTCPCompoundHandler
{
public:
    RTCPSenderInfo* getMRSenderInfo(SyncSource& src);

    RTCPReceiverInfo* getMRReceiverInfo(SyncSource& srcFrom);

    void setLeavingDelay(microtimeout_t delay)
    { leavingDelay = delay; }

    inline void
    setEnd2EndDelay(microtimeout_t t)
        { end2EndDelay = t; }
 
    inline microtimeout_t
    getDefaultEnd2EndDelay() const
    { return defaultEnd2EndDelay; }
 
    inline microtimeout_t
    getEnd2EndDelay() const
    { return end2EndDelay; }

    inline void
    setSendersControlFraction(float fraction)
    { sendControlBwFract = fraction; recvControlBwFract = 1 - fraction;}

    void
    setMinRTCPInterval(microtimeout_t interval)
    { rtcpMinInterval = interval; }

    inline uint32
    getSendRTCPPacketCount() const
    { return ctrlSendCount; }

    void
    setOutQueueCryptoContextCtrl(CryptoContextCtrl* cc);

    void
    removeOutQueueCryptoContextCtrl(CryptoContextCtrl* cc);

    CryptoContextCtrl*
    getOutQueueCryptoContextCtrl(uint32 ssrc);
 

    void
    setInQueueCryptoContextCtrl(CryptoContextCtrl* cc);

    void
    removeInQueueCryptoContextCtrl(CryptoContextCtrl* cc);

    CryptoContextCtrl*
    getInQueueCryptoContextCtrl(uint32 ssrc);
 
protected:
    QueueRTCPManager(uint32 size = RTPDataQueue::defaultMembersHashSize,
             RTPApplication& app = defaultApplication());
 
    QueueRTCPManager(uint32 ssrc,
             uint32 size = RTPDataQueue::defaultMembersHashSize,
             RTPApplication& app = defaultApplication());
 
    virtual
    ~QueueRTCPManager();
 
    const RTPApplication&
    getApplication()
    { return queueApplication; }
 
    inline void
    setControlBandwidth(float fraction)
    { controlBwFract = fraction; }
 
    float
    getControlBandwidth() const
    { return controlBwFract; }

    void
    controlTransmissionService();

    void
    controlReceptionService();

    bool checkSSRCInRTCPPkt(SyncSourceLink& sourceLink, bool is_new,
                InetAddress& na, tpport_t tp);
 
    void
    endQueueRTCPManager();

    virtual void
    onGotSR(SyncSource& source, SendReport& SR, uint8 blocks);

    virtual void
    onGotRR(SyncSource& source, RecvReport& RR, uint8 blocks);

    bool
    onGotSDES(SyncSource& source, RTCPPacket& pkt);

    virtual bool
    onGotSDESChunk(SyncSource& source, SDESChunk& chunk, size_t len);

    inline virtual void
    onGotAPP(SyncSource&, RTCPCompoundHandler::APPPacket&,
         size_t)
    { return; }
 
    inline timeval
    getRTCPCheckInterval()
    { return rtcpCheckInterval; }

    uint32
    getLastSendPacketCount() const
    { return lastSendPacketCount; }

    inline void
    setPrevMembersNum(uint32 n)
    { reconsInfo.rtcpPMembers = n; }
 
    inline uint32
    getPrevMembersCount() const
    { return reconsInfo.rtcpPMembers; }

    size_t
    dispatchBYE(const std::string& reason);
 
    size_t
    sendControlToDestinations(unsigned char* buffer, size_t len);
 
private:
    QueueRTCPManager(const QueueRTCPManager &o);
 
    QueueRTCPManager&
    operator=(const QueueRTCPManager &o);

    size_t
    dispatchControlPacket();

    void
    takeInControlPacket();

    virtual timeval
    computeRTCPInterval();

    virtual SDESItemType
    scheduleSDESItem();

    inline virtual void
    onSSRCCollision(const SyncSource&)
    { }

    virtual bool
    end2EndDelayed(IncomingRTPPktLink& p);

    inline virtual void
    onGotRRSRExtension(unsigned char*, size_t)
    { return; }

    inline virtual void
    onGotGoodbye(const SyncSource&, const std::string&)
    { return; }

    bool
    getBYE(RTCPPacket &pkt, size_t &pointer, size_t len);

    uint8
    packReportBlocks(RRBlock* blocks, uint16& len, uint16& available);

    void
    packSDES(uint16& len);

    void
    updateAvgRTCPSize(size_t len);

    void
    reverseReconsideration();
 
    bool
    timerReconsideration();

    void
    expireSSRCs();

    void
    getOnlyBye();

    void
    setSDESItem(Participant* part, SDESItemType type,
            const char* const value, size_t len);

    void
    setPRIVPrefix(Participant* part, const char* const value, size_t len);

    inline virtual uint16
    networkHeaderSize()
    { return 20; }

    inline virtual uint16
    transportHeaderSize()
    { return 8; }
 
 
    int32 protect(uint8* pkt, size_t len, CryptoContextCtrl* cc);
    int32 unprotect(uint8* pkt, size_t len, CryptoContextCtrl* cc);
    
    
    SDESItemType
    nextSDESType(SDESItemType t);
 
    virtual size_t
    sendControl(const unsigned char* const buffer, size_t len) = 0;
 
    virtual size_t
    recvControl(unsigned char* buffer, size_t len,
            InetHostAddress& na, tpport_t& tp) = 0;
 
    virtual bool
    isPendingControl(microtimeout_t timeout) = 0;
 
    // whether the RTCP service is active
    volatile bool controlServiceActive;
    float controlBwFract, sendControlBwFract, recvControlBwFract;
    // number of RTCP packets sent since the beginning
    uint32 ctrlSendCount;
 
    // Network + transport headers size, typically size of IP +
    // UDP headers
    uint16 lowerHeadersSize;
 
    SDESItemType nextScheduledSDESItem;
    static const SDESItemType firstSchedulable;
    static const SDESItemType lastSchedulable;
 
    // state for rtcp timing. Its meaning is defined in
    // draft-ietf-avt-rtp-new, 6.3.
 
    // Parameters for timer reconsideration algorithm
    struct {
        timeval rtcpTp, rtcpTc, rtcpTn;
        uint32 rtcpPMembers;
    } reconsInfo;
    bool rtcpWeSent;
    uint16 rtcpAvgSize;
    bool rtcpInitial;
    // last time we checked if there were incoming RTCP packets
    timeval rtcpLastCheck;
    // interval to check if there are incoming RTCP packets
    timeval rtcpCheckInterval;
    // next time to check if there are incoming RTCP packets
    timeval rtcpNextCheck;
 
    // number of RTP data packets sent at the time of the last
    // RTCP packet transmission.
    uint32 lastSendPacketCount;
 
    // minimum interval for transmission of RTCP packets. The
    // result of computeRTCPInterval will always be >= (times a
    // random number between 0.5 and 1.5).
    microtimeout_t rtcpMinInterval;
 
    microtimeout_t leavingDelay;
    static const microtimeout_t defaultEnd2EndDelay;
    // Maximum delay allowed between packet timestamping and
    // packet availability for the application.
    microtimeout_t end2EndDelay;
    // Application this queue is bound to.
    RTPApplication& queueApplication;
 
    // an empty RTPData
    static const uint16 TIMEOUT_MULTIPLIER;
    static const double RECONSIDERATION_COMPENSATION;
    
    mutable Mutex outCryptoMutex;
    std::list<CryptoContextCtrl *> outCryptoContexts;
    uint32 srtcpIndex;
 
    mutable Mutex inCryptoMutex;
    std::list<CryptoContextCtrl *> inCryptoContexts;
 
};

class __EXPORT AVPQueue : public QueueRTCPManager
{
public:
    inline void
    setControlBandwidth(float fraction)
    { QueueRTCPManager::setControlBandwidth(fraction); }
 
    float
    getControlBandwidth() const
    { return QueueRTCPManager::getControlBandwidth(); }
 
protected:
    AVPQueue(uint32 size = RTPDataQueue::defaultMembersHashSize,
         RTPApplication& app = defaultApplication()) :
        QueueRTCPManager(size,app)
    { }

    AVPQueue(uint32 ssrc, uint32 size =
         RTPDataQueue::defaultMembersHashSize,
         RTPApplication& app = defaultApplication()) :
        QueueRTCPManager(ssrc,size,app)
    { }
    inline virtual ~AVPQueue()
    { }
};
 // cqueue
 
END_NAMESPACE
 
#endif  //CCXX_RTP_CQUEUE_H_