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 + csrc_count * sizeof (guint32)
  74       + payload_len + pad_len;
  75
  76   //g_return_val_if_fail(len < RTP_MTU, NULL);
  77
  78   packet = g_malloc (sizeof *packet);
  79
  80   packet->data_len = len;
  81   packet->data = g_malloc (len);
  82
  83   return (packet);
  84 }
  85
  86
  87 void
  88 rtp_packet_free (Rtp_Packet packet)
  89 {
  90   g_return_if_fail (packet != NULL);
  91
  92   g_free (packet->data);
  93   g_free (packet);
  94 }
  95
  96 /*Rtp_Packet
  97 rtp_packet_read(int fd, struct sockaddr *fromaddr, socklen_t *fromlen)
  98 {
  99   int packlen;
 100   gpointer buf;
 101
 102   buf = g_malloc(RTP_MTU);
 103
 104   packlen = recvfrom(fd, buf, RTP_MTU, 0, fromaddr, fromlen);
 105
 106   if (packlen < 0) {
 107     g_error("rtp_packet_read: recvfrom: %d %s", errno, strerror(errno));
 108     //exit(1);
 109     return NULL;
 110   }
 111
 112   return rtp_packet_new_take_data(buf, packlen);
 113 }*/
 114
 115 /*void
 116 rtp_packet_send(Rtp_Packet packet, int fd, struct sockaddr *toaddr, socklen_t tolen)
 117 {
 118   g_return_if_fail(packet != NULL);
 119
 120   sendto(fd, (void *) packet -> data,
 121          packet -> data_len, 0,
 122          toaddr, tolen);
 123 }*/
 124
 125 guint8
 126 rtp_packet_get_version (Rtp_Packet packet)
 127 {
 128   g_return_val_if_fail (packet != NULL, 0);
 129
 130   return ((Rtp_Header) packet->data)->version;
 131 }
 132
 133 void
 134 rtp_packet_set_version (Rtp_Packet packet, guint8 version)
 135 {
 136   g_return_if_fail (packet != NULL);
 137   g_return_if_fail (version < 0x04);
 138
 139   ((Rtp_Header) packet->data)->version = version;
 140 }
 141
 142 guint8
 143 rtp_packet_get_padding (Rtp_Packet packet)
 144 {
 145   g_return_val_if_fail (packet != NULL, 0);
 146
 147   return ((Rtp_Header) packet->data)->padding;
 148 }
 149
 150 void
 151 rtp_packet_set_padding (Rtp_Packet packet, guint8 padding)
 152 {
 153   g_return_if_fail (packet != NULL);
 154   g_return_if_fail (padding < 0x02);
 155
 156   ((Rtp_Header) packet->data)->padding = padding;
 157 }
 158
 159 guint8
 160 rtp_packet_get_csrc_count (Rtp_Packet packet)
 161 {
 162   g_return_val_if_fail (packet != NULL, 0);
 163
 164   return ((Rtp_Header) packet->data)->csrc_count;
 165 }
 166
 167 guint8
 168 rtp_packet_get_extension (Rtp_Packet packet)
 169 {
 170   g_return_val_if_fail (packet != NULL, 0);
 171
 172   return ((Rtp_Header) packet->data)->extension;
 173 }
 174
 175 void
 176 rtp_packet_set_extension (Rtp_Packet packet, guint8 extension)
 177 {
 178   g_return_if_fail (packet != NULL);
 179   g_return_if_fail (extension < 0x02);
 180
 181   ((Rtp_Header) packet->data)->extension = extension;
 182 }
 183
 184 void
 185 rtp_packet_set_csrc_count (Rtp_Packet packet, guint8 csrc_count)
 186 {
 187   g_return_if_fail (packet != NULL);
 188   g_return_if_fail (csrc_count < 0x04);
 189
 190   ((Rtp_Header) packet->data)->csrc_count = csrc_count;
 191 }
 192
 193 guint8
 194 rtp_packet_get_marker (Rtp_Packet packet)
 195 {
 196   g_return_val_if_fail (packet != NULL, 0);
 197
 198   return ((Rtp_Header) packet->data)->marker;
 199 }
 200
 201 void
 202 rtp_packet_set_marker (Rtp_Packet packet, guint8 marker)
 203 {
 204   g_return_if_fail (packet != NULL);
 205   g_return_if_fail (marker < 0x02);
 206
 207   ((Rtp_Header) packet->data)->marker = marker;
 208 }
 209
 210 guint8
 211 rtp_packet_get_payload_type (Rtp_Packet packet)
 212 {
 213   g_return_val_if_fail (packet != NULL, 0);
 214
 215   return ((Rtp_Header) packet->data)->payload_type;
 216 }
 217
 218 void
 219 rtp_packet_set_payload_type (Rtp_Packet packet, guint8 payload_type)
 220 {
 221   g_return_if_fail (packet != NULL);
 222   g_return_if_fail (payload_type < 0x80);
 223
 224   ((Rtp_Header) packet->data)->payload_type = payload_type;
 225 }
 226
 227 guint16
 228 rtp_packet_get_seq (Rtp_Packet packet)
 229 {
 230   g_return_val_if_fail (packet != NULL, 0);
 231
 232   return g_ntohs (((Rtp_Header) packet->data)->seq);
 233 }
 234
 235 void
 236 rtp_packet_set_seq (Rtp_Packet packet, guint16 seq)
 237 {
 238   g_return_if_fail (packet != NULL);
 239
 240   ((Rtp_Header) packet->data)->seq = g_htons (seq);
 241 }
 242
 243 guint32
 244 rtp_packet_get_timestamp (Rtp_Packet packet)
 245 {
 246   g_return_val_if_fail (packet != NULL, 0);
 247
 248   return g_ntohl (((Rtp_Header) packet->data)->timestamp);
 249 }
 250
 251 void
 252 rtp_packet_set_timestamp (Rtp_Packet packet, guint32 timestamp)
 253 {
 254   g_return_if_fail (packet != NULL);
 255
 256   ((Rtp_Header) packet->data)->timestamp = g_htonl (timestamp);
 257 }
 258
 259 guint32
 260 rtp_packet_get_ssrc (Rtp_Packet packet)
 261 {
 262   g_return_val_if_fail (packet != NULL, 0);
 263
 264   return g_ntohl (((Rtp_Header) packet->data)->ssrc);
 265 }
 266
 267 void
 268 rtp_packet_set_ssrc (Rtp_Packet packet, guint32 ssrc)
 269 {
 270   g_return_if_fail (packet != NULL);
 271
 272   ((Rtp_Header) packet->data)->ssrc = g_htonl (ssrc);
 273 }
 274
 275 guint
 276 rtp_packet_get_payload_len (Rtp_Packet packet)
 277 {
 278   guint len;
 279
 280   g_return_val_if_fail (packet != NULL, 0);
 281
 282   len = packet->data_len
 283       - RTP_HEADER_LEN - rtp_packet_get_csrc_count (packet) * sizeof (guint32);
 284
 285   if (rtp_packet_get_padding (packet)) {
 286     len -= ((guint8 *) packet->data)[packet->data_len - 1];
 287   }
 288
 289   return len;
 290 }
 291
 292 gpointer
 293 rtp_packet_get_payload (Rtp_Packet packet)
 294 {
 295   g_return_val_if_fail (packet != NULL, NULL);
 296
 297   return ((char *) packet->data)
 298       + RTP_HEADER_LEN + rtp_packet_get_csrc_count (packet) * sizeof (guint32);
 299 }
 300
 301 guint
 302 rtp_packet_get_packet_len (Rtp_Packet packet)
 303 {
 304   g_return_val_if_fail (packet != NULL, 0);
 305
 306   return packet->data_len;
 307 }