/* GStreamer

 * Copyright (C) <2005> Philippe Khalaf <burger@speedy.org>

 * Copyright (C) <2006> Wim Taymans <wim@fluendo.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/**

 * SECTION:gstrtpbuffer

 * @short_description: Helper methods for dealing with RTP buffers

 * @see_also: #GstBaseRTPPayload, #GstBaseRTPDepayload, gstrtcpbuffer

 *

 * <refsect2>

 * <para>

 * The GstRTPBuffer helper functions makes it easy to parse and create regular 

 * #GstBuffer objects that contain RTP payloads. These buffers are typically of

 * 'application/x-rtp' #GstCaps.

 * </para>

 * </refsect2>

 *

 * Last reviewed on 2006-07-17 (0.10.10)

 */

#include "gstrtpbuffer.h"

#include <stdlib.h>

#include <string.h>

#define GST_RTP_HEADER_LEN 12

/* Note: we use bitfields here to make sure the compiler doesn't add padding

 * between fields on certain architectures; can't assume aligned access either

 */

typedef struct _GstRTPHeader

{

#if G_BYTE_ORDER == G_LITTLE_ENDIAN

  unsigned int csrc_count:4;    /* CSRC count */

  unsigned int extension:1;     /* header extension flag */

  unsigned int padding:1;       /* padding flag */

  unsigned int version:2;       /* protocol version */

  unsigned int payload_type:7;  /* payload type */

  unsigned int marker:1;        /* marker bit */

#elif G_BYTE_ORDER == G_BIG_ENDIAN

  unsigned int version:2;       /* protocol version */

  unsigned int padding:1;       /* padding flag */

  unsigned int extension:1;     /* header extension flag */

  unsigned int csrc_count:4;    /* CSRC count */

  unsigned int marker:1;        /* marker bit */

  unsigned int payload_type:7;  /* payload type */

#else

#error "G_BYTE_ORDER should be big or little endian."

#endif

  unsigned int seq:16;          /* sequence number */

  unsigned int timestamp:32;    /* timestamp */

  unsigned int ssrc:32;         /* synchronization source */

  guint8 csrclist[4];           /* optional CSRC list, 32 bits each */

} GstRTPHeader;

    ((i) * sizeof(guint32))

/**

 * gst_rtp_buffer_allocate_data:

 * @buffer: a #GstBuffer

 * @payload_len: the length of the payload

 * @pad_len: the amount of padding

 * @csrc_count: the number of CSRC entries

 *

 * Allocate enough data in @buffer to hold an RTP packet with @csrc_count CSRCs,

 * a payload length of @payload_len and padding of @pad_len.

 * MALLOCDATA of @buffer will be overwritten and will not be freed. 

 * All other RTP header fields will be set to 0/FALSE.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_rtp_buffer_allocate_data (GstBuffer * buffer, guint payload_len,

    guint8 pad_len, guint8 csrc_count)

{

  guint len;

  g_return_if_fail (csrc_count <= 15);

  g_return_if_fail (GST_IS_BUFFER (buffer));

  len = GST_RTP_HEADER_LEN + csrc_count * sizeof (guint32)

      + payload_len + pad_len;

  GST_BUFFER_SIZE (buffer) = len;

  /* fill in defaults */

      csrc_count * sizeof (guint32));

}

/**

 * gst_rtp_buffer_new_take_data:

 * @data: data for the new buffer

 * @len: the length of data

 *

 * Create a new buffer and set the data and size of the buffer to @data and @len

 * respectively. @data will be freed when the buffer is unreffed, so this

 * function transfers ownership of @data to the new buffer.

 *

 * Returns: A newly allocated buffer with @data and of size @len.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstBuffer *

gst_rtp_buffer_new_take_data (gpointer data, guint len)

{

  GstBuffer *result;

  g_return_val_if_fail (data != NULL, NULL);

  g_return_val_if_fail (len > 0, NULL);

  result = gst_buffer_new ();

  GST_BUFFER_MALLOCDATA (result) = data;

  GST_BUFFER_DATA (result) = data;

  GST_BUFFER_SIZE (result) = len;

  return result;

}

/**

 * gst_rtp_buffer_new_copy_data:

 * @data: data for the new buffer

 * @len: the length of data

 *

 * Create a new buffer and set the data to a copy of @len

 * bytes of @data and the size to @len. The data will be freed when the buffer

 * is freed.

 *

 * Returns: A newly allocated buffer with a copy of @data and of size @len.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstBuffer *

gst_rtp_buffer_new_copy_data (gpointer data, guint len)

{

  return gst_rtp_buffer_new_take_data (g_memdup (data, len), len);

}

/**

 * gst_rtp_buffer_new_allocate:

 * @payload_len: the length of the payload

 * @pad_len: the amount of padding

 * @csrc_count: the number of CSRC entries

 *

 * Allocate a new #Gstbuffer with enough data to hold an RTP packet with @csrc_count CSRCs,

 * a payload length of @payload_len and padding of @pad_len.

 * All other RTP header fields will be set to 0/FALSE.

 *

 * Returns: A newly allocated buffer that can hold an RTP packet with given

 * parameters.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstBuffer *

gst_rtp_buffer_new_allocate (guint payload_len, guint8 pad_len,

    guint8 csrc_count)

{

  GstBuffer *result;

  g_return_val_if_fail (csrc_count <= 15, NULL);

  result = gst_buffer_new ();

  gst_rtp_buffer_allocate_data (result, payload_len, pad_len, csrc_count);

  return result;

}

/**

 * gst_rtp_buffer_new_allocate_len:

 * @packet_len: the total length of the packet

 * @pad_len: the amount of padding

 * @csrc_count: the number of CSRC entries

 *

 * Create a new #GstBuffer that can hold an RTP packet that is exactly

 * @packet_len long. The length of the payload depends on @pad_len and

 * @csrc_count and can be calculated with gst_rtp_buffer_calc_payload_len().

 * All RTP header fields will be set to 0/FALSE.

 *

 * Returns: A newly allocated buffer that can hold an RTP packet of @packet_len.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstBuffer *

gst_rtp_buffer_new_allocate_len (guint packet_len, guint8 pad_len,

    guint8 csrc_count)

{

  guint len;

  g_return_val_if_fail (csrc_count <= 15, NULL);

  len = gst_rtp_buffer_calc_payload_len (packet_len, pad_len, csrc_count);

  return gst_rtp_buffer_new_allocate (len, pad_len, csrc_count);

}

/**

 * gst_rtp_buffer_calc_header_len:

 * @csrc_count: the number of CSRC entries

 *

 * Calculate the header length of an RTP packet with @csrc_count CSRC entries.

 * An RTP packet can have at most 15 CSRC entries.

 *

 * Returns: The length of an RTP header with @csrc_count CSRC entries.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

guint

gst_rtp_buffer_calc_header_len (guint8 csrc_count)

{

  g_return_val_if_fail (csrc_count <= 15, 0);

  return GST_RTP_HEADER_LEN + (csrc_count * sizeof (guint32));

}

/**

 * gst_rtp_buffer_calc_packet_len:

 * @payload_len: the length of the payload

 * @pad_len: the amount of padding

 * @csrc_count: the number of CSRC entries

 *

 * Calculate the total length of an RTP packet with a payload size of @payload_len,

 * a padding of @pad_len and a @csrc_count CSRC entries.

 *

 * Returns: The total length of an RTP header with given parameters.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

guint

gst_rtp_buffer_calc_packet_len (guint payload_len, guint8 pad_len,

    guint8 csrc_count)

{

  g_return_val_if_fail (csrc_count <= 15, 0);

  return payload_len + GST_RTP_HEADER_LEN + (csrc_count * sizeof (guint32))

      + pad_len;

}

/**

 * gst_rtp_buffer_calc_payload_len:

 * @packet_len: the length of the total RTP packet

 * @pad_len: the amount of padding

 * @csrc_count: the number of CSRC entries

 *

 * Calculate the length of the payload of an RTP packet with size @packet_len,

 * a padding of @pad_len and a @csrc_count CSRC entries.

 *

 * Returns: The length of the payload of an RTP packet  with given parameters.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

guint

gst_rtp_buffer_calc_payload_len (guint packet_len, guint8 pad_len,

    guint8 csrc_count)

{

  g_return_val_if_fail (csrc_count <= 15, 0);

  return packet_len - GST_RTP_HEADER_LEN - (csrc_count * sizeof (guint32))

      - pad_len;

}

/**

 * @data: the data to validate

 * @len: the length of @data to validate

 *

 *

 */

{

  guint8 padding;

  guint8 csrc_count;

  guint header_len;

  guint8 version;

  g_return_val_if_fail (data != NULL, FALSE);

  header_len = GST_RTP_HEADER_LEN;

  if (G_UNLIKELY (len < header_len))

    goto wrong_length;

  /* check version */

    goto wrong_version;

  /* calc header length with csrc */

  csrc_count = (data[0] & 0x0f);

  header_len += csrc_count * sizeof (guint32);

  /* calc extension length when present. */

  if (data[0] & 0x10) {

    guint8 *extpos;

    guint16 extlen;

    /* this points to the extenstion bits and header length */

    extpos = &data[header_len];

    /* skip the header and check that we have enough space */

    header_len += 4;

    if (G_UNLIKELY (len < header_len))

      goto wrong_length;

    /* skip id */

    extpos += 2;

    /* read length as the number of 32 bits words */

    extlen = GST_READ_UINT16_BE (extpos);

    header_len += extlen * sizeof (guint32);

  }

  /* check for padding */

    padding = 0;

    goto wrong_padding;

  return TRUE;

  /* ERRORS */

wrong_length:

  {

    GST_DEBUG ("len < header_len check failed (%d < %d)", len, header_len);

    return FALSE;

  }

wrong_version:

  {

    GST_DEBUG ("version check failed (%d != %d)", version, GST_RTP_VERSION);

    return FALSE;

  }

wrong_padding:

  {

    GST_DEBUG ("padding check failed (%d - %d < %d)", len, header_len, padding);

    return FALSE;

  }

}

/**

 * gst_rtp_buffer_validate:

 * @buffer: the buffer to validate

 *

 * Check if the data pointed to by @buffer is a valid RTP packet using

 *

 * Returns: TRUE if @buffer is a valid RTP packet.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gboolean

gst_rtp_buffer_validate (GstBuffer * buffer)

{

  guint8 *data;

  guint len;

  g_return_val_if_fail (GST_IS_BUFFER (buffer), FALSE);

  data = GST_BUFFER_DATA (buffer);

  len = GST_BUFFER_SIZE (buffer);