GstRTPBuffer

GstRtp.RTPBuffer

GstRtp.RTPBuffer.prototype.add_extension_onebyte_header

function GstRtp.RTPBuffer.prototype.add_extension_onebyte_header(id: Number, data: [ Number ], size: Number): {
    // javascript wrapper for 'gst_rtp_buffer_add_extension_onebyte_header'
}

Adds a RFC 5285 header extension with a one byte header to the end of the RTP header. If there is already a RFC 5285 header extension with a one byte header, the new extension will be appended. It will not work if there is already a header extension that does not follow the mechanism described in RFC 5285 or if there is a header extension with a two bytes header as described in RFC 5285. In that case, use GstRtp.RTPBuffer.prototype.add_extension_twobytes_header

GstRtp.RTPBuffer.prototype.add_extension_twobytes_header

function GstRtp.RTPBuffer.prototype.add_extension_twobytes_header(appbits: Number, id: Number, data: [ Number ], size: Number): {
    // javascript wrapper for 'gst_rtp_buffer_add_extension_twobytes_header'
}

Adds a RFC 5285 header extension with a two bytes header to the end of the RTP header. If there is already a RFC 5285 header extension with a two bytes header, the new extension will be appended. It will not work if there is already a header extension that does not follow the mechanism described in RFC 5285 or if there is a header extension with a one byte header as described in RFC 5285. In that case, use GstRtp.RTPBuffer.prototype.add_extension_onebyte_header

GstRtp.RTPBuffer.prototype.get_csrc

function GstRtp.RTPBuffer.prototype.get_csrc(idx: Number): {
    // javascript wrapper for 'gst_rtp_buffer_get_csrc'
}

Get the CSRC at index idx in buffer.

GstRtp.RTPBuffer.prototype.get_csrc_count

function GstRtp.RTPBuffer.prototype.get_csrc_count(): {
    // javascript wrapper for 'gst_rtp_buffer_get_csrc_count'
}

Get the CSRC count of the RTP packet in buffer.

GstRtp.RTPBuffer.prototype.get_extension

function GstRtp.RTPBuffer.prototype.get_extension(): {
    // javascript wrapper for 'gst_rtp_buffer_get_extension'
}

Check if the extension bit is set on the RTP packet in buffer.

GstRtp.RTPBuffer.prototype.get_extension_bytes

function GstRtp.RTPBuffer.prototype.get_extension_bytes(): {
    // javascript wrapper for 'gst_rtp_buffer_get_extension_bytes'
}

Similar to gst_rtp_buffer_get_extension_data, but more suitable for language bindings usage. bits will contain the extension 16 bits of custom data and the extension data (not including the extension header) is placed in a new GBytes (not introspectable) structure.

If rtp did not contain an extension, this function will return null, with bits unchanged. If there is an extension header but no extension data then an empty GBytes (not introspectable) will be returned.

Since : 1.2

GstRtp.RTPBuffer.prototype.get_extension_onebyte_header

function GstRtp.RTPBuffer.prototype.get_extension_onebyte_header(id: Number, nth: Number): {
    // javascript wrapper for 'gst_rtp_buffer_get_extension_onebyte_header'
}

Parses RFC 5285 style header extensions with a one byte header. It will return the nth extension with the requested id.

GstRtp.RTPBuffer.prototype.get_extension_twobytes_header

function GstRtp.RTPBuffer.prototype.get_extension_twobytes_header(id: Number, nth: Number): {
    // javascript wrapper for 'gst_rtp_buffer_get_extension_twobytes_header'
}

Parses RFC 5285 style header extensions with a two bytes header. It will return the nth extension with the requested id.

GstRtp.RTPBuffer.prototype.get_header_len

function GstRtp.RTPBuffer.prototype.get_header_len(): {
    // javascript wrapper for 'gst_rtp_buffer_get_header_len'
}

Return the total length of the header in buffer. This include the length of the fixed header, the CSRC list and the extension header.

GstRtp.RTPBuffer.prototype.get_marker

function GstRtp.RTPBuffer.prototype.get_marker(): {
    // javascript wrapper for 'gst_rtp_buffer_get_marker'
}

Check if the marker bit is set on the RTP packet in buffer.

GstRtp.RTPBuffer.prototype.get_packet_len

function GstRtp.RTPBuffer.prototype.get_packet_len(): {
    // javascript wrapper for 'gst_rtp_buffer_get_packet_len'
}

Return the total length of the packet in buffer.

GstRtp.RTPBuffer.prototype.get_padding

function GstRtp.RTPBuffer.prototype.get_padding(): {
    // javascript wrapper for 'gst_rtp_buffer_get_padding'
}

Check if the padding bit is set on the RTP packet in buffer.

GstRtp.RTPBuffer.prototype.get_payload_buffer

function GstRtp.RTPBuffer.prototype.get_payload_buffer(): {
    // javascript wrapper for 'gst_rtp_buffer_get_payload_buffer'
}

Create a buffer of the payload of the RTP packet in buffer. This function will internally create a subbuffer of buffer so that a memcpy can be avoided.

GstRtp.RTPBuffer.prototype.get_payload_bytes

function GstRtp.RTPBuffer.prototype.get_payload_bytes(): {
    // javascript wrapper for 'gst_rtp_buffer_get_payload_bytes'
}

Similar to gst_rtp_buffer_get_payload, but more suitable for language bindings usage. The return value is a pointer to a GBytes (not introspectable) structure containing the payload data in rtp.

Since : 1.2

GstRtp.RTPBuffer.prototype.get_payload_len

function GstRtp.RTPBuffer.prototype.get_payload_len(): {
    // javascript wrapper for 'gst_rtp_buffer_get_payload_len'
}

Get the length of the payload of the RTP packet in buffer.

GstRtp.RTPBuffer.prototype.get_payload_subbuffer

function GstRtp.RTPBuffer.prototype.get_payload_subbuffer(offset: Number, len: Number): {
    // javascript wrapper for 'gst_rtp_buffer_get_payload_subbuffer'
}

Create a subbuffer of the payload of the RTP packet in buffer. offset bytes are skipped in the payload and the subbuffer will be of size len. If len is -1 the total payload starting from offset is subbuffered.

GstRtp.RTPBuffer.prototype.get_payload_type

function GstRtp.RTPBuffer.prototype.get_payload_type(): {
    // javascript wrapper for 'gst_rtp_buffer_get_payload_type'
}

Get the payload type of the RTP packet in buffer.

GstRtp.RTPBuffer.prototype.get_seq

function GstRtp.RTPBuffer.prototype.get_seq(): {
    // javascript wrapper for 'gst_rtp_buffer_get_seq'
}

Get the sequence number of the RTP packet in buffer.

GstRtp.RTPBuffer.prototype.get_ssrc

function GstRtp.RTPBuffer.prototype.get_ssrc(): {
    // javascript wrapper for 'gst_rtp_buffer_get_ssrc'
}

Get the SSRC of the RTP packet in buffer.

GstRtp.RTPBuffer.prototype.get_timestamp

function GstRtp.RTPBuffer.prototype.get_timestamp(): {
    // javascript wrapper for 'gst_rtp_buffer_get_timestamp'
}

Get the timestamp of the RTP packet in buffer.

GstRtp.RTPBuffer.prototype.get_version

function GstRtp.RTPBuffer.prototype.get_version(): {
    // javascript wrapper for 'gst_rtp_buffer_get_version'
}

Get the version number of the RTP packet in buffer.

GstRtp.RTPBuffer.prototype.pad_to

function GstRtp.RTPBuffer.prototype.pad_to(len: Number): {
    // javascript wrapper for 'gst_rtp_buffer_pad_to'
}

Set the amount of padding in the RTP packet in buffer to len. If len is 0, the padding is removed.

NOTE: This function does not work correctly.

GstRtp.RTPBuffer.prototype.remove_extension_data

function GstRtp.RTPBuffer.prototype.remove_extension_data(): {
    // javascript wrapper for 'gst_rtp_buffer_remove_extension_data'
}

Unsets the extension bit of the RTP buffer and removes the extension header and data.

If the RTP buffer has no header extension data, the action has no effect. The RTP buffer must be mapped READWRITE only once and the underlying GstBuffer must be writable.

Since : 1.20

GstRtp.RTPBuffer.prototype.set_csrc

function GstRtp.RTPBuffer.prototype.set_csrc(idx: Number, csrc: Number): {
    // javascript wrapper for 'gst_rtp_buffer_set_csrc'
}

Modify the CSRC at index idx in buffer to csrc.

GstRtp.RTPBuffer.prototype.set_extension

function GstRtp.RTPBuffer.prototype.set_extension(extension: Number): {
    // javascript wrapper for 'gst_rtp_buffer_set_extension'
}

Set the extension bit on the RTP packet in buffer to extension.

GstRtp.RTPBuffer.prototype.set_extension_data

function GstRtp.RTPBuffer.prototype.set_extension_data(bits: Number, length: Number): {
    // javascript wrapper for 'gst_rtp_buffer_set_extension_data'
}

Set the extension bit of the rtp buffer and fill in the bits and length of the extension header. If the existing extension data is not large enough, it will be made larger.

Will also shorten the extension data from 1.20.

GstRtp.RTPBuffer.prototype.set_marker

function GstRtp.RTPBuffer.prototype.set_marker(marker: Number): {
    // javascript wrapper for 'gst_rtp_buffer_set_marker'
}

Set the marker bit on the RTP packet in buffer to marker.

GstRtp.RTPBuffer.prototype.set_packet_len

function GstRtp.RTPBuffer.prototype.set_packet_len(len: Number): {
    // javascript wrapper for 'gst_rtp_buffer_set_packet_len'
}

Set the total rtp size to len. The data in the buffer will be made larger if needed. Any padding will be removed from the packet.

GstRtp.RTPBuffer.prototype.set_padding

function GstRtp.RTPBuffer.prototype.set_padding(padding: Number): {
    // javascript wrapper for 'gst_rtp_buffer_set_padding'
}

Set the padding bit on the RTP packet in buffer to padding.

GstRtp.RTPBuffer.prototype.set_payload_type

function GstRtp.RTPBuffer.prototype.set_payload_type(payload_type: Number): {
    // javascript wrapper for 'gst_rtp_buffer_set_payload_type'
}

Set the payload type of the RTP packet in buffer to payload_type.

GstRtp.RTPBuffer.prototype.set_seq

function GstRtp.RTPBuffer.prototype.set_seq(seq: Number): {
    // javascript wrapper for 'gst_rtp_buffer_set_seq'
}

Set the sequence number of the RTP packet in buffer to seq.

GstRtp.RTPBuffer.prototype.set_ssrc

function GstRtp.RTPBuffer.prototype.set_ssrc(ssrc: Number): {
    // javascript wrapper for 'gst_rtp_buffer_set_ssrc'
}

Set the SSRC on the RTP packet in buffer to ssrc.

GstRtp.RTPBuffer.prototype.set_timestamp

function GstRtp.RTPBuffer.prototype.set_timestamp(timestamp: Number): {
    // javascript wrapper for 'gst_rtp_buffer_set_timestamp'
}

Set the timestamp of the RTP packet in buffer to timestamp.

GstRtp.RTPBuffer.prototype.set_version

function GstRtp.RTPBuffer.prototype.set_version(version: Number): {
    // javascript wrapper for 'gst_rtp_buffer_set_version'
}

Set the version of the RTP packet in buffer to version.

GstRtp.RTPBuffer.prototype.unmap

function GstRtp.RTPBuffer.prototype.unmap(): {
    // javascript wrapper for 'gst_rtp_buffer_unmap'
}

Unmap rtp previously mapped with GstRtp.RTPBuffer.prototype.map.

GstRtp.RTPBuffer.prototype.allocate_data

function GstRtp.RTPBuffer.prototype.allocate_data(buffer: Gst.Buffer, payload_len: Number, pad_len: Number, csrc_count: Number): {
    // javascript wrapper for 'gst_rtp_buffer_allocate_data'
}

Allocate enough data in buffer to hold an RTP packet with csrc_count CSRCs, a payload length of payload_len and padding of pad_len. buffer must be writable and all previous memory in buffer will be freed. If pad_len is >0, the padding bit will be set. All other RTP header fields will be set to 0/FALSE.

GstRtp.RTPBuffer.prototype.calc_header_len

function GstRtp.RTPBuffer.prototype.calc_header_len(csrc_count: Number): {
    // javascript wrapper for 'gst_rtp_buffer_calc_header_len'
}

Calculate the header length of an RTP packet with csrc_count CSRC entries. An RTP packet can have at most 15 CSRC entries.

GstRtp.RTPBuffer.prototype.calc_packet_len

function GstRtp.RTPBuffer.prototype.calc_packet_len(payload_len: Number, pad_len: Number, csrc_count: Number): {
    // javascript wrapper for 'gst_rtp_buffer_calc_packet_len'
}

Calculate the total length of an RTP packet with a payload size of payload_len, a padding of pad_len and a csrc_count CSRC entries.

GstRtp.RTPBuffer.prototype.calc_payload_len

function GstRtp.RTPBuffer.prototype.calc_payload_len(packet_len: Number, pad_len: Number, csrc_count: Number): {
    // javascript wrapper for 'gst_rtp_buffer_calc_payload_len'
}

Calculate the length of the payload of an RTP packet with size packet_len, a padding of pad_len and a csrc_count CSRC entries.

GstRtp.RTPBuffer.prototype.compare_seqnum

function GstRtp.RTPBuffer.prototype.compare_seqnum(seqnum1: Number, seqnum2: Number): {
    // javascript wrapper for 'gst_rtp_buffer_compare_seqnum'
}

Compare two sequence numbers, taking care of wraparounds. This function returns the difference between seqnum1 and seqnum2.

GstRtp.RTPBuffer.prototype.default_clock_rate

function GstRtp.RTPBuffer.prototype.default_clock_rate(payload_type: Number): {
    // javascript wrapper for 'gst_rtp_buffer_default_clock_rate'
}

Get the default clock-rate for the static payload type payload_type.

GstRtp.RTPBuffer.prototype.ext_timestamp

function GstRtp.RTPBuffer.prototype.ext_timestamp(exttimestamp: Number, timestamp: Number): {
    // javascript wrapper for 'gst_rtp_buffer_ext_timestamp'
}

Update the exttimestamp field with the extended timestamp of timestamp For the first call of the method, exttimestamp should point to a location with a value of -1.

This function is able to handle both forward and backward timestamps taking into account:

• timestamp wraparound making sure that the returned value is properly increased.
• timestamp unwraparound making sure that the returned value is properly decreased.

GstRtp.RTPBuffer.prototype.get_extension_onebyte_header_from_bytes

function GstRtp.RTPBuffer.prototype.get_extension_onebyte_header_from_bytes(bytes: GBytes (not introspectable), bit_pattern: Number, id: Number, nth: Number): {
    // javascript wrapper for 'gst_rtp_buffer_get_extension_onebyte_header_from_bytes'
}

Similar to gst_rtp_buffer_get_extension_onebyte_header, but working on the GBytes (not introspectable) you get from gst_rtp_buffer_get_extension_bytes. Parses RFC 5285 style header extensions with a one byte header. It will return the nth extension with the requested id.

Since : 1.18

GstRtp.RTPBuffer.prototype.map

function GstRtp.RTPBuffer.prototype.map(buffer: Gst.Buffer, flags: Gst.MapFlags): {
    // javascript wrapper for 'gst_rtp_buffer_map'
}

Map the contents of buffer into rtp.

GstRtp.RTPBuffer.prototype.new_allocate

function GstRtp.RTPBuffer.prototype.new_allocate(payload_len: Number, pad_len: Number, csrc_count: Number): {
    // javascript wrapper for 'gst_rtp_buffer_new_allocate'
}

Allocate a new Gst.Buffer with enough data to hold an RTP packet with csrc_count CSRCs, a payload length of payload_len and padding of pad_len. All other RTP header fields will be set to 0/FALSE.

GstRtp.RTPBuffer.prototype.new_allocate_len

function GstRtp.RTPBuffer.prototype.new_allocate_len(packet_len: Number, pad_len: Number, csrc_count: Number): {
    // javascript wrapper for 'gst_rtp_buffer_new_allocate_len'
}

Create a new Gst.Buffer that can hold an RTP packet that is exactly packet_len long. The length of the payload depends on pad_len and csrc_count and can be calculated with GstRtp.RTPBuffer.prototype.calc_payload_len. All RTP header fields will be set to 0/FALSE.

GstRtp.RTPBuffer.prototype.new_copy_data

function GstRtp.RTPBuffer.prototype.new_copy_data(data: [ Number ], len: Number): {
    // javascript wrapper for 'gst_rtp_buffer_new_copy_data'
}

Create a new buffer and set the data to a copy of len bytes of data and the size to len. The data will be freed when the buffer is freed.

GstRtp.RTPBuffer.prototype.new_take_data

function GstRtp.RTPBuffer.prototype.new_take_data(data: [ Number ], len: Number): {
    // javascript wrapper for 'gst_rtp_buffer_new_take_data'
}

Create a new buffer and set the data and size of the buffer to data and len respectively. data will be freed when the buffer is unreffed, so this function transfers ownership of data to the new buffer.

GstRtp.RTPBufferFlags

Additional RTP buffer flags. These flags can potentially be used on any buffers carrying RTP packets.

Note that these are only valid for Gst.Caps of type: application/x-rtp (x-rtcp). They can conflict with other extended buffer flags.

Since : 1.10

GstRtp.RTPBufferMapFlags

Additional mapping flags for GstRtp.RTPBuffer.prototype.map.

Since : 1.6.1

GstRtp.RTP_VERSION

The supported RTP version 2.