MNRTPEncoderSH.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_RTP_ENCODER_STREAM_HANDLER_H
#define MN_RTP_ENCODER_STREAM_HANDLER_H

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

#include "SH.h"
#include "SHEndpoint.h"
#include "SHEndpointSpec.h"
#include "MNTimerCall.h"
#include "MNValid.h"
#include "var_type.h"
#include "MNRTPutildefs.h"
#include "lcrtp/MNLCRTPdefs.h"
#include "lcrtp/MNLCRTPLossList.h"
#include "MNTFRCSend.h"
#include "sdp/PayloadTypes.h"
#include "sdp/PayloadTypeEntry.h"

class MNRTP;
class MNUDPSocket;
class MNRTPEncoderBase;
class RetransBase;
class MNRope;
class MNRTPPacket;
class MNStreamer;

#define RTP_NAME   "LCTZ"
#define TIMED_OUT  200
#define PACK_SIZE  512

namespace SH
{

class RTPEncoderSH;
class RTPEncoderSinkEndpointSpec;
class RTPEncoderSourceEndpointSpec;
class RTPEncoderSinkEndpoint;
class RTPEncoderSourceEndpoint;

class CBPointer : public TimerCall<RTPEncoderSH>
{
    typedef void (RTPEncoderSH::*callback)( void* data, TimerCallBase* self );
    int                      _idx;
public:
    CBPointer( int idx, RTPEncoderSH* encSH, callback cb ); 
    virtual ~CBPointer( ) { };

    int getIndex( ) { return _idx; }
};

/**********************************************************************/
/* RTPEncoderSinkEndpoint                                           */
/**********************************************************************/

class RTPEncoderSinkEndpoint
    : public SinkEndpoint
{
public:
    RTPEncoderSinkEndpoint( RTPEncoderSH* mySH );
    virtual ~RTPEncoderSinkEndpoint( );
};

/**********************************************************************/
/* RTPEncoderSourceEndpoint                                         */
/**********************************************************************/

class RTPEncoderSourceEndpoint
    : public SourceEndpoint
{
public:
    RTPEncoderSourceEndpoint( RTPEncoderSH* mySH );
    virtual ~RTPEncoderSourceEndpoint( );
};

/**********************************************************************/
/* RTPEncoderSH                                                     */
/**********************************************************************/

class RTPEncoderSH
    : public Base
{
    DECLARE_VALID

    MNRTPEncoderBase* _codec;
    RetransBase*      _retrans;
    // int               _fd;
    CBPointer**       _cbp;

    MNTimer _timer;
    Timeval         _last_playtime_packet;  

    SH_RC verify_codec( );

    SA_RTP_MAX_PACKET_SIZE _max_packet_size;

    SA_RTP_RTP_PAYLOAD_TYPE _rtp_pt;  // indicates RTP packet header pt
    SA_RTP_INT_PAYLOAD_TYPE _int_pt;  // indicates true pt
    SA_RTP_INT_RETRANS_TYPE _int_rt;  // indicates retransmission type

    SA_ACTIVE_DELAY _delay;

    SA_RTP_PLAYOUT_SCALE _playout_scale;
    SA_RTP_BANDWIDTH     _bandwidth;
    SA_HAS_ORDERED_DATA  _hasOrderedData;
    SA_RTP_SSRC          _ssrc;
    SA_TCPF              _tcpf;
    SA_CLIENT_MAX_BW     _client_max_bw;

    SA_LCRTP_REPEAT_TIMES _repeat_times_attr;

    struct timeval _media_time;
    MNMutex        _block_pull;
    bool           _resync_required;

    struct timeval _construction_time;

    struct timeval _pause_time;

    struct timeval _delta_paused;

    /* Experimental for TFRC - MZ */
    MNTFRCSend*        _tfrc;
    MNMutex            _tfrc_mutex;
    // int64              _help_packet;

    MediaState _streamer_state;

    struct timeval _timeneu;

    /* for lcrtp */
    MNMutex           _send_mutex;
    Timeval           _resend_timeout;
    ProtectedU_int32  _repeat_timeouts;
    bool              _isEndReached;

    void evalRTCPPacket( u_int32 ssrc,
                           void*   data,
                           int     len,
                           int     subtype,
                           char*   name,
                           bool    inCallback );

    // SH_RC push_decode( MNRope* data  );
    // SH_RC pull_encode( DataPtr& item, int cbindex );
    SH_RC pull_encode( DataPtr& item );

    void  set_retrans( );
    // void  send_end();

public:
    RTPEncoderSH( SHGraphManager* mgr,
                  u_int32_t       runtimeId,
                  MNSelector&     sel );

    virtual ~RTPEncoderSH();
    void  send_end();

private:

    RTPEncoderSH( const RTPEncoderSH& );

    RTPEncoderSH& operator=( const RTPEncoderSH& );

public:
    virtual SH_RC initSH();
    virtual SH_RC uninitSH();

    virtual SH_RC startStreaming();
    virtual SH_RC stopStreaming();

    // Attributes have been moved to SH.h

public:
    SH_RC pause( );

    bool isEndReached() const;
    void setEndIsReached();

    /******************************************************************/
    /* functions required for Status                                */
    /******************************************************************/
protected:
    friend class RTPEncoderSinkEndpoint;
    friend class RTPEncoderSourceEndpoint;

    SinkEndpoint*                  _in_ep_a[1];
    SourceEndpoint*                _out_ep_a[1];
    RTPEncoderSinkEndpoint       _inEP;
    RTPEncoderSourceEndpoint     _outEP;

    void pushReport( ReportPtr report, Base::Direction d );

public:
    virtual SinkEndpoint**   getSinkSpecs();
    virtual SourceEndpoint** getSourceSpecs();

    virtual bool isConnected() const;

    void send_timer_callback( void* timer, TimerCallBase* ptr );

    void resend_timer_callback( void* timer, TimerCallBase* ptr );
    
    void notifyEndIsReached( void* timer, TimerCallBase* ptr);
};


}; // namespace SH

#endif /* MN_RTP_ENCODER_STREAM_HANDLER_H */

---