SendBlockSH.h

Go to the documentation of this file.

/* Copyright (C) 2002 Carsten Griwodz
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, this code may be used in unmodified form
 * provided that this copyright notice and this permission notice appear
 * in supporting documentation.
 *
 * The code may be made subject to the terms of the GNU General Public
 * License, Version 2, and re-distributed under the terms of this license.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after negotiation of conditions with the authors.
 */
#ifndef SEND_BLOCK_SH_H
#define SEND_BLOCK_SH_H

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

#include "SH.h"
#include "SHEndpoint.h"
#include "SHEndpointSpec.h"
#include "DummyLayerSourceSH.h"
#include "MNTimerCall.h"
#include "var_type.h"
#include "MNRTPutildefs.h"
#include "MNLCRTPdefs.h"
#include "MNLCRTPLossList.h"
#include "MNTFRCSend.h"
#include "sdp/PayloadTypes.h"
#include "sdp/PayloadTypeEntry.h"
#include "MNTimeval.h"
#include "DummyList.h"
#include "var_type.h"
#include "var_type.h"
#include "MNRTPcallback.h"
#include "sh/SHData.h"
#include "MNValid.h"
#include "MNTimeval.h"

#define CLOCKRATE       8000
#define LayerDummy_BANDWIDTH  8000
#define RTP_NAME   "LCTZ"
#define TIMED_OUT  200
#define PACK_SIZE  512

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

namespace SH
{

class SendBlockSH;

class SendBlockSH
    : public Base
{
public:
    SendBlockSH( SHGraphManager* mgr,
                 u_int32_t       runtimeId,
                 MNSelector&     sel );

    virtual ~SendBlockSH();

    SH_RC getPos ( long &pos );

private:

    SendBlockSH( const SendBlockSH& );

    SendBlockSH& operator=( const SendBlockSH& );

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

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

    /******************************************************************/
    /* additional attributes for the set() functions                  */
    /******************************************************************/
private:
    DummyLayerSourceSH        _dls;

public:
    SA_RTP_MAX_PACKET_SIZE    _max_packet_size;
    SA_RTP_RTP_PAYLOAD_TYPE   _rtp_pt;
    SA_RTP_INT_PAYLOAD_TYPE   _int_pt;
    SA_RTP_INT_RETRANS_TYPE   _int_rt;
    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;
    SA_FILE_NAME              _filename;
    SA_FILESRC_START_POS      _start_pos;
    SA_FILESRC_STOP_POS       _stop_pos;
    SA_PUSH_PULL_INITIAL_FILL _initial_fill;
    SA_RTPSNK_RTP_SOCK_PORT   _rtp_socket;
    SA_RTPSNK_RTCP_SOCK_PORT  _rtcp_socket;
    SA_RTPSNK_CLIENT_NAME     _client;
    SA_RTPSNK_CLIENT_PORT     _port;

    // Attributes haved been moved to SH.h

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

    /******************************************************************/
    /* functions required for SHStatus                                */
    /******************************************************************/
    virtual bool isConnected() const;

private:
    // bool      _initialized; ///< check if initSH has already been called
    // u_int64_t _bytes_read;  ///< pseudo byte pos in pseudo file
    // u_int64_t _bytes_sent;  ///< number of bytes sent
    // u_int32_t _cnt;         ///< sent packet counter for debug output
    // u_int32_t _null_cnt;    ///< number of times pulled from empty queue

    // u_int32_t _duration;    ///< duration in seconds
    // u_int32_t _blk_sz;      ///< block size
    // u_int32_t _bw;          ///< bandwidth

    // DummyList _entries;

private:
    // from RTPSinkSH

    MNRTP*  _rtp;
    u_int16 _rtp_seq;
    u_int32 _rtp_time;
    int     _file_handle;

    SH_RC push_to_net( DataPtr item );

    virtual u_int16 get_rtp_seq();
    virtual u_int32 get_rtp_time(); 
public:
    virtual u_int32 get_ssrc(); 

private:
    // from EncLayerDummy

    bool        _first_run;
    Timeval     _first_pull;
    SH::DataPtr _last_data_ptr;

    MNRope* get_data( size_t          max_bytes_to_pull,
                      SH::ReturnCode&   except,
                      size_t&         pulled_bytes,
                      bool&           rtp_marker,
                      u_int32&        rtp_timestamp,
                      Timeval&        next_playtime_packet,
                      int             bandwidth,
                      u_int32         filepos  );

    MNRope* get_next_data( size_t            max_bytes_to_pull,
                           SH::ReturnCode&   except,
                           size_t&           pulled_bytes,
                           bool&             rtp_marker,
                           u_int32&          rtp_timestamp,
                           Timeval&          next_playtime_packet,
                           int               bandwidth );

    virtual u_int32_t get_std_bw( int fd );
    virtual int       get_timer_type( );

private:
    // from RTPEncoderSH

    int                     _fd;
    MNTimer                 _timer;
    Timeval                 _last_playtime_packet;  
    TimerCall<SendBlockSH> _cb;
    TimerCall<SendBlockSH> _resend_cb;
    struct timeval          _media_time;
    MNMutex                 _block_pull;
    bool                    _resync_required;
    u_int64                 _offset;
    struct timeval          _construction_time;
    struct timeval          _pause_time;
    struct timeval          _delta_paused;
    MNTFRCSend*             _tfrc;
    MNMutex                 _tfrc_mutex;
    MediaState              _streamer_state;
    struct timeval          _timeneu;
    MNMutex                 _send_mutex;
    MNTimer                 _resend_timer;
    Timeval                 _resend_timeout;
    ProtectedInt32          _end_timeout;
    ProtectedU_int32        _repeat_timeouts;
    lcstreamer_send_t       _StreamData;
    bool                    _isEndReached;

    SH_RC verify_codec( );
    void  evalLCRTCPPacket( u_int32 ssrc,
                            void*   data,
                            int     len,
                            int     subtype,
                            char*   name,
                            bool    inCallback );
    SH_RC pull_encode( DataPtr& item );
    void  send_end();
public:
    SH_RC pause( );
    bool  isEndReached() const;
    void  setEndIsReached();
    void  send_timer_callback( void* timer, TimerCallBase* ptr );
    void  resend_timer_callback( void* timer, TimerCallBase* ptr );

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

private:
    // from MNRTPEncoderBase
    size_t _std_packet_length;
    size_t _cur_packet_length;
    Timeval _cur_time_offset;
    size_t  _cur_rtp_timestamp_offset;
    enum timer_type
    {
        TT_PERIODIC,
        TT_DYNAMIC
    };
    size_t get_std_packetsize() const;
    void   set_std_packetsize( size_t sz );
    size_t get_packetsize() const;
    Timeval get_timeout( ) const;
    size_t get_ts_offset() const;
    void   set_ts_offset( size_t ts );

private:
    // from MNRTPEncoderCommon
    Timeval _std_time_offset;
    size_t _total_bytes_read;
    size_t _absolute_byte_position;
    size_t  _accum_rtp_timestamp;
    size_t  _pulled_bytes;

    Timeval get_std_timeout() const;
    void    set_std_timeout( size_t pause );
    void           inc_total_bytes_read( size_t sz );
    size_t         get_total_bytes_read( ) const;
    virtual size_t get_abs_byte_pos() const;
    void           inc_abs_byte_pos( size_t sz );
    size_t         get_accum_rtp_ts() const;
    void           inc_accum_rtp_ts( size_t sz );
    virtual void   update_absolute_position( int32 offset );
    size_t         get_pulled_bytes();

private:
    // from LCRetrans
    MNRope* createExtensionHeaderData( );
};


}; // namespace SH

#endif /* SEND_BLOCK_SH_H */

---