sources.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_SOURCES_H_
#define CCXX_RTP_SOURCES_H_

#include <string>
#include <ccrtp/rtcppkt.h>

NAMESPACE_COMMONCPP

class __EXPORT SDESItemsHolder
{
public:
    const std::string&
    getItem(SDESItemType type) const;

    inline const std::string&
    getPRIVPrefix() const
    { return sdesItems[SDESItemTypeEND]; }

    void
    setItem(SDESItemType item, const std::string& val);

    inline void
    setPRIVPrefix(const std::string& val)
    { sdesItems[SDESItemTypeEND] = val; }

protected:
    SDESItemsHolder()
    { }

    inline virtual ~SDESItemsHolder()
    { }

private:
    // SDES items for a participant.
    // sdesItems[0] (== sdesItems[SDESItemTypeEND]) holds the prefix
    // value for the PRIV item. The rest of entries hold the
    // correponding SDES item value.
    std::string sdesItems[SDESItemTypeLast + 1];
};

class __EXPORT Participant : private SDESItemsHolder
{
public:
    const std::string&
    getSDESItem(SDESItemType type) const
    { return SDESItemsHolder::getItem(type); }

    inline const std::string&
    getPRIVPrefix() const
    { return SDESItemsHolder::getPRIVPrefix(); }

    Participant(const std::string& cname);

    ~Participant();

private:
    friend class ParticipantHandler;

    inline void
    setSDESItem(SDESItemType item, const std::string& val)
    { SDESItemsHolder::setItem(item,val); }

    inline void
    setPRIVPrefix(const std::string val)
    { SDESItemsHolder::setPRIVPrefix(val); }
};

class __EXPORT SyncSource
{
public:
    typedef enum {
        stateUnknown,     
        statePrevalid,    


        stateActive,      

        stateInactive,    


        stateLeaving      

    }       State;

    SyncSource(uint32 ssrc);

    ~SyncSource();

    State
    getState() const
    { return state; }

    bool isSender() const
    { return activeSender; }

    uint32 getID() const
    { return SSRC; }

    inline Participant*
    getParticipant() const
    { return participant; }

    tpport_t getDataTransportPort() const
    { return dataTransportPort; }

    tpport_t getControlTransportPort() const
    { return controlTransportPort; }

    const InetAddress& getNetworkAddress() const
    { return networkAddress; }

protected:
    SyncSource(const SyncSource& source);

    SyncSource&
    operator=(const SyncSource& source);

private:
    friend class SyncSourceHandler;

    inline void
    setState(State st)
    { state = st; }

    inline void
    setSender(bool active)
    { activeSender = active; }

    inline void
    setParticipant(Participant& p)
    { participant = &p; }

    void setDataTransportPort(tpport_t p)
    { dataTransportPort = p; }

    void setControlTransportPort(tpport_t p)
    { controlTransportPort = p; }

    void setNetworkAddress(InetAddress addr)
    { networkAddress = addr; }

    inline void
    setLink(void *l)
    { link = l; }

    void *getLink() const
    { return link; }

    // validity state of this source
    State state;
    // 32-bit SSRC identifier.
    uint32 SSRC;
    // A valid source not always is active
        bool activeSender;
    // The corresponding participant.
    Participant* participant;

    // Network protocol address for data and control connection
    // (both are assumed to be the same).
    InetAddress networkAddress;
    tpport_t dataTransportPort;
    tpport_t controlTransportPort;

    // Pointer to the SyncSourceLink or similar object in the
    // service queue. Saves a lot of searches in the membership
    // table.
    void* link;
};

class __EXPORT RTPApplication : private SDESItemsHolder
{
private:
    struct ParticipantLink;

public:
    RTPApplication(const std::string& cname);

    ~RTPApplication();

    inline void
    setSDESItem(SDESItemType item, const std::string& val)
    { SDESItemsHolder::setItem(item,val); }

    inline void
    setPRIVPrefix(const std::string& val)
    { SDESItemsHolder::setPRIVPrefix(val); }

    const std::string&
    getSDESItem(SDESItemType item) const
    { return SDESItemsHolder::getItem(item); }

    inline const std::string&
    getPRIVPrefix() const
    { return SDESItemsHolder::getPRIVPrefix(); }

    class ParticipantsIterator
    {
    public:
        typedef std::forward_iterator_tag iterator_category;
        typedef Participant value_type;
        typedef std::ptrdiff_t difference_type;
        typedef const Participant* pointer;
        typedef const Participant& reference;

        ParticipantsIterator(ParticipantLink* p = NULL) :
            link(p)
        { }

        ParticipantsIterator(const ParticipantsIterator& pi) :
            link(pi.link)
        { }

        reference operator*() const
        { return *(link->getParticipant()); }

        pointer operator->() const
        { return link->getParticipant(); }

        ParticipantsIterator& operator++() {
            link = link->getNext();
            return *this;
        }

        ParticipantsIterator operator++(int) {
            ParticipantsIterator result(*this);
            ++(*this);
            return result;
        }
        friend bool operator==(const ParticipantsIterator& l,
                       const ParticipantsIterator& r)
        { return l.link == r.link; }

        friend bool operator!=(const ParticipantsIterator& l,
                       const ParticipantsIterator& r)
        { return l.link != r.link; }
    private:
        ParticipantLink *link;
    };

    ParticipantsIterator begin()
    { return ParticipantsIterator(firstPart); }

    ParticipantsIterator end()
    { return ParticipantsIterator(NULL); }

    const Participant*
    getParticipant(const std::string& cname) const;

private:
    friend class ApplicationHandler;

    struct ParticipantLink {
        ParticipantLink(Participant& p,
                ParticipantLink* l) :
            participant(&p), next(l)
        { }
        inline ~ParticipantLink() { delete participant; }
        inline Participant* getParticipant() { return participant; }
        inline ParticipantLink* getPrev() { return prev; }
        inline ParticipantLink* getNext() { return next; }
        inline void setPrev(ParticipantLink* l) { prev = l; }
        inline void setNext(ParticipantLink* l) { next = l; }
        Participant* participant;
        ParticipantLink* next, *prev;
    };

    void
    addParticipant(Participant& part);

    void
    removeParticipant(ParticipantLink* part);

    void
    findCNAME();

    static const size_t defaultParticipantsNum;
    Participant** participants;
    ParticipantLink* firstPart, * lastPart;
};

__EXPORT RTPApplication& defaultApplication();
 // sources

END_NAMESPACE

#endif //CCXX_RTP_SOURCES_H_

---