LCRetransRecv.h

Go to the documentation of this file.

#include "RetransRecvCommon.h"
#include "sh/SH.h"
#include "MNTimerCall.h"
#include "lcrtp/MNLCRTPLossList.h"
#include "sh/MNRTPDecoderSH.h"

namespace SH
{

class LossList : public RetransRecvCommon
{
    class TL : public TimerCall<LossList>
    {
        u_int32 _ssrc;
    public:
        TL( u_int32 ssrc,
        LossList* t,
        TimerCall<LossList>::callback cb )
        : TimerCall<LossList>( TimerCallBase::DontClean, t, cb )
        , _ssrc( ssrc )
        {
        }
        inline u_int32 getSsrc( ) const {
        return _ssrc;
        }

        inline void setSsrc( u_int32 s ) {
        _ssrc = s;
        }
    };
    
    bool              _isStreaming;

    RTPDecoderSH&     _pushReportInterface;
    MNMutex           _mutex;
public:
    MNTimer           _timer; // when the losslist will be resent
    MNTimer           _timeout_timer;
    MNLCRTPLossList*  _l;
    TL                _cb;
    TL                _timer_call;
    int32             _list_timeout;
    u_int32           _repeat_timeouts;
    lcstreamer_recv_t _StreamDesc;
    bool              _first_time;
    public:
    LossList( RTPDecoderSH* caller, MNSelector& sel );
    virtual ~LossList( );
    void init( int32 list_timeout, u_int32 repeat_timeouts );
    void uninit( );

    inline void startStreaming( ) {
        _isStreaming = true;
    }

    inline void stopStreaming( ) {
        _timer.terminate_timer( );
        _isStreaming = false;
    }
    void init_timeout( struct timeval& lossList_timeout );
    void insert_rel_timeout_timer( bool inCallback );
    void insert_lc_gap( u_int32 ssrc,
                        u_int64 from,
                        u_int64 to );
     bool schedule_send_list( u_int32 ssrc,
                              bool    inCallback );
    void schedule_retrans_timer( bool inCallback );
    void schedule_transtrans_timer_again( bool inCallback );
        inline void lock( ) {
        _mutex.lock( );
    }

    inline void unlock( ) {
        _mutex.unlock( );
    }
    bool process_lc_packet( u_int32 ssrc,
                            u_int64 bytecount,
                            int32   rd_len );
     int64 sendLossList( );
     void    evalLCRTCPPacket( u_int32 ssrc,
                               void*   data,
                               int     len,
                               int     subtype,
                               char*   name,
                               bool    inCallback );
      DataPtr evalLCRTPPacket( MNRTPPacketPtr packet,
                               MNRope*&       payload,
                               u_int64_t&     bytecount );
private:
    void timer_callback( void* ref_data, TimerCallBase* ptr );
    void timeout_callback( void* ref_data, TimerCallBase* ptr );
    
    inline bool isStreaming( ) const {
        return _isStreaming;
    }
private:
    LossList( const LossList& );
    LossList& operator=( const LossList& );
};

}; //namespace SH

---