RTSPServerSession.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 _RTSPServerSession_h
#define _RTSPServerSession_h 1

#include "MNString.h"
#include "MNMutex.h"
#include "MNValid.h"
#include "StreamRequestHeader.h"

#include "Container.h"
#include "ParseTransport.h"
#include "RTSPParserBase.h"
#include "ReqQueueEntry.h"
#include "KomServer.h"

class ParseTimeRange;
class MNRTSPSessionFactory;
class ControlBase;
class RTSPSetupHeader;
class RTSPSetParameterHeader;
class RTSPReplyHeader;

class RTSPServerSession : public KomServer
{
    DECLARE_VALID

    int                   _sessionID;           
    int                   _rtsp_socket;
    Container*            _container;
    MNRTSPSessionFactory* _factory;
    bool                  _firstSetup;
    bool                  _ismc;
    bool                  _streamnew;
    // bool                  _tfrc;
    int                   _mcport;
    MNString              _mchost;


    RTSPParserBase*       _lastCmd;
    RTSPParserBase*       _lastReply;
    const MNString&       _name;
    bool                  _isFormatswitchingDemanded;
    int                   _lastCSeq;
    StreamDescriptor*     _streamdesc; 
  
private:
    bool        ChckContainerList(const MNString& path);

    // Req Queues
    ReqQueueEntryDLList ImmReqQueue;
    ReqQueueEntryDLList DefReqQueue;    
    // flag used to signal a chnage of the deferred request queue
    int                 DefReqChanged;
    
    // saves data about all streams of actual session stream data
    StreamRequestHeader AboutStreams;
    
    
public: 
    RTSPServerSession( MNRTSPSessionFactory* factory,
                       MNSelector&           selector,
                       int                   sessionId,
                       int                   rtspSocket,
                       const MNString&       path );

private:
    ~RTSPServerSession();
    
public:
    int  Setup( const MNString& StreamName,
                ParseTransport* Trans,
                int             bw,
                RTSPSetupHeader*   cmd );
    int  SetParameter( RTSPSetParameterHeader* cmd );
    int  Ok( RTSPReplyHeader* reply );
    

    // cg 10nov2001 - are these functions unused?
    // int       StreamEnded( const MNString& path);
    // int       StreamStarted( const MNString& path );

    int  LookQueuedReqs();
    int  InsertImmPlayRequest( const MNString& path,
                               ParseTimeRange* range,
                               RTSPParserBase* cmd );
    int  InsertDefPlayRequest( const MNString& StreamName,
                               ParseTimeRange* range,
                               RTSPParserBase* cmd );
    int  PauseReq( const MNString&   path,
                   MNList<MNString>& ContainerPaths,
                   RTSPParserBase*   cmd );
    // int  PlayRequestEnd( const MNString& StreamName, int ContNo); 
    // if we don't declare it virtual we would have to define it 
    void GetSecImmQueueAccess();
    void RelSecImmQueueAccess();
    void GetSecDefQueueAccess();
    void RelSecDefQueueAccess();        
    void SendNow( int command, int mask,int nextState);

    // cg 11nov2001 - the automaton provides ::stop() itself
    // void sessStop( ); 

    // to get run by HelpToRunThread timethread must be public
    void timethread();
    
    void QueueImm();
    //misc functions
    int  ChckContainerState(Container* HelpContainer);

    virtual void streamerSetupResponse( bool success );
    virtual void streamerResponse( int port, const char* msg );
    virtual void sendSetParameterRequest( );
    virtual void sendSetParameterOk( );
    virtual void setDataPump( dataPump* pump ); 
    virtual void sendAnnounce( int  new_pt,
                               long old_ssrc,
                               long old_bytepos,
                               long new_ssrc,
                               long new_bytepos );

    const MNString& getSessionName( );

    int             getRtspSocket( ) const;

    bool            mcStreamPlaying( );
    bool            isMc( );
    bool            isSessionMulticast();
    int             getMulticastInformation( MNString& mchost, int& mcport );

    inline const    bool hasGui() const  { return false; }
    inline bool     isFormatswitchingDemanded() const { return _isFormatswitchingDemanded; }
    inline int      getLastCSeq( ) const { return _lastCSeq; }

private:
    size_t _ref;
public:
    void ref();
    void deref();
};

#endif

---