MNRTCPPacket.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_RTCP_PACKET_H
#define MN_RTCP_PACKET_H

#include <config.h>

#include <assert.h>

#include "sh/SHData.h"
#include "MNArrayList.h"
#include "MNRTPNetTypes.h"
#include "MNRTPdefs.h"
#include "MNRTPtime.h"
#include "var_type.h"
#include "sh/SHReport.h"

/***********************************************************************
 * MNRTCPPacket
 ***********************************************************************/

class MNRTCPPacket : public SH::Report
{
    unsigned int version:2;

    unsigned int p:1;

    unsigned int count:5;    // this is the subtype!!!!

    unsigned int pt:8;

    u_int16 length;

private:
    MNRTCPPacket( const MNRTCPPacket& orig );
    MNRTCPPacket& operator=( const MNRTCPPacket& orig );

protected:
    MNRTCPPacket( )
    { }

public:
    MNRTCPPacket( unsigned int pt_ );

    virtual ~MNRTCPPacket();

    virtual bool isA( SH::Report::ID id ) const; 
    static SH::Report::ID Id;                    

    void init( unsigned int pt_ );

    u_int8              getCount( ) const;
    void                setCount( u_int8 cnt );
    void                setLength( unsigned int len );
    inline unsigned int getLength() const { return length; };
    inline unsigned int getType() const   { return pt; };

    virtual void write_to_buffer( u_int8* buffer, size_t len ) const;
    virtual void dump( ostream& ostr ) const;
};

/***********************************************************************
 * MNRTCPPacket_SR
 ***********************************************************************/

class MNRTCPPacket_SR
    : public MNRTCPPacket
{
    friend class MNRTCP;
    friend class MNRTCPPacket;

    u_int32 _ssrc;

    u_int32 _ntp_sec;
    u_int32 _ntp_frac;

    u_int32 _rtp_ts;

    u_int32 _psent;

    u_int32 _osent;

private:
    MNRTCPPacket_SR( const MNRTCPPacket_SR& orig );
    MNRTCPPacket_SR& operator=( const MNRTCPPacket_SR& orig );

protected:
    MNRTCPPacket_SR( )
    { }

public:
    MNRTCPPacket_SR( u_int16      count,
                     u_int32      ssrc,
                     const ntp64& now,
                     u_int32      rtp_timestamp,
                     u_int32      packets_sent,
                     u_int32      octets_sent );

    void init( u_int16      count,
               u_int32      ssrc,
               const ntp64& now,
               u_int32      rtp_timestamp,
               u_int32      packets_sent,
               u_int32      octets_sent );

    virtual bool isA( SH::Report::ID id ) const; 
    static SH::Report::ID Id;                    

    virtual void write_to_buffer( u_int8* buffer, size_t len ) const;
    virtual void dump( ostream& ostr ) const;

    u_int32 getNTPUpper() { return _ntp_sec;}
    u_int32 getNTPLower() { return _ntp_frac;}
    u_int32 getRTPTimestamp() {return _rtp_ts;}
};

/***********************************************************************
 * MNRTCPPacket_RR
 ***********************************************************************/

class MNRTCPPacket_RR
    : public MNRTCPPacket
{
    friend class MNRTCP;
    friend class MNRTCPPacket;

    u_int32 _ssrc;
    unsigned int fraction;
    int          lost;
    u_int32      last_seq;
    u_int32      jitter;
    u_int32      lsr;
    u_int32      dlsr;

private:
    MNRTCPPacket_RR( const MNRTCPPacket_RR& orig );
    MNRTCPPacket_RR& operator=( const MNRTCPPacket_RR& orig );

protected:
    MNRTCPPacket_RR( )
    { }

public:
    MNRTCPPacket_RR( u_int16 count,
                     u_int32 ssrc );
    MNRTCPPacket_RR( rtcp_rr_t report );

    void init( u_int16 count,
               u_int32 ssrc );

    virtual bool isA( SH::Report::ID id ) const; 
    static SH::Report::ID Id;                    

    virtual void write_to_buffer( u_int8* buffer, size_t len ) const;
    virtual void dump( ostream& ostr ) const;
};

/***********************************************************************
 * MNRTCPPacket_APP
 ***********************************************************************/

class MNRTCPPacket_APP
    : public MNRTCPPacket
{
    friend class MNRTCP;
    friend class MNRTCPPacket;

    u_int32 _ssrc;
    char    _name[4];
    u_int32*_payload;
    
private:
    MNRTCPPacket_APP( const MNRTCPPacket_APP& orig );
    MNRTCPPacket_APP& operator=( const MNRTCPPacket_APP& orig );

protected:
    MNRTCPPacket_APP ( )
    { }

public:
    MNRTCPPacket_APP( u_int8     subtype,
                      u_int16    nb_byte_pl, 
                      u_int32    ssrc,
                      const char* name,
                      u_int32*    pl );

    void init ( u_int8     subtype,
                u_int16    nb_byte_pl, 
                u_int32    ssrc,
                const char* name,
                u_int32*    pl );

    virtual bool isA( SH::Report::ID id ) const; 
    static SH::Report::ID Id;                    

    virtual ~MNRTCPPacket_APP( );

    virtual void write_to_buffer( u_int8* buffer, size_t len ) const;
    u_int32      getSSrc() { return _ssrc; };
    char*        getName() { return _name; };
    u_int32*     getPayload() {return _payload;};

   virtual void dump( ostream& ostr ) const;
};

/***********************************************************************
 * MNRTCPPacket_SDES
 ***********************************************************************/

class MNRTCPPacket_SDES
    : public MNRTCPPacket
{
    friend class MNRTCP;
    friend class MNRTCPPacket;

    u_int32 _src;

private:
    MNRTCPPacket_SDES( const MNRTCPPacket_SDES& orig );
    MNRTCPPacket_SDES& operator=( const MNRTCPPacket_SDES& orig );

protected:
    MNRTCPPacket_SDES( )
    { }

public:
    MNRTCPPacket_SDES( u_int16 sdes_length,
                       u_int32 ssrc );

    void init( u_int16 sdes_length,
               u_int32 ssrc );

    virtual bool isA( SH::Report::ID id ) const; 
    static SH::Report::ID Id;                    

    virtual void write_to_buffer( u_int8* buffer, size_t len ) const;
    virtual void dump( ostream& ostr ) const;
};

ostream& operator<<( ostream& ostr, const MNRTCPPacket& sr );

#endif /* MN_RTCP_PACKET_H */

---