GstByteWriter

typedef struct {
  GstByteReader parent;

  guint alloc_size;

  gboolean fixed;
  gboolean owned;
} GstByteWriter;

A byte writer instance.

gst_byte_writer_new ()

GstByteWriter *     gst_byte_writer_new                 (void);

Creates a new, empty GstByteWriter instance

Free-function: gst_byte_writer_free

gst_byte_writer_new_with_data ()

GstByteWriter *     gst_byte_writer_new_with_data       (guint8 *data,
                                                         guint size,
                                                         gboolean initialized);

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

gst_byte_writer_new_with_size ()

GstByteWriter *     gst_byte_writer_new_with_size       (guint size,
                                                         gboolean fixed);

Creates a new GstByteWriter instance with the given initial data size.

Free-function: gst_byte_writer_free

gst_byte_writer_init ()

void                gst_byte_writer_init                (GstByteWriter *writer);

Initializes writer to an empty instance

gst_byte_writer_init_with_data ()

void                gst_byte_writer_init_with_data      (GstByteWriter *writer,
                                                         guint8 *data,
                                                         guint size,
                                                         gboolean initialized);

Initializes writer with the given memory area. If initialized is TRUE it is possible to read size bytes from the GstByteWriter from the beginning.

gst_byte_writer_init_with_size ()

void                gst_byte_writer_init_with_size      (GstByteWriter *writer,
                                                         guint size,
                                                         gboolean fixed);

Initializes writer with the given initial data size.

gst_byte_writer_free ()

void                gst_byte_writer_free                (GstByteWriter *writer);

Frees writer and all memory allocated by it.

gst_byte_writer_free_and_get_buffer ()

GstBuffer *         gst_byte_writer_free_and_get_buffer (GstByteWriter *writer);

Frees writer and all memory allocated by it except the current data, which is returned as GstBuffer.

Free-function: gst_buffer_unref

gst_byte_writer_free_and_get_data ()

guint8 *            gst_byte_writer_free_and_get_data   (GstByteWriter *writer);

Frees writer and all memory allocated by it except the current data, which is returned.

Free-function: g_free

gst_byte_writer_reset ()

void                gst_byte_writer_reset               (GstByteWriter *writer);

Resets writer and frees the data if it's owned by writer.

gst_byte_writer_reset_and_get_data ()

guint8 *            gst_byte_writer_reset_and_get_data  (GstByteWriter *writer);

Resets writer and returns the current data.

Free-function: g_free

gst_byte_writer_reset_and_get_buffer ()

GstBuffer *         gst_byte_writer_reset_and_get_buffer
                                                        (GstByteWriter *writer);

Resets writer and returns the current data as buffer.

Free-function: gst_buffer_unref

gst_byte_writer_get_pos ()

guint               gst_byte_writer_get_pos             (const GstByteWriter *writer);

gst_byte_writer_set_pos ()

gboolean            gst_byte_writer_set_pos             (GstByteWriter *writer,
                                                         guint pos);

Sets the current read/write cursor of writer. The new position can only be between 0 and the current size.

gst_byte_writer_get_remaining ()

guint               gst_byte_writer_get_remaining       (const GstByteWriter *writer);

Returns the remaining size of data that can still be written. If -1 is returned the remaining size is only limited by system resources.

gst_byte_writer_get_size ()

guint               gst_byte_writer_get_size            (const GstByteWriter *writer);

gst_byte_writer_ensure_free_space ()

gboolean            gst_byte_writer_ensure_free_space   (GstByteWriter *writer,
                                                         guint size);

Checks if enough free space from the current write cursor is available and reallocates if necessary.

gst_byte_writer_put_int8 ()

gboolean            gst_byte_writer_put_int8            (GstByteWriter *writer,
                                                         gint8 val);

Writes a signed 8 bit integer to writer.

gst_byte_writer_put_int16_be ()

gboolean            gst_byte_writer_put_int16_be        (GstByteWriter *writer,
                                                         gint16 val);

Writes a signed big endian 16 bit integer to writer.

gst_byte_writer_put_int16_le ()

gboolean            gst_byte_writer_put_int16_le        (GstByteWriter *writer,
                                                         gint16 val);

Writes a signed little endian 16 bit integer to writer.

gst_byte_writer_put_int24_be ()

gboolean            gst_byte_writer_put_int24_be        (GstByteWriter *writer,
                                                         gint32 val);

Writes a signed big endian 24 bit integer to writer.

gst_byte_writer_put_int24_le ()

gboolean            gst_byte_writer_put_int24_le        (GstByteWriter *writer,
                                                         gint32 val);

Writes a signed little endian 24 bit integer to writer.

gst_byte_writer_put_int32_be ()

gboolean            gst_byte_writer_put_int32_be        (GstByteWriter *writer,
                                                         gint32 val);

Writes a signed big endian 32 bit integer to writer.

gst_byte_writer_put_int32_le ()

gboolean            gst_byte_writer_put_int32_le        (GstByteWriter *writer,
                                                         gint32 val);

Writes a signed little endian 32 bit integer to writer.

gst_byte_writer_put_int64_be ()

gboolean            gst_byte_writer_put_int64_be        (GstByteWriter *writer,
                                                         gint64 val);

Writes a signed big endian 64 bit integer to writer.

gst_byte_writer_put_int64_le ()

gboolean            gst_byte_writer_put_int64_le        (GstByteWriter *writer,
                                                         gint64 val);

Writes a signed little endian 64 bit integer to writer.

gst_byte_writer_put_uint8 ()

gboolean            gst_byte_writer_put_uint8           (GstByteWriter *writer,
                                                         guint8 val);

Writes a unsigned 8 bit integer to writer.

gst_byte_writer_put_uint16_be ()

gboolean            gst_byte_writer_put_uint16_be       (GstByteWriter *writer,
                                                         guint16 val);

Writes a unsigned big endian 16 bit integer to writer.

gst_byte_writer_put_uint16_le ()

gboolean            gst_byte_writer_put_uint16_le       (GstByteWriter *writer,
                                                         guint16 val);

Writes a unsigned little endian 16 bit integer to writer.

gst_byte_writer_put_uint24_be ()

gboolean            gst_byte_writer_put_uint24_be       (GstByteWriter *writer,
                                                         guint32 val);

Writes a unsigned big endian 24 bit integer to writer.

gst_byte_writer_put_uint24_le ()

gboolean            gst_byte_writer_put_uint24_le       (GstByteWriter *writer,
                                                         guint32 val);

Writes a unsigned little endian 24 bit integer to writer.

gst_byte_writer_put_uint32_be ()

gboolean            gst_byte_writer_put_uint32_be       (GstByteWriter *writer,
                                                         guint32 val);

Writes a unsigned big endian 32 bit integer to writer.

gst_byte_writer_put_uint32_le ()

gboolean            gst_byte_writer_put_uint32_le       (GstByteWriter *writer,
                                                         guint32 val);

Writes a unsigned little endian 32 bit integer to writer.

gst_byte_writer_put_uint64_be ()

gboolean            gst_byte_writer_put_uint64_be       (GstByteWriter *writer,
                                                         guint64 val);

Writes a unsigned big endian 64 bit integer to writer.

gst_byte_writer_put_uint64_le ()

gboolean            gst_byte_writer_put_uint64_le       (GstByteWriter *writer,
                                                         guint64 val);

Writes a unsigned little endian 64 bit integer to writer.

gst_byte_writer_put_float32_be ()

gboolean            gst_byte_writer_put_float32_be      (GstByteWriter *writer,
                                                         gfloat val);

Writes a big endian 32 bit float to writer.

gst_byte_writer_put_float32_le ()

gboolean            gst_byte_writer_put_float32_le      (GstByteWriter *writer,
                                                         gfloat val);

Writes a little endian 32 bit float to writer.

gst_byte_writer_put_float64_be ()

gboolean            gst_byte_writer_put_float64_be      (GstByteWriter *writer,
                                                         gdouble val);

Writes a big endian 64 bit float to writer.

gst_byte_writer_put_float64_le ()

gboolean            gst_byte_writer_put_float64_le      (GstByteWriter *writer,
                                                         gdouble val);

Writes a little endian 64 bit float to writer.

gst_byte_writer_put_string()

#define             gst_byte_writer_put_string(writer, data)

Write a NUL-terminated string to writer (including the terminator). The string is assumed to be in an 8-bit encoding (e.g. ASCII,UTF-8 or ISO-8859-1).

gst_byte_writer_put_string_utf16 ()

gboolean            gst_byte_writer_put_string_utf16    (GstByteWriter *writer,
                                                         const guint16 *data);

Writes a NUL-terminated UTF16 string to writer (including the terminator).

gst_byte_writer_put_string_utf32 ()

gboolean            gst_byte_writer_put_string_utf32    (GstByteWriter *writer,
                                                         const guint32 *data);

Writes a NUL-terminated UTF32 string to writer (including the terminator).

gst_byte_writer_put_string_utf8 ()

gboolean            gst_byte_writer_put_string_utf8     (GstByteWriter *writer,
                                                         const gchar *data);

Writes a NUL-terminated UTF8 string to writer (including the terminator).

gst_byte_writer_put_data ()

gboolean            gst_byte_writer_put_data            (GstByteWriter *writer,
                                                         const guint8 *data,
                                                         guint size);

Writes size bytes of data to writer.

gst_byte_writer_fill ()

gboolean            gst_byte_writer_fill                (GstByteWriter *writer,
                                                         guint8 value,
                                                         guint size);

Writes size bytes containing value to writer.

gst_byte_writer_put_int8_unchecked ()

void                gst_byte_writer_put_int8_unchecked  (GstByteWriter *writer,
                                                         gint8 val);

gst_byte_writer_put_int16_be_unchecked ()

void                gst_byte_writer_put_int16_be_unchecked
                                                        (GstByteWriter *writer,
                                                         gint16 val);

Writes a signed big endian 16 bit integer to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_int16_le_unchecked ()

void                gst_byte_writer_put_int16_le_unchecked
                                                        (GstByteWriter *writer,
                                                         gint16 val);

Writes a signed little endian 16 bit integer to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_int24_be_unchecked ()

void                gst_byte_writer_put_int24_be_unchecked
                                                        (GstByteWriter *writer,
                                                         gint32 val);

Writes a signed big endian 24 bit integer to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_int24_le_unchecked ()

void                gst_byte_writer_put_int24_le_unchecked
                                                        (GstByteWriter *writer,
                                                         gint32 val);

Writes a signed little endian 24 bit integer to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_int32_be_unchecked ()

void                gst_byte_writer_put_int32_be_unchecked
                                                        (GstByteWriter *writer,
                                                         gint32 val);

Writes a signed big endian 32 bit integer to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_int32_le_unchecked ()

void                gst_byte_writer_put_int32_le_unchecked
                                                        (GstByteWriter *writer,
                                                         gint32 val);

Writes a signed little endian 32 bit integer to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_int64_be_unchecked ()

void                gst_byte_writer_put_int64_be_unchecked
                                                        (GstByteWriter *writer,
                                                         gint64 val);

Writes a signed big endian 64 bit integer to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_int64_le_unchecked ()

void                gst_byte_writer_put_int64_le_unchecked
                                                        (GstByteWriter *writer,
                                                         gint64 val);

Writes a signed little endian 64 bit integer to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_uint8_unchecked ()

void                gst_byte_writer_put_uint8_unchecked (GstByteWriter *writer,
                                                         guint8 val);

Writes a unsigned 8 bit integer to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_uint16_be_unchecked ()

void                gst_byte_writer_put_uint16_be_unchecked
                                                        (GstByteWriter *writer,
                                                         guint16 val);

Writes a unsigned big endian 16 bit integer to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_uint16_le_unchecked ()

void                gst_byte_writer_put_uint16_le_unchecked
                                                        (GstByteWriter *writer,
                                                         guint16 val);

Writes a unsigned little endian 16 bit integer to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_uint24_be_unchecked ()

void                gst_byte_writer_put_uint24_be_unchecked
                                                        (GstByteWriter *writer,
                                                         guint32 val);

Writes a unsigned big endian 24 bit integer to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_uint24_le_unchecked ()

void                gst_byte_writer_put_uint24_le_unchecked
                                                        (GstByteWriter *writer,
                                                         guint32 val);

Writes a unsigned little endian 24 bit integer to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_uint32_be_unchecked ()

void                gst_byte_writer_put_uint32_be_unchecked
                                                        (GstByteWriter *writer,
                                                         guint32 val);

Writes a unsigned big endian 32 bit integer to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_uint32_le_unchecked ()

void                gst_byte_writer_put_uint32_le_unchecked
                                                        (GstByteWriter *writer,
                                                         guint32 val);

Writes a unsigned little endian 32 bit integer to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_uint64_be_unchecked ()

void                gst_byte_writer_put_uint64_be_unchecked
                                                        (GstByteWriter *writer,
                                                         guint64 val);

Writes a unsigned big endian 64 bit integer to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_uint64_le_unchecked ()

void                gst_byte_writer_put_uint64_le_unchecked
                                                        (GstByteWriter *writer,
                                                         guint64 val);

Writes a unsigned little endian 64 bit integer to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_float32_be_unchecked ()

void                gst_byte_writer_put_float32_be_unchecked
                                                        (GstByteWriter *writer,
                                                         gfloat val);

Writes a big endian 32 bit float to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_float32_le_unchecked ()

void                gst_byte_writer_put_float32_le_unchecked
                                                        (GstByteWriter *writer,
                                                         gfloat val);

Writes a little endian 32 bit float to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_float64_be_unchecked ()

void                gst_byte_writer_put_float64_be_unchecked
                                                        (GstByteWriter *writer,
                                                         gdouble val);

Writes a big endian 64 bit float to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_float64_le_unchecked ()

void                gst_byte_writer_put_float64_le_unchecked
                                                        (GstByteWriter *writer,
                                                         gdouble val);

Writes a little endian 64 bit float to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_put_data_unchecked ()

void                gst_byte_writer_put_data_unchecked  (GstByteWriter *writer,
                                                         const guint8 *data,
                                                         guint size);

Writes size bytes of data to writer without checking if there is enough free space available in the byte writer.

gst_byte_writer_fill_unchecked ()

void                gst_byte_writer_fill_unchecked      (GstByteWriter *writer,
                                                         guint8 value,
                                                         guint size);

Writes size bytes containing value to writer without checking if there is enough free space available in the byte writer.