PatchGM.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_PatchGM_H
#define MN_PatchGM_H

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

#include "ServerGM.h"
#include "MNSem.h"
#include "MNMutex.h"
#include "MNString.h"
#include "MNRTPutildefs.h"
#include "sdp/PayloadTypes.h"

namespace SH
{
    class Base;
    class RTPSourceSH;
    class RTPSinkSH;
    class RTPDecoderSH;
    class RTPEncoderSH;
    class ConcatinizerSH;
    class FileSinkSH;
    class PushPullSH;
};

class PatchGM : public ServerGM
{
    struct timeval* _tv;

    SH::RTPSourceSH*    _patchSource;
    SH::RTPDecoderSH*   _patchDecoder;
    SH::PushPullSH*     _patchQueue;
    SH::RTPSourceSH*    _mainSource;
    SH::RTPDecoderSH*   _mainDecoder;
    SH::PushPullSH*     _mainQueue;
    SH::ConcatinizerSH* _concatinizer;
    SH::FileSinkSH*     _fileCache;
    SH::PushPullSH*     _netQueue;
    SH::RTPEncoderSH*   _netEncoder;
    SH::RTPSinkSH*      _netSink;

    MediaState _streamer_state;
    MNSem      _eof_sig;
    MNMutex    _eof_lock;

    MNMutex    _notifyLock;

    MNString   _mainServer;  // hostname of the server of the main multicast stream
    MNString   _patchServer; // hostname of the server of the patch stream
    MNString   _client;      // hostname of the client

    // int        _MainPortUp;      // server port of the main multicast stream
    int        _DistantPortUp;   // server port of the patch stream
    // int        _LocalPortUp;     // proxy port of the patch stream
    // int        _LocalPortDown;   // proxy port of the combined stream
    int        _DistantPortDown; // client port

    MNSocket* _local_upstream_main_rtp;
    MNSocket* _local_upstream_main_rtcp;
    MNSocket* _local_upstream_patch_rtp;
    MNSocket* _local_upstream_patch_rtcp;
    MNSocket* _local_down_rtp;
    MNSocket* _local_down_rtcp;

    bool       _cachingEnabled;
    bool       _patchComplete;
    bool       _mainComplete;
    bool       _netComplete;

public:
    PatchGM( GMUser* user, MNSelector& sel, bool cachingEnabled );

    virtual ~PatchGM();
 
    virtual void init(int idx);

    virtual void uninit();
    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 );

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 bool graphManNotify( int idx, 
                                 SH::Base* caller,
                                 SH::Notification attribute,
                                 void* msg );

    void         setMainSource( MNString  hostname,
                                MNSocket* mainRtp,
                                MNSocket* mainRtcp );
    void         setBufferOptions( int threshold, int size);
};


#endif /* MN_PatchGM_H */

---