LCRTPCachingReflectorGM.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_LCRTPCachingReflectorGM_H
#define MN_LCRTPCachingReflectorGM_H

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

#include "MNSem.h"
#include "MNMutex.h"

#include "MNRTPutildefs.h"

#include "ServerGM.h"

#include "MNFileSinkSH.h"
#include "MNPacketMultiplierSH.h"

#include "SDPMediaDescription.h"

namespace SH
{
    class PushPullSH;
    class RTPDecoderSH;
    class RTPEncoderSH;
    class RTPSourceSH;
    class RTPSinkSH;
    class DummyLayerSinkSH;
};

struct Subsession 
{
    SH::RTPSourceSH*          _RTPSourceSH;         // SH*
    SH::PacketMultiplierSH*   _MultiplierSH;   
    SH::RTPDecoderSH*         _DecoderSH;
    SH::FileSinkSH*           _FileSinkSH;
    SH::PacketMultiplierSH*   _filterMultiSH;
    SH::RTPDecoderSH*         _filterDecSH;
    SH::PushPullSH*           _filterBufferSH;
    SH::RTPEncoderSH*         _filterEncSH;
    SH::DummyLayerSinkSH*     _filterDropSH;
    SH::RTPSinkSH*            _RTPSinkSH;

    MNSem                     _eof_sig;
    MNMutex                   _eof_lock;  

 
    MNSocket*                 _local_down_rtp;
    MNSocket*                 _local_down_rtcp;
    MNSocket*                 _local_up_rtp;
    MNSocket*                 _local_up_rtcp;
    int                       _DistantPortDown;
    int                       _DistantPortUp;
    bool                      _use_file;
    char*                     _filename;
    MDescPtr                  _mdesc;
};



class LCRTPCachingReflectorGM : public ServerGM
{
    MNList<struct Subsession*>* _subsessions;

    MediaState                _streamer_state;

    MNString                  _client; 
    MNString                  _server;
  
    bool                        _initialized;
    char*                     _logfile;

    RTSP::TransportTypes _requested_transport;


public:
    LCRTPCachingReflectorGM( GMUser* user, MNSelector& sel, RTSP::TransportTypes requested_transport = RTSP::RTP_AVP_UDP );
    virtual ~LCRTPCachingReflectorGM();

    void addSubsession(); // make this virtual and declare in superclass?
 
    virtual void init();
    virtual void init(int idx);
    virtual void uninit();
    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 );
    void set_mdesc(int idx, MDescPtr mdesc);
    virtual void start();
    virtual bool graphManNotify( int idx, SH::Base* caller, SH::Notification attribute, void* msg );
    virtual bool synchronousGet( int idx, GetValue what, u_int32& outVar );
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 );
    void        set_write_to_file( int idx, bool yes );
}; 


#endif /* MN_LCRTPFileRecorderGM_H */

---