MNRTPNetTypes.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_NET_TYPES_H
#define MN_RTP_NET_TYPES_H

#include <config.h>

#include <assert.h>
#include <sys/time.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <stdio.h>
#include <dlfcn.h>
#include <net/if.h>

#ifdef sun
#include <sys/sockio.h>
#include <arpa/inet.h>
#endif

#include "mnstream.h"
#include "var_type.h"
#include "protected_var_type.h"
#include "sdp/PayloadTypes.h"

/* RTP defs */

/*
 * Current protocol version.
 */
#define RTP_VERSION    2

#define RTP_MAX_SDES 255         /* maximum text length for SDES */

/* maximum misordered packet arrival.
 * If the Jump is greater than this, it is counted as a wrap
 * around (backward jump) / only needed in RTPList, as seq
 * misorder and wrap arounds should be processed by the app
 */
#define RTP_MAX_BACK_JUMP 3000

#define RTP_HDR_SIZE       12
#define RTPX_HDR_SIZE       4
#define RTCP_CMN_HDR_SIZE   4
#define RTCP_SR_HDR_SIZE   24
#define RTCP_RR_HDR_SIZE    4
#define RTCP_RRBLOCK_SIZE  24
#define RTCP_SDES_HDR_SIZE  4
#define RTCP_APP_HDR_SIZE   8
#define RTCP_APP_TFRC_SIZE 16 /* Experimental for TFRC integration - MZ */
#define RTCP_BYE_HDR_SIZE   4

enum rtcp_type_t
{
  RTCP_SR   = 200,
  RTCP_RR   = 201,
  RTCP_SDES = 202,
  RTCP_BYE  = 203,
  RTCP_APP  = 204
};

enum rtcp_sdes_type_t
{
  RTCP_SDES_END   = 0,
  RTCP_SDES_CNAME = 1,
  RTCP_SDES_NAME  = 2,
  RTCP_SDES_EMAIL = 3,
  RTCP_SDES_PHONE = 4,
  RTCP_SDES_LOC   = 5,
  RTCP_SDES_TOOL  = 6,
  RTCP_SDES_NOTE  = 7,
  RTCP_SDES_PRIV  = 8
};

/* Experimental for TFRC integration - MZ */
enum rtp_ext_hdr_type_t
{
  RTP_EXT_HDR_RT   = 211,
  RTP_EXT_HDR_LC   = 242,
  RTP_EXT_HDR_TFRC = 243
};

/**********************************************************************/
/* RTP packet in network byte order                                  */
/**********************************************************************/

/**********************************************************************/
struct rtp_hdr_t
{
#ifdef WORDS_BIGENDIAN

    unsigned int version:2;
    unsigned int p:1;
    unsigned int x:1;
    unsigned int cc:4;
    unsigned int m:1;
    unsigned int pt:7;
#else
    unsigned int cc:4;
    unsigned int x:1;
    unsigned int p:1;
    unsigned int version:2;
    unsigned int pt:7;
    unsigned int m:1;
#endif

    u_int16 seq;
    u_int32 ts;
    u_int32 ssrc;
    u_int32 csrc[1];

    int rate() const
    {
        return SDP::default_rate_from_pt( SDP::pt_from_int( pt ) );
    }

    u_int32 get_ssrc() const
    {
        return ntohl(ssrc);
    }

    u_int32 get_hdr_and_csrc_byte_size() const
    {
        return ( RTP_HDR_SIZE + cc * sizeof(u_int32) );
    }

    bool check_version() const;
};

struct rtp_hdr_ext
{
    u_int16 etype;
    u_int16 elen;
    u_int32 epayload[1];

    u_int32 get_ext_hdr_byte_size() const
    {
        return ( RTPX_HDR_SIZE + ntohs(elen) * sizeof(u_int32) );
    }
};

/* Experimental for TFRC integration - MZ */
//struct rtp_hdr_ext_tfrc : public rtp_hdr_ext
struct rtp_hdr_ext_tfrc
{
    u_int32 rtt;
    u_int32 bitrate;
    u_int32 lmr;
    u_int32 mode;
};

struct rtp_packet
{
  rtp_hdr_t *RTP_header;
  rtp_hdr_ext *RTP_Extension;
  char *payload;
  long payload_len;
};


/**********************************************************************/
/* RTCP packet in network byte order                                  */
/**********************************************************************/

struct text_item_t;

/**********************************************************************/
struct rtcp_common_t
{
#ifdef WORDS_BIGENDIAN

    unsigned int version:2;
    unsigned int p:1;
    unsigned int count:5;
#else
    unsigned int count:5;
    unsigned int p:1;
    unsigned int version:2;
#endif

    unsigned int pt:8;
    u_int16 length;
};

/**********************************************************************/
struct rtcp_rr_t
{
    u_int32 ssrc;

    unsigned int fraction:8;

    int lost:24;

    u_int32 last_seq;

    u_int32 jitter;

    u_int32 lsr;

    u_int32 dlsr;
};

/**********************************************************************/
struct rr_t
{
    u_int32 ssrc;

    rtcp_rr_t rr[1];
};

/**********************************************************************/
struct sr_t
{
    u_int32 ssrc;

    u_int32 ntp_sec;
    u_int32 ntp_frac;

    u_int32 rtp_ts;

    u_int32 psent;

    u_int32 osent;

    rtcp_rr_t rr[1];
};

/**********************************************************************/
struct rtcp_sdes_item_t
{
    u_int8 type;
    u_int8 length;
    char data[1];
};

/**********************************************************************/
struct rtcp_sdes_t
{
    u_int32          src;
    rtcp_sdes_item_t item[1];
};

/**********************************************************************/
struct app_t
{
    u_int32 ssrc;
    char name[4];
    char data[1];
};

/**********************************************************************/
struct bye_t
{
    u_int32 src[1];
    /* can't express trailing text for reason */
};

/**********************************************************************/
struct rtcp_t
{
    rtcp_common_t common;     /* common header */
    union
    {
        /* sender report (SR) */
        sr_t sr;
    
        /* reception report (RR) */
        rr_t rr;
    
        /* source description (SDES) */
        rtcp_sdes_t sdes;
    
        /* BYE */
        bye_t bye;

        /* APP */
        app_t app;
    } r;

    u_int16 get_length() const;

    size_t get_byte_length() const;

    size_t get_total_byte_length() const;

    size_t get_app_data_byte_length() const;

    size_t get_bye_text_byte_length() const;

    text_item_t* get_bye_text_ptr() const;

    u_int32 get_rr_ssrc() const;

    bool check_version() const;

    bool check_first_pt() const;
};

/**********************************************************************/
struct text_item_t
{
    u_int8 length;
    char   data[1];

    size_t init( const char* msg, size_t len )
    {
        length = len;

        // Text items must be padded to 32bit boundaries without
        // additional indication.
        // Add the length field first, because this may break the
        // alignment.
        len++;
        while ((len % sizeof(u_int32)) != 0) len++;

        // Initialize the data field, but don't forget to subtract
        // one for the length field.
        memset( data, 0, len-1 );
        memcpy( data, msg, length );
        return len;
    }
};

/**********************************************************************/
/* Convert between network byte order and host byte order             */
/**********************************************************************/

inline int32 hton24(int32 x);

inline int32 ntoh24(int32 x);

inline int64 htonll(int64 number);

inline int64 ntohll(int64 number);

#ifdef WORDS_BIGENDIAN
inline int32 hton24(int32 x)
{
    return x;
}

inline int32 ntoh24(int32 x)
{
    return x;
}

inline int64 htonll(int64 number)
{
  return number;
}

inline int64 ntohll(int64 number)
{
  return number;
}

#else /* WORDS_BIGENDIAN */

inline int32 hton24(int32 x)
{
    int32 ergebnis;

    ergebnis = (x & 0xFF00) | ( (x & 0xFF) << 16) | ( (x & 0xFF0000) >> 16);
    return ergebnis;
}

inline int32 ntoh24(int32 x)
{
    int32 ergebnis;

    ergebnis = (x & 0xFF00) | ( (x & 0xFF) << 16) | ( (x & 0xFF0000) >> 16);
    return ergebnis;
}

inline int64 htonll(int64 number)
{
  return ( htonl( (number >> 32) & 0xFFFFFFFF) |
          ((int64) (htonl(number & 0xFFFFFFFF))  << 32));
}

inline int64 ntohll(int64 number)
{
    return ( htonl( (number >> 32) & 0xFFFFFFFF) |
             ((int64) (htonl(number & 0xFFFFFFFF))  << 32));
}
#endif /* WORDS_BIGENDIAN */

#endif /* MN_RTP_NET_TYPES_H */

---