# GstByteWriter

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.

## GstByteWriter

A byte writer instance.

### Members

`parent` (GstByteReader) –

GstByteReader parent

`alloc_size` (guint) –

Allocation size of the data

`fixed` (gboolean) –

If TRUE no reallocations are allowed

`owned` (gboolean) –

If FALSE no reallocations are allowed and copies of data are returned

## GstBase.ByteWriter

A byte writer instance.

### Members

`parent` (GstBase.ByteReader) –

GstBase.ByteReader parent

`alloc_size` (Number) –

Allocation size of the data

`fixed` (Number) –

If true no reallocations are allowed

`owned` (Number) –

If false no reallocations are allowed and copies of data are returned

## GstBase.ByteWriter

A byte writer instance.

### Members

`parent` (GstBase.ByteReader) –

GstBase.ByteReader parent

`alloc_size` (int) –

Allocation size of the data

`fixed` (bool) –

If True no reallocations are allowed

`owned` (bool) –

If False no reallocations are allowed and copies of data are returned

### Methods

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

Parameters:

`writer` –

GstByteWriter instance

`size` –

Number of bytes that should be available

Returns –

TRUE if at least size bytes are still available

#### GstBase.ByteWriter.prototype.ensure_free_space

    function GstBase.ByteWriter.prototype.ensure_free_space(size: Number): {
        // javascript wrapper for 'gst_byte_writer_ensure_free_space'
    }

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

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`size` (Number) –

Number of bytes that should be available

Returns (Number) –

true if at least size bytes are still available

#### GstBase.ByteWriter.ensure_free_space

    def GstBase.ByteWriter.ensure_free_space (self, size):
        #python wrapper for 'gst_byte_writer_ensure_free_space'

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

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`size` (int) –

Number of bytes that should be available

Returns (bool) –

True if at least size bytes are still available

#### gst_byte_writer_fill

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

Writes size bytes containing value to writer.

Parameters:

`writer` –

GstByteWriter instance

`value` –

Value to be written

`size` –

Number of bytes to be written

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.fill

    function GstBase.ByteWriter.prototype.fill(value: Number, size: Number): {
        // javascript wrapper for 'gst_byte_writer_fill'
    }

Writes size bytes containing value to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`value` (Number) –

Value to be written

`size` (Number) –

Number of bytes to be written

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.fill

    def GstBase.ByteWriter.fill (self, value, size):
        #python wrapper for 'gst_byte_writer_fill'

Writes size bytes containing value to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`value` (int) –

Value to be written

`size` (int) –

Number of bytes to be written

Returns (bool) –

True if the value could be written

#### gst_byte_writer_free

    gst_byte_writer_free (GstByteWriter * writer)

Frees writer and all memory allocated by it.

Parameters:

`writer` ( [in][transfer: full]) –

GstByteWriter instance

#### GstBase.ByteWriter.prototype.free

    function GstBase.ByteWriter.prototype.free(): {
        // javascript wrapper for 'gst_byte_writer_free'
    }

Frees writer and all memory allocated by it.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

#### GstBase.ByteWriter.free

    def GstBase.ByteWriter.free (self):
        #python wrapper for 'gst_byte_writer_free'

Frees writer and all memory allocated by it.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

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

Parameters:

`writer` ( [in][transfer: full]) –

GstByteWriter instance

Returns ( [transfer: full]) –

the current data as buffer. gst_buffer_unref after usage.

#### GstBase.ByteWriter.prototype.free_and_get_buffer

    function GstBase.ByteWriter.prototype.free_and_get_buffer(): {
        // javascript wrapper for 'gst_byte_writer_free_and_get_buffer'
    }

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

Free-function: gst_buffer_unref

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

Returns (Gst.Buffer) –

the current data as buffer. gst_buffer_unref (not introspectable) after usage.

#### GstBase.ByteWriter.free_and_get_buffer

    def GstBase.ByteWriter.free_and_get_buffer (self):
        #python wrapper for 'gst_byte_writer_free_and_get_buffer'

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

Free-function: gst_buffer_unref

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

Returns (Gst.Buffer) –

the current data as buffer. gst_buffer_unref (not introspectable) after usage.

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

Parameters:

`writer` ( [in][transfer: full]) –

GstByteWriter instance

Returns ( [transfer: full][array]) –

the current data. g_free after usage.

#### GstBase.ByteWriter.prototype.free_and_get_data

    function GstBase.ByteWriter.prototype.free_and_get_data(): {
        // javascript wrapper for 'gst_byte_writer_free_and_get_data'
    }

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

Free-function: g_free

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

Returns ([ Number ]) –

the current data. GLib.prototype.free after usage.

#### GstBase.ByteWriter.free_and_get_data

    def GstBase.ByteWriter.free_and_get_data (self):
        #python wrapper for 'gst_byte_writer_free_and_get_data'

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

Free-function: g_free

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

Returns ([ int ]) –

the current data. GLib.free after usage.

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

Parameters:

`writer` –

GstByteWriter instance

Returns –

the remaining size of data that can still be written

#### GstBase.ByteWriter.prototype.get_remaining

    function GstBase.ByteWriter.prototype.get_remaining(): {
        // javascript wrapper for 'gst_byte_writer_get_remaining'
    }

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

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

Returns (Number) –

the remaining size of data that can still be written

#### GstBase.ByteWriter.get_remaining

    def GstBase.ByteWriter.get_remaining (self):
        #python wrapper for 'gst_byte_writer_get_remaining'

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

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

Returns (int) –

the remaining size of data that can still be written

#### gst_byte_writer_init

    gst_byte_writer_init (GstByteWriter * writer)

Initializes writer to an empty instance

Parameters:

`writer` –

GstByteWriter instance

#### GstBase.ByteWriter.prototype.init

    function GstBase.ByteWriter.prototype.init(): {
        // javascript wrapper for 'gst_byte_writer_init'
    }

Initializes writer to an empty instance

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

#### GstBase.ByteWriter.init

    def GstBase.ByteWriter.init (self):
        #python wrapper for 'gst_byte_writer_init'

Initializes writer to an empty instance

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

#### gst_byte_writer_init_with_data

    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.

Parameters:

`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

#### GstBase.ByteWriter.prototype.init_with_data

    function GstBase.ByteWriter.prototype.init_with_data(data: [ Number ], size: Number, initialized: Number): {
        // javascript wrapper for 'gst_byte_writer_init_with_data'
    }

Initializes writer with the given memory area. If initialized is true it is possible to read size bytes from the GstBase.ByteWriter from the beginning.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`data` ([ Number ]) –

Memory area for writing

`size` (Number) –

Size of data in bytes

`initialized` (Number) –

If true the complete data can be read from the beginning

#### GstBase.ByteWriter.init_with_data

    def GstBase.ByteWriter.init_with_data (self, data, size, initialized):
        #python wrapper for 'gst_byte_writer_init_with_data'

Initializes writer with the given memory area. If initialized is True it is possible to read size bytes from the GstBase.ByteWriter from the beginning.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`data` ([ int ]) –

Memory area for writing

`size` (int) –

Size of data in bytes

`initialized` (bool) –

If True the complete data can be read from the beginning

#### gst_byte_writer_init_with_size

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

Initializes writer with the given initial data size.

Parameters:

`writer` –

GstByteWriter instance

`size` –

Initial size of data

`fixed` –

If TRUE the data can't be reallocated

#### GstBase.ByteWriter.prototype.init_with_size

    function GstBase.ByteWriter.prototype.init_with_size(size: Number, fixed: Number): {
        // javascript wrapper for 'gst_byte_writer_init_with_size'
    }

Initializes writer with the given initial data size.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`size` (Number) –

Initial size of data

`fixed` (Number) –

If true the data can't be reallocated

#### GstBase.ByteWriter.init_with_size

    def GstBase.ByteWriter.init_with_size (self, size, fixed):
        #python wrapper for 'gst_byte_writer_init_with_size'

Initializes writer with the given initial data size.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`size` (int) –

Initial size of data

`fixed` (bool) –

If True the data can't be reallocated

#### gst_byte_writer_put_buffer

    gboolean
    gst_byte_writer_put_buffer (GstByteWriter * writer,
                                GstBuffer * buffer,
                                gsize offset,
                                gssize size)

Writes size bytes of data to writer.

Parameters:

`writer` –

GstByteWriter instance

`buffer` ( [transfer: none]) –

source GstBuffer

`offset` –

offset to copy from

`size` –

total size to copy. If -1, all data is copied

Returns –

TRUE if the data could be written

#### GstBase.ByteWriter.prototype.put_buffer

    function GstBase.ByteWriter.prototype.put_buffer(buffer: Gst.Buffer, offset: Number, size: Number): {
        // javascript wrapper for 'gst_byte_writer_put_buffer'
    }

Writes size bytes of data to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`buffer` (Gst.Buffer) –

source Gst.Buffer

`offset` (Number) –

offset to copy from

`size` (Number) –

total size to copy. If -1, all data is copied

Returns (Number) –

true if the data could be written

#### GstBase.ByteWriter.put_buffer

    def GstBase.ByteWriter.put_buffer (self, buffer, offset, size):
        #python wrapper for 'gst_byte_writer_put_buffer'

Writes size bytes of data to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`buffer` (Gst.Buffer) –

source Gst.Buffer

`offset` (int) –

offset to copy from

`size` (int) –

total size to copy. If -1, all data is copied

Returns (bool) –

True if the data 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.

Parameters:

`writer` –

GstByteWriter instance

`data` ( [transfer: none][array length=size]) –

Data to write

`size` –

Size of data in bytes

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_data

    function GstBase.ByteWriter.prototype.put_data(data: [ Number ], size: Number): {
        // javascript wrapper for 'gst_byte_writer_put_data'
    }

Writes size bytes of data to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`data` ([ Number ]) –

Data to write

`size` (Number) –

Size of data in bytes

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_data

    def GstBase.ByteWriter.put_data (self, data, size):
        #python wrapper for 'gst_byte_writer_put_data'

Writes size bytes of data to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`data` ([ int ]) –

Data to write

`size` (int) –

Size of data in bytes

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_float32_be

    function GstBase.ByteWriter.prototype.put_float32_be(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_float32_be'
    }

Writes a big endian 32 bit float to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_float32_be

    def GstBase.ByteWriter.put_float32_be (self, val):
        #python wrapper for 'gst_byte_writer_put_float32_be'

Writes a big endian 32 bit float to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (float) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_float32_le

    function GstBase.ByteWriter.prototype.put_float32_le(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_float32_le'
    }

Writes a little endian 32 bit float to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_float32_le

    def GstBase.ByteWriter.put_float32_le (self, val):
        #python wrapper for 'gst_byte_writer_put_float32_le'

Writes a little endian 32 bit float to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (float) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_float64_be

    function GstBase.ByteWriter.prototype.put_float64_be(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_float64_be'
    }

Writes a big endian 64 bit float to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_float64_be

    def GstBase.ByteWriter.put_float64_be (self, val):
        #python wrapper for 'gst_byte_writer_put_float64_be'

Writes a big endian 64 bit float to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (float) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_float64_le

    function GstBase.ByteWriter.prototype.put_float64_le(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_float64_le'
    }

Writes a little endian 64 bit float to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_float64_le

    def GstBase.ByteWriter.put_float64_le (self, val):
        #python wrapper for 'gst_byte_writer_put_float64_le'

Writes a little endian 64 bit float to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (float) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_int16_be

    function GstBase.ByteWriter.prototype.put_int16_be(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_int16_be'
    }

Writes a signed big endian 16 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_int16_be

    def GstBase.ByteWriter.put_int16_be (self, val):
        #python wrapper for 'gst_byte_writer_put_int16_be'

Writes a signed big endian 16 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_int16_le

    function GstBase.ByteWriter.prototype.put_int16_le(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_int16_le'
    }

Writes a signed little endian 16 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_int16_le

    def GstBase.ByteWriter.put_int16_le (self, val):
        #python wrapper for 'gst_byte_writer_put_int16_le'

Writes a signed little endian 16 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_int24_be

    function GstBase.ByteWriter.prototype.put_int24_be(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_int24_be'
    }

Writes a signed big endian 24 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_int24_be

    def GstBase.ByteWriter.put_int24_be (self, val):
        #python wrapper for 'gst_byte_writer_put_int24_be'

Writes a signed big endian 24 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_int24_le

    function GstBase.ByteWriter.prototype.put_int24_le(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_int24_le'
    }

Writes a signed little endian 24 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_int24_le

    def GstBase.ByteWriter.put_int24_le (self, val):
        #python wrapper for 'gst_byte_writer_put_int24_le'

Writes a signed little endian 24 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_int32_be

    function GstBase.ByteWriter.prototype.put_int32_be(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_int32_be'
    }

Writes a signed big endian 32 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_int32_be

    def GstBase.ByteWriter.put_int32_be (self, val):
        #python wrapper for 'gst_byte_writer_put_int32_be'

Writes a signed big endian 32 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_int32_le

    function GstBase.ByteWriter.prototype.put_int32_le(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_int32_le'
    }

Writes a signed little endian 32 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_int32_le

    def GstBase.ByteWriter.put_int32_le (self, val):
        #python wrapper for 'gst_byte_writer_put_int32_le'

Writes a signed little endian 32 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_int64_be

    function GstBase.ByteWriter.prototype.put_int64_be(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_int64_be'
    }

Writes a signed big endian 64 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_int64_be

    def GstBase.ByteWriter.put_int64_be (self, val):
        #python wrapper for 'gst_byte_writer_put_int64_be'

Writes a signed big endian 64 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_int64_le

    function GstBase.ByteWriter.prototype.put_int64_le(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_int64_le'
    }

Writes a signed little endian 64 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_int64_le

    def GstBase.ByteWriter.put_int64_le (self, val):
        #python wrapper for 'gst_byte_writer_put_int64_le'

Writes a signed little endian 64 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –

True if the value could be written

#### gst_byte_writer_put_int8

    gboolean
    gst_byte_writer_put_int8 (GstByteWriter * writer,
                              gint8 val)

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

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –
No description available

#### GstBase.ByteWriter.prototype.put_int8

    function GstBase.ByteWriter.prototype.put_int8(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_int8'
    }

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

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –
No description available

#### GstBase.ByteWriter.put_int8

    def GstBase.ByteWriter.put_int8 (self, val):
        #python wrapper for 'gst_byte_writer_put_int8'

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

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –
No description available

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

Parameters:

`writer` –

GstByteWriter instance

`data` ( [transfer: none][array zero-terminated=1]) –

UTF16 string to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_string_utf16

    function GstBase.ByteWriter.prototype.put_string_utf16(data: [ Number ]): {
        // javascript wrapper for 'gst_byte_writer_put_string_utf16'
    }

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

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`data` ([ Number ]) –

UTF16 string to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_string_utf16

    def GstBase.ByteWriter.put_string_utf16 (self, data):
        #python wrapper for 'gst_byte_writer_put_string_utf16'

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

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`data` ([ int ]) –

UTF16 string to write

Returns (bool) –

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

Parameters:

`writer` –

GstByteWriter instance

`data` ( [transfer: none][array zero-terminated=1]) –

UTF32 string to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_string_utf32

    function GstBase.ByteWriter.prototype.put_string_utf32(data: [ Number ]): {
        // javascript wrapper for 'gst_byte_writer_put_string_utf32'
    }

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

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`data` ([ Number ]) –

UTF32 string to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_string_utf32

    def GstBase.ByteWriter.put_string_utf32 (self, data):
        #python wrapper for 'gst_byte_writer_put_string_utf32'

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

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`data` ([ int ]) –

UTF32 string to write

Returns (bool) –

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

Parameters:

`writer` –

GstByteWriter instance

`data` ( [transfer: none]) –

UTF8 string to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_string_utf8

    function GstBase.ByteWriter.prototype.put_string_utf8(data: String): {
        // javascript wrapper for 'gst_byte_writer_put_string_utf8'
    }

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

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`data` (String) –

UTF8 string to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_string_utf8

    def GstBase.ByteWriter.put_string_utf8 (self, data):
        #python wrapper for 'gst_byte_writer_put_string_utf8'

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

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`data` (str) –

UTF8 string to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_uint16_be

    function GstBase.ByteWriter.prototype.put_uint16_be(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_uint16_be'
    }

Writes a unsigned big endian 16 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_uint16_be

    def GstBase.ByteWriter.put_uint16_be (self, val):
        #python wrapper for 'gst_byte_writer_put_uint16_be'

Writes a unsigned big endian 16 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_uint16_le

    function GstBase.ByteWriter.prototype.put_uint16_le(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_uint16_le'
    }

Writes a unsigned little endian 16 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_uint16_le

    def GstBase.ByteWriter.put_uint16_le (self, val):
        #python wrapper for 'gst_byte_writer_put_uint16_le'

Writes a unsigned little endian 16 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_uint24_be

    function GstBase.ByteWriter.prototype.put_uint24_be(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_uint24_be'
    }

Writes a unsigned big endian 24 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_uint24_be

    def GstBase.ByteWriter.put_uint24_be (self, val):
        #python wrapper for 'gst_byte_writer_put_uint24_be'

Writes a unsigned big endian 24 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_uint24_le

    function GstBase.ByteWriter.prototype.put_uint24_le(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_uint24_le'
    }

Writes a unsigned little endian 24 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_uint24_le

    def GstBase.ByteWriter.put_uint24_le (self, val):
        #python wrapper for 'gst_byte_writer_put_uint24_le'

Writes a unsigned little endian 24 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_uint32_be

    function GstBase.ByteWriter.prototype.put_uint32_be(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_uint32_be'
    }

Writes a unsigned big endian 32 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_uint32_be

    def GstBase.ByteWriter.put_uint32_be (self, val):
        #python wrapper for 'gst_byte_writer_put_uint32_be'

Writes a unsigned big endian 32 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_uint32_le

    function GstBase.ByteWriter.prototype.put_uint32_le(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_uint32_le'
    }

Writes a unsigned little endian 32 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_uint32_le

    def GstBase.ByteWriter.put_uint32_le (self, val):
        #python wrapper for 'gst_byte_writer_put_uint32_le'

Writes a unsigned little endian 32 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_uint64_be

    function GstBase.ByteWriter.prototype.put_uint64_be(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_uint64_be'
    }

Writes a unsigned big endian 64 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_uint64_be

    def GstBase.ByteWriter.put_uint64_be (self, val):
        #python wrapper for 'gst_byte_writer_put_uint64_be'

Writes a unsigned big endian 64 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_uint64_le

    function GstBase.ByteWriter.prototype.put_uint64_le(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_uint64_le'
    }

Writes a unsigned little endian 64 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_uint64_le

    def GstBase.ByteWriter.put_uint64_le (self, val):
        #python wrapper for 'gst_byte_writer_put_uint64_le'

Writes a unsigned little endian 64 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –

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.

Parameters:

`writer` –

GstByteWriter instance

`val` –

Value to write

Returns –

TRUE if the value could be written

#### GstBase.ByteWriter.prototype.put_uint8

    function GstBase.ByteWriter.prototype.put_uint8(val: Number): {
        // javascript wrapper for 'gst_byte_writer_put_uint8'
    }

Writes a unsigned 8 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (Number) –

Value to write

Returns (Number) –

true if the value could be written

#### GstBase.ByteWriter.put_uint8

    def GstBase.ByteWriter.put_uint8 (self, val):
        #python wrapper for 'gst_byte_writer_put_uint8'

Writes a unsigned 8 bit integer to writer.

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

`val` (int) –

Value to write

Returns (bool) –

True if the value could be written

#### gst_byte_writer_reset

    gst_byte_writer_reset (GstByteWriter * writer)

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

Parameters:

`writer` –

GstByteWriter instance

#### GstBase.ByteWriter.prototype.reset

    function GstBase.ByteWriter.prototype.reset(): {
        // javascript wrapper for 'gst_byte_writer_reset'
    }

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

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

#### GstBase.ByteWriter.reset

    def GstBase.ByteWriter.reset (self):
        #python wrapper for 'gst_byte_writer_reset'

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

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

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

Parameters:

`writer` –

GstByteWriter instance

Returns ( [transfer: full]) –

the current data as buffer. gst_buffer_unref after usage.

#### GstBase.ByteWriter.prototype.reset_and_get_buffer

    function GstBase.ByteWriter.prototype.reset_and_get_buffer(): {
        // javascript wrapper for 'gst_byte_writer_reset_and_get_buffer'
    }

Resets writer and returns the current data as buffer.

Free-function: gst_buffer_unref

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

Returns (Gst.Buffer) –

the current data as buffer. gst_buffer_unref (not introspectable) after usage.

#### GstBase.ByteWriter.reset_and_get_buffer

    def GstBase.ByteWriter.reset_and_get_buffer (self):
        #python wrapper for 'gst_byte_writer_reset_and_get_buffer'

Resets writer and returns the current data as buffer.

Free-function: gst_buffer_unref

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

Returns (Gst.Buffer) –

the current data as buffer. gst_buffer_unref (not introspectable) after usage.

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

Parameters:

`writer` –

GstByteWriter instance

Returns ( [array][transfer: full]) –

the current data. g_free after usage.

#### GstBase.ByteWriter.prototype.reset_and_get_data

    function GstBase.ByteWriter.prototype.reset_and_get_data(): {
        // javascript wrapper for 'gst_byte_writer_reset_and_get_data'
    }

Resets writer and returns the current data.

Free-function: g_free

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

Returns ([ Number ]) –

the current data. GLib.prototype.free after usage.

#### GstBase.ByteWriter.reset_and_get_data

    def GstBase.ByteWriter.reset_and_get_data (self):
        #python wrapper for 'gst_byte_writer_reset_and_get_data'

Resets writer and returns the current data.

Free-function: g_free

Parameters:

`writer` (GstBase.ByteWriter) –

GstBase.ByteWriter instance

Returns ([ int ]) –

the current data. GLib.free after usage.

### Functions

#### gst_byte_writer_new

    GstByteWriter *
    gst_byte_writer_new ()

Creates a new, empty GstByteWriter instance

Free-function: gst_byte_writer_free

Returns ( [transfer: full]) –

a new, empty GstByteWriter instance

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

Parameters:

`data` ( [array length=size]) –

Memory area for writing

`size` –

Size of data in bytes

`initialized` –

If TRUE the complete data can be read from the beginning

Returns ( [transfer: full]) –

a new GstByteWriter instance

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

Parameters:

`size` –

Initial size of data

`fixed` –

If TRUE the data can't be reallocated

Returns ( [transfer: full]) –

a new GstByteWriter instance

## Function Macros

### __GST_BYTE_WRITER_CREATE_WRITE_FUNC

    #define __GST_BYTE_WRITER_CREATE_WRITE_FUNC(bits,type,name,write_func) \
    static inline void \
    gst_byte_writer_put_##name##_unchecked (GstByteWriter *writer, type val) \
    { \
      guint8 *write_data; \
      \
      write_data = (guint8 *) writer->parent.data + writer->parent.byte; \
      write_func (write_data, val); \
      writer->parent.byte += bits/8; \
      writer->parent.size = MAX (writer->parent.size, writer->parent.byte); \
    } \
    \
    static inline gboolean \
    _gst_byte_writer_put_##name##_inline (GstByteWriter *writer, type val) \
    { \
      g_return_val_if_fail (writer != NULL, FALSE); \
      \
      if (G_UNLIKELY (!_gst_byte_writer_ensure_free_space_inline(writer, bits/8))) \
        return FALSE; \
      \
      gst_byte_writer_put_##name##_unchecked (writer, val); \
      \
      return TRUE; \
    }

### gst_byte_writer_put_string

    #define gst_byte_writer_put_string(writer, data) \
      gst_byte_writer_put_string_utf8(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).

Parameters:

`writer` –

GstByteWriter instance

`data` ( [in][array zero-terminated=1]) –

Null terminated string

Returns –

TRUE if the string could be written

The results of the search are