/* 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., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

/**

 * SECTION:gstrtcpbuffer

 * @title: GstRTCPBuffer

 * @short_description: Helper methods for dealing with RTCP buffers

 * @see_also: #GstRTPBasePayload, #GstRTPBaseDepayload, #gstrtpbuffer

 *

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

 *

 * 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.

 *

 * 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

 * into the RTCP buffer; you can move to the next packet with

 * gst_rtcp_packet_move_to_next().

 *

 */

#include <string.h>

#include "gstrtcpbuffer.h"

/**

 * gst_rtcp_buffer_new_take_data:

 * @data: (array length=len) (element-type guint8): 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.

 */

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_wrapped (data, len);

  return result;

}

/**

 * gst_rtcp_buffer_new_copy_data:

 * @data: (array length=len) (element-type guint8): 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.

 */

GstBuffer *

gst_rtcp_buffer_new_copy_data (gconstpointer data, guint len)

{

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

}

static gboolean

gst_rtcp_buffer_validate_data_internal (guint8 * data, guint len,

    guint16 valid_mask)

{

  guint16 header_mask;

  guint 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]) & 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;

    /* padding only allowed on last packet */

    if (padding)

      break;

    /* check version of new packet */

    version = data[0] & 0xc0;

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

      goto wrong_version;

    /* check padding of new packet */

    if (data[0] & 0x20) {

      padding = TRUE;

      /* last byte of padding contains the number of padded bytes including

       * itself. must be a multiple of 4, but cannot be 0. */

      pad_bytes = data[data_len - 1];

      if (pad_bytes == 0 || (pad_bytes & 0x3))

        goto wrong_padding;

    }

  }

  if (data_len != 0) {

    /* some leftover bytes */

    goto wrong_length;

  }

  return TRUE;

  /* ERRORS */

wrong_length:

  {

    GST_DEBUG ("len check failed");

    return FALSE;

  }

wrong_mask:

  {

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

    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_data_reduced:

 * @data: (array length=len): 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 packet.

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

 * this module.

 *

 * This function is updated to support reduced size rtcp packets according to

 * RFC 5506 and will validate full compound RTCP packets as well as reduced

 * size RTCP packets.

 *

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

 *

 * Since: 1.6

 */

gboolean

gst_rtcp_buffer_validate_data_reduced (guint8 * data, guint len)

{

  return gst_rtcp_buffer_validate_data_internal (data, len,

      GST_RTCP_REDUCED_SIZE_VALID_MASK);

}

/**

 * gst_rtcp_buffer_validate_data:

 * @data: (array length=len): the data to validate

 * @len: the length of @data to validate

 *

 * Check if the @data and @size point to the data of a valid compound,

 * non-reduced size RTCP 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.

 */

gboolean

gst_rtcp_buffer_validate_data (guint8 * data, guint len)

{

  return gst_rtcp_buffer_validate_data_internal (data, len,

      GST_RTCP_VALID_MASK);

}

/**

 * gst_rtcp_buffer_validate_reduced:

 * @buffer: the buffer to validate

 *

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

 * gst_rtcp_buffer_validate_reduced().

 *

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

 *

 * Since: 1.6

 */

gboolean

gst_rtcp_buffer_validate_reduced (GstBuffer * buffer)

{

  gboolean res;

  GstMapInfo map;

  g_return_val_if_fail (GST_IS_BUFFER (buffer), FALSE);

  gst_buffer_map (buffer, &map, GST_MAP_READ);

  res = gst_rtcp_buffer_validate_data_reduced (map.data, map.size);

  gst_buffer_unmap (buffer, &map);

  return res;

}

/**

 * 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.

 */

gboolean

gst_rtcp_buffer_validate (GstBuffer * buffer)

{

  gboolean res;

  GstMapInfo map;

  g_return_val_if_fail (GST_IS_BUFFER (buffer), FALSE);

  gst_buffer_map (buffer, &map, GST_MAP_READ);

  res = gst_rtcp_buffer_validate_data (map.data, map.size);

  gst_buffer_unmap (buffer, &map);

  return res;

}

/**

 * 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.

 */

GstBuffer *

gst_rtcp_buffer_new (guint mtu)

{

  GstBuffer *result;

  guint8 *data;

  g_return_val_if_fail (mtu > 0, NULL);

  data = g_malloc0 (mtu);

  result = gst_buffer_new_wrapped_full (0, data, mtu, 0, 0, data, g_free);

  return result;

}

/**

 * gst_rtcp_buffer_map:

 * @buffer: a buffer with an RTCP packet

 * @flags: flags for the mapping

 * @rtcp: resulting #GstRTCPBuffer

 *

 * Open @buffer for reading or writing, depending on @flags. The resulting RTCP

 * buffer state is stored in @rtcp.

 */

gboolean

gst_rtcp_buffer_map (GstBuffer * buffer, GstMapFlags flags,

    GstRTCPBuffer * rtcp)

{

  g_return_val_if_fail (rtcp != NULL, FALSE);

  g_return_val_if_fail (rtcp->buffer == NULL, FALSE);

  g_return_val_if_fail (GST_IS_BUFFER (buffer), FALSE);

  g_return_val_if_fail (flags & GST_MAP_READ, FALSE);

  rtcp->buffer = buffer;

  gst_buffer_map (buffer, &rtcp->map, flags);

  return TRUE;

}

/**

 * gst_rtcp_buffer_unmap:

 * @rtcp: a buffer with an RTCP packet

 *

 * Finish @rtcp after being constructed. This function is usually called

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

 *

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

 * added packets.

 */

gboolean

gst_rtcp_buffer_unmap (GstRTCPBuffer * rtcp)

{

  g_return_val_if_fail (rtcp != NULL, FALSE);

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

  if (rtcp->map.flags & GST_MAP_WRITE) {

    /* shrink size */

    gst_buffer_resize (rtcp->buffer, 0, rtcp->map.size);

  }

  gst_buffer_unmap (rtcp->buffer, &rtcp->map);

  rtcp->buffer = NULL;

  return TRUE;

}

/**

 * gst_rtcp_buffer_get_packet_count:

 * @rtcp: a valid RTCP buffer

 *

 * Get the number of RTCP packets in @rtcp.

 *

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

 */

guint

gst_rtcp_buffer_get_packet_count (GstRTCPBuffer * rtcp)

{

  GstRTCPPacket packet;

  guint count;

  g_return_val_if_fail (rtcp != NULL, 0);

  g_return_val_if_fail (GST_IS_BUFFER (rtcp->buffer), 0);

  g_return_val_if_fail (rtcp != NULL, 0);

  g_return_val_if_fail (rtcp->map.flags & GST_MAP_READ, 0);

  count = 0;

  if (gst_rtcp_buffer_get_first_packet (rtcp, &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;

  gsize maxsize;

  guint offset;

  g_return_val_if_fail (packet != NULL, FALSE);

  data = packet->rtcp->map.data;

  maxsize = packet->rtcp->map.size;

  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 > maxsize)

    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;

  /* Ensure no overread from the claimed data size. The packet length

     is expressed in multiple of 32 bits, to make things obvious. */

  if (offset + 4 + packet->length * 4 > maxsize)

    return FALSE;

  return TRUE;

}

/**

 * gst_rtcp_buffer_get_first_packet:

 * @rtcp: a valid RTCP buffer

 * @packet: a #GstRTCPPacket

 *

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

 * @rtcp.

 *

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

 */

gboolean

gst_rtcp_buffer_get_first_packet (GstRTCPBuffer * rtcp, GstRTCPPacket * packet)

{

  g_return_val_if_fail (rtcp != NULL, FALSE);

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

  g_return_val_if_fail (packet != NULL, FALSE);

  g_return_val_if_fail (rtcp != NULL, 0);

  g_return_val_if_fail (rtcp->map.flags & GST_MAP_READ, 0);

  /* init to 0 */

  packet->rtcp = rtcp;

  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.

 */

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 (packet->rtcp != NULL, FALSE);

  g_return_val_if_fail (packet->rtcp->map.flags & GST_MAP_READ, 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:

 * @rtcp: a valid RTCP buffer

 * @type: the #GstRTCPType of the new packet

 * @packet: pointer to new packet

 *

 * Add a new packet of @type to @rtcp. @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.

 */

gboolean

gst_rtcp_buffer_add_packet (GstRTCPBuffer * rtcp, GstRTCPType type,

    GstRTCPPacket * packet)

{

  guint len;

  gsize maxsize;

  guint8 *data;

  gboolean result;

  g_return_val_if_fail (rtcp != NULL, FALSE);

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

  g_return_val_if_fail (type != GST_RTCP_TYPE_INVALID, FALSE);

  g_return_val_if_fail (packet != NULL, FALSE);

  g_return_val_if_fail (rtcp->map.flags & GST_MAP_WRITE, FALSE);

  /* find free space */

  if (gst_rtcp_buffer_get_first_packet (rtcp, packet))

    while (gst_rtcp_packet_move_to_next (packet));

  maxsize = rtcp->map.maxsize;

  /* 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;

    case GST_RTCP_TYPE_RTPFB:

      len = 12;

      break;

    case GST_RTCP_TYPE_PSFB:

      len = 12;

      break;

    case GST_RTCP_TYPE_XR:

      len = 4;

      break;

    default:

      goto unknown_type;

  }

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

    goto no_space;

  rtcp->map.size += len;

  data = rtcp->map.data + 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;

  }

no_space:

  {

    return FALSE;

  }

}

/**

 * gst_rtcp_packet_remove:

 * @packet: a #GstRTCPPacket

 *

 * Removes the packet pointed to by @packet and moves pointer to the next one

 *

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

 * function.

 */

gboolean

gst_rtcp_packet_remove (GstRTCPPacket * packet)

{

  gboolean ret = FALSE;

  guint offset = 0;

  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 (packet->rtcp != NULL, FALSE);

  g_return_val_if_fail (packet->rtcp->map.flags & GST_MAP_WRITE, FALSE);

  /* The next packet starts at offset + length + 4 (the header) */

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

  /* Overwrite this packet with the rest of the data */

  memmove (packet->rtcp->map.data + packet->offset,

      packet->rtcp->map.data + offset, packet->rtcp->map.size - offset);

  packet->rtcp->map.size -= offset - packet->offset;

  /* try to read next header */

  ret = read_packet_header (packet);

  if (!ret)

    packet->type = GST_RTCP_TYPE_INVALID;

  return ret;

}

/**

 * gst_rtcp_packet_get_padding:

 * @packet: a valid #GstRTCPPacket

 *

 * Get the packet padding of the packet pointed to by @packet.

 *

 * Returns: If the packet has the padding bit set.

 */

gboolean

gst_rtcp_packet_get_padding (GstRTCPPacket * packet)

{

  g_return_val_if_fail (packet != NULL, FALSE);

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

  return packet->padding;

}

/**

 * gst_rtcp_packet_get_type:

 * @packet: a valid #GstRTCPPacket

 *

 * Get the packet type of the packet pointed to by @packet.

 *

 * Returns: The packet type or GST_RTCP_TYPE_INVALID when @packet is not

 * pointing to a valid packet.

 */

GstRTCPType

gst_rtcp_packet_get_type (GstRTCPPacket * packet)

{

  g_return_val_if_fail (packet != NULL, GST_RTCP_TYPE_INVALID);

  return packet->type;

}

/**

 * gst_rtcp_packet_get_count:

 * @packet: a valid #GstRTCPPacket

 *

 * Get the count field in @packet.

 *

 * Returns: The count field in @packet or -1 if @packet does not point to a

 * valid packet.

 */

guint8

gst_rtcp_packet_get_count (GstRTCPPacket * packet)

{

  g_return_val_if_fail (packet != NULL, -1);

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

  return packet->count;

}

/**

 * gst_rtcp_packet_get_length:

 * @packet: a valid #GstRTCPPacket

 *

 * Get the length field of @packet. This is the length of the packet in

 * 32-bit words minus one.

 *

 * Returns: The length field of @packet.

 */

guint16

gst_rtcp_packet_get_length (GstRTCPPacket * packet)

{

  g_return_val_if_fail (packet != NULL, 0);

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

  return packet->length;

}

/**

 * gst_rtcp_packet_sr_get_sender_info:

 * @packet: a valid SR #GstRTCPPacket

 * @ssrc: (out): result SSRC

 * @ntptime: (out): result NTP time

 * @rtptime: (out): result RTP time

 * @packet_count: (out): result packet count

 * @octet_count: (out): result octet count

 *

 * Parse the SR sender info and store the values.

 */

void

gst_rtcp_packet_sr_get_sender_info (GstRTCPPacket * packet, guint32 * ssrc,

    guint64 * ntptime, guint32 * rtptime, guint32 * packet_count,

    guint32 * octet_count)

{

  guint8 *data;

  g_return_if_fail (packet != NULL);

  g_return_if_fail (packet->type == GST_RTCP_TYPE_SR);

  g_return_if_fail (packet->rtcp != NULL);

  g_return_if_fail (packet->rtcp->map.flags & GST_MAP_READ);

  data = packet->rtcp->map.data;

  /* skip header */

  data += packet->offset + 4;

  if (ssrc)

    *ssrc = GST_READ_UINT32_BE (data);

  data += 4;

  if (ntptime)

    *ntptime = GST_READ_UINT64_BE (data);

  data += 8;

  if (rtptime)

    *rtptime = GST_READ_UINT32_BE (data);

  data += 4;

  if (packet_count)

    *packet_count = GST_READ_UINT32_BE (data);

  data += 4;

  if (octet_count)

    *octet_count = GST_READ_UINT32_BE (data);

}

/**

 * gst_rtcp_packet_sr_set_sender_info:

 * @packet: a valid SR #GstRTCPPacket

 * @ssrc: the SSRC

 * @ntptime: the NTP time

 * @rtptime: the RTP time

 * @packet_count: the packet count

 * @octet_count: the octet count

 *

 * Set the given values in the SR packet @packet.

 */

void

gst_rtcp_packet_sr_set_sender_info (GstRTCPPacket * packet, guint32 ssrc,

    guint64 ntptime, guint32 rtptime, guint32 packet_count, guint32 octet_count)

{

  guint8 *data;

  g_return_if_fail (packet != NULL);

  g_return_if_fail (packet->type == GST_RTCP_TYPE_SR);

  g_return_if_fail (packet->rtcp != NULL);

  g_return_if_fail (packet->rtcp->map.flags & GST_MAP_WRITE);

  data = packet->rtcp->map.data;

  /* skip header */

  data += packet->offset + 4;

  GST_WRITE_UINT32_BE (data, ssrc);

  data += 4;

  GST_WRITE_UINT64_BE (data, ntptime);

  data += 8;

  GST_WRITE_UINT32_BE (data, rtptime);

  data += 4;

  GST_WRITE_UINT32_BE (data, packet_count);

  data += 4;

  GST_WRITE_UINT32_BE (data, octet_count);

}

/**

 * gst_rtcp_packet_rr_get_ssrc:

 * @packet: a valid RR #GstRTCPPacket

 *

 * Get the ssrc field of the RR @packet.

 *

 * Returns: the ssrc.

 */

guint32

gst_rtcp_packet_rr_get_ssrc (GstRTCPPacket * packet)

{

  guint8 *data;

  guint32 ssrc;

  g_return_val_if_fail (packet != NULL, 0);

  g_return_val_if_fail (packet->type == GST_RTCP_TYPE_RR, 0);

  g_return_val_if_fail (packet->rtcp != NULL, 0);

  g_return_val_if_fail (packet->rtcp->map.flags & GST_MAP_READ, 0);

  data = packet->rtcp->map.data;

  /* skip header */

  data += packet->offset + 4;

  ssrc = GST_READ_UINT32_BE (data);

  return ssrc;

}

/**

 * gst_rtcp_packet_rr_set_ssrc:

 * @packet: a valid RR #GstRTCPPacket

 * @ssrc: the SSRC to set

 *

 * Set the ssrc field of the RR @packet.

 */

void

gst_rtcp_packet_rr_set_ssrc (GstRTCPPacket * packet, guint32 ssrc)

{

  guint8 *data;

  g_return_if_fail (packet != NULL);

  g_return_if_fail (packet->type == GST_RTCP_TYPE_RR);

  g_return_if_fail (packet->rtcp != NULL);

  g_return_if_fail (packet->rtcp->map.flags & GST_MAP_WRITE);

  data = packet->rtcp->map.data;

  /* skip header */

  data += packet->offset + 4;

  GST_WRITE_UINT32_BE (data, ssrc);

}

/**

 * gst_rtcp_packet_get_rb_count:

 * @packet: a valid SR or RR #GstRTCPPacket

 *

 * Get the number of report blocks in @packet.

 *

 * Returns: The number of report blocks in @packet.

 */

guint

gst_rtcp_packet_get_rb_count (GstRTCPPacket * packet)

{

  g_return_val_if_fail (packet != NULL, 0);

  g_return_val_if_fail (packet->type == GST_RTCP_TYPE_RR ||

      packet->type == GST_RTCP_TYPE_SR, 0);

  g_return_val_if_fail (packet->rtcp != NULL, 0);

  g_return_val_if_fail (packet->rtcp->map.flags & GST_MAP_READ, 0);

  return packet->count;

}

/**

 * gst_rtcp_packet_get_rb:

 * @packet: a valid SR or RR #GstRTCPPacket

 * @nth: the nth report block in @packet

 * @ssrc: (out): result for data source being reported

 * @fractionlost: (out): result for fraction lost since last SR/RR

 * @packetslost: (out): result for the cumululative number of packets lost

 * @exthighestseq: (out): result for the extended last sequence number received

 * @jitter: (out): result for the interarrival jitter

 * @lsr: (out): result for the last SR packet from this source

 * @dlsr: (out): result for the delay since last SR packet

 *

 * Parse the values of the @nth report block in @packet and store the result in

 * the values.

 */

void

gst_rtcp_packet_get_rb (GstRTCPPacket * packet, guint nth, guint32 * ssrc,

    guint8 * fractionlost, gint32 * packetslost, guint32 * exthighestseq,

    guint32 * jitter, guint32 * lsr, guint32 * dlsr)

{

  guint offset;

  guint8 *data;

  guint32 tmp;

  g_return_if_fail (packet != NULL);

  g_return_if_fail (packet->type == GST_RTCP_TYPE_RR ||

      packet->type == GST_RTCP_TYPE_SR);

  g_return_if_fail (packet->rtcp != NULL);

  g_return_if_fail (packet->rtcp->map.flags & GST_MAP_READ);

  g_return_if_fail (nth < packet->count);

  /* get offset in 32-bits words into packet, skip the header */

  if (packet->type == GST_RTCP_TYPE_RR)

    offset = 2;