MNRTPPacket.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_PACKET_H
#define MN_RTP_PACKET_H

#include <assert.h>

#include "sh/SHData.h"
#include "MNArrayList.h"
#include "MNRTPNetTypes.h"
#include "MNRTPdefs.h"

class MNRope;

class MNRTPPacket;
class MNRTPHdrExt;

/**********************************************************************/
/* MNRTPPacket                                                        */
/**********************************************************************/

class MNRTPPacket : public SH::Data
{
    bool               _is_from_addr;

    struct sockaddr_in _addr;

    unsigned int version;

    // unsigned int p:1; /// Padding flag

    // unsigned int x:1; /// Header extension flag

    // unsigned int cc:4; /// CSRC (contributing source) count

    bool marker;

    unsigned int _payload_type;

    u_int16 seq;

    u_int32 timestamp;

    u_int32 ssrc;

    MNArrayList<u_int32> _csrc;

    MNRTPHdrExt* _ext;

    MNRope* _data;

public:
    enum DataDirection
    {
        To   = false,
        From = true
    };

private:
    void copy( const MNRTPPacket& orig );

    void copy( const rtp_hdr_t* pkt );

    void copy( const rtp_hdr_ext* xpkt );

    void copy( const struct sockaddr_in* addr,
               bool                      from_addr );

public:
    MNRTPPacket( MNRope*& data, bool consume_data );

    MNRTPPacket( const MNRTPPacket& orig );

    MNRTPPacket( const rtp_hdr_t*          pkt,
                 const rtp_hdr_ext*        xpkt,
                 MNRope*&                  data,
                 const struct sockaddr_in* addr,
                 bool                      from_addr );

    MNRTPPacket( MNRope*                   data,
                 const struct sockaddr_in* addr,
                 bool                      from_addr,
                 RTP_RC&                   retCode );

    MNRTPPacket& operator=( const MNRTPPacket& orig );

    virtual ~MNRTPPacket();

    virtual SH::DataPtr clone();

    virtual size_t getByteSize( ) const;

    virtual MNRTPHdrExt* parseHeaderExt( const rtp_hdr_ext* xpkt );

    bool check_version() const;

    u_int32 get_ssrc( ) const;

    int get_payload_type() const;

    u_int16 get_seq() const;

    int rate() const;

    u_int32 get_ts() const;

    size_t payload_length() const;

    const uchar_t* payload();

    MNRope* extract_payload();

    bool has_ext_hdr() const;

    u_int16        get_ext_hdr_byte_len() const;
    u_int16        get_ext_hdr_word_len() const;
    u_int16        get_ext_hdr_type() const;
    const uchar_t* get_ext_hdr_payload();
    
    virtual void set_data( MNRope* data );

    virtual void set_timestamp( u_int32 tstamp );

    virtual void set_markerbit( bool yesno = true );

    virtual u_int32 get_timestamp( );

    virtual bool get_markerbit( );

    virtual void set_ext_header( MNRTPHdrExt* exthdr );

    virtual bool isPlainData( )   const { return false; } 
    virtual bool isOrderedData( ) const { return false; } 
    virtual bool isRTPData( )     const { return true;  } 
    virtual bool isDummyData( )   const { return false; } 
      virtual bool isSHRTPData( ) const { return false; } 
};

/**********************************************************************/
/* MNRTPPacketPtr                                                     */
/**********************************************************************/

typedef SH::RPtr<MNRTPPacket> MNRTPPacketPtr;

/**********************************************************************/
/* MNRTPHdrExt                                                        */
/**********************************************************************/

class MNRTPHdrExt
{
protected:
    u_int16 _etype;
    MNRope* _edata;
private:
    void copy( const MNRTPHdrExt& orig );
    void copy( const rtp_hdr_ext* xpkt );

public:
    MNRTPHdrExt(  );
    MNRTPHdrExt( const MNRTPHdrExt& orig );
    MNRTPHdrExt( const rtp_hdr_ext* xpkt );
    MNRTPHdrExt( u_int16 type, MNRope*& data );

    virtual ~MNRTPHdrExt( );

    MNRTPHdrExt& operator=( const MNRTPHdrExt& orig );

    virtual MNRTPHdrExt* clone( );

    u_int16        get_byte_len() const;
    u_int16        get_word_len() const;
    u_int16        get_type() const;
    const uchar_t* get_payload();
};
/**********************************************************************/
/* MNLCRTPHdrExt                                                      */
/**********************************************************************/

class MNLCRTPHdrExt : public MNRTPHdrExt
{
public:
    MNLCRTPHdrExt ( u_int16 type, MNRope*& data );
};

/**********************************************************************/
/* MNTFRCRTPHdrExt - Experimental for TFRC - MZ                       */
/**********************************************************************/

struct tfrc_payload
{
    u_int32 nrtt;
    u_int32 nbitrate; 
    u_int32 nlmr; 
    u_int32 nmode; 
    u_int64 bytecount;
};

class MNTFRCRTPHdrExt : public MNRTPHdrExt
{
protected:
    tfrc_payload _pload;
public:
    MNTFRCRTPHdrExt ( u_int16 type, u_int32 rtt, u_int32 bitrate,
                      u_int32 lmr, u_int32 mode, u_int64 bytecount );
};
#endif /* MN_RTP_PACKET_H */

---