yatesdp.h

 
#ifndef __YATESDP_H
#define __YATESDP_H
 
#ifndef __cplusplus
#error C++ is required
#endif
 
#include <yatemime.h>
#include <yatephone.h>
 
#ifdef _WINDOWS
 
#ifdef LIBYSDP_EXPORTS
#define YSDP_API __declspec(dllexport)
#else
#ifndef LIBYSDP_STATIC
#define YSDP_API __declspec(dllimport)
#endif
#endif
 
#endif /* _WINDOWS */
 
#ifndef YSDP_API
#define YSDP_API
#endif

namespace TelEngine {
 
class SDPMedia;
class SDPSession;
class SDPParser;

class YSDP_API SDPMedia : public NamedList
{
public:
    SDPMedia(const char* media, const char* transport, const char* formats,
        int rport = -1, int lport = -1);

    virtual ~SDPMedia();

    inline bool isAudio() const
        { return m_audio; }

    inline bool isVideo() const
        { return m_video; }

    inline bool isModified() const
        { return m_modified; }

    inline void setModified(bool modified = true)
        { m_modified = modified; }

    inline const String& suffix() const
        { return m_suffix; }

    inline bool isStarted() const
        { return m_id && m_transport && m_format && m_lPort; }

    inline const String& transport() const
        { return m_transport; }

    inline const String& id() const
        { return m_id; }

    inline const String& format() const
        { return m_format; }

    inline const String& formats() const
        { return m_formats; }

    inline const String& remotePort() const
        { return m_rPort; }

    inline const String& localPort() const
        { return m_lPort; }

    inline const String& mappings() const
        { return m_mappings; }

    inline void mappings(const char* newMap)
        { if (newMap) m_mappings = newMap; }

    inline const String& rfc2833() const
        { return m_rfc2833; }

    inline void rfc2833(int payload)
        {
            if (payload >= 0)
                m_rfc2833 = payload;
            else
                m_rfc2833 = String::boolText(false);
        }

    inline const String& remoteCrypto() const
        { return m_rCrypto; }

    inline const String& localCrypto() const
        { return m_lCrypto; }

    inline bool securable() const
        { return m_securable; }

    bool sameAs(const SDPMedia* other, bool ignorePort = false, bool checkStarted = false) const;

    inline bool localChanged() const
        { return m_localChanged; }

    inline void setLocalChanged(bool chg = false)
        { m_localChanged = chg; }

    const char* fmtList() const;

    bool update(const char* formats, int rport = -1, int lport = -1, bool force = false);

    void update(const NamedList& msg, bool pickFormat);

    void parameter(const char* name, const char* value, bool append);

    void parameter(NamedString* param, bool append);

    void crypto(const char* desc, bool remote);

    void putMedia(NamedList& msg, bool putPort = true);

    void keepRtp(const SDPMedia& other);

    static int payloadMapping(const String& mappings, const String& fmt);
 
private:
    bool m_audio;
    bool m_video;
    bool m_modified;
    bool m_securable;
    // local rtp data changed flag
    bool m_localChanged;
    // suffix used for this type
    String m_suffix;
    // transport protocol
    String m_transport;
    // list of supported format names
    String m_formats;
    // format used for sending data
    String m_format;
    // id of the local media channel
    String m_id;
    // remote media port
    String m_rPort;
    // mappings of RTP payloads
    String m_mappings;
    // local media port
    String m_lPort;
    // payload for telephone/event
    String m_rfc2833;
    // remote security descriptor
    String m_rCrypto;
    // local security descriptor
    String m_lCrypto;
};
 

class YSDP_API SDPSession
{
public:
    enum {
        MediaMissing,
        MediaStarted,
        MediaMuted
    };

    SDPSession(SDPParser* parser);

    SDPSession(SDPParser* parser, NamedList& params);

    virtual ~SDPSession();

    inline const String& getHost() const
        { return m_host; }

    inline const String& getRtpAddr() const
        { return m_externalAddr ? m_externalAddr : m_rtpLocalAddr; }

    bool setMedia(ObjList* media, bool preserveExisting = false);

    static void putMedia(NamedList& msg, ObjList* media, bool putPort = true);

    inline void putMedia(NamedList& msg, bool putPort = true)
        { putMedia(msg,m_rtpMedia,putPort); }

    SDPMedia* getMedia(const String& name) const
        { return m_rtpMedia ? static_cast<SDPMedia*>((*m_rtpMedia)[name]) : 0; }

    void setRfc2833(const String& value);

    inline void setRfc2833(const String* value)
        { if (value) setRfc2833(*value); }

    bool dispatchRtp(SDPMedia* media, const char* addr,      bool start, bool pick, RefObject* context = 0);

    bool dispatchRtp(const char* addr, bool start, RefObject* context = 0);

    bool startRtp(RefObject* context = 0);

    bool updateSDP(const NamedList& params, bool defaults = true);

    bool updateRtpSDP(const NamedList& params);

    MimeSdpBody* createSDP(const char* addr, ObjList* mediaList = 0);

    MimeSdpBody* createSDP();

    MimeSdpBody* createPasstroughSDP(NamedList& msg, bool update = true,
        bool allowEmptyAddr = false);

    inline MimeSdpBody* createRtpSDP(const char* addr, const NamedList& msg)
        { updateSDP(msg); return createRtpSDP(addr,false); }

    inline MimeSdpBody* createRtpSDP(const char* addr, bool start)
        { return dispatchRtp(addr,start) ? createSDP(getRtpAddr()) : 0; }

    inline MimeSdpBody* createRtpSDP(bool start)
        {
            if (m_rtpAddr.null()) {
                m_mediaStatus = MediaMuted;
                return createSDP(0);
            }
            return createRtpSDP(m_rtpAddr,start);
        }

    void updateFormats(const NamedList& msg, bool changeMedia = false);

    bool addSdpParams(NamedList& msg, const MimeBody* body);

    bool addSdpParams(NamedList& msg, const String& rawSdp);

    bool addRtpParams(NamedList& msg, const String& natAddr = String::empty(),
        const MimeBody* body = 0, bool force = false, bool allowEmptyAddr = false);

    virtual void resetSdp(bool all = true);

    virtual Message* buildChanRtp(SDPMedia* media, const char* addr, bool start, RefObject* context);

    virtual Message* buildChanRtp(RefObject* context) = 0;

    bool localRtpChanged() const;

    void setLocalRtpChanged(bool chg = false);

    static ObjList* updateRtpSDP(const NamedList& params, String& rtpAddr,
        ObjList* oldList = 0, bool allowEmptyAddr = false);
 
protected:
    virtual void mediaChanged(const SDPMedia& media);

    virtual void dispatchingRtp(Message*& msg, SDPMedia* media);

    void setSdpDebug(DebugEnabler* enabler = 0, void* ptr = 0, const String& traceId = String::empty());

    void printRtpMedia(const char* reason);

    void setFormatsExtra(const NamedList& list, bool out);
 
    SDPParser* m_parser;
    int m_mediaStatus;
    bool m_rtpForward;                   // Forward RTP flag
    bool m_sdpForward;                   // Forward SDP (only if RTP is forwarded)
    String m_originAddr;                 // Our SDP origin address
    String m_externalAddr;               // Our external IP address, possibly outside of a NAT
    String m_rtpAddr;                    // Remote RTP address
    String m_rtpLocalAddr;               // Local RTP address
    String m_rtpNatAddr;                 // Advertised local IP in sdp (override any local IP)
    ObjList* m_rtpMedia;                 // List of media descriptors
    int m_sdpSession;                    // Unique SDP session number
    int m_sdpVersion;                    // SDP version number, incremented each time we generate a new SDP
    unsigned int m_sdpHash;              // SDP content hash
    String m_host;
    bool m_secure;
    int m_rfc2833;                       // Payload of RFC 2833 for remote party
    bool m_ipv6;                         // IPv6 support
    NamedList m_amrExtra;                // Extra AMR codec parameters
 
private:
    // Add extra AMR params to fmtp line
    void addFmtpAmrExtra(String& buf, const String* fmtp);
 
    DebugEnabler* m_enabler;             // Debug enabler used for output
    void* m_ptr;                         // Pointer to show in debug messages
    String m_traceId;
};

class YSDP_API SDPParser : public DebugEnabler, public Mutex
{
    friend class SDPSession;
 
public:
    inline SDPParser(const char* dbgName, const char* sessName, const char* fmts = "alaw,mulaw")
        : Mutex(true,"SDPParser"),
          m_rfc2833(101),
          m_sdpForward(false), m_secure(false), m_ignorePort(false),
          m_sessionName(sessName), m_audioFormats(fmts),
          m_codecs(""), m_hacks("")
        { debugName(dbgName); }

    inline void getAudioFormats(String& buf)
        { Lock lock(this); buf = m_audioFormats; }

    inline int rfc2833() const
        { return m_rfc2833; }

    inline bool secure() const
        { return m_secure; }

    inline bool sdpForward() const
        { return m_sdpForward; }

    inline bool ignorePort() const
        { return m_ignorePort; }

    ObjList* parse(const MimeSdpBody& sdp, String& addr, ObjList* oldMedia = 0,
        const String& media = String::empty(), bool force = false);

    inline ObjList* parse(const MimeSdpBody* sdp, String& addr, ObjList* oldMedia = 0,
        const String& media = String::empty(), bool force = false)
        { return sdp ? parse(*sdp,addr,oldMedia,media,force) : 0; }

    void initialize(const NamedList* codecs, const NamedList* hacks, const NamedList* general = 0);

    static const TokenDict s_payloads[];

    static const TokenDict s_rtpmap[];
 
private:
    int m_rfc2833;                       // RFC 2833 payload offered to remote
    bool m_sdpForward;                   // Include raw SDP for forwarding
    bool m_secure;                       // Offer SRTP
    bool m_ignorePort;                   // Ignore port only changes in SDP
    String m_sessionName;
    String m_audioFormats;               // Default audio formats to be advertised to remote party
    NamedList m_codecs;                  // Codecs configuration list
    NamedList m_hacks;                   // Various potentially standard breaking settings
};
 
}; // namespace TelEngine
 
#endif /* __YATESDP_H */
 
/* vi: set ts=8 sw=4 sts=4 noet: */