GstByteReader

GstBase.ByteReader

GstBase.ByteReader.prototype.dup_data

function GstBase.ByteReader.prototype.dup_data(): {
    // javascript wrapper for 'gst_byte_reader_dup_data'
}

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 GLib.prototype.free when no longer needed.

GstBase.ByteReader.prototype.dup_string_utf16

function GstBase.ByteReader.prototype.dup_string_utf16(): {
    // javascript wrapper for 'gst_byte_reader_dup_string_utf16'
}

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.

GstBase.ByteReader.prototype.dup_string_utf32

function GstBase.ByteReader.prototype.dup_string_utf32(): {
    // javascript wrapper for 'gst_byte_reader_dup_string_utf32'
}

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.

GstBase.ByteReader.prototype.dup_string_utf8

function GstBase.ByteReader.prototype.dup_string_utf8(): {
    // javascript wrapper for 'gst_byte_reader_dup_string_utf8'
}

Free-function: g_free

FIXME:Reads (copies) a NUL-terminated string in the GstBase.ByteReader 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.

GstBase.ByteReader.prototype.free

function GstBase.ByteReader.prototype.free(): {
    // javascript wrapper for 'gst_byte_reader_free'
}

Frees a GstBase.ByteReader instance, which was previously allocated by gst_byte_reader_new (not introspectable).

GstBase.ByteReader.prototype.get_data

function GstBase.ByteReader.prototype.get_data(): {
    // javascript wrapper for 'gst_byte_reader_get_data'
}

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

GstBase.ByteReader.prototype.get_float32_be

function GstBase.ByteReader.prototype.get_float32_be(): {
    // javascript wrapper for 'gst_byte_reader_get_float32_be'
}

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

GstBase.ByteReader.prototype.get_float32_le

function GstBase.ByteReader.prototype.get_float32_le(): {
    // javascript wrapper for 'gst_byte_reader_get_float32_le'
}

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

GstBase.ByteReader.prototype.get_float64_be

function GstBase.ByteReader.prototype.get_float64_be(): {
    // javascript wrapper for 'gst_byte_reader_get_float64_be'
}

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

GstBase.ByteReader.prototype.get_float64_le

function GstBase.ByteReader.prototype.get_float64_le(): {
    // javascript wrapper for 'gst_byte_reader_get_float64_le'
}

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

GstBase.ByteReader.prototype.get_int16_be

function GstBase.ByteReader.prototype.get_int16_be(): {
    // javascript wrapper for 'gst_byte_reader_get_int16_be'
}

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

GstBase.ByteReader.prototype.get_int16_le

function GstBase.ByteReader.prototype.get_int16_le(): {
    // javascript wrapper for 'gst_byte_reader_get_int16_le'
}

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

GstBase.ByteReader.prototype.get_int24_be

function GstBase.ByteReader.prototype.get_int24_be(): {
    // javascript wrapper for 'gst_byte_reader_get_int24_be'
}

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

GstBase.ByteReader.prototype.get_int24_le

function GstBase.ByteReader.prototype.get_int24_le(): {
    // javascript wrapper for 'gst_byte_reader_get_int24_le'
}

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

GstBase.ByteReader.prototype.get_int32_be

function GstBase.ByteReader.prototype.get_int32_be(): {
    // javascript wrapper for 'gst_byte_reader_get_int32_be'
}

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

GstBase.ByteReader.prototype.get_int32_le

function GstBase.ByteReader.prototype.get_int32_le(): {
    // javascript wrapper for 'gst_byte_reader_get_int32_le'
}

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

GstBase.ByteReader.prototype.get_int64_be

function GstBase.ByteReader.prototype.get_int64_be(): {
    // javascript wrapper for 'gst_byte_reader_get_int64_be'
}

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

GstBase.ByteReader.prototype.get_int64_le

function GstBase.ByteReader.prototype.get_int64_le(): {
    // javascript wrapper for 'gst_byte_reader_get_int64_le'
}

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

GstBase.ByteReader.prototype.get_int8

function GstBase.ByteReader.prototype.get_int8(): {
    // javascript wrapper for 'gst_byte_reader_get_int8'
}

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

GstBase.ByteReader.prototype.get_pos

function GstBase.ByteReader.prototype.get_pos(): {
    // javascript wrapper for 'gst_byte_reader_get_pos'
}

Returns the current position of a GstBase.ByteReader instance in bytes.

GstBase.ByteReader.prototype.get_remaining

function GstBase.ByteReader.prototype.get_remaining(): {
    // javascript wrapper for 'gst_byte_reader_get_remaining'
}

Returns the remaining number of bytes of a GstBase.ByteReader instance.

GstBase.ByteReader.prototype.get_size

function GstBase.ByteReader.prototype.get_size(): {
    // javascript wrapper for 'gst_byte_reader_get_size'
}

Returns the total number of bytes of a GstBase.ByteReader instance.

GstBase.ByteReader.prototype.get_string_utf8

function GstBase.ByteReader.prototype.get_string_utf8(): {
    // javascript wrapper for 'gst_byte_reader_get_string_utf8'
}

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.

GstBase.ByteReader.prototype.get_uint16_be

function GstBase.ByteReader.prototype.get_uint16_be(): {
    // javascript wrapper for 'gst_byte_reader_get_uint16_be'
}

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

GstBase.ByteReader.prototype.get_uint16_le

function GstBase.ByteReader.prototype.get_uint16_le(): {
    // javascript wrapper for 'gst_byte_reader_get_uint16_le'
}

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

GstBase.ByteReader.prototype.get_uint24_be

function GstBase.ByteReader.prototype.get_uint24_be(): {
    // javascript wrapper for 'gst_byte_reader_get_uint24_be'
}

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

GstBase.ByteReader.prototype.get_uint24_le

function GstBase.ByteReader.prototype.get_uint24_le(): {
    // javascript wrapper for 'gst_byte_reader_get_uint24_le'
}

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

GstBase.ByteReader.prototype.get_uint32_be

function GstBase.ByteReader.prototype.get_uint32_be(): {
    // javascript wrapper for 'gst_byte_reader_get_uint32_be'
}

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

GstBase.ByteReader.prototype.get_uint32_le

function GstBase.ByteReader.prototype.get_uint32_le(): {
    // javascript wrapper for 'gst_byte_reader_get_uint32_le'
}

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

GstBase.ByteReader.prototype.get_uint64_be

function GstBase.ByteReader.prototype.get_uint64_be(): {
    // javascript wrapper for 'gst_byte_reader_get_uint64_be'
}

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

GstBase.ByteReader.prototype.get_uint64_le

function GstBase.ByteReader.prototype.get_uint64_le(): {
    // javascript wrapper for 'gst_byte_reader_get_uint64_le'
}

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

GstBase.ByteReader.prototype.get_uint8

function GstBase.ByteReader.prototype.get_uint8(): {
    // javascript wrapper for 'gst_byte_reader_get_uint8'
}

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

GstBase.ByteReader.prototype.init

function GstBase.ByteReader.prototype.init(data: [ Number ], size: Number): {
    // javascript wrapper for 'gst_byte_reader_init'
}

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

GstBase.ByteReader.prototype.masked_scan_uint32

function GstBase.ByteReader.prototype.masked_scan_uint32(mask: Number, pattern: Number, offset: Number, size: Number): {
    // javascript wrapper for 'gst_byte_reader_masked_scan_uint32'
}

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.

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

GstBase.ByteReader.prototype.masked_scan_uint32_peek

function GstBase.ByteReader.prototype.masked_scan_uint32_peek(mask: Number, pattern: Number, offset: Number, size: Number): {
    // javascript wrapper for 'gst_byte_reader_masked_scan_uint32_peek'
}

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

GstBase.ByteReader.prototype.peek_data

function GstBase.ByteReader.prototype.peek_data(): {
    // javascript wrapper for 'gst_byte_reader_peek_data'
}

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

GstBase.ByteReader.prototype.peek_float32_be

function GstBase.ByteReader.prototype.peek_float32_be(): {
    // javascript wrapper for 'gst_byte_reader_peek_float32_be'
}

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

GstBase.ByteReader.prototype.peek_float32_le

function GstBase.ByteReader.prototype.peek_float32_le(): {
    // javascript wrapper for 'gst_byte_reader_peek_float32_le'
}

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

GstBase.ByteReader.prototype.peek_float64_be

function GstBase.ByteReader.prototype.peek_float64_be(): {
    // javascript wrapper for 'gst_byte_reader_peek_float64_be'
}

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

GstBase.ByteReader.prototype.peek_float64_le

function GstBase.ByteReader.prototype.peek_float64_le(): {
    // javascript wrapper for 'gst_byte_reader_peek_float64_le'
}

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

GstBase.ByteReader.prototype.peek_int16_be

function GstBase.ByteReader.prototype.peek_int16_be(): {
    // javascript wrapper for 'gst_byte_reader_peek_int16_be'
}

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

GstBase.ByteReader.prototype.peek_int16_le

function GstBase.ByteReader.prototype.peek_int16_le(): {
    // javascript wrapper for 'gst_byte_reader_peek_int16_le'
}

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

GstBase.ByteReader.prototype.peek_int24_be

function GstBase.ByteReader.prototype.peek_int24_be(): {
    // javascript wrapper for 'gst_byte_reader_peek_int24_be'
}

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

GstBase.ByteReader.prototype.peek_int24_le

function GstBase.ByteReader.prototype.peek_int24_le(): {
    // javascript wrapper for 'gst_byte_reader_peek_int24_le'
}

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

GstBase.ByteReader.prototype.peek_int32_be

function GstBase.ByteReader.prototype.peek_int32_be(): {
    // javascript wrapper for 'gst_byte_reader_peek_int32_be'
}

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

GstBase.ByteReader.prototype.peek_int32_le

function GstBase.ByteReader.prototype.peek_int32_le(): {
    // javascript wrapper for 'gst_byte_reader_peek_int32_le'
}

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

GstBase.ByteReader.prototype.peek_int64_be

function GstBase.ByteReader.prototype.peek_int64_be(): {
    // javascript wrapper for 'gst_byte_reader_peek_int64_be'
}

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

GstBase.ByteReader.prototype.peek_int64_le

function GstBase.ByteReader.prototype.peek_int64_le(): {
    // javascript wrapper for 'gst_byte_reader_peek_int64_le'
}

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

GstBase.ByteReader.prototype.peek_int8

function GstBase.ByteReader.prototype.peek_int8(): {
    // javascript wrapper for 'gst_byte_reader_peek_int8'
}

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

GstBase.ByteReader.prototype.peek_string_utf8

function GstBase.ByteReader.prototype.peek_string_utf8(): {
    // javascript wrapper for 'gst_byte_reader_peek_string_utf8'
}

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.

GstBase.ByteReader.prototype.peek_uint16_be

function GstBase.ByteReader.prototype.peek_uint16_be(): {
    // javascript wrapper for 'gst_byte_reader_peek_uint16_be'
}

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

GstBase.ByteReader.prototype.peek_uint16_le

function GstBase.ByteReader.prototype.peek_uint16_le(): {
    // javascript wrapper for 'gst_byte_reader_peek_uint16_le'
}

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

GstBase.ByteReader.prototype.peek_uint24_be

function GstBase.ByteReader.prototype.peek_uint24_be(): {
    // javascript wrapper for 'gst_byte_reader_peek_uint24_be'
}

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

GstBase.ByteReader.prototype.peek_uint24_le

function GstBase.ByteReader.prototype.peek_uint24_le(): {
    // javascript wrapper for 'gst_byte_reader_peek_uint24_le'
}

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

GstBase.ByteReader.prototype.peek_uint32_be

function GstBase.ByteReader.prototype.peek_uint32_be(): {
    // javascript wrapper for 'gst_byte_reader_peek_uint32_be'
}

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

GstBase.ByteReader.prototype.peek_uint32_le

function GstBase.ByteReader.prototype.peek_uint32_le(): {
    // javascript wrapper for 'gst_byte_reader_peek_uint32_le'
}

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

GstBase.ByteReader.prototype.peek_uint64_be

function GstBase.ByteReader.prototype.peek_uint64_be(): {
    // javascript wrapper for 'gst_byte_reader_peek_uint64_be'
}

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

GstBase.ByteReader.prototype.peek_uint64_le

function GstBase.ByteReader.prototype.peek_uint64_le(): {
    // javascript wrapper for 'gst_byte_reader_peek_uint64_le'
}

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

GstBase.ByteReader.prototype.peek_uint8

function GstBase.ByteReader.prototype.peek_uint8(): {
    // javascript wrapper for 'gst_byte_reader_peek_uint8'
}

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

GstBase.ByteReader.prototype.set_pos

function GstBase.ByteReader.prototype.set_pos(pos: Number): {
    // javascript wrapper for 'gst_byte_reader_set_pos'
}

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