MNRTSPClient.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 MN_RTSP_CLIENT_H
#define MN_RTSP_CLIENT_H

#include <stdio.h>

#include "MNSessionState.h"
#include "RTSPClient.h"
#include "MNList.h"
#include "MNString.h"
#include "MNValid.h"
#include "TimeDefs.h"
#include "GMUser.h"

class GUIPanel;
class RTSPParserBase;
class MNRTSPClient;
class KomPlayer;
class RTSPClientSocket;
class MNSelector;
class MNPipeNotifier;
class MNSocketBase;
class TimerCallBase;

/***********************************************************************
 * MNRTSPClient
 ***********************************************************************/

class MNRTSPClient
    : public RTSPClient
        , public GMUser
{
    DECLARE_VALID

    struct CurrentRequest
    {
        int        cseq;
        u_short    type;
    };

private:
    MNSessionState    _session_state;
    RTSPClientSocket* _socket;
    CurrentRequest    _last_request; /* code for last request message sent */

    MNSelector&       _selector;

    int                 _multicastPort;
    bool                _encrypt;

    int                 _sessionsSetup;
    int                 _numSessions;
    MNString            _setupUrl;

    struct sockaddr_in* _client_interface_address;
    MNString            _destination;
    bool                _isRealServer;
    bool                _isDarwinServer;
    bool                _isJVCCamera;
    ParseTimeRange*     _play_time;

// protected:
//     RTSPClientSocket*     socket() const;
// 
private:
//     void handle_options_request(void);
//     void handle_options_reply(int status, RTSPParserBase* base);
//     void handle_pause_reply(int status, RTSPParserBase* base);
//     void handle_getpara_reply(int status, RTSPParserBase* base);
    int  handle_describe_reply( int status, RTSPParserBase* base );
    void handle_setup_reply( int status, RTSPParserBase* base );
    void handle_pause_reply( int status, RTSPParserBase* base );
    void handle_teardown_reply( int status, RTSPParserBase* base);
    void handle_play_reply( int status, RTSPParserBase* base );

    virtual void init_stage_2( ) = 0;
    virtual void open_stage_2( ) = 0;
    virtual void play_stage_2( ) = 0;
    virtual void pause_stage_2( ) = 0;
    virtual void stop_stage_2( ) = 0;

    virtual void init_stage_2_failed( const char* file,
                                      int         line,
                                      const char* text ) = 0;
    virtual void open_stage_2_failed( const char* file,
                                      int         line,
                                      const char* text ) = 0;
    virtual void play_stage_2_failed( const char* file,
                                      int         line,
                                      const char* text ) = 0;
    virtual void pause_stage_2_failed( const char* file,
                                      int         line,
                                      const char* text ) = 0;
    virtual void stop_stage_2_failed( const char* file,
                                      int         line,
                                      const char* text ) = 0;

    virtual void unknown_stage_2( const char* file,
                                  int         line,
                                  const char* text ) = 0;

public:
//     KomPlayer* _interface; 

    MNRTSPClient( MNSelector& selector );
    virtual ~MNRTSPClient ( );

    inline MNSelector& mainSelector( ) {
        return _selector;
    }

    void insert( MNSocketBase* sock );
    void remove( MNSocketBase* sock );

    void set_local_sockaddr( const struct sockaddr_in& addr );

    void send_options_request(  const char* url );
    void send_teardown_request( int idx, const MNString& url );
    void send_describe_request( const MNString& url );
    void send_setup_request( int rtpPort, const MNString& Url );
    void send_play_request(  int startpos, int endpos, const MNString& Url );
    void send_pause_request( const MNString& url );
//     void send_getpara_request(const MNString& parameter, const MNString& type,
//                               MNString Url);
private:
    bool private_parse_url( const char* url,
                            MNString&   server,
                            u_short&    port,
                            MNString&   file_name );
    void private_store_last_request( int cseq, u_short req );
    void send_play_range_request( char *range, const MNString& Url );

    virtual void handle_event(int seq, RTSPParserBase* base);
//     int  getFreePort( int port );
// 
//     /* funcions for Komplayer FSA */
protected:
    bool protected_connect( const char* url );
    void protected_disconnect( );

    bool isConnected( ) const;
    bool isInitialized( ) const;
    bool isPlaying( ) const;
//     int          getClientPort();
    int          getServerPort();
//     u_short      lastRequest( );
//     void         teardown( MNString Url );
//     void         pause( MNString Url );
//     void         stop( MNString Url );
// 
//     bool         connectedToServer() const;
    bool        getMulticast() const;
    int         getMulticastPort() const;
    bool        getBandwidth() const;
    const char* getServerHostname() const;
    const char* getHostName();

    int         getPlayTimeSeconds() const;

    MDescPtr getMediaDesc() const;
    MDescPtr getMediaDesc(int i) const;
    
    int getNumSessions() const;

protected:
    //some methods inherited from GMUser
    virtual const SDP::PayloadTypeTable* getPayloadTypes(int idx);
    virtual SDP::PayloadTypes            getInternalPayloadType(int idx);
    virtual int                          getRTPPayloadType(int idx);    

protected:
    bool setNotifyEnd( );
private:
    void notifyEndTimeout( void* data, TimerCallBase* self );
};

#endif /* MN_RTSP_CLIENT_H */

---