gst/rtp/rtp-packet.c

   1 /*
   2   Librtp - a library for the RTP/RTCP protocol
   3   Copyright (C) 2000  Roland Dreier
   4
   5   This program is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation; either version 2 of the License, or
   8   (at your option) any later version.
   9
  10   This program is distributed in the hope that it will be useful,
  11   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13   GNU General Public License for more details.
  14
  15   You should have received a copy of the GNU General Public License
  16   along with this program; if not, write to the Free Software
  17   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19   $Id$
  20 */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <errno.h>
  29 #include <sys/types.h>
  30 #include <netinet/in.h>
  31 #include <glib.h>
  32
  33 #include "rtp-packet.h"
  34
  35 Rtp_Packet
  36 rtp_packet_new_take_data(gpointer data, guint data_len)
  37 {
  38   Rtp_Packet packet;
  39
  40   //g_return_val_if_fail(data_len < RTP_MTU, NULL);
  41
  42   packet = g_malloc(sizeof *packet);
  43
  44   packet -> data = data;
  45   packet -> data_len = data_len;
  46
  47   return packet;
  48 }
  49
  50 Rtp_Packet
  51 rtp_packet_new_copy_data(gpointer data, guint data_len)
  52 {
  53   Rtp_Packet packet;
  54
  55   //g_return_val_if_fail(data_len < RTP_MTU, NULL);
  56
  57   packet = g_malloc(sizeof *packet);
  58
  59   packet -> data = g_memdup(data, data_len);
  60   packet -> data_len = data_len;
  61
  62   return packet;
  63 }
  64
  65 Rtp_Packet
  66 rtp_packet_new_allocate(guint payload_len, guint pad_len, guint csrc_count)
  67 {
  68   guint len;
  69   Rtp_Packet packet;
  70
  71   g_return_val_if_fail(csrc_count <= 15, NULL);
  72
  73   len = RTP_HEADER_LEN
  74     + csrc_count * sizeof(guint32)
  75     + payload_len + pad_len;
  76
  77   //g_return_val_if_fail(len < RTP_MTU, NULL);
  78
  79   packet = g_malloc(sizeof *packet);
  80
  81   packet -> data_len = len;
  82   packet -> data = g_malloc(len);
  83
  84   return(packet);
  85 }
  86
  87
  88 void
  89 rtp_packet_free(Rtp_Packet packet)
  90 {
  91   g_return_if_fail(packet != NULL);
  92
  93   g_free(packet -> data);
  94   g_free(packet);
  95 }
  96
  97 /*Rtp_Packet
  98 rtp_packet_read(int fd, struct sockaddr *fromaddr, socklen_t *fromlen)
  99 {
 100   int packlen;
 101   gpointer buf;
 102
 103   buf = g_malloc(RTP_MTU);
 104
 105   packlen = recvfrom(fd, buf, RTP_MTU, 0, fromaddr, fromlen);
 106
 107   if (packlen < 0) {
 108     g_error("rtp_packet_read: recvfrom: %d %s", errno, strerror(errno));
 109     //exit(1);
 110     return NULL;
 111   }
 112
 113   return rtp_packet_new_take_data(buf, packlen);
 114 }*/
 115
 116 /*void
 117 rtp_packet_send(Rtp_Packet packet, int fd, struct sockaddr *toaddr, socklen_t tolen)
 118 {
 119   g_return_if_fail(packet != NULL);
 120
 121   sendto(fd, (void *) packet -> data,
 122          packet -> data_len, 0,
 123          toaddr, tolen);
 124 }*/
 125
 126 guint8
 127 rtp_packet_get_version(Rtp_Packet packet)
 128 {
 129   g_return_val_if_fail(packet != NULL, 0);
 130
 131   return ((Rtp_Header) packet -> data) -> version;
 132 }
 133
 134 void
 135 rtp_packet_set_version(Rtp_Packet packet, guint8 version)
 136 {
 137   g_return_if_fail(packet != NULL);
 138   g_return_if_fail(version < 0x04);
 139
 140   ((Rtp_Header) packet -> data) -> version = version;
 141 }
 142
 143 guint8
 144 rtp_packet_get_padding(Rtp_Packet packet)
 145 {
 146   g_return_val_if_fail(packet != NULL, 0);
 147
 148   return ((Rtp_Header) packet -> data) -> padding;
 149 }
 150
 151 void
 152 rtp_packet_set_padding(Rtp_Packet packet, guint8 padding)
 153 {
 154   g_return_if_fail(packet != NULL);
 155   g_return_if_fail(padding < 0x02);
 156
 157   ((Rtp_Header) packet -> data) -> padding = padding;
 158 }
 159
 160 guint8
 161 rtp_packet_get_csrc_count(Rtp_Packet packet)
 162 {
 163   g_return_val_if_fail(packet != NULL, 0);
 164
 165   return ((Rtp_Header) packet -> data) -> csrc_count;
 166 }
 167
 168 guint8
 169 rtp_packet_get_extension(Rtp_Packet packet)
 170 {
 171   g_return_val_if_fail(packet != NULL, 0);
 172
 173   return ((Rtp_Header) packet -> data) -> extension;
 174 }
 175
 176 void
 177 rtp_packet_set_extension(Rtp_Packet packet, guint8 extension)
 178 {
 179   g_return_if_fail(packet != NULL);
 180   g_return_if_fail(extension < 0x02);
 181
 182   ((Rtp_Header) packet -> data) -> extension = extension;
 183 }
 184
 185 void
 186 rtp_packet_set_csrc_count(Rtp_Packet packet, guint8 csrc_count)
 187 {
 188   g_return_if_fail(packet != NULL);
 189   g_return_if_fail(csrc_count < 0x04);
 190
 191   ((Rtp_Header) packet -> data) -> csrc_count = csrc_count;
 192 }
 193
 194 guint8
 195 rtp_packet_get_marker(Rtp_Packet packet)
 196 {
 197   g_return_val_if_fail(packet != NULL, 0);
 198
 199   return ((Rtp_Header) packet -> data) -> marker;
 200 }
 201
 202 void
 203 rtp_packet_set_marker(Rtp_Packet packet, guint8 marker)
 204 {
 205   g_return_if_fail(packet != NULL);
 206   g_return_if_fail(marker < 0x02);
 207
 208   ((Rtp_Header) packet -> data) -> marker = marker;
 209 }
 210
 211 guint8
 212 rtp_packet_get_payload_type(Rtp_Packet packet)
 213 {
 214   g_return_val_if_fail(packet != NULL, 0);
 215
 216   return ((Rtp_Header) packet -> data) -> payload_type;
 217 }
 218
 219 void
 220 rtp_packet_set_payload_type(Rtp_Packet packet, guint8 payload_type)
 221 {
 222   g_return_if_fail(packet != NULL);
 223   g_return_if_fail(payload_type < 0x80);
 224
 225   ((Rtp_Header) packet -> data) -> payload_type = payload_type;
 226 }
 227
 228 guint16
 229 rtp_packet_get_seq(Rtp_Packet packet)
 230 {
 231   g_return_val_if_fail(packet != NULL, 0);
 232
 233   return g_ntohs(((Rtp_Header) packet -> data) -> seq);
 234 }
 235
 236 void
 237 rtp_packet_set_seq(Rtp_Packet packet, guint16 seq)
 238 {
 239   g_return_if_fail(packet != NULL);
 240
 241   ((Rtp_Header) packet -> data) -> seq = g_htons(seq);
 242 }
 243
 244 guint32
 245 rtp_packet_get_timestamp(Rtp_Packet packet)
 246 {
 247   g_return_val_if_fail(packet != NULL, 0);
 248
 249   return g_ntohl(((Rtp_Header) packet -> data) -> timestamp);
 250 }
 251
 252 void
 253 rtp_packet_set_timestamp(Rtp_Packet packet, guint32 timestamp)
 254 {
 255   g_return_if_fail(packet != NULL);
 256
 257   ((Rtp_Header) packet -> data) -> timestamp = g_htonl(timestamp);
 258 }
 259
 260 guint32
 261 rtp_packet_get_ssrc(Rtp_Packet packet)
 262 {
 263   g_return_val_if_fail(packet != NULL, 0);
 264
 265   return g_ntohl(((Rtp_Header) packet -> data) -> ssrc);
 266 }
 267
 268 void
 269 rtp_packet_set_ssrc(Rtp_Packet packet, guint32 ssrc)
 270 {
 271   g_return_if_fail(packet != NULL);
 272
 273   ((Rtp_Header) packet -> data) -> ssrc = g_htonl(ssrc);
 274 }
 275
 276 guint
 277 rtp_packet_get_payload_len(Rtp_Packet packet)
 278 {
 279   guint len;
 280
 281   g_return_val_if_fail(packet != NULL, 0);
 282
 283   len = packet -> data_len
 284     - RTP_HEADER_LEN
 285     - rtp_packet_get_csrc_count(packet) * sizeof(guint32);
 286
 287   if (rtp_packet_get_padding(packet)) {
 288     len -= ((guint8 *) packet -> data)[packet -> data_len - 1];
 289   }
 290
 291   return len;
 292 }
 293
 294 gpointer
 295 rtp_packet_get_payload(Rtp_Packet packet)
 296 {
 297   g_return_val_if_fail(packet != NULL, NULL);
 298
 299   return ((char *) packet -> data)
 300     + RTP_HEADER_LEN
 301     + rtp_packet_get_csrc_count(packet) * sizeof(guint32);
 302 }
 303
 304 guint
 305 rtp_packet_get_packet_len(Rtp_Packet packet)
 306 {
 307   g_return_val_if_fail(packet != NULL, 0);
 308
 309   return packet -> data_len;
 310 }