dataPump.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 DATA_PUMP_H
#define DATA_PUMP_H

#include "mnstream.h"
#include "MNString.h"
#include "GMUser.h"     // includes the base class GMUser
#include "MNRTPSockets.h" // includes the base class GMUser
#include "RTSPProxySession.h"
#include "var_type.h"
#include "sdp/TransportTypes.h"

#include <vector>

class KomServer;
class SDPSessionDescription;


enum StreamingType
{
    StreamingFromFileToPort,        
    StreamingFromFileToPortTuned,   
    StreamingFromPortToPortAndFile, 
    StreamingFromPortToPort,        
    StreamingFromPortToPortDynReflection,  
    StreamingFromPortToFile,        
    PatchStreaming,                 
    PatchGleaning,                  
    NoStreaming
};

ostream& operator<<( ostream& ostr, StreamingType s );

class DataPumpResponse
{
public:
    virtual int stream_started( int serverport ) = 0;
    virtual int formatswitching_suggested( int new_pt, long old_ssrc, long old_bytepos, 
                                                       long new_ssrc, long new_bytepos ) = 0;
    virtual void fileComplete( const char* filename, bool comp ) = 0;
};

class dataPump : public GMUser
{
    MNSelector&            _main_selector;
    SDPSessionDescription* _sdesc;

    typedef std::vector<int> PortVector;
    typedef std::vector<MNSocket*> SocketVector;
public:
    enum Server_Type
    {
         MN_SERVER,
         VC_SERVER
    };

    Server_Type            _stype;
    DataPumpResponse*      _resp;

protected:
    StreamingType      _StreamingType;

    //int _DistantPortDownstream;
    PortVector _DistantPortDownstream;

    //int _DistantPortUpstream;    
    PortVector _DistantPortUpstream;

    /* Experimental for TFRC - MZ */
    bool _tfrc;

    int _client_bw;
    PortVector _client_bw_vec; // added 

    MNString _clientname;
    
    MNString _url;

private:
      //   MNSocket* _local_down_rtpsock;
      SocketVector _local_down_rtpsock_vec;

        //    MNSocket* _local_down_rtcpsock;
        SocketVector _local_down_rtcpsock_vec;

        //    MNSocket* _local_up_rtpsock;
        SocketVector _local_up_rtpsock_vec;

        //    MNSocket* _local_up_rtcpsock;
        SocketVector _local_up_rtcpsock_vec;

public:
    dataPump( MNSelector& sel, DataPumpResponse* resp, SDPSessionDescription* sdesc );
    virtual ~dataPump ( ); 

    DataPumpResponse* responder ( );

    MNSelector& mainSelector( );

    // griff 31aug2001
    // THIS FUNCTION IS EVIL - IT IS THE REASON FOR LOTS 'N LOTS OF CORE DUMPS
    // virtual int getFreePort( int );

    virtual int init ( KomServer*, StreamingType type ) = 0;
    
    void setUrl(MNString& url);
    
    virtual void setNptSeek(int npt);
    virtual int getNptSeconds();
    virtual void setRTPTimestamp(int idx, u_int32 rtptime);

    virtual bool createUpstreamSocks(int     idx,
                                     int&                    requested,
                                     RTPSockets::FactoryMode mode,
                                     RTSP::TransportTypes    requested_transport = RTSP::RTP_AVP_UDP ) = 0;


    virtual bool createDownstreamSocks( int                     idx,
                                        int&                    requested,
                                        RTPSockets::FactoryMode mode,
                                        RTSP::TransportTypes    requested_transport = RTSP::RTP_AVP_UDP ) = 0;

    virtual int stream_start ( int             idx,
                               const MNString& filename,
                               const MNString& DescFileName,
                               const MNString& client,
                               const MNString& server, 
                               int             ClientPortAnnounced,
                               int             ServerPortAnnounced ) = 0;
    virtual void setupNewServerSideReflectorGM(int idx);
    virtual void setupExistingServerSideReflectorGM(int idx);
    virtual int play ( int start, int stop ) = 0;
    virtual int stop ( ) = 0;
    virtual int pause ( );
    virtual int jump ( int startpos );
    virtual void fileComplete( const char* filename, bool comp );

    virtual long getFilePos();

    // virtual int print_all_movies ( MNString& listofAssets );

    Server_Type getServerType ( ); 
    void        setServerType ( Server_Type stype );

    /*
    inline bool upStreamReady() const {
        return ( getLocalUpRtp() != NULL );
    }
    */

    inline bool upStreamReady(int idx) const {
      return (getLocalUpRtp(idx) != NULL );
    }

    inline bool downStreamReady(int idx) const {
        return ( getLocalDownRtp(idx) != NULL );
    }

    virtual MNSocket* getLocalDownRtp(int idx ) const;
    virtual MNSocket* getLocalDownRtcp(int idx ) const;
    virtual MNSocket* getLocalUpRtp(int idx ) const;
    virtual MNSocket* getLocalUpRtcp(int idx ) const;

    virtual bool fillTransportString( int idx, MNString& out, bool mc ) const = 0;

    virtual void setLocalDownSocks( int idx, MNSocket* rtp, MNSocket* rtcp );
    virtual void setLocalUpSocks( int idx, MNSocket* rtp, MNSocket* rtcp );

    virtual int  getDistantPortDownstream(int idx ) const;
    virtual void setDistantPortDownstream( int idx, int );
    virtual int  getDistantPortUpstream( int idx) const;
    virtual void setDistantPortUpstream( int idx, int );

    virtual int  getLocalPortDownstream(int idx ) const;
    virtual int  getLocalPortUpstream(int idx ) const;

    virtual StreamingType getStreamingType() const {
        return _StreamingType;
    }

    virtual void set_client_port( int /*idx*/, int ) {};

    virtual long getCorrespondingSsrc( int payloadtype );

    virtual void addFmtSsrcMapping( SDPSessionDescription* sdesc );

    virtual void switchFormat() { };

    void         setSessionDescription( SDPSessionDescription* desc );
    SDPSessionDescription* getSessionDescription( );

    virtual const SDP::PayloadTypeTable* getPayloadTypes();

    virtual SDP::PayloadTypes getInternalPayloadType();
    virtual int               getRTPPayloadType();
    virtual const SDP::PayloadTypeTable* getPayloadTypes(int idx);

    virtual SDP::PayloadTypes getInternalPayloadType(int idx);
    virtual int               getRTPPayloadType(int idx);
    virtual int               getPlayTimeSeconds();

    virtual bool isPatchingCapable() const {
        return false;
    }

    virtual void setMulticastInformation( MNString  /*server*/,
                                          MNSocket* /*main_rtp*/,
                                          MNSocket* /*main_rtcp*/ )
    { }

    virtual void setBufferInformation( int /*threshold*/,
                                       int /*size*/ )
    { }

    static int getLegalEvenPortnum();

private:
    unsigned               _proxy_formatswitching : 1;

public:
    void setProxyFormatswitching( bool yesno );
    bool getProxyFormatswitching( ) const;
    void setTCPfriendly( bool yesno ); 
    void setClientHostname( MNString client );
    bool getTCPfriendly( ) const;
    void setClientBandwidth( int client_bw);
    int  getClientBandwidth( ) const;
    void setClientBandwidth( int idx, int client_bw);
    int  getClientBandwidth( int idx ) const;
};

#endif /* DATA_PUMP_H */

---