libs/gst/base/gstbytewriter.c - mtk-gstreamer-debian - Git at Google

 /* GStreamer byte writer
  *
  * Copyright (C) 2009 Sebastian Dröge <sebastian.droege@collabora.co.uk>.
  *
  * 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.
  */

 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif

 #define GST_BYTE_WRITER_DISABLE_INLINES
 #include "gstbytewriter.h"

 /**
  * SECTION:gstbytewriter
  * @short_description: Writes different integer, string and floating point
  *     types to a memory buffer and allows reading
  *
  * #GstByteWriter provides a byte writer and reader that can write/read different
  * integer and floating point types to/from a memory buffer. It provides functions
  * for writing/reading signed/unsigned, little/big endian integers of 8, 16, 24,
  * 32 and 64 bits and functions for reading little/big endian floating points numbers of
  * 32 and 64 bits. It also provides functions to write/read NUL-terminated strings
  * in various character encodings.
  */

 /**
  * gst_byte_writer_new: (skip)
  *
  * Creates a new, empty #GstByteWriter instance
  *
  * Free-function: gst_byte_writer_free
  *
  * Returns: (transfer full): a new, empty #GstByteWriter instance
  */
 GstByteWriter *
 gst_byte_writer_new (void)
 {
   GstByteWriter *ret = g_slice_new0 (GstByteWriter);

   ret->owned = TRUE;
   return ret;
 }

 /**
  * gst_byte_writer_new_with_size: (skip)
  * @size: Initial size of data
  * @fixed: If %TRUE the data can't be reallocated
  *
  * Creates a new #GstByteWriter instance with the given
  * initial data size.
  *
  * Free-function: gst_byte_writer_free
  *
  * Returns: (transfer full): a new #GstByteWriter instance
  */
 GstByteWriter *
 gst_byte_writer_new_with_size (guint size, gboolean fixed)
 {
   GstByteWriter *ret = gst_byte_writer_new ();

   ret->alloc_size = size;
   ret->parent.data = g_malloc (ret->alloc_size);
   ret->fixed = fixed;
   ret->owned = TRUE;

   return ret;
 }

 /**
  * gst_byte_writer_new_with_data: (skip)
  * @data: Memory area for writing
  * @size: Size of @data in bytes
  * @initialized: If %TRUE the complete data can be read from the beginning
  *
  * Creates a new #GstByteWriter instance with the given
  * memory area. If @initialized is %TRUE it is possible to
  * read @size bytes from the #GstByteWriter from the beginning.
  *
  * Free-function: gst_byte_writer_free
  *
  * Returns: (transfer full): a new #GstByteWriter instance
  */
 GstByteWriter *
 gst_byte_writer_new_with_data (guint8 * data, guint size, gboolean initialized)
 {
   GstByteWriter *ret = gst_byte_writer_new ();

   ret->parent.data = data;
   ret->parent.size = (initialized) ? size : 0;
   ret->alloc_size = size;
   ret->fixed = TRUE;
   ret->owned = FALSE;

   return ret;
 }

 /**
  * gst_byte_writer_init:
  * @writer: #GstByteWriter instance
  *
  * Initializes @writer to an empty instance
  */
 void
 gst_byte_writer_init (GstByteWriter * writer)
 {
   g_return_if_fail (writer != NULL);

   memset (writer, 0, sizeof (GstByteWriter));

   writer->owned = TRUE;
 }

 /**
  * gst_byte_writer_init_with_size:
  * @writer: #GstByteWriter instance
  * @size: Initial size of data
  * @fixed: If %TRUE the data can't be reallocated
  *
  * Initializes @writer with the given initial data size.
  */
 void
 gst_byte_writer_init_with_size (GstByteWriter * writer, guint size,
     gboolean fixed)
 {
   g_return_if_fail (writer != NULL);

   gst_byte_writer_init (writer);

   writer->parent.data = g_malloc (size);
   writer->alloc_size = size;
   writer->fixed = fixed;
   writer->owned = TRUE;
 }

 /**
  * gst_byte_writer_init_with_data:
  * @writer: #GstByteWriter instance
  * @data: (array length=size) (transfer none): Memory area for writing
  * @size: Size of @data in bytes
  * @initialized: If %TRUE the complete data can be read from the beginning
  *
  * Initializes @writer with the given
  * memory area. If @initialized is %TRUE it is possible to
  * read @size bytes from the #GstByteWriter from the beginning.
  */
 void
 gst_byte_writer_init_with_data (GstByteWriter * writer, guint8 * data,
     guint size, gboolean initialized)
 {
   g_return_if_fail (writer != NULL);

   gst_byte_writer_init (writer);

   writer->parent.data = data;
   writer->parent.size = (initialized) ? size : 0;
   writer->alloc_size = size;
   writer->fixed = TRUE;
   writer->owned = FALSE;
 }

 /**
  * gst_byte_writer_reset:
  * @writer: #GstByteWriter instance
  *
  * Resets @writer and frees the data if it's
  * owned by @writer.
  */
 void
 gst_byte_writer_reset (GstByteWriter * writer)
 {
   g_return_if_fail (writer != NULL);

   if (writer->owned)
     g_free ((guint8 *) writer->parent.data);
   memset (writer, 0, sizeof (GstByteWriter));
 }

 /**
  * gst_byte_writer_reset_and_get_data:
  * @writer: #GstByteWriter instance
  *
  * Resets @writer and returns the current data.
  *
  * Free-function: g_free
  *
  * Returns: (array) (transfer full): the current data. g_free() after
  * usage.
  */
 guint8 *
 gst_byte_writer_reset_and_get_data (GstByteWriter * writer)
 {
   guint8 *data;

   g_return_val_if_fail (writer != NULL, NULL);

   data = (guint8 *) writer->parent.data;
   if (!writer->owned)
     data = g_memdup (data, writer->parent.size);
   writer->parent.data = NULL;
   gst_byte_writer_reset (writer);

   return data;
 }

 /**
  * gst_byte_writer_reset_and_get_buffer:
  * @writer: #GstByteWriter instance
  *
  * Resets @writer and returns the current data as buffer.
  *
  * Free-function: gst_buffer_unref
  *
  * Returns: (transfer full): the current data as buffer. gst_buffer_unref()
  *     after usage.
  */
 GstBuffer *
 gst_byte_writer_reset_and_get_buffer (GstByteWriter * writer)
 {
   GstBuffer *buffer;
   gpointer data;
   gsize size;

   g_return_val_if_fail (writer != NULL, NULL);

   size = writer->parent.size;
   data = gst_byte_writer_reset_and_get_data (writer);

   buffer = gst_buffer_new ();
   if (data != NULL) {
     gst_buffer_append_memory (buffer,
         gst_memory_new_wrapped (0, data, size, 0, size, data, g_free));
   }

   return buffer;
 }

 /**
  * gst_byte_writer_free:
  * @writer: (in) (transfer full): #GstByteWriter instance
  *
  * Frees @writer and all memory allocated by it.
  */
 void
 gst_byte_writer_free (GstByteWriter * writer)
 {
   g_return_if_fail (writer != NULL);

   gst_byte_writer_reset (writer);
   g_slice_free (GstByteWriter, writer);
 }

 /**
  * gst_byte_writer_free_and_get_data:
  * @writer: (in) (transfer full): #GstByteWriter instance
  *
  * Frees @writer and all memory allocated by it except
  * the current data, which is returned.
  *
  * Free-function: g_free
  *
  * Returns: (transfer full): the current data. g_free() after usage.
  */
 guint8 *
 gst_byte_writer_free_and_get_data (GstByteWriter * writer)
 {
   guint8 *data;

   g_return_val_if_fail (writer != NULL, NULL);

   data = gst_byte_writer_reset_and_get_data (writer);
   g_slice_free (GstByteWriter, writer);

   return data;
 }

 /**
  * gst_byte_writer_free_and_get_buffer:
  * @writer: (in) (transfer full): #GstByteWriter instance
  *
  * Frees @writer and all memory allocated by it except
  * the current data, which is returned as #GstBuffer.
  *
  * Free-function: gst_buffer_unref
  *
  * Returns: (transfer full): the current data as buffer. gst_buffer_unref()
  *     after usage.
  */
 GstBuffer *
 gst_byte_writer_free_and_get_buffer (GstByteWriter * writer)
 {
   GstBuffer *buffer;

   g_return_val_if_fail (writer != NULL, NULL);

   buffer = gst_byte_writer_reset_and_get_buffer (writer);
   g_slice_free (GstByteWriter, writer);

   return buffer;
 }

 /**
  * gst_byte_writer_get_remaining:
  * @writer: #GstByteWriter instance
  *
  * Returns the remaining size of data that can still be written. If
  * -1 is returned the remaining size is only limited by system resources.
  *
  * Returns: the remaining size of data that can still be written
  */
 guint
 gst_byte_writer_get_remaining (const GstByteWriter * writer)
 {
   g_return_val_if_fail (writer != NULL, -1);

   if (!writer->fixed)
     return -1;
   else
     return writer->alloc_size - writer->parent.byte;
 }

 /**
  * gst_byte_writer_ensure_free_space:
  * @writer: #GstByteWriter instance
  * @size: Number of bytes that should be available
  *
  * Checks if enough free space from the current write cursor is
  * available and reallocates if necessary.
  *
  * Returns: %TRUE if at least @size bytes are still available
  */
 gboolean
 gst_byte_writer_ensure_free_space (GstByteWriter * writer, guint size)
 {
   return _gst_byte_writer_ensure_free_space_inline (writer, size);
 }


 #define CREATE_WRITE_FUNC(bits,type,name,write_func) \
 gboolean \
 gst_byte_writer_put_##name (GstByteWriter *writer, type val) \
 { \
   return _gst_byte_writer_put_##name##_inline (writer, val); \
 }

 CREATE_WRITE_FUNC (8, guint8, uint8, GST_WRITE_UINT8);
 CREATE_WRITE_FUNC (8, gint8, int8, GST_WRITE_UINT8);
 CREATE_WRITE_FUNC (16, guint16, uint16_le, GST_WRITE_UINT16_LE);
 CREATE_WRITE_FUNC (16, guint16, uint16_be, GST_WRITE_UINT16_BE);
 CREATE_WRITE_FUNC (16, gint16, int16_le, GST_WRITE_UINT16_LE);
 CREATE_WRITE_FUNC (16, gint16, int16_be, GST_WRITE_UINT16_BE);
 CREATE_WRITE_FUNC (24, guint32, uint24_le, GST_WRITE_UINT24_LE);
 CREATE_WRITE_FUNC (24, guint32, uint24_be, GST_WRITE_UINT24_BE);
 CREATE_WRITE_FUNC (24, gint32, int24_le, GST_WRITE_UINT24_LE);
 CREATE_WRITE_FUNC (24, gint32, int24_be, GST_WRITE_UINT24_BE);
 CREATE_WRITE_FUNC (32, guint32, uint32_le, GST_WRITE_UINT32_LE);
 CREATE_WRITE_FUNC (32, guint32, uint32_be, GST_WRITE_UINT32_BE);
 CREATE_WRITE_FUNC (32, gint32, int32_le, GST_WRITE_UINT32_LE);
 CREATE_WRITE_FUNC (32, gint32, int32_be, GST_WRITE_UINT32_BE);
 CREATE_WRITE_FUNC (64, guint64, uint64_le, GST_WRITE_UINT64_LE);
 CREATE_WRITE_FUNC (64, guint64, uint64_be, GST_WRITE_UINT64_BE);
 CREATE_WRITE_FUNC (64, gint64, int64_le, GST_WRITE_UINT64_LE);
 CREATE_WRITE_FUNC (64, gint64, int64_be, GST_WRITE_UINT64_BE);

 CREATE_WRITE_FUNC (32, gfloat, float32_be, GST_WRITE_FLOAT_BE);
 CREATE_WRITE_FUNC (32, gfloat, float32_le, GST_WRITE_FLOAT_LE);
 CREATE_WRITE_FUNC (64, gdouble, float64_be, GST_WRITE_DOUBLE_BE);
 CREATE_WRITE_FUNC (64, gdouble, float64_le, GST_WRITE_DOUBLE_LE);

 gboolean
 gst_byte_writer_put_data (GstByteWriter * writer, const guint8 * data,
     guint size)
 {
   return _gst_byte_writer_put_data_inline (writer, data, size);
 }

 gboolean
 gst_byte_writer_fill (GstByteWriter * writer, guint8 value, guint size)
 {
   return _gst_byte_writer_fill_inline (writer, value, size);
 }

 #define CREATE_WRITE_STRING_FUNC(bits,type) \
 gboolean \
 gst_byte_writer_put_string_utf##bits (GstByteWriter *writer, const type * data) \
 { \
   guint size = 0; \
   \
   g_return_val_if_fail (writer != NULL, FALSE); \
   \
   /* endianness does not matter if we are looking for a NUL terminator */ \
   while (data[size] != 0) { \
     /* have prevent overflow */ \
     if (G_UNLIKELY (size == G_MAXUINT)) \
       return FALSE; \
     ++size; \
   } \
   ++size; \
   \
   if (G_UNLIKELY (!_gst_byte_writer_ensure_free_space_inline(writer, size * (bits / 8)))) \
     return FALSE; \
   \
   _gst_byte_writer_put_data_inline (writer, (const guint8 *) data, size * (bits / 8)); \
   \
   return TRUE; \
 }

 CREATE_WRITE_STRING_FUNC (8, gchar);
 CREATE_WRITE_STRING_FUNC (16, guint16);
 CREATE_WRITE_STRING_FUNC (32, guint32);
 /**
  * gst_byte_writer_put_uint8:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a unsigned 8 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_uint16_be:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a unsigned big endian 16 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_uint24_be:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a unsigned big endian 24 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_uint32_be:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a unsigned big endian 32 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_uint64_be:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a unsigned big endian 64 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_uint16_le:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a unsigned little endian 16 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_uint24_le:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a unsigned little endian 24 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_uint32_le:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a unsigned little endian 32 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_uint64_le:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a unsigned little endian 64 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_int8:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a signed 8 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_int16_be:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a signed big endian 16 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_int24_be:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a signed big endian 24 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_int32_be:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a signed big endian 32 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_int64_be:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a signed big endian 64 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_int16_le:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a signed little endian 16 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_int24_le:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a signed little endian 24 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_int32_le:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a signed little endian 32 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_int64_le:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a signed little endian 64 bit integer to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_float32_be:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a big endian 32 bit float to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_float64_be:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a big endian 64 bit float to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_float32_le:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a little endian 32 bit float to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_float64_le:
  * @writer: #GstByteWriter instance
  * @val: Value to write
  *
  * Writes a little endian 64 bit float to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_string_utf8:
  * @writer: #GstByteWriter instance
  * @data: (transfer none) (array zero-terminated=1) (type utf8): UTF8 string to
  *     write
  *
  * Writes a NUL-terminated UTF8 string to @writer (including the terminator).
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_string_utf16:
  * @writer: #GstByteWriter instance
  * @data: (transfer none) (array zero-terminated=1): UTF16 string to write
  *
  * Writes a NUL-terminated UTF16 string to @writer (including the terminator).
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_string_utf32:
  * @writer: #GstByteWriter instance
  * @data: (transfer none) (array zero-terminated=1): UTF32 string to write
  *
  * Writes a NUL-terminated UTF32 string to @writer (including the terminator).
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_put_data:
  * @writer: #GstByteWriter instance
  * @data: (transfer none) (array length=size): Data to write
  * @size: Size of @data in bytes
  *
  * Writes @size bytes of @data to @writer.
  *
  * Returns: %TRUE if the value could be written
  */
 /**
  * gst_byte_writer_fill:
  * @writer: #GstByteWriter instance
  * @value: Value to be written
  * @size: Number of bytes to be written
  *
  * Writes @size bytes containing @value to @writer.
  *
  * Returns: %TRUE if the value could be written
  */

 /**
  * gst_byte_writer_put_buffer:
  * @writer: #GstByteWriter instance
  * @buffer: (transfer none): source #GstBuffer
  * @offset: offset to copy from
  * @size: total size to copy. If -1, all data is copied
  *
  * Writes @size bytes of @data to @writer.
  *
  * Returns: %TRUE if the data could be written
  *
  */
	/* GStreamer byte writer
	*
	* Copyright (C) 2009 Sebastian Dröge <sebastian.droege@collabora.co.uk>.
	*
	* 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.
	*/

	#ifdef HAVE_CONFIG_H
	#include "config.h"
	#endif

	#define GST_BYTE_WRITER_DISABLE_INLINES
	#include "gstbytewriter.h"

	/**
	* SECTION:gstbytewriter
	* @short_description: Writes different integer, string and floating point
	* types to a memory buffer and allows reading
	*
	* #GstByteWriter provides a byte writer and reader that can write/read different
	* integer and floating point types to/from a memory buffer. It provides functions
	* for writing/reading signed/unsigned, little/big endian integers of 8, 16, 24,
	* 32 and 64 bits and functions for reading little/big endian floating points numbers of
	* 32 and 64 bits. It also provides functions to write/read NUL-terminated strings
	* in various character encodings.
	*/

	/**
	* gst_byte_writer_new: (skip)
	*
	* Creates a new, empty #GstByteWriter instance
	*
	* Free-function: gst_byte_writer_free
	*
	* Returns: (transfer full): a new, empty #GstByteWriter instance
	*/
	GstByteWriter *
	gst_byte_writer_new (void)
	{
	GstByteWriter *ret = g_slice_new0 (GstByteWriter);

	ret->owned = TRUE;
	return ret;
	}

	/**
	* gst_byte_writer_new_with_size: (skip)
	* @size: Initial size of data
	* @fixed: If %TRUE the data can't be reallocated
	*
	* Creates a new #GstByteWriter instance with the given
	* initial data size.
	*
	* Free-function: gst_byte_writer_free
	*
	* Returns: (transfer full): a new #GstByteWriter instance
	*/
	GstByteWriter *
	gst_byte_writer_new_with_size (guint size, gboolean fixed)
	{
	GstByteWriter *ret = gst_byte_writer_new ();

	ret->alloc_size = size;
	ret->parent.data = g_malloc (ret->alloc_size);
	ret->fixed = fixed;
	ret->owned = TRUE;

	return ret;
	}

	/**
	* gst_byte_writer_new_with_data: (skip)
	* @data: Memory area for writing
	* @size: Size of @data in bytes
	* @initialized: If %TRUE the complete data can be read from the beginning
	*
	* Creates a new #GstByteWriter instance with the given
	* memory area. If @initialized is %TRUE it is possible to
	* read @size bytes from the #GstByteWriter from the beginning.
	*
	* Free-function: gst_byte_writer_free
	*
	* Returns: (transfer full): a new #GstByteWriter instance
	*/
	GstByteWriter *
	gst_byte_writer_new_with_data (guint8 * data, guint size, gboolean initialized)
	{
	GstByteWriter *ret = gst_byte_writer_new ();

	ret->parent.data = data;
	ret->parent.size = (initialized) ? size : 0;
	ret->alloc_size = size;
	ret->fixed = TRUE;
	ret->owned = FALSE;

	return ret;
	}

	/**
	* gst_byte_writer_init:
	* @writer: #GstByteWriter instance
	*
	* Initializes @writer to an empty instance
	*/
	void
	gst_byte_writer_init (GstByteWriter * writer)
	{
	g_return_if_fail (writer != NULL);

	memset (writer, 0, sizeof (GstByteWriter));

	writer->owned = TRUE;
	}

	/**
	* gst_byte_writer_init_with_size:
	* @writer: #GstByteWriter instance
	* @size: Initial size of data
	* @fixed: If %TRUE the data can't be reallocated
	*
	* Initializes @writer with the given initial data size.
	*/
	void
	gst_byte_writer_init_with_size (GstByteWriter * writer, guint size,
	gboolean fixed)
	{
	g_return_if_fail (writer != NULL);

	gst_byte_writer_init (writer);

	writer->parent.data = g_malloc (size);
	writer->alloc_size = size;
	writer->fixed = fixed;
	writer->owned = TRUE;
	}

	/**
	* gst_byte_writer_init_with_data:
	* @writer: #GstByteWriter instance
	* @data: (array length=size) (transfer none): Memory area for writing
	* @size: Size of @data in bytes
	* @initialized: If %TRUE the complete data can be read from the beginning
	*
	* Initializes @writer with the given
	* memory area. If @initialized is %TRUE it is possible to
	* read @size bytes from the #GstByteWriter from the beginning.
	*/
	void
	gst_byte_writer_init_with_data (GstByteWriter * writer, guint8 * data,
	guint size, gboolean initialized)
	{
	g_return_if_fail (writer != NULL);

	gst_byte_writer_init (writer);

	writer->parent.data = data;
	writer->parent.size = (initialized) ? size : 0;
	writer->alloc_size = size;
	writer->fixed = TRUE;
	writer->owned = FALSE;
	}

	/**
	* gst_byte_writer_reset:
	* @writer: #GstByteWriter instance
	*
	* Resets @writer and frees the data if it's
	* owned by @writer.
	*/
	void
	gst_byte_writer_reset (GstByteWriter * writer)
	{
	g_return_if_fail (writer != NULL);

	if (writer->owned)
	g_free ((guint8 *) writer->parent.data);
	memset (writer, 0, sizeof (GstByteWriter));
	}

	/**
	* gst_byte_writer_reset_and_get_data:
	* @writer: #GstByteWriter instance
	*
	* Resets @writer and returns the current data.
	*
	* Free-function: g_free
	*
	* Returns: (array) (transfer full): the current data. g_free() after
	* usage.
	*/
	guint8 *
	gst_byte_writer_reset_and_get_data (GstByteWriter * writer)
	{
	guint8 *data;

	g_return_val_if_fail (writer != NULL, NULL);

	data = (guint8 *) writer->parent.data;
	if (!writer->owned)
	data = g_memdup (data, writer->parent.size);
	writer->parent.data = NULL;
	gst_byte_writer_reset (writer);

	return data;
	}

	/**
	* gst_byte_writer_reset_and_get_buffer:
	* @writer: #GstByteWriter instance
	*
	* Resets @writer and returns the current data as buffer.
	*
	* Free-function: gst_buffer_unref
	*
	* Returns: (transfer full): the current data as buffer. gst_buffer_unref()
	* after usage.
	*/
	GstBuffer *
	gst_byte_writer_reset_and_get_buffer (GstByteWriter * writer)
	{
	GstBuffer *buffer;
	gpointer data;
	gsize size;

	g_return_val_if_fail (writer != NULL, NULL);

	size = writer->parent.size;
	data = gst_byte_writer_reset_and_get_data (writer);

	buffer = gst_buffer_new ();
	if (data != NULL) {
	gst_buffer_append_memory (buffer,
	gst_memory_new_wrapped (0, data, size, 0, size, data, g_free));
	}

	return buffer;
	}

	/**
	* gst_byte_writer_free:
	* @writer: (in) (transfer full): #GstByteWriter instance
	*
	* Frees @writer and all memory allocated by it.
	*/
	void
	gst_byte_writer_free (GstByteWriter * writer)
	{
	g_return_if_fail (writer != NULL);

	gst_byte_writer_reset (writer);
	g_slice_free (GstByteWriter, writer);
	}

	/**
	* gst_byte_writer_free_and_get_data:
	* @writer: (in) (transfer full): #GstByteWriter instance
	*
	* Frees @writer and all memory allocated by it except
	* the current data, which is returned.
	*
	* Free-function: g_free
	*
	* Returns: (transfer full): the current data. g_free() after usage.
	*/
	guint8 *
	gst_byte_writer_free_and_get_data (GstByteWriter * writer)
	{
	guint8 *data;

	g_return_val_if_fail (writer != NULL, NULL);

	data = gst_byte_writer_reset_and_get_data (writer);
	g_slice_free (GstByteWriter, writer);

	return data;
	}

	/**
	* gst_byte_writer_free_and_get_buffer:
	* @writer: (in) (transfer full): #GstByteWriter instance
	*
	* Frees @writer and all memory allocated by it except
	* the current data, which is returned as #GstBuffer.
	*
	* Free-function: gst_buffer_unref
	*
	* Returns: (transfer full): the current data as buffer. gst_buffer_unref()
	* after usage.
	*/
	GstBuffer *
	gst_byte_writer_free_and_get_buffer (GstByteWriter * writer)
	{
	GstBuffer *buffer;

	g_return_val_if_fail (writer != NULL, NULL);

	buffer = gst_byte_writer_reset_and_get_buffer (writer);
	g_slice_free (GstByteWriter, writer);

	return buffer;
	}

	/**
	* gst_byte_writer_get_remaining:
	* @writer: #GstByteWriter instance
	*
	* Returns the remaining size of data that can still be written. If
	* -1 is returned the remaining size is only limited by system resources.
	*
	* Returns: the remaining size of data that can still be written
	*/
	guint
	gst_byte_writer_get_remaining (const GstByteWriter * writer)
	{
	g_return_val_if_fail (writer != NULL, -1);

	if (!writer->fixed)
	return -1;
	else
	return writer->alloc_size - writer->parent.byte;
	}

	/**
	* gst_byte_writer_ensure_free_space:
	* @writer: #GstByteWriter instance
	* @size: Number of bytes that should be available
	*
	* Checks if enough free space from the current write cursor is
	* available and reallocates if necessary.
	*
	* Returns: %TRUE if at least @size bytes are still available
	*/
	gboolean
	gst_byte_writer_ensure_free_space (GstByteWriter * writer, guint size)
	{
	return _gst_byte_writer_ensure_free_space_inline (writer, size);
	}


	#define CREATE_WRITE_FUNC(bits,type,name,write_func) \
	gboolean \
	gst_byte_writer_put_##name (GstByteWriter *writer, type val) \
	{ \
	return _gst_byte_writer_put_##name##_inline (writer, val); \
	}

	CREATE_WRITE_FUNC (8, guint8, uint8, GST_WRITE_UINT8);
	CREATE_WRITE_FUNC (8, gint8, int8, GST_WRITE_UINT8);
	CREATE_WRITE_FUNC (16, guint16, uint16_le, GST_WRITE_UINT16_LE);
	CREATE_WRITE_FUNC (16, guint16, uint16_be, GST_WRITE_UINT16_BE);
	CREATE_WRITE_FUNC (16, gint16, int16_le, GST_WRITE_UINT16_LE);
	CREATE_WRITE_FUNC (16, gint16, int16_be, GST_WRITE_UINT16_BE);
	CREATE_WRITE_FUNC (24, guint32, uint24_le, GST_WRITE_UINT24_LE);
	CREATE_WRITE_FUNC (24, guint32, uint24_be, GST_WRITE_UINT24_BE);
	CREATE_WRITE_FUNC (24, gint32, int24_le, GST_WRITE_UINT24_LE);
	CREATE_WRITE_FUNC (24, gint32, int24_be, GST_WRITE_UINT24_BE);
	CREATE_WRITE_FUNC (32, guint32, uint32_le, GST_WRITE_UINT32_LE);
	CREATE_WRITE_FUNC (32, guint32, uint32_be, GST_WRITE_UINT32_BE);
	CREATE_WRITE_FUNC (32, gint32, int32_le, GST_WRITE_UINT32_LE);
	CREATE_WRITE_FUNC (32, gint32, int32_be, GST_WRITE_UINT32_BE);
	CREATE_WRITE_FUNC (64, guint64, uint64_le, GST_WRITE_UINT64_LE);
	CREATE_WRITE_FUNC (64, guint64, uint64_be, GST_WRITE_UINT64_BE);
	CREATE_WRITE_FUNC (64, gint64, int64_le, GST_WRITE_UINT64_LE);
	CREATE_WRITE_FUNC (64, gint64, int64_be, GST_WRITE_UINT64_BE);

	CREATE_WRITE_FUNC (32, gfloat, float32_be, GST_WRITE_FLOAT_BE);
	CREATE_WRITE_FUNC (32, gfloat, float32_le, GST_WRITE_FLOAT_LE);
	CREATE_WRITE_FUNC (64, gdouble, float64_be, GST_WRITE_DOUBLE_BE);
	CREATE_WRITE_FUNC (64, gdouble, float64_le, GST_WRITE_DOUBLE_LE);

	gboolean
	gst_byte_writer_put_data (GstByteWriter * writer, const guint8 * data,
	guint size)
	{
	return _gst_byte_writer_put_data_inline (writer, data, size);
	}

	gboolean
	gst_byte_writer_fill (GstByteWriter * writer, guint8 value, guint size)
	{
	return _gst_byte_writer_fill_inline (writer, value, size);
	}

	#define CREATE_WRITE_STRING_FUNC(bits,type) \
	gboolean \
	gst_byte_writer_put_string_utf##bits (GstByteWriter writer, const type data) \
	{ \
	guint size = 0; \
	\
	g_return_val_if_fail (writer != NULL, FALSE); \
	\
	/* endianness does not matter if we are looking for a NUL terminator */ \
	while (data[size] != 0) { \
	/* have prevent overflow */ \
	if (G_UNLIKELY (size == G_MAXUINT)) \
	return FALSE; \
	++size; \
	} \
	++size; \
	\
	if (G_UNLIKELY (!_gst_byte_writer_ensure_free_space_inline(writer, size * (bits / 8)))) \
	return FALSE; \
	\
	_gst_byte_writer_put_data_inline (writer, (const guint8 ) data, size (bits / 8)); \
	\
	return TRUE; \
	}

	CREATE_WRITE_STRING_FUNC (8, gchar);
	CREATE_WRITE_STRING_FUNC (16, guint16);
	CREATE_WRITE_STRING_FUNC (32, guint32);
	/**
	* gst_byte_writer_put_uint8:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a unsigned 8 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_uint16_be:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a unsigned big endian 16 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_uint24_be:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a unsigned big endian 24 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_uint32_be:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a unsigned big endian 32 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_uint64_be:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a unsigned big endian 64 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_uint16_le:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a unsigned little endian 16 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_uint24_le:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a unsigned little endian 24 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_uint32_le:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a unsigned little endian 32 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_uint64_le:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a unsigned little endian 64 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_int8:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a signed 8 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_int16_be:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a signed big endian 16 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_int24_be:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a signed big endian 24 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_int32_be:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a signed big endian 32 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_int64_be:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a signed big endian 64 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_int16_le:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a signed little endian 16 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_int24_le:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a signed little endian 24 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_int32_le:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a signed little endian 32 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_int64_le:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a signed little endian 64 bit integer to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_float32_be:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a big endian 32 bit float to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_float64_be:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a big endian 64 bit float to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_float32_le:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a little endian 32 bit float to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_float64_le:
	* @writer: #GstByteWriter instance
	* @val: Value to write
	*
	* Writes a little endian 64 bit float to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_string_utf8:
	* @writer: #GstByteWriter instance
	* @data: (transfer none) (array zero-terminated=1) (type utf8): UTF8 string to
	* write
	*
	* Writes a NUL-terminated UTF8 string to @writer (including the terminator).
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_string_utf16:
	* @writer: #GstByteWriter instance
	* @data: (transfer none) (array zero-terminated=1): UTF16 string to write
	*
	* Writes a NUL-terminated UTF16 string to @writer (including the terminator).
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_string_utf32:
	* @writer: #GstByteWriter instance
	* @data: (transfer none) (array zero-terminated=1): UTF32 string to write
	*
	* Writes a NUL-terminated UTF32 string to @writer (including the terminator).
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_put_data:
	* @writer: #GstByteWriter instance
	* @data: (transfer none) (array length=size): Data to write
	* @size: Size of @data in bytes
	*
	* Writes @size bytes of @data to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/
	/**
	* gst_byte_writer_fill:
	* @writer: #GstByteWriter instance
	* @value: Value to be written
	* @size: Number of bytes to be written
	*
	* Writes @size bytes containing @value to @writer.
	*
	* Returns: %TRUE if the value could be written
	*/

	/**
	* gst_byte_writer_put_buffer:
	* @writer: #GstByteWriter instance
	* @buffer: (transfer none): source #GstBuffer
	* @offset: offset to copy from
	* @size: total size to copy. If -1, all data is copied
	*
	* Writes @size bytes of @data to @writer.
	*
	* Returns: %TRUE if the data could be written
	*
	*/