ParseTransport.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 _TRANPORT_H 
#define _TRANPORT_H 1

#include "mnstream.h"
#include "MNString.h"
#include "MNValid.h"
#include "sdp/TransportTypes.h"

#define TRANS_RTP                       1
#define TRANS_AVP                       2
#define TRANS_TCP                       3
#define TRANS_UDP                       4
#define TRANS_UNICAST           5
#define TRANS_MULTICAST         6
#define TRANS_PLAY                      1
#define TRANS_RECORD                    2

class ParseTransport
{
public:
    enum IntSpec {
        PORT,
        SERVER_PORT,
        CLIENT_PORT,
        INTERLEAVED
    };

    enum Mode {
        PLAY,
        RECORD
    };

    friend ostream& operator<<( ostream& ostr, IntSpec p );
    friend ostream& operator<<( ostream& ostr, Mode p );

private:
    int                   startPort;
    int                   endPort;
    int                   startClientPort;
    int                   endClientPort;
    int                   startServerPort;
    int                   endServerPort;
    int                   startChannel;
    int                   endChannel;
    int*                  ttl;
    int*                  layers;
    long*                 ssrc;
    RTSP::TransportTypes  _protocol;
    bool                  _multicast;
    bool                  _append;
    MNString*             destination;
    Mode                  mode;
    bool                  proxy_streaming;
    bool                  proxy_caching;
    MNString*             proxy_rtcp;
    bool                  proxy_formatswitching;

    int                   _errorNum;
    MNString              _errorString;

    ParseTransport*       _next;

    DECLARE_VALID

public:

    ParseTransport( RTSP::TransportTypes p );
    ~ParseTransport( );

    RTSP::TransportTypes getProtocol( );

    ParseTransport* getNextTransport();
    void            setNextTransport( ParseTransport* pt );
    int             setDestination( const char* dest = "" );
    bool            hasDestination( );
    const MNString& getDestination( );
    int             setRange( int s, int start );
    int             setRange( int s, int start, int end );
    bool            hasPort( );
    bool            hasClientPort( );
    bool            hasServerPort( );
    bool            hasInterleaved( );
    int             getStartPort( );
    int             getEndPort( );
    int             getStartClientPort( );
    int             getEndClientPort( );
    int             getStartServerPort( );
    int             getEndServerPort( );
    int             getStartInterleaved( );
    int             getEndInterleaved( );
    int             setMulticast( bool m );
    bool            getMulticast( );
    int             setAppend( bool a );
    bool            getAppend( );
    int             setTtl( int t );
    bool            hasTtl( );
    int             getTtl( );
    int             setLayers( int l );
    bool            hasLayers( );
    int             getLayers( );
    int             setSsrc( long s );
    bool            hasSsrc( );
    long            getSsrc( );
    int             setMode( const char* m );
    Mode            getMode( );
    int             setProxyCaching( bool m );
    bool            getProxyCaching( );
    int             setProxyStreaming( bool m );
    bool            getProxyStreaming( );
    int             setProxyRtcp( const char* rtcp );
    bool            hasProxyRtcp( );
    const MNString& getProxyRtcp( );
    int             setProxyFormatswitching( bool m );
    bool            getProxyFormatswitching( );

    const MNString& getErrorString();
    int             getErrorNum();

    void            append( ParseTransport* p );
    MNString&       toString();
};

#endif

---