## GstByteWriter

GstByteWriter — Writes different integer, string and floating point types to a memory buffer and allows reading

## Synopsis

    #include <gst/base/gstbytewriter.h>

                        GstByteWriter;
    GstByteWriter *     gst_byte_writer_new                 (void);
    GstByteWriter *     gst_byte_writer_new_with_data       (guint8 *data,
                                                             guint size,
                                                             gboolean initialized);
    GstByteWriter *     gst_byte_writer_new_with_size       (guint size,
                                                             gboolean fixed);
    void                gst_byte_writer_init                (GstByteWriter *writer);
    void                gst_byte_writer_init_with_data      (GstByteWriter *writer,
                                                             guint8 *data,
                                                             guint size,
                                                             gboolean initialized);
    void                gst_byte_writer_init_with_size      (GstByteWriter *writer,
                                                             guint size,
                                                             gboolean fixed);
    void                gst_byte_writer_free                (GstByteWriter *writer);
    GstBuffer *         gst_byte_writer_free_and_get_buffer (GstByteWriter *writer);
    guint8 *            gst_byte_writer_free_and_get_data   (GstByteWriter *writer);
    void                gst_byte_writer_reset               (GstByteWriter *writer);
    guint8 *            gst_byte_writer_reset_and_get_data  (GstByteWriter *writer);
    GstBuffer *         gst_byte_writer_reset_and_get_buffer
                                                            (GstByteWriter *writer);
    guint               gst_byte_writer_get_pos             (const GstByteWriter *writer);
    gboolean            gst_byte_writer_set_pos             (GstByteWriter *writer,
                                                             guint pos);
    guint               gst_byte_writer_get_remaining       (const GstByteWriter *writer);
    guint               gst_byte_writer_get_size            (const GstByteWriter *writer);
    gboolean            gst_byte_writer_ensure_free_space   (GstByteWriter *writer,
                                                             guint size);
    gboolean            gst_byte_writer_put_int8            (GstByteWriter *writer,
                                                             gint8 val);
    gboolean            gst_byte_writer_put_int16_be        (GstByteWriter *writer,
                                                             gint16 val);
    gboolean            gst_byte_writer_put_int16_le        (GstByteWriter *writer,
                                                             gint16 val);
    gboolean            gst_byte_writer_put_int24_be        (GstByteWriter *writer,
                                                             gint32 val);
    gboolean            gst_byte_writer_put_int24_le        (GstByteWriter *writer,
                                                             gint32 val);
    gboolean            gst_byte_writer_put_int32_be        (GstByteWriter *writer,
                                                             gint32 val);
    gboolean            gst_byte_writer_put_int32_le        (GstByteWriter *writer,
                                                             gint32 val);
    gboolean            gst_byte_writer_put_int64_be        (GstByteWriter *writer,
                                                             gint64 val);
    gboolean            gst_byte_writer_put_int64_le        (GstByteWriter *writer,
                                                             gint64 val);
    gboolean            gst_byte_writer_put_uint8           (GstByteWriter *writer,
                                                             guint8 val);
    gboolean            gst_byte_writer_put_uint16_be       (GstByteWriter *writer,
                                                             guint16 val);
    gboolean            gst_byte_writer_put_uint16_le       (GstByteWriter *writer,
                                                             guint16 val);
    gboolean            gst_byte_writer_put_uint24_be       (GstByteWriter *writer,
                                                             guint32 val);
    gboolean            gst_byte_writer_put_uint24_le       (GstByteWriter *writer,
                                                             guint32 val);
    gboolean            gst_byte_writer_put_uint32_be       (GstByteWriter *writer,
                                                             guint32 val);
    gboolean            gst_byte_writer_put_uint32_le       (GstByteWriter *writer,
                                                             guint32 val);
    gboolean            gst_byte_writer_put_uint64_be       (GstByteWriter *writer,
                                                             guint64 val);
    gboolean            gst_byte_writer_put_uint64_le       (GstByteWriter *writer,
                                                             guint64 val);
    gboolean            gst_byte_writer_put_float32_be      (GstByteWriter *writer,
                                                             gfloat val);
    gboolean            gst_byte_writer_put_float32_le      (GstByteWriter *writer,
                                                             gfloat val);
    gboolean            gst_byte_writer_put_float64_be      (GstByteWriter *writer,
                                                             gdouble val);
    gboolean            gst_byte_writer_put_float64_le      (GstByteWriter *writer,
                                                             gdouble val);
    #define             gst_byte_writer_put_string          (writer,
                                                             data)
    gboolean            gst_byte_writer_put_string_utf16    (GstByteWriter *writer,
                                                             const guint16 *data);
    gboolean            gst_byte_writer_put_string_utf32    (GstByteWriter *writer,
                                                             const guint32 *data);
    gboolean            gst_byte_writer_put_string_utf8     (GstByteWriter *writer,
                                                             const gchar *data);
    gboolean            gst_byte_writer_put_data            (GstByteWriter *writer,
                                                             const guint8 *data,
                                                             guint size);
    gboolean            gst_byte_writer_fill                (GstByteWriter *writer,
                                                             guint8 value,
                                                             guint size);
    void                gst_byte_writer_put_int8_unchecked  (GstByteWriter *writer,
                                                             gint8 val);
    void                gst_byte_writer_put_int16_be_unchecked
                                                            (GstByteWriter *writer,
                                                             gint16 val);
    void                gst_byte_writer_put_int16_le_unchecked
                                                            (GstByteWriter *writer,
                                                             gint16 val);
    void                gst_byte_writer_put_int24_be_unchecked
                                                            (GstByteWriter *writer,
                                                             gint32 val);
    void                gst_byte_writer_put_int24_le_unchecked
                                                            (GstByteWriter *writer,
                                                             gint32 val);
    void                gst_byte_writer_put_int32_be_unchecked
                                                            (GstByteWriter *writer,
                                                             gint32 val);
    void                gst_byte_writer_put_int32_le_unchecked
                                                            (GstByteWriter *writer,
                                                             gint32 val);
    void                gst_byte_writer_put_int64_be_unchecked
                                                            (GstByteWriter *writer,
                                                             gint64 val);
    void                gst_byte_writer_put_int64_le_unchecked
                                                            (GstByteWriter *writer,
                                                             gint64 val);
    void                gst_byte_writer_put_uint8_unchecked (GstByteWriter *writer,
                                                             guint8 val);
    void                gst_byte_writer_put_uint16_be_unchecked
                                                            (GstByteWriter *writer,
                                                             guint16 val);
    void                gst_byte_writer_put_uint16_le_unchecked
                                                            (GstByteWriter *writer,
                                                             guint16 val);
    void                gst_byte_writer_put_uint24_be_unchecked
                                                            (GstByteWriter *writer,
                                                             guint32 val);
    void                gst_byte_writer_put_uint24_le_unchecked
                                                            (GstByteWriter *writer,
                                                             guint32 val);
    void                gst_byte_writer_put_uint32_be_unchecked
                                                            (GstByteWriter *writer,
                                                             guint32 val);
    void                gst_byte_writer_put_uint32_le_unchecked
                                                            (GstByteWriter *writer,
                                                             guint32 val);
    void                gst_byte_writer_put_uint64_be_unchecked
                                                            (GstByteWriter *writer,
                                                             guint64 val);
    void                gst_byte_writer_put_uint64_le_unchecked
                                                            (GstByteWriter *writer,
                                                             guint64 val);
    void                gst_byte_writer_put_float32_be_unchecked
                                                            (GstByteWriter *writer,
                                                             gfloat val);
    void                gst_byte_writer_put_float32_le_unchecked
                                                            (GstByteWriter *writer,
                                                             gfloat val);
    void                gst_byte_writer_put_float64_be_unchecked
                                                            (GstByteWriter *writer,
                                                             gdouble val);
    void                gst_byte_writer_put_float64_le_unchecked
                                                            (GstByteWriter *writer,
                                                             gdouble val);
    void                gst_byte_writer_put_data_unchecked  (GstByteWriter *writer,
                                                             const guint8 *data,
                                                             guint size);
    void                gst_byte_writer_fill_unchecked      (GstByteWriter *writer,
                                                             guint8 value,
                                                             guint size);

## Description

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.

## Details

### GstByteWriter

    typedef struct {
      GstByteReader parent;

      guint alloc_size;

      gboolean fixed;
      gboolean owned;
    } GstByteWriter;

A byte writer instance.

GstByteReader `parent`; | GstByteReader parent
guint `alloc_size`; | Allocation size of the data
gboolean `fixed`; | If `TRUE` no reallocations are allowed
gboolean `owned`; | If `FALSE` no reallocations are allowed and copies of data are returned

### gst_byte_writer_new ()

    GstByteWriter *     gst_byte_writer_new                 (void);

Creates a new, empty GstByteWriter instance

Free-function: gst_byte_writer_free

Returns : | a new, empty GstByteWriter instance. [transfer full]

### 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

`data` : | Memory area for writing
`size` : | Size of `data` in bytes
`initialized` : | If `TRUE` the complete data can be read from the beginning
Returns : | a new GstByteWriter instance. [transfer full]

### 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

`size` : | Initial size of data
`fixed` : | If `TRUE` the data can't be reallocated
Returns : | a new GstByteWriter instance. [transfer full]

### gst_byte_writer_init ()

    void                gst_byte_writer_init                (GstByteWriter *writer);

Initializes `writer` to an empty instance

`writer` : | GstByteWriter 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.

`writer` : | GstByteWriter instance
`data` : | Memory area for writing. [array length=size][transfer none]
`size` : | Size of `data` in bytes
`initialized` : | If `TRUE` the complete data can be read 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.

`writer` : | GstByteWriter instance
`size` : | Initial size of data
`fixed` : | If `TRUE` the data can't be reallocated

### gst_byte_writer_free ()

    void                gst_byte_writer_free                (GstByteWriter *writer);

Frees `writer` and all memory allocated by it.

`writer` : | GstByteWriter instance. [in][transfer full]

### 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

`writer` : | GstByteWriter instance. [in][transfer full]
Returns : | the current data as buffer. `gst_buffer_unref()` after usage. [transfer full]

### 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

`writer` : | GstByteWriter instance. [in][transfer full]
Returns : | the current data. `g_free()` after usage. [transfer full]

### gst_byte_writer_reset ()

    void                gst_byte_writer_reset               (GstByteWriter *writer);

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

`writer` : | GstByteWriter instance

### 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

`writer` : | GstByteWriter instance
Returns : | the current data. `g_free()` after usage. [array][transfer full]

### 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

`writer` : | GstByteWriter instance
Returns : | the current data as buffer. `gst_buffer_unref()` after usage. [transfer full]

### gst_byte_writer_get_pos ()

    guint               gst_byte_writer_get_pos             (const GstByteWriter *writer);

`writer` : | GstByteWriter instance
Returns : | The current position of the read/write cursor

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

`writer` : | GstByteWriter instance
`pos` : | new position
Returns : | `TRUE` if the new position could be set

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

`writer` : | GstByteWriter instance
Returns : | the remaining size of data that can still be written

### gst_byte_writer_get_size ()

    guint               gst_byte_writer_get_size            (const GstByteWriter *writer);

`writer` : | GstByteWriter instance
Returns : | The current, initialized size of the data

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

`writer` : | GstByteWriter instance
`size` : | Number of bytes that should be available
Returns : | `TRUE` if at least `size` bytes are still available

### gst_byte_writer_put_int8 ()

    gboolean            gst_byte_writer_put_int8            (GstByteWriter *writer,
                                                             gint8 val);

Writes a signed 8 bit integer to `writer`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### gst_byte_writer_put_uint8 ()

    gboolean            gst_byte_writer_put_uint8           (GstByteWriter *writer,
                                                             guint8 val);

Writes a unsigned 8 bit integer to `writer`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`val` : | Value to write
Returns : | `TRUE` if the value could be written

### 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).

`writer` : | GstByteWriter instance
`data` : | Null terminated string. [in][array zero-terminated=1]
Returns : | `TRUE` if the string could be written

### 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).

`writer` : | GstByteWriter instance
`data` : | UTF16 string to write. [transfer none][array zero-terminated=1]
Returns : | `TRUE` if the value could be written

### 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).

`writer` : | GstByteWriter instance
`data` : | UTF32 string to write. [transfer none][array zero-terminated=1]
Returns : | `TRUE` if the value could be written

### 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).

`writer` : | GstByteWriter instance
`data` : | UTF8 string to write. [transfer none][array zero-terminated=1][type utf8]
Returns : | `TRUE` if the value could be written

### 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`.

`writer` : | GstByteWriter instance
`data` : | Data to write. [transfer none][array length=size]
`size` : | Size of `data` in bytes
Returns : | `TRUE` if the value could be written

### gst_byte_writer_fill ()

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

Writes `size` bytes containing `value` to `writer`.

`writer` : | GstByteWriter instance
`value` : | Value to be writen
`size` : | Number of bytes to be writen
Returns : | `TRUE` if the value could be written

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`val` : | Value to write

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

`writer` : | GstByteWriter instance
`data` : | Data to write. [in][transfer none][array length=size]
`size` : | Size of `data` in bytes

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

`writer` : | GstByteWriter instance
`value` : | Value to be writen
`size` : | Number of bytes to be writen