PlayerGM.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 PLAYER_GM_H
#define PLAYER_GM_H

#include <sys/types.h>
#include <sys/time.h>

#include "sh/SHGraphManager.h"
#include "SDPMediaDescription.h"
#include "MNUDPSocket.h"
#include "MNRTPSockets.h"

class MpeglibPlayer;
namespace SH
{
    class SH;
    class RTPSourceSH;
    class RTPDecoderSH;
    class PushPullSH;
    class DataPopSinkSH;
};

class PlayerGM : public SHGraphManager
{
public:
    enum SourceMode
    {
        Uninitialized,
        RtpAny,
        RtpUnicastUDP,
        RtpMulticast
    };

    /*******************************************************************
     * PlayerGM::RtpPlay
     *******************************************************************/

    struct RtpPlay
    {
        RTPSockets* socks;
        MNSocket*    rtpUdpSocket;
        MNSocket*    rtcpUdpSocket;
        SH::RTPSourceSH*  rtp;
        SH::RTPDecoderSH* rtpDecoder;
        int             reqRtpPort;
        int             rtpSenderPort;
        MNString        rtpSenderHostname;
        bool            multicast;

        void init( );
        void uninit( );
    };

    struct Subsession {
      size_t     _bandwidth;
      MDescPtr   _mdesc;
      RtpPlay    _r;
      SH::PushPullSH*  _pushPullSH;
      SH::DataPopSinkSH* _popSinkSH;
      MNRope*            _lastRope;
      struct timeval     _lastPresentationTime;
      bool               _synchronized;

    };


private:
    MNList<struct Subsession*>*     _subsessions;
    size_t             _bandwidth;
    MDescPtr           _mdesc;
    RtpPlay            _r;
    SH::PushPullSH*    _pushPullSH;
    SH::DataPopSinkSH* _popSinkSH;
    MNRope*            _lastRope;
    
private:
    PlayerGM(const PlayerGM & orig);

    PlayerGM& operator=( const PlayerGM& orig );

public:
    PlayerGM(GMUser* user, MNSelector& sel );

    virtual ~PlayerGM( );

    void clear( );

    void addSubsession(Subsession* s);
    void addSubsession();

    virtual bool graphManNotify( int idx,
                                 SH::Base* caller,
                                 SH::Notification attribute,
                                 void* msg );

    void setMediaDesc( MDescPtr mdesc );
    void setMediaDesc(int idx, MDescPtr mdesc);

    void setRtpBandwidth( size_t bandwidth );
    void setRtpBandwidth(int idx, size_t bandwidth);

    void setRequestedPort( int port );

    void setRequestedPort(int idx, int port);

    bool open( SourceMode sourceMode );
    bool openall(SourceMode sourceMode);

    int getOpenRtpPort( ) const;
    int getOpenRtpPort(int startPort) const;
    int getOpenRtpPort(Subsession* s) const;

    void setRtpSenderPort( int port );
    void setRtpSenderPort( int idx, int port);

    void setRtpSenderHostname( const MNString& name );
    void setRtpSenderHostname( int idx, const MNString& name );

    void getPT(int idx, struct timeval& presentationTime);
    
    void resetSyncTime();

    bool hasBeenSynchronized(int idx);

    bool start( );
    bool startall( );

    void stop( );
    void stopall( );

    int checkBuffer( );
    int checkBuffer(int idx);
    int fillBuffer( unsigned char* buffer, int length );
    int fillBuffer( int idx, unsigned char* buffer, int length );

//     /** The player has died, either completely unexpectedly or duing
//      *  teardown due to a race condition in clearing the notifications.
//      *  Report its demise to the automaton in the first case.
//      * @pre  caller is Player<BR>
//      *       state == Initializing || state == Initialized ||
//      *       state == Opening || state == Open
//      *       state == Clear
//      */
//     void ll_player_died( );
// 
//     void teardown( );
// 
//     inline void setVolume( double vol )
//     {
//         if ( _llAsync ) _llAsync->DownSetVolume ( vol );
//     }
// 
//     inline void setBalance( double bal )
//     {
//         if ( _llAsync ) _llAsync->DownSetBalance ( bal );
//     }
// 
//     inline void getFramesReport( )
//     {
//         if ( _llAsync ) _llAsync->DownGetFrames ( );
//     }
// 
//     inline void getPosReport( )
//     {
//         if ( _llAsync ) _llAsync->DownGetPos ( );
//     }
// 
//     inline void unpause( )
//     {
//         // if ( _llAsync ) _llAsync->DownPlay( );
//         if ( _llAsync ) _llAsync->DownCont( );
//     }
// 
//     inline void pause( )
//     {
//         if ( _llAsync ) _llAsync->DownPause (  );
//     }
// 
//     friend ostream& operator<< ( ostream& ostr, State sm );
//     friend ostream& operator<< ( ostream& ostr, SourceMode sm );
};

#endif /* PLAYER_GM_H */

---