MNRTPDecoderSH.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_DECODER_STREAM_HANDLER_H
#define MN_RTP_DECODER_STREAM_HANDLER_H

#include <sys/types.h>

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

class MNRTP;
class MNUDPSocket;
class MNRTPDecoderBase;
class RetransRecvBase;
class MNRope;

namespace SH
{

class RTPDecoderSH;
class RTPDecoderSinkEndpointSpec;
class RTPDecoderSourceEndpointSpec;
class RTPDecoderSinkEndpoint;
class RTPDecoderSourceEndpoint;

/**********************************************************************/
/* RTPDecoderSinkEndpoint                                           */
/**********************************************************************/

class RTPDecoderSinkEndpoint
    : public SinkEndpoint
{
public:
    RTPDecoderSinkEndpoint( RTPDecoderSH* mySH );
    virtual ~RTPDecoderSinkEndpoint( );

    virtual SH_RC push( DataPtr item );

    RTPDecoderSH* dsh();
};

/**********************************************************************/
/* RTPDecoderSourceEndpoint                                         */
/**********************************************************************/

class RTPDecoderSourceEndpoint
    : public SourceEndpoint
{
public:
    RTPDecoderSourceEndpoint( RTPDecoderSH* mySH );
    virtual ~RTPDecoderSourceEndpoint( );

    virtual SH_RC pull( DataPtr& item,
                        SourceUnit su = UnitDefault,
                        size_t amount = 0 );

    RTPDecoderSH* dsh();
};

class RTPDecoderSH
    : public Base
{
    MNRTPDecoderBase*    _codec;
    RetransRecvBase*     _retrans;

    SA_HAS_ORDERED_DATA     _hasOrderedData;
    //    SA_RTP_PAYLOAD_TYPES _payload_types;
    const SDP::PayloadTypeTable*      _payload_types;
    SA_RTP_RTP_PAYLOAD_TYPE _rtp_pt;
    SA_RTP_INT_PAYLOAD_TYPE _int_pt;
    SA_RTP_INT_RETRANS_TYPE _int_rt;  // indicates retransmission type
    
    //sequencenumber and time of the first RTP-packet to listen to
    SA_RTP_SEQ_LISTEN   _rtp_seq;
    SA_RTP_TIME_LISTEN  _rtp_time;

    /* Experimental for RTP timestamp synchronization */
    SA_IGNORE_SYNC_TIMESTAMP   _ignore_sync_ts;
    unsigned            _syncTimestamp;
    struct timeval      _syncTime;
    bool                _hasBeenSynced;
    
    MNRope*             _decodedDataRope;

    bool _gotFirstPacket;

    ProtectedVarEnum<streamer_state_t> _streamer_state;

    SH_RC verify_codec( );

    MNSelector& _sel;
    void  set_retrans( MNSelector& sel ); 
    

    /* Experimental for TFRC - MZ */
    MNTFRCRecv*       _tfrc;

public:
    void set_payload_types(const SDP::PayloadTypeTable* ptt_ptr);
  
    // SH_RC push_decode( MNRope* data, u_int32 payload_type );
    SH_RC push_decode( DataPtr  item );
    SH_RC pull_decode( DataPtr& item );

    DataPtr evalLCRTPPacket( MNRTPPacketPtr packet,
                             MNRope*&       payload,
                             u_int64_t&     bytecount );

    /* Experimental for TFRC - MZ */
    void    tfrc_packet_received( MNRope*& payload,
                                  MNRTPPacketPtr packet);
    void    send_feedback(u_int32 ssrc, LCfeedb_tfrc_t* reply);

    DataPtr evalRTPPacket( MNRTPPacketPtr packet,
                           MNRope*& payload,
                           u_int64_t& bytecount);
    void  evalSyncTimestamp(unsigned rtpTimestamp, struct timeval& resPT);

    void evalSyncRTCP(u_int32 ntp_upper, u_int32 ntp_lower, u_int32 rtpTimestamp);
    
    inline void resetSyncTime() { _syncTime.tv_sec = _syncTime.tv_usec = 0; }

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

    virtual ~RTPDecoderSH();

private:

    RTPDecoderSH( const RTPDecoderSH& );

    RTPDecoderSH& operator=( const RTPDecoderSH& );

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

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

    /******************************************************************/
    /* additional attributes for the set() functions                  */
    /******************************************************************/
public:
     // Attributes have been moved to SH.h

    /******************************************************************/
    /* functions required for SHStatus                                */
    /******************************************************************/
protected:
    friend class RTPDecoderSinkEndpoint;
    friend class RTPDecoderSourceEndpoint;

    friend class LossList;

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

    SinkEndpoint*                _in_ep_a[1];
    SourceEndpoint*              _out_ep_a[1];
    RTPDecoderSinkEndpoint       _inEP;
    RTPDecoderSourceEndpoint     _outEP;

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

    virtual bool isConnected() const  ;
};


}; // namespace SH

#endif /* MN_RTP_DECODER_STREAM_HANDLER_H */

---