FileStreamerGM.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_FileStreamerGM_H
#define MN_FileStreamerGM_H

#include <sys/types.h>
#include "var_type.h"

#include "ServerGM.h"
#include "MNFileSourceSH.h"
#include "MNSem.h"
#include "MNMutex.h"
#include "MNRTPutildefs.h"
 
#define min(a, b) (((a) < (b))? (a): (b))

namespace SH
{
    class Base;
    class RTPEncoderSH;
    class DummyLayerSourceSH;
};

class MNUDPSocket;
 
class FileStreamerGM : public ServerGM
{
    struct timeval* _tv;
 
    union
    {
        SH::Base*               a;
        SH::FileSourceSH*       f;
        SH::DummyLayerSourceSH* d;
    }                 _fsh;
    SH::RTPEncoderSH* _esh;
    SH::Base*         _ssh;
    MNString _client; 
 
    MediaState _streamer_state;
    MNSem      _eof_sig;
    MNMutex    _eof_lock;  
    bool       _initialized;

    bool       _udl;

    MNSocket*    _local_down_rtp;
    MNSocket*    _local_down_rtcp;
    int          _DistantPortDown;

    RTSP::TransportTypes _requested_transport;

public:
    FileStreamerGM( GMUser*              user,
                    MNSelector&          sel,
                    bool                 useDummyLayerSource = false,
                    RTSP::TransportTypes requested_transport = RTSP::RTP_AVP_UDP );
 
    virtual ~FileStreamerGM();
 
    virtual void init(int idx);

    virtual void uninit();

    virtual u_int32 getSsrc();
 
    virtual void start();

    virtual void set_hostnames( const MNString& client, const MNString& server );
    virtual void set_ports( int idx,
                            MNSocket*    locDownRtp,
                            MNSocket*    locDownRtcp,
                            int          distDown,
                            MNSocket*    locUpRtp,
                            MNSocket*    locUpRtcp,
                            int          distUp );
    virtual bool graphManNotify( int idx, SH::Base* caller, SH::Notification attribute, void* msg );

private:
    virtual int start_streamer( int idx, int bandwidth );

public:

    virtual int open_file( int idx,
                           const char*       name,
                           int               rtp_pt,
                           SDP::PayloadTypes int_pt,
                           u_int32           bw,
                           SDP::RetransTypes int_rt,
                           int               packetsize );
    virtual int play( int startp, int stopp );
    virtual int stop( );
    virtual int pause( );
    virtual int jump ( long pos );
    virtual long getFilePos();

    void send_forced( size_t timeout, size_t packetsize );

    void stop_forced( );

    void recv_forced( );

    virtual bool synchronousGet( GetValue what, u_int32& outVar );

    // new requirements due to the integration of LCFtpSend,
    // dummies right now

    void set_repeat_times( u_int32 /*lc_max_loop*/ ) { }
};


#endif /* MN_FileStreamerGM_H */

---