/* GStreamer

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

 *

 * gstrtcpbuffer.h: various helper functions to manipulate buffers

 *     with RTCP payload.

 *

 * 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:gstrtcpbuffer

 * @short_description: Helper methods for dealing with RTCP buffers

 * @see_also: #GstBaseRTPPayload, #GstBaseRTPDepayload, #gstrtpbuffer

 *

 * Note: The API in this module is not yet declared stable.

 *

 * <refsect2>

 * <para>

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

 * #GstBuffer objects that contain compound RTCP packets. These buffers are typically

 * of 'application/x-rtcp' #GstCaps.

 * </para>

 * <para>

 * An RTCP buffer consists of 1 or more #GstRTCPPacket structures that you can

 * retrieve with gst_rtcp_buffer_get_first_packet(). #GstRTCPPacket acts as a pointer

 * gst_rtcp_packet_move_to_next().

 * </para>

 * </refsect2>

 *

 *

 */

#include <string.h>

#include "gstrtcpbuffer.h"

/**

 * gst_rtcp_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_rtcp_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_rtcp_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_rtcp_buffer_new_copy_data (gpointer data, guint len)

{

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

}

/**

 * gst_rtcp_buffer_validate_data:

 * @data: the data to validate

 * @len: the length of @data to validate

 *

 * Check if the @data and @size point to the data of a valid RTCP (compound)

 * packet. 

 * Use this function to validate a packet before using the other functions in

 * this module.

 *

 * Returns: TRUE if the data points to a valid RTCP packet.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gboolean

gst_rtcp_buffer_validate_data (guint8 * data, guint len)

{

  guint16 header_mask;

  guint16 header_len;

  guint8 version;

  guint data_len;

  gboolean padding;

  guint8 pad_bytes;

  g_return_val_if_fail (data != NULL, FALSE);

  /* we need 4 bytes for the type and length */

  if (G_UNLIKELY (len < 4))

    goto wrong_length;

  /* first packet must be RR or SR  and version must be 2 */

  header_mask = ((data[0] << 8) | data[1]) & GST_RTCP_VALID_MASK;

  if (G_UNLIKELY (header_mask != GST_RTCP_VALID_VALUE))

    goto wrong_mask;

  /* no padding when mask succeeds */

  padding = FALSE;

  /* store len */

  data_len = len;

  while (TRUE) {

    /* get packet length */

    header_len = (((data[2] << 8) | data[3]) + 1) << 2;

    if (data_len < header_len)

      goto wrong_length;

    /* move to next compount packet */

    data += header_len;

    data_len -= header_len;

    /* we are at the end now */

    if (data_len < 4)

      break;

    /* check version of new packet */

    version = data[0] & 0xc0;

    if (version != (GST_RTCP_VERSION << 6))

      goto wrong_version;

    /* padding only allowed on last packet */

    if ((padding = data[0] & 0x20))

      break;

  }

  if (data_len > 0) {

    /* some leftover bytes, check padding */

    if (!padding)

      goto wrong_length;

    /* get padding */

    pad_bytes = data[len - 1];

    if (data_len != pad_bytes)

      goto wrong_padding;

  }

  return TRUE;

  /* ERRORS */

wrong_length:

  {

    GST_DEBUG ("len check failed");

    return FALSE;

  }

wrong_mask:

  {

    GST_DEBUG ("mask check failed (%04x != %04x)", header_mask,

        GST_RTCP_VALID_VALUE);

    return FALSE;

  }

wrong_version:

  {

    GST_DEBUG ("wrong version (%d < 2)", version >> 6);

    return FALSE;

  }

wrong_padding:

  {

    GST_DEBUG ("padding check failed");

    return FALSE;

  }

}

/**

 * gst_rtcp_buffer_validate:

 * @buffer: the buffer to validate

 *

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

 * gst_rtcp_buffer_validate_data().

 *  

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

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gboolean

gst_rtcp_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);

  return gst_rtcp_buffer_validate_data (data, len);

}

/**

 * gst_rtcp_buffer_new:

 * @mtu: the maximum mtu size.

 *

 * Create a new buffer for constructing RTCP packets. The packet will have a

 * maximum size of @mtu.

 *

 * Returns: A newly allocated buffer.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstBuffer *

gst_rtcp_buffer_new (guint mtu)

{

  GstBuffer *result;

  g_return_val_if_fail (mtu > 0, NULL);

  result = gst_buffer_new ();

  GST_BUFFER_MALLOCDATA (result) = g_malloc0 (mtu);

  GST_BUFFER_DATA (result) = GST_BUFFER_MALLOCDATA (result);

  GST_BUFFER_SIZE (result) = mtu;

  return result;

}

/**

 * gst_rtcp_buffer_end:

 * @buffer: a buffer with an RTCP packet

 *

 * Finish @buffer after being constructured. This function is usually called

 * after gst_rtcp_buffer_new() and after adding the RTCP items to the new buffer. 

 *

 * The function adjusts the size of @buffer with the total length of all the

 * added packets.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_rtcp_buffer_end (GstBuffer * buffer)

{

  GstRTCPPacket packet;

  g_return_if_fail (GST_IS_BUFFER (buffer));

  /* move to the first free space */

  if (gst_rtcp_buffer_get_first_packet (buffer, &packet))

    while (gst_rtcp_packet_move_to_next (&packet));

  /* shrink size */

  GST_BUFFER_SIZE (buffer) = packet.offset;

}

/**

 * gst_rtcp_buffer_get_packet_count:

 * @buffer: a valid RTCP buffer

 *

 * Get the number of RTCP packets in @buffer.

 *

 * Returns: the number of RTCP packets in @buffer.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

guint

gst_rtcp_buffer_get_packet_count (GstBuffer * buffer)

{

  GstRTCPPacket packet;

  guint count;

  g_return_val_if_fail (GST_IS_BUFFER (buffer), 0);

  count = 0;

  if (gst_rtcp_buffer_get_first_packet (buffer, &packet)) {

    do {

      count++;

    } while (gst_rtcp_packet_move_to_next (&packet));

  }

  return count;

}

/**

 * read_packet_header:

 * @packet: a packet

 *

 * Read the packet headers for the packet pointed to by @packet.

 *

 * Returns: TRUE if @packet pointed to a valid header.

 */

static gboolean

read_packet_header (GstRTCPPacket * packet)

{

  guint8 *data;

  guint size;

  guint offset;

  g_return_val_if_fail (packet != NULL, FALSE);

  g_return_val_if_fail (GST_IS_BUFFER (packet->buffer), FALSE);

  data = GST_BUFFER_DATA (packet->buffer);

  size = GST_BUFFER_SIZE (packet->buffer);

  offset = packet->offset;

  /* check if we are at the end of the buffer, we add 4 because we also want to

   * ensure we can read the header. */

  if (offset + 4 > size)

    return FALSE;

  if ((data[offset] & 0xc0) != (GST_RTCP_VERSION << 6))

    return FALSE;

  /* read count, type and length */

  packet->padding = (data[offset] & 0x20) == 0x20;

  packet->count = data[offset] & 0x1f;

  packet->type = data[offset + 1];

  packet->length = (data[offset + 2] << 8) | data[offset + 3];

  packet->item_offset = 4;

  packet->item_count = 0;

  packet->entry_offset = 4;

  return TRUE;

}

/**

 * gst_rtcp_buffer_get_first_packet:

 * @buffer: a valid RTCP buffer

 * @packet: a #GstRTCPPacket

 *

 * Initialize a new #GstRTCPPacket pointer that points to the first packet in

 * @buffer.

 *

 * Returns: TRUE if the packet existed in @buffer.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gboolean

gst_rtcp_buffer_get_first_packet (GstBuffer * buffer, GstRTCPPacket * packet)

{

  g_return_val_if_fail (GST_IS_BUFFER (buffer), FALSE);

  g_return_val_if_fail (packet != NULL, FALSE);

  /* init to 0 */

  packet->buffer = buffer;

  packet->offset = 0;

  packet->type = GST_RTCP_TYPE_INVALID;

  if (!read_packet_header (packet))

    return FALSE;

  return TRUE;

}

/**

 * gst_rtcp_packet_move_to_next:

 * @packet: a #GstRTCPPacket

 *

 * Move the packet pointer @packet to the next packet in the payload.

 * Use gst_rtcp_buffer_get_first_packet() to initialize @packet.

 *

 * Returns: TRUE if @packet is pointing to a valid packet after calling this

 * function.

 */

#ifdef __SYMBIAN32__

EXPORT_C

gboolean

gst_rtcp_packet_move_to_next (GstRTCPPacket * packet)

{

  g_return_val_if_fail (packet != NULL, FALSE);

  g_return_val_if_fail (packet->type != GST_RTCP_TYPE_INVALID, FALSE);

  g_return_val_if_fail (GST_IS_BUFFER (packet->buffer), FALSE);

  /* if we have a padding or invalid packet, it must be the last, 

   * return FALSE */

  if (packet->type == GST_RTCP_TYPE_INVALID || packet->padding)

    goto end;

  /* move to next packet. Add 4 because the header is not included in length */

  packet->offset += (packet->length << 2) + 4;

  /* try to read new header */

  if (!read_packet_header (packet))

    goto end;

  return TRUE;

  /* ERRORS */

end:

  {

    packet->type = GST_RTCP_TYPE_INVALID;

    return FALSE;

  }

}

/**

 * gst_rtcp_buffer_add_packet:

 * @buffer: a valid RTCP buffer

 * @type: the #GstRTCPType of the new packet

 * @packet: pointer to new packet

 *

 * Add a new packet of @type to @buffer. @packet will point to the newly created 

 * packet.

 *

 * Returns: %TRUE if the packet could be created. This function returns %FALSE

 * if the max mtu is exceeded for the buffer.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gboolean

gst_rtcp_buffer_add_packet (GstBuffer * buffer, GstRTCPType type,

    GstRTCPPacket * packet)

{

  guint len, size;

  guint8 *data;

  gboolean result;

  g_return_val_if_fail (GST_IS_BUFFER (buffer), FALSE);

  g_return_val_if_fail (type != GST_RTCP_TYPE_INVALID, FALSE);

  g_return_val_if_fail (packet != NULL, FALSE);

  /* find free space */

  if (gst_rtcp_buffer_get_first_packet (buffer, packet))

    while (gst_rtcp_packet_move_to_next (packet));

  size = GST_BUFFER_SIZE (buffer);

  /* packet->offset is now pointing to the next free offset in the buffer to

   * start a compount packet. Next we figure out if we have enough free space in

   * the buffer to continue. */

  switch (type) {

    case GST_RTCP_TYPE_SR:

      len = 28;

      break;

    case GST_RTCP_TYPE_RR:

      len = 8;

      break;

    case GST_RTCP_TYPE_SDES:

      len = 4;

      break;

    case GST_RTCP_TYPE_BYE:

      len = 4;

      break;

    case GST_RTCP_TYPE_APP:

      len = 12;

      break;

    default:

      goto unknown_type;

  }

  if (packet->offset + len >= size)

    goto no_space;

  data = GST_BUFFER_DATA (buffer) + packet->offset;

  data[0] = (GST_RTCP_VERSION << 6);

  data[1] = type;

  /* length is stored in multiples of 32 bit words minus the length of the

   * header */

  len = (len - 4) >> 2;

  data[2] = len >> 8;

  data[3] = len & 0xff;

  /* now try to position to the packet */

  result = read_packet_header (packet);

  return result;

  /* ERRORS */

unknown_type:

  {

    g_warning ("unknown type %d", type);

    return FALSE;

  }