GST_BYTE_READER_INIT()

#define GST_BYTE_READER_INIT(data, size) {data, size, 0}

A GstByteReader must be initialized with this macro, before it can be used. This macro can used be to initialize a variable, but it cannot be assigned to a variable. In that case you have to use gst_byte_reader_init().

gst_byte_reader_new ()

GstByteReader *
gst_byte_reader_new (const guint8 *data,
                     guint size);

Create a new GstByteReader instance, which will read from data .

Free-function: gst_byte_reader_free

[skip]

gst_byte_reader_free ()

void
gst_byte_reader_free (GstByteReader *reader);

Frees a GstByteReader instance, which was previously allocated by gst_byte_reader_new().

gst_byte_reader_init ()

void
gst_byte_reader_init (GstByteReader *reader,
                      const guint8 *data,
                      guint size);

Initializes a GstByteReader instance to read from data . This function can be called on already initialized instances.

gst_byte_reader_peek_sub_reader ()

gboolean
gst_byte_reader_peek_sub_reader (GstByteReader *reader,
                                 GstByteReader *sub_reader,
                                 guint size);

Initializes a GstByteReader sub-reader instance to contain size bytes of data from the current position of reader . This is useful to read chunked formats and make sure that one doesn't read beyond the size of the sub-chunk.

Unlike gst_byte_reader_get_sub_reader(), this function does not modify the current position of reader .

[skip]

Since: 1.6

gst_byte_reader_get_sub_reader ()

gboolean
gst_byte_reader_get_sub_reader (GstByteReader *reader,
                                GstByteReader *sub_reader,
                                guint size);

Initializes a GstByteReader sub-reader instance to contain size bytes of data from the current position of reader . This is useful to read chunked formats and make sure that one doesn't read beyond the size of the sub-chunk.

Unlike gst_byte_reader_peek_sub_reader(), this function also modifies the position of reader and moves it forward by size bytes.

[skip]

Since: 1.6

gst_byte_reader_get_pos ()

guint
gst_byte_reader_get_pos (const GstByteReader *reader);

Returns the current position of a GstByteReader instance in bytes.

gst_byte_reader_get_remaining ()

guint
gst_byte_reader_get_remaining (const GstByteReader *reader);

Returns the remaining number of bytes of a GstByteReader instance.

gst_byte_reader_set_pos ()

gboolean
gst_byte_reader_set_pos (GstByteReader *reader,
                         guint pos);

Sets the new position of a GstByteReader instance to pos in bytes.

gst_byte_reader_get_size ()

guint
gst_byte_reader_get_size (const GstByteReader *reader);

Returns the total number of bytes of a GstByteReader instance.

gst_byte_reader_skip ()

gboolean
gst_byte_reader_skip (GstByteReader *reader,
                      guint nbytes);

Skips nbytes bytes of the GstByteReader instance.

gst_byte_reader_get_int8 ()

gboolean
gst_byte_reader_get_int8 (GstByteReader *reader,
                          gint8 *val);

Read a signed 8 bit integer into val and update the current position.

gst_byte_reader_get_int16_be ()

gboolean
gst_byte_reader_get_int16_be (GstByteReader *reader,
                              gint16 *val);

Read a signed 16 bit big endian integer into val and update the current position.

gst_byte_reader_get_int16_le ()

gboolean
gst_byte_reader_get_int16_le (GstByteReader *reader,
                              gint16 *val);

Read a signed 16 bit little endian integer into val and update the current position.

gst_byte_reader_get_int24_be ()

gboolean
gst_byte_reader_get_int24_be (GstByteReader *reader,
                              gint32 *val);

Read a signed 24 bit big endian integer into val and update the current position.

gst_byte_reader_get_int24_le ()

gboolean
gst_byte_reader_get_int24_le (GstByteReader *reader,
                              gint32 *val);

Read a signed 24 bit little endian integer into val and update the current position.

gst_byte_reader_get_int32_be ()

gboolean
gst_byte_reader_get_int32_be (GstByteReader *reader,
                              gint32 *val);

Read a signed 32 bit big endian integer into val and update the current position.

gst_byte_reader_get_int32_le ()

gboolean
gst_byte_reader_get_int32_le (GstByteReader *reader,
                              gint32 *val);

Read a signed 32 bit little endian integer into val and update the current position.

gst_byte_reader_get_int64_be ()

gboolean
gst_byte_reader_get_int64_be (GstByteReader *reader,
                              gint64 *val);

Read a signed 64 bit big endian integer into val and update the current position.

gst_byte_reader_get_int64_le ()

gboolean
gst_byte_reader_get_int64_le (GstByteReader *reader,
                              gint64 *val);

Read a signed 64 bit little endian integer into val and update the current position.

gst_byte_reader_get_uint8 ()

gboolean
gst_byte_reader_get_uint8 (GstByteReader *reader,
                           guint8 *val);

Read an unsigned 8 bit integer into val and update the current position.

gst_byte_reader_get_uint16_be ()

gboolean
gst_byte_reader_get_uint16_be (GstByteReader *reader,
                               guint16 *val);

Read an unsigned 16 bit big endian integer into val and update the current position.

gst_byte_reader_get_uint16_le ()

gboolean
gst_byte_reader_get_uint16_le (GstByteReader *reader,
                               guint16 *val);

Read an unsigned 16 bit little endian integer into val and update the current position.

gst_byte_reader_get_uint24_be ()

gboolean
gst_byte_reader_get_uint24_be (GstByteReader *reader,
                               guint32 *val);

Read an unsigned 24 bit big endian integer into val and update the current position.

gst_byte_reader_get_uint24_le ()

gboolean
gst_byte_reader_get_uint24_le (GstByteReader *reader,
                               guint32 *val);

Read an unsigned 24 bit little endian integer into val and update the current position.

gst_byte_reader_get_uint32_be ()

gboolean
gst_byte_reader_get_uint32_be (GstByteReader *reader,
                               guint32 *val);

Read an unsigned 32 bit big endian integer into val and update the current position.

gst_byte_reader_get_uint32_le ()

gboolean
gst_byte_reader_get_uint32_le (GstByteReader *reader,
                               guint32 *val);

Read an unsigned 32 bit little endian integer into val and update the current position.

gst_byte_reader_get_uint64_be ()

gboolean
gst_byte_reader_get_uint64_be (GstByteReader *reader,
                               guint64 *val);

Read an unsigned 64 bit big endian integer into val and update the current position.

gst_byte_reader_get_uint64_le ()

gboolean
gst_byte_reader_get_uint64_le (GstByteReader *reader,
                               guint64 *val);

Read an unsigned 64 bit little endian integer into val and update the current position.

gst_byte_reader_peek_int8 ()

gboolean
gst_byte_reader_peek_int8 (const GstByteReader *reader,
                           gint8 *val);

Read a signed 8 bit integer into val but keep the current position.

gst_byte_reader_peek_int16_be ()

gboolean
gst_byte_reader_peek_int16_be (const GstByteReader *reader,
                               gint16 *val);

Read a signed 16 bit big endian integer into val but keep the current position.

gst_byte_reader_peek_int16_le ()

gboolean
gst_byte_reader_peek_int16_le (const GstByteReader *reader,
                               gint16 *val);

Read a signed 16 bit little endian integer into val but keep the current position.

gst_byte_reader_peek_int24_be ()

gboolean
gst_byte_reader_peek_int24_be (const GstByteReader *reader,
                               gint32 *val);

Read a signed 24 bit big endian integer into val but keep the current position.

gst_byte_reader_peek_int24_le ()

gboolean
gst_byte_reader_peek_int24_le (const GstByteReader *reader,
                               gint32 *val);

Read a signed 24 bit little endian integer into val but keep the current position.

gst_byte_reader_peek_int32_be ()

gboolean
gst_byte_reader_peek_int32_be (const GstByteReader *reader,
                               gint32 *val);

Read a signed 32 bit big endian integer into val but keep the current position.

gst_byte_reader_peek_int32_le ()

gboolean
gst_byte_reader_peek_int32_le (const GstByteReader *reader,
                               gint32 *val);

Read a signed 32 bit little endian integer into val but keep the current position.

gst_byte_reader_peek_int64_be ()

gboolean
gst_byte_reader_peek_int64_be (const GstByteReader *reader,
                               gint64 *val);

Read a signed 64 bit big endian integer into val but keep the current position.

gst_byte_reader_peek_int64_le ()

gboolean
gst_byte_reader_peek_int64_le (const GstByteReader *reader,
                               gint64 *val);

Read a signed 64 bit little endian integer into val but keep the current position.

gst_byte_reader_peek_uint8 ()

gboolean
gst_byte_reader_peek_uint8 (const GstByteReader *reader,
                            guint8 *val);

Read an unsigned 8 bit integer into val but keep the current position.

gst_byte_reader_peek_uint16_be ()

gboolean
gst_byte_reader_peek_uint16_be (const GstByteReader *reader,
                                guint16 *val);

Read an unsigned 16 bit big endian integer into val but keep the current position.

gst_byte_reader_peek_uint16_le ()

gboolean
gst_byte_reader_peek_uint16_le (const GstByteReader *reader,
                                guint16 *val);

Read an unsigned 16 bit little endian integer into val but keep the current position.

gst_byte_reader_peek_uint24_be ()

gboolean
gst_byte_reader_peek_uint24_be (const GstByteReader *reader,
                                guint32 *val);

Read an unsigned 24 bit big endian integer into val but keep the current position.

gst_byte_reader_peek_uint24_le ()

gboolean
gst_byte_reader_peek_uint24_le (const GstByteReader *reader,
                                guint32 *val);

Read an unsigned 24 bit little endian integer into val but keep the current position.

gst_byte_reader_peek_uint32_be ()

gboolean
gst_byte_reader_peek_uint32_be (const GstByteReader *reader,
                                guint32 *val);

Read an unsigned 32 bit big endian integer into val but keep the current position.

gst_byte_reader_peek_uint32_le ()

gboolean
gst_byte_reader_peek_uint32_le (const GstByteReader *reader,
                                guint32 *val);

Read an unsigned 32 bit little endian integer into val but keep the current position.

gst_byte_reader_peek_uint64_be ()

gboolean
gst_byte_reader_peek_uint64_be (const GstByteReader *reader,
                                guint64 *val);

Read an unsigned 64 bit big endian integer into val but keep the current position.

gst_byte_reader_peek_uint64_le ()

gboolean
gst_byte_reader_peek_uint64_le (const GstByteReader *reader,
                                guint64 *val);

Read an unsigned 64 bit little endian integer into val but keep the current position.

gst_byte_reader_get_float32_le ()

gboolean
gst_byte_reader_get_float32_le (GstByteReader *reader,
                                gfloat *val);

Read a 32 bit little endian floating point value into val and update the current position.

gst_byte_reader_get_float32_be ()

gboolean
gst_byte_reader_get_float32_be (GstByteReader *reader,
                                gfloat *val);

Read a 32 bit big endian floating point value into val and update the current position.

gst_byte_reader_get_float64_le ()

gboolean
gst_byte_reader_get_float64_le (GstByteReader *reader,
                                gdouble *val);

Read a 64 bit little endian floating point value into val and update the current position.

gst_byte_reader_get_float64_be ()

gboolean
gst_byte_reader_get_float64_be (GstByteReader *reader,
                                gdouble *val);

Read a 64 bit big endian floating point value into val and update the current position.

gst_byte_reader_peek_float32_le ()

gboolean
gst_byte_reader_peek_float32_le (const GstByteReader *reader,
                                 gfloat *val);

Read a 32 bit little endian floating point value into val but keep the current position.

gst_byte_reader_peek_float32_be ()

gboolean
gst_byte_reader_peek_float32_be (const GstByteReader *reader,
                                 gfloat *val);

Read a 32 bit big endian floating point value into val but keep the current position.

gst_byte_reader_peek_float64_le ()

gboolean
gst_byte_reader_peek_float64_le (const GstByteReader *reader,
                                 gdouble *val);

Read a 64 bit little endian floating point value into val but keep the current position.

gst_byte_reader_peek_float64_be ()

gboolean
gst_byte_reader_peek_float64_be (const GstByteReader *reader,
                                 gdouble *val);

Read a 64 bit big endian floating point value into val but keep the current position.

gst_byte_reader_get_data ()

gboolean
gst_byte_reader_get_data (GstByteReader *reader,
                          guint size,
                          const guint8 **val);

Returns a constant pointer to the current data position if at least size bytes are left and updates the current position.

gst_byte_reader_dup_data ()

gboolean
gst_byte_reader_dup_data (GstByteReader *reader,
                          guint size,
                          guint8 **val);

Free-function: g_free

Returns a newly-allocated copy of the current data position if at least size bytes are left and updates the current position. Free with g_free() when no longer needed.

gst_byte_reader_peek_data ()

gboolean
gst_byte_reader_peek_data (const GstByteReader *reader,
                           guint size,
                           const guint8 **val);

Returns a constant pointer to the current data position if at least size bytes are left and keeps the current position.

gst_byte_reader_masked_scan_uint32 ()

guint
gst_byte_reader_masked_scan_uint32 (const GstByteReader *reader,
                                    guint32 mask,
                                    guint32 pattern,
                                    guint offset,
                                    guint size);

Scan for pattern pattern with applied mask mask in the byte reader data, starting from offset offset relative to the current position.

The bytes in pattern and mask are interpreted left-to-right, regardless of endianness. All four bytes of the pattern must be present in the byte reader data for it to match, even if the first or last bytes are masked out.

It is an error to call this function without making sure that there is enough data (offset+size bytes) in the byte reader.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// Assume the reader contains 0x00 0x01 0x02 ... 0xfe 0xff
gst_byte_reader_masked_scan_uint32 (reader, 0xffffffff, 0x00010203, 0, 256);
// -> returns 0
gst_byte_reader_masked_scan_uint32 (reader, 0xffffffff, 0x00010203, 1, 255);
// -> returns -1
gst_byte_reader_masked_scan_uint32 (reader, 0xffffffff, 0x01020304, 1, 255);
// -> returns 1
gst_byte_reader_masked_scan_uint32 (reader, 0xffff, 0x0001, 0, 256);
// -> returns -1
gst_byte_reader_masked_scan_uint32 (reader, 0xffff, 0x0203, 0, 256);
// -> returns 0
gst_byte_reader_masked_scan_uint32 (reader, 0xffff0000, 0x02030000, 0, 256);
// -> returns 2
gst_byte_reader_masked_scan_uint32 (reader, 0xffff0000, 0x02030000, 0, 4);
// -> returns -1

gst_byte_reader_masked_scan_uint32_peek ()

guint
gst_byte_reader_masked_scan_uint32_peek
                               (const GstByteReader *reader,
                                guint32 mask,
                                guint32 pattern,
                                guint offset,
                                guint size,
                                guint32 *value);

Scan for pattern pattern with applied mask mask in the byte reader data, starting from offset offset relative to the current position.

The bytes in pattern and mask are interpreted left-to-right, regardless of endianness. All four bytes of the pattern must be present in the byte reader data for it to match, even if the first or last bytes are masked out.

It is an error to call this function without making sure that there is enough data (offset+size bytes) in the byte reader.

Since: 1.6

gst_byte_reader_get_string()

#define             gst_byte_reader_get_string(reader,str)

gst_byte_reader_get_string_utf8 ()

gboolean
gst_byte_reader_get_string_utf8 (GstByteReader *reader,
                                 const gchar **str);

Returns a constant pointer to the current data position if there is a NUL-terminated string in the data (this could be just a NUL terminator), advancing the current position to the byte after the string. This will work for any NUL-terminated string with a character width of 8 bits, so ASCII, UTF-8, ISO-8859-N etc.

No input checking for valid UTF-8 is done.

This function will fail if no NUL-terminator was found in in the data.

gst_byte_reader_peek_string()

#define             gst_byte_reader_peek_string(reader,str)

Returns a constant pointer to the current data position if there is a NUL-terminated string in the data (this could be just a NUL terminator). The current position will be maintained. This will work for any NUL-terminated string with a character width of 8 bits, so ASCII, UTF-8, ISO-8859-N etc.

This function will fail if no NUL-terminator was found in in the data.

gst_byte_reader_peek_string_utf8 ()

gboolean
gst_byte_reader_peek_string_utf8 (const GstByteReader *reader,
                                  const gchar **str);

Returns a constant pointer to the current data position if there is a NUL-terminated string in the data (this could be just a NUL terminator). The current position will be maintained. This will work for any NUL-terminated string with a character width of 8 bits, so ASCII, UTF-8, ISO-8859-N etc.

No input checking for valid UTF-8 is done.

This function will fail if no NUL-terminator was found in in the data.

gst_byte_reader_dup_string()

#define             gst_byte_reader_dup_string(reader,str)

gst_byte_reader_dup_string_utf8 ()

gboolean
gst_byte_reader_dup_string_utf8 (GstByteReader *reader,
                                 gchar **str);

Free-function: g_free

FIXME:Reads (copies) a NUL-terminated string in the GstByteReader instance, advancing the current position to the byte after the string. This will work for any NUL-terminated string with a character width of 8 bits, so ASCII, UTF-8, ISO-8859-N etc. No input checking for valid UTF-8 is done.

This function will fail if no NUL-terminator was found in in the data.

gst_byte_reader_dup_string_utf16 ()

gboolean
gst_byte_reader_dup_string_utf16 (GstByteReader *reader,
                                  guint16 **str);

Free-function: g_free

Returns a newly-allocated copy of the current data position if there is a NUL-terminated UTF-16 string in the data (this could be an empty string as well), and advances the current position.

No input checking for valid UTF-16 is done. This function is endianness agnostic - you should not assume the UTF-16 characters are in host endianness.

This function will fail if no NUL-terminator was found in in the data.

Note: there is no peek or get variant of this function to ensure correct byte alignment of the UTF-16 string.

gst_byte_reader_dup_string_utf32 ()

gboolean
gst_byte_reader_dup_string_utf32 (GstByteReader *reader,
                                  guint32 **str);

Free-function: g_free

Returns a newly-allocated copy of the current data position if there is a NUL-terminated UTF-32 string in the data (this could be an empty string as well), and advances the current position.

No input checking for valid UTF-32 is done. This function is endianness agnostic - you should not assume the UTF-32 characters are in host endianness.

This function will fail if no NUL-terminator was found in in the data.

Note: there is no peek or get variant of this function to ensure correct byte alignment of the UTF-32 string.

gst_byte_reader_skip_string()

#define             gst_byte_reader_skip_string(reader)

Skips a NUL-terminated string in the GstByteReader instance, advancing the current position to the byte after the string. This will work for any NUL-terminated string with a character width of 8 bits, so ASCII, UTF-8, ISO-8859-N etc.

This function will fail if no NUL-terminator was found in in the data.

gst_byte_reader_skip_string_utf8 ()

gboolean
gst_byte_reader_skip_string_utf8 (GstByteReader *reader);

Skips a NUL-terminated string in the GstByteReader instance, advancing the current position to the byte after the string. This will work for any NUL-terminated string with a character width of 8 bits, so ASCII, UTF-8, ISO-8859-N etc. No input checking for valid UTF-8 is done.

This function will fail if no NUL-terminator was found in in the data.

gst_byte_reader_skip_string_utf16 ()

gboolean
gst_byte_reader_skip_string_utf16 (GstByteReader *reader);

Skips a NUL-terminated UTF-16 string in the GstByteReader instance, advancing the current position to the byte after the string.

No input checking for valid UTF-16 is done.

This function will fail if no NUL-terminator was found in in the data.

gst_byte_reader_skip_string_utf32 ()

gboolean
gst_byte_reader_skip_string_utf32 (GstByteReader *reader);

Skips a NUL-terminated UTF-32 string in the GstByteReader instance, advancing the current position to the byte after the string.

No input checking for valid UTF-32 is done.

This function will fail if no NUL-terminator was found in in the data.

gst_byte_reader_skip_unchecked ()

void
gst_byte_reader_skip_unchecked (GstByteReader *reader,
                                guint nbytes);

Skips nbytes bytes of the GstByteReader instance without checking if there are enough bytes available in the byte reader.

gst_byte_reader_get_int8_unchecked ()

gint8
gst_byte_reader_get_int8_unchecked (GstByteReader *reader);

Read an signed 8 bit integer without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_get_int16_be_unchecked ()

gint16
gst_byte_reader_get_int16_be_unchecked
                               (GstByteReader *reader);

Read a signed 16 bit integer in big endian format without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_get_int16_le_unchecked ()

gint16
gst_byte_reader_get_int16_le_unchecked
                               (GstByteReader *reader);

Read a signed 16 bit integer in little endian format without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_get_int24_be_unchecked ()

gint32
gst_byte_reader_get_int24_be_unchecked
                               (GstByteReader *reader);

Read a signed 24 bit integer in big endian format without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_get_int24_le_unchecked ()

gint32
gst_byte_reader_get_int24_le_unchecked
                               (GstByteReader *reader);

Read a signed 24 bit integer in little endian format without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_get_int32_be_unchecked ()

gint32
gst_byte_reader_get_int32_be_unchecked
                               (GstByteReader *reader);

Read a signed 32 bit integer in big endian format without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_get_int32_le_unchecked ()

gint32
gst_byte_reader_get_int32_le_unchecked
                               (GstByteReader *reader);

Read a signed 32 bit integer in little endian format without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_get_int64_be_unchecked ()

gint64
gst_byte_reader_get_int64_be_unchecked
                               (GstByteReader *reader);

Read a signed 64 bit integer in big endian format without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_get_int64_le_unchecked ()

gint64
gst_byte_reader_get_int64_le_unchecked
                               (GstByteReader *reader);

Read a signed 64 bit integer in little endian format without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_get_uint8_unchecked ()

guint8
gst_byte_reader_get_uint8_unchecked (GstByteReader *reader);

Read an unsigned 8 bit integer without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_get_uint16_be_unchecked ()

guint16
gst_byte_reader_get_uint16_be_unchecked
                               (GstByteReader *reader);

Read an unsigned 16 bit integer in big endian format without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_get_uint16_le_unchecked ()

guint16
gst_byte_reader_get_uint16_le_unchecked
                               (GstByteReader *reader);

Read an unsigned 16 bit integer in little endian format without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_get_uint24_be_unchecked ()

guint32
gst_byte_reader_get_uint24_be_unchecked
                               (GstByteReader *reader);

Read an unsigned 24 bit integer in big endian format without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_get_uint24_le_unchecked ()

guint32
gst_byte_reader_get_uint24_le_unchecked
                               (GstByteReader *reader);

Read an unsigned 24 bit integer in little endian format without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_get_uint32_be_unchecked ()

guint32
gst_byte_reader_get_uint32_be_unchecked
                               (GstByteReader *reader);

Read an unsigned 32 bit integer in big endian format without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_get_uint32_le_unchecked ()

guint32
gst_byte_reader_get_uint32_le_unchecked
                               (GstByteReader *reader);

Read an unsigned 32 bit integer in little endian format without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_get_uint64_be_unchecked ()

guint64
gst_byte_reader_get_uint64_be_unchecked
                               (GstByteReader *reader);

Read an unsigned 64 bit integer in big endian format without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_get_uint64_le_unchecked ()

guint64
gst_byte_reader_get_uint64_le_unchecked
                               (GstByteReader *reader);

Read an unsigned 64 bit integer in little endian format without checking if there are enough bytes available in the byte reader and update the current position.

gst_byte_reader_peek_int8_unchecked ()

gint8
gst_byte_reader_peek_int8_unchecked (GstByteReader *reader);

Read an signed 8 bit integer without checking if there are enough bytes available in the byte reader, but do not advance the current read position.

gst_byte_reader_peek_int16_be_unchecked ()

gint16
gst_byte_reader_peek_int16_be_unchecked
                               (GstByteReader *reader);

Read a signed 16 bit integer in big endian format without checking if there are enough bytes available in the byte reader, but do not advance the current position.

gst_byte_reader_peek_int16_le_unchecked ()

gint16
gst_byte_reader_peek_int16_le_unchecked
                               (GstByteReader *reader);

Read a signed 16 bit integer in little endian format without checking if there are enough bytes available in the byte reader, but do not advance the current position.

gst_byte_reader_peek_int24_be_unchecked ()

gint32
gst_byte_reader_peek_int24_be_unchecked
                               (GstByteReader *reader);

Read a signed 24 bit integer in big endian format without checking if there are enough bytes available in the byte reader, but do not advance the current position.

gst_byte_reader_peek_int24_le_unchecked ()

gint32
gst_byte_reader_peek_int24_le_unchecked
                               (GstByteReader *reader);

Read a signed 24 bit integer in little endian format without checking if there are enough bytes available in the byte reader, but do not advance the current position.

gst_byte_reader_peek_int32_be_unchecked ()

gint32
gst_byte_reader_peek_int32_be_unchecked
                               (GstByteReader *reader);

Read a signed 32 bit integer in big endian format without checking if there are enough bytes available in the byte reader, but do not advance the current position.

gst_byte_reader_peek_int32_le_unchecked ()

gint32
gst_byte_reader_peek_int32_le_unchecked
                               (GstByteReader *reader);

Read a signed 32 bit integer in little endian format without checking if there are enough bytes available in the byte reader, but do not advance the current position.

gst_byte_reader_peek_int64_be_unchecked ()

gint64
gst_byte_reader_peek_int64_be_unchecked
                               (GstByteReader *reader);

Read a signed 64 bit integer in big endian format without checking if there are enough bytes available in the byte reader, but do not advance the current position.

gst_byte_reader_peek_int64_le_unchecked ()

gint64
gst_byte_reader_peek_int64_le_unchecked
                               (GstByteReader *reader);

Read a signed 64 bit integer in little endian format without checking if there are enough bytes available in the byte reader, but do not advance the current position.

gst_byte_reader_peek_uint8_unchecked ()

guint8
gst_byte_reader_peek_uint8_unchecked (GstByteReader *reader);

Read an unsigned 8 bit integer without checking if there are enough bytes available in the byte reader, but do not advance the current read position.

gst_byte_reader_peek_uint16_be_unchecked ()

guint16
gst_byte_reader_peek_uint16_be_unchecked
                               (GstByteReader *reader);

Read an unsigned 16 bit integer in big endian format without checking if there are enough bytes available in the byte reader, but do not advance the current position.

gst_byte_reader_peek_uint16_le_unchecked ()

guint16
gst_byte_reader_peek_uint16_le_unchecked
                               (GstByteReader *reader);

Read an unsigned 16 bit integer in little endian format without checking if there are enough bytes available in the byte reader, but do not advance the current position.

gst_byte_reader_peek_uint24_be_unchecked ()

guint32
gst_byte_reader_peek_uint24_be_unchecked
                               (GstByteReader *reader);

Read an unsigned 24 bit integer in big endian format without checking if there are enough bytes available in the byte reader, but do not advance the current position.

gst_byte_reader_peek_uint24_le_unchecked ()

guint32
gst_byte_reader_peek_uint24_le_unchecked
                               (GstByteReader *reader);

Read an unsigned 24 bit integer in little endian format without checking if there are enough bytes available in the byte reader, but do not advance the current position.

gst_byte_reader_peek_uint32_be_unchecked ()

guint32
gst_byte_reader_peek_uint32_be_unchecked
                               (GstByteReader *reader);

Read an unsigned 32 bit integer in big endian format without checking if there are enough bytes available in the byte reader, but do not advance the current position.

gst_byte_reader_peek_uint32_le_unchecked ()

guint32
gst_byte_reader_peek_uint32_le_unchecked
                               (GstByteReader *reader);

Read an unsigned 32 bit integer in little endian format without checking if there are enough bytes available in the byte reader, but do not advance the current position.

gst_byte_reader_peek_uint64_be_unchecked ()

guint64
gst_byte_reader_peek_uint64_be_unchecked
                               (GstByteReader *reader);

Read an unsigned 64 bit integer in big endian format without checking if there are enough bytes available in the byte reader, but do not advance the current position.

gst_byte_reader_peek_uint64_le_unchecked ()

guint64
gst_byte_reader_peek_uint64_le_unchecked
                               (GstByteReader *reader);

Read an unsigned 64 bit integer in little endian format without checking if there are enough bytes available in the byte reader, but do not advance the current position.

gst_byte_reader_get_float32_le_unchecked ()

gfloat
gst_byte_reader_get_float32_le_unchecked
                               (GstByteReader *reader);

Read a 32 bit little endian float without checking if there is enough data available and update the current position.

gst_byte_reader_get_float32_be_unchecked ()

gfloat
gst_byte_reader_get_float32_be_unchecked
                               (GstByteReader *reader);

Read a 32 bit big endian float without checking if there is enough data available and update the current position.

gst_byte_reader_get_float64_le_unchecked ()

gdouble
gst_byte_reader_get_float64_le_unchecked
                               (GstByteReader *reader);

Read a 64 bit little endian float without checking if there is enough data available and update the current position.

gst_byte_reader_get_float64_be_unchecked ()

gdouble
gst_byte_reader_get_float64_be_unchecked
                               (GstByteReader *reader);

Read a 64 bit big endian float without checking if there is enough data available and update the current position.

gst_byte_reader_peek_float32_le_unchecked ()

gfloat
gst_byte_reader_peek_float32_le_unchecked
                               (GstByteReader *reader);

Read a 32 bit little endian float without checking if there is enough data available, but keep the current position.

gst_byte_reader_peek_float32_be_unchecked ()

gfloat
gst_byte_reader_peek_float32_be_unchecked
                               (GstByteReader *reader);

Read a 32 bit big endian float without checking if there is enough data available, but keep the current position.

gst_byte_reader_peek_float64_le_unchecked ()

gdouble
gst_byte_reader_peek_float64_le_unchecked
                               (GstByteReader *reader);

Read a 64 bit little endian float without checking if there is enough data available, but keep the current position.

gst_byte_reader_peek_float64_be_unchecked ()

gdouble
gst_byte_reader_peek_float64_be_unchecked
                               (GstByteReader *reader);

Read a 64 bit big endian float without checking if there is enough data available, but keep the current position.

gst_byte_reader_dup_data_unchecked ()

guint8 *
gst_byte_reader_dup_data_unchecked (GstByteReader *reader,
                                    guint size);

Returns a newly-allocated copy of the data at the current data position without checking if at least size bytes are left. Advances the current read position by size bytes.

Free-function: g_free

gst_byte_reader_get_data_unchecked ()

const guint8 *
gst_byte_reader_get_data_unchecked (GstByteReader *reader,
                                    guint size);

Returns a constant pointer to the current data position without checking if at least size bytes are left. Advances the current read position by size bytes.

gst_byte_reader_peek_data_unchecked ()

const guint8 *
gst_byte_reader_peek_data_unchecked (const GstByteReader *reader);

GstByteReader

typedef struct {
  const guint8 *data;
  guint size;

  guint byte;  /* Byte position */
} GstByteReader;

A byte reader instance.