MNStreamer.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_STREAMER_H
#define MN_STREAMER_H

#include "MNString.h"
#include "MNSocket.h"
#include "MNValid.h"
#include "dataPump.h"
#include "sdp/PayloadTypes.h"
#include "sdp/RetransTypes.h"
#include "sdp/TransportTypes.h"

#include <vector>

class KomServer;

class FileStreamerGM;
class SendBlockStreamerGM;
class LCRTPFileRecorderGM;
class LCRTPCachingReflectorGM;
class RTPReflectorGM;
class PatchGM;
class MNUDPSocket;
class SDPSessionDescription;
class TranscodingGM;
class ServerGM;
class ClientSideReflectorGM;

class MNStreamer : public dataPump
{
    DECLARE_VALID
      typedef std::vector<int> IntVector;
    typedef std::vector<int32_t*> BwVector;
    typedef std::vector<MNSocket*> SocketVector;
    typedef std::vector<SDP::PayloadTypes*> PayloadTypeVector;
private:
    union GMChoice
    {
        ServerGM*                all;
        ServerGM*                fs; // default works for FileStreamerGM
        LCRTPFileRecorderGM*     lcrecord;
        LCRTPCachingReflectorGM* lcreflect;
        RTPReflectorGM*          reflect;
        PatchGM*                 patch;
        TranscodingGM*           trans; // GM for Transcoding streams in realtime (hopefully)
        ClientSideReflectorGM*   clientSideReflectorGM;
    };

    int                    _bandwidth;
    BwVector              _bandwidth_vec;
    long                   _BytesPerSecond;
    GMChoice               RTPServer;
    int                    _ClientPortDesired;
    IntVector              _ClientPortDesiredVec;
    struct DescFile
    {
        bool _useLCRTP;

        int  _plannedPort;

        bool _mc;

      // SDP::PayloadTypes _payload;
      //  SDP::PayloadTypes _payload_codec;
      PayloadTypeVector _payload_vec;
      PayloadTypeVector _payload_codec_vec;
        SDP::RetransTypes _retrans;

        float             _playtime;

        DescFile( )
        {
            _useLCRTP      = false;
            _plannedPort   = -1;
            _mc            = false;
            //_payload       = SDP::PT_DEFAULT;
            //_payload_codec = SDP::PT_DEFAULT;
            // _payload_vec = PayloadTypeVector(getSessionDescription()->getMediaDescriptionCount(), SDP::PT_DEFAULT);
            //_payload_codec_vec = PayloadTypeVector(getSessionDescription()->getMediaDescriptionCount(), SDP::PT_DEFAULT);
            _retrans       = SDP::NONE;
        }
    };

    DescFile _d;

    MNString               _mcHost;

    // int                    _mcPort;
      //   MNSocket*           _remote_up_main_rtp;
      //MNSocket*           _remote_up_main_rtcp;
      SocketVector _remote_up_main_rtp_vec;
      SocketVector _remote_up_main_rtcp_vec;

    bool                   _gleaning;

    int                    _memThreshold;

    int                    _bufferSize;

    RTSP::TransportTypes   _req_transport;

private:
    MNStreamer( const MNStreamer& );

    MNStreamer& operator=( const MNStreamer& );

public:
    MNStreamer( MNSelector& sel, DataPumpResponse* resp );

    MNStreamer( MNSelector& sel, DataPumpResponse* resp, SDPSessionDescription* sdesc );

    virtual ~MNStreamer ( );

    int          getBandwidth( const MNString& DescFileName );
    int          getBandwidth(int idx, const MNString& DescFileName);
    static  bool check_time( const MNString& DescFileName, MNString& time );
    // virtual int  init ( KomServer* streamer, StreamingType type = StreamingFromFileToPort );
    virtual int  init ( KomServer* streamer, StreamingType type );

    virtual bool createUpstreamSocks( int                     idx,
                                      int&                    requested,
                                      RTPSockets::FactoryMode mode,
                                      RTSP::TransportTypes    requested_transport = RTSP::RTP_AVP_UDP );

    virtual bool createDownstreamSocks( int                     idx,
                                        int&                    requested,
                                        RTPSockets::FactoryMode mode,
                                        RTSP::TransportTypes    requested_transport = RTSP::RTP_AVP_UDP );

    virtual bool fillTransportString( int idx, MNString& out, bool mc ) const;

    virtual int  stream_start ( int idx,
                                const MNString& filename,
                                const MNString& DescFileName,
                                const MNString& client,
                                const MNString& server,
                                int ClientPortAnnounced,
                                int ServerPortAnnounced );
    virtual void setupNewServerSideReflectorGM(int idx);
    virtual void setupExistingServerSideReflectorGM(int idx);
    virtual int  play ( int start, int stop );
    virtual int  stop ( );
    void detach();
    virtual int  pause ( );
    virtual int  jump ( int cont_time );
    virtual void fileComplete( const char* filename, bool comp );
    virtual long getFilePos();

    virtual void set_client_port( int a ) { _ClientPortDesired = a;} ;
    virtual void set_client_port( int idx, int a ) { _ClientPortDesiredVec[idx] = a;} ;

    void         examineSDP();

    /*
    virtual void setMulticastInformation( MNString server,
                                          MNSocket* main_rtp,
                                          MNSocket* main_rtcp );
    */
    virtual void setMulticastInformation( int idx,
                                          MNString server,
                                          MNSocket* main_rtp,
                                          MNSocket* main_rtcp );
    virtual void setBufferInformation( int threshold, int size );

    virtual bool isPatchingCapable() const { return true; }
    
    virtual void setNptSeek(int npt);
    virtual int getNptSeconds();
    virtual void setRTPTimestamp(int idx, u_int32 rtptime);

  
private:
    int private_open_file( int idx, const MNString&  FileName );
};

#endif /* MN_STREAMER_H */

---