SDPMediaDescription.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef SDP_MEDIA_DESCRIPTION_H
#define SDP_MEDIA_DESCRIPTION_H

#include <stdlib.h>
#include <vector>

#include "MNString.h"
#include "MNArrayList.h"
#include "MNList.h"
#include "MNValid.h"
#include "GCPtr.h"
#include "sdp/PayloadTypes.h"
#include "sdp/PayloadTypeEntry.h"

namespace SDP
{
    /*******************************************************************
     * enum SDP::MNMediaType
     *******************************************************************/

    enum MNMediaType
    {
        audio,
        video,
        application,
        data,
        control,
        INVALIDTYPE
    };

    /*******************************************************************
     * enum SDP::SessionFieldName
     *******************************************************************/

    enum SessionFieldName
    {
        Version,
        Origin,
        SessionName,
        Information,
        Uri,
        Email,
        Phone,

        A_Range
    };

    /*******************************************************************
     * SDP::Bandwidth
     *******************************************************************/

    class Bandwidth
    {
        DECLARE_VALID
    private:
        static const size_t _default = 150;

        char*     _s;

        unsigned  _ok : 1; 
        unsigned  _ct : 1; 
        unsigned  _as : 1; 
        unsigned  _x  : 1; 
        size_t    _bw;     

    public:
        Bandwidth( );
        Bandwidth( const char* in );
        Bandwidth( const Bandwidth& orig );

        ~Bandwidth( );

        Bandwidth& operator=( const Bandwidth& orig );

        void dump( ostream& ostr ) const;

        inline const char* getS() const {
            return _s;
        }

        inline bool isCT() const {
            return ( _ct == 1 );
        }

        inline bool isAS() const {
            return ( _as == 1 );
        }

        inline size_t getBW() const {
            if( _ok ) return _bw;
            else      return _default;
        }

        friend ostream& operator<<( ostream& ostr, const Bandwidth& o );

    private:
        void private_parse( );
    };

    /*******************************************************************
     * struct SDP::Bandwidths
     *******************************************************************/

    typedef std::vector<Bandwidth>                 Bandwidths;
    typedef std::vector<Bandwidth>::iterator       Bandwidth_it;
    typedef std::vector<Bandwidth>::const_iterator Bandwidth_cit;

    ostream& operator<<( ostream& ostr, const Bandwidths& orig );

    /*******************************************************************
     * struct SDP::RangeAttribute
     *******************************************************************/

    struct RangeAttribute
    {
        size_t _from_seconds;
        size_t _from_fraction;
        size_t _to_seconds;
        size_t _to_fraction;
    };

}; // namespace SDP

enum MNTransportProtocol
{
    RTP_AVP,
    UDP,
    INVALIDPROT
};

class Formatswitch
{
public:
    Formatswitch()
    {
        Ssrc_old=-1;
        Ssrc_new=-1;
        Bytepos_old=-1;
        Bytepos_new=-1;
    }

    Formatswitch( const Formatswitch& orig )
    {
        Ssrc_old=orig.Ssrc_old;
        Ssrc_new=orig.Ssrc_new;
        Bytepos_old=orig.Bytepos_old;
        Bytepos_new=orig.Bytepos_new;
    }

    long Ssrc_old;
    long Ssrc_new;
    long Bytepos_old;
    long Bytepos_new;
};

/***********************************************************************
 * SDPMediaDescription
 ***********************************************************************/

class SDPMediaDescription
{
    /*******************************************************************
     * SDPMediaDescription::MediaField
     *******************************************************************/
public:
    class MediaField
    {
        MNString            _s;
        SDP::MNMediaType    _mediaType;
        int                 _port;
        MNTransportProtocol _protocol;
        MNString            _payloadFormatEntries;

        DECLARE_VALID

    public:
        MediaField( const MNString& in );
        MediaField( const MediaField& );

        ~MediaField( );

        MediaField& operator=( const MediaField& );

        inline const MNString& getField() const {
            CHECK_VALID
            return _s;
        }

        inline SDP::MNMediaType getMediaType() const {
            CHECK_VALID
            return _mediaType;
        }

        inline int getPort() const {
            CHECK_VALID
            return _port;
        }

        inline MNTransportProtocol getProtocol() const {
            CHECK_VALID
            return _protocol;
        }

        inline const MNString& getPayloadFormatEntries() const {
            CHECK_VALID
            return _payloadFormatEntries;
        }

        void dump( ostream& ostr ) const;

        friend ostream& operator<<( ostream& ostr, const MediaField& o );
    };

    MediaField* _media_field;

    MNString*             _information_field;
    MNString*             _connection_field;

    SDP::Bandwidths       _bandwidths;

    MNString*             _key_field;
    MNList<MNString>*     _attribute_fields;
    SDP::PayloadTypeTable _payloadTypes;
    Formatswitch*         _f_switch;
    MNString*             _trackIDString;

    DECLARE_VALID

public:

    SDPMediaDescription();
    SDPMediaDescription( const SDPMediaDescription& orig );
    SDPMediaDescription( const char* media );
    virtual ~SDPMediaDescription();

    SDPMediaDescription& operator=( const SDPMediaDescription& orig );

    bool hasMedia() const;
    void setMedia( const MNString& in );
    void setMedia( const char* in );
    const MNString&      getMedia() const;
    SDP::MNMediaType     getMediaType() const;
    int                  getPort() const;
    MNTransportProtocol  getTransportProtocol() const;
    const MNString&      getPayloadFormatEntries() const;


    bool hasInformation() const;
    void setInformation( const MNString& in );
    void setInformation( const char* in );
    const MNString& getInformation() const;

    bool hasConnection() const;
    void setConnection( const MNString& in );
    void setConnection( const char* in );
    const MNString& getConnection() const;

    void   addBandwidth( const char* in );
    bool   hasASBandwidth() const;
    size_t getASBandwidth();

    bool hasKey() const;
    void setKey( const MNString& in );
    void setKey( const char* in );
    const MNString& getKey() const;

    bool hasAttributes() const;
    void insertAttribute( const MNString& in );
    void insertAttribute( const char* in );
    void insertRtpmapAttribute( const char* in );
    const MNList<MNString>& getAttributes() const;
    bool hasLCRTPAttribute();

    // following functions: 
    // no set functions, they are set when attributes are set and mediadesc
    // is set to avoid inconsisteny with the strings
 
    int getNbFormats() const;

    const SDP::PayloadTypeTable* getPayloadTypes() const
    {
        CHECK_VALID
        return &_payloadTypes;
    }

    inline bool hasFormatswitch() const
    {
        return ( _f_switch!=NULL );
    }

    inline Formatswitch getFormatswitch()
    {
        return ( *_f_switch );
    }

    inline bool hasTrackIDString() const
      {
        return ( _trackIDString != NULL );
      }

    inline const MNString& getTrackIDString() const
      {
        return ( *_trackIDString );
      }

    void dump( MNString& desc );

    MNString toString();

private:
    void private_delete_fields( );

    void private_clear_fields( );

    void private_copy_fields( const SDPMediaDescription& orig );
    
      //    unsigned char* parseConfig( const char* confstr, unsigned& conflen);

};

/*
static bool getNibble(char const*& configStr,
                         unsigned char& resultNibble);
static bool getByte(char const*& configStr, unsigned char& resultByte);
*/

/***********************************************************************
 * MDescPtr
 ***********************************************************************/

typedef OS::GCPtr<SDPMediaDescription> MDescPtr;

/***********************************************************************
 * MDescList
 * This list is used for all operations after parsing
 ***********************************************************************/

typedef std::vector<MDescPtr> MDescList;

#endif

---