Convenience macro to access the source pad of #GstAggregator a #GstAggregator This class is for elements that receive buffers in an undesired size. While for example raw video contains one image per buffer, the same is not true for a lot of other formats, especially those that come directly from a file. So if you have undefined buffer sizes and require a specific size, this object is for you. An adapter is created with gst_adapter_new(). It can be freed again with g_object_unref(). The theory of operation is like this: All buffers received are put into the adapter using gst_adapter_push() and the data is then read back in chunks of the desired size using gst_adapter_map()/gst_adapter_unmap() and/or gst_adapter_copy(). After the data has been processed, it is freed using gst_adapter_unmap(). Other methods such as gst_adapter_take() and gst_adapter_take_buffer() combine gst_adapter_map() and gst_adapter_unmap() in one method and are potentially more convenient for some use cases. For example, a sink pad's chain function that needs to pass data to a library in 512-byte chunks could be implemented like this: |[<!-- language="C" --> static GstFlowReturn sink_pad_chain (GstPad *pad, GstObject *parent, GstBuffer *buffer) { MyElement *this; GstAdapter *adapter; GstFlowReturn ret = GST_FLOW_OK; this = MY_ELEMENT (parent); adapter = this->adapter; // put buffer into adapter gst_adapter_push (adapter, buffer); // while we can read out 512 bytes, process them while (gst_adapter_available (adapter) >= 512 && ret == GST_FLOW_OK) { const guint8 *data = gst_adapter_map (adapter, 512); // use flowreturn as an error value ret = my_library_foo (data); gst_adapter_unmap (adapter); gst_adapter_flush (adapter, 512); } return ret; } ]| For another example, a simple element inside GStreamer that uses #GstAdapter is the libvisual element. An element using #GstAdapter in its sink pad chain function should ensure that when the FLUSH_STOP event is received, that any queued data is cleared using gst_adapter_clear(). Data should also be cleared or processed on EOS and when changing state from %GST_STATE_PAUSED to %GST_STATE_READY. Also check the GST_BUFFER_FLAG_DISCONT flag on the buffer. Some elements might need to clear the adapter after a discontinuity. The adapter will keep track of the timestamps of the buffers that were pushed. The last seen timestamp before the current position can be queried with gst_adapter_prev_pts(). This function can optionally return the number of bytes between the start of the buffer that carried the timestamp and the current adapter position. The distance is useful when dealing with, for example, raw audio samples because it allows you to calculate the timestamp of the current adapter position by using the last seen timestamp and the amount of bytes since. Additionally, the gst_adapter_prev_pts_at_offset() can be used to determine the last seen timestamp at a particular offset in the adapter. The adapter will also keep track of the offset of the buffers (#GST_BUFFER_OFFSET) that were pushed. The last seen offset before the current position can be queried with gst_adapter_prev_offset(). This function can optionally return the number of bytes between the start of the buffer that carried the offset and the current adapter position. Additionally the adapter also keeps track of the PTS, DTS and buffer offset at the last discontinuity, which can be retrieved with gst_adapter_pts_at_discont(), gst_adapter_dts_at_discont() and gst_adapter_offset_at_discont(). The number of bytes that were consumed since then can be queried with gst_adapter_distance_from_discont(). A last thing to note is that while #GstAdapter is pretty optimized, merging buffers still might be an operation that requires a `malloc()` and `memcpy()` operation, and these operations are not the fastest. Because of this, some functions like gst_adapter_available_fast() are provided to help speed up such cases should you want to. To avoid repeated memory allocations, gst_adapter_copy() can be used to copy data into a (statically allocated) user provided buffer. #GstAdapter is not MT safe. All operations on an adapter must be serialized by the caller. This is not normally a problem, however, as the normal use case of #GstAdapter is inside one pad's chain function, in which case access is serialized via the pad's STREAM_LOCK. Note that gst_adapter_push() takes ownership of the buffer passed. Use gst_buffer_ref() before pushing it into the adapter if you still want to access the buffer later. The adapter will never modify the data in the buffer pushed in it. Creates a new #GstAdapter. Free with g_object_unref(). a new #GstAdapter Gets the maximum amount of bytes available, that is it returns the maximum value that can be supplied to gst_adapter_map() without that function returning %NULL. number of bytes available in @adapter a #GstAdapter Gets the maximum number of bytes that are immediately available without requiring any expensive operations (like copying the data into a temporary buffer). number of bytes that are available in @adapter without expensive operations a #GstAdapter Removes all buffers from @adapter. a #GstAdapter Copies @size bytes of data starting at @offset out of the buffers contained in #GstAdapter into an array @dest provided by the caller. The array @dest should be large enough to contain @size bytes. The user should check that the adapter has (@offset + @size) bytes available before calling this function. a #GstAdapter the memory to copy into the bytes offset in the adapter to start from the number of bytes to copy Similar to gst_adapter_copy, but more suitable for language bindings. @size bytes of data starting at @offset will be copied out of the buffers contained in @adapter and into a new #GBytes structure which is returned. Depending on the value of the @size argument an empty #GBytes structure may be returned. A new #GBytes structure containing the copied data. a #GstAdapter the bytes offset in the adapter to start from the number of bytes to copy Get the distance in bytes since the last buffer with the %GST_BUFFER_FLAG_DISCONT flag. The distance will be reset to 0 for all buffers with %GST_BUFFER_FLAG_DISCONT on them, and then calculated for all other following buffers based on their size. The offset. Can be %GST_BUFFER_OFFSET_NONE. a #GstAdapter Get the DTS that was on the last buffer with the GST_BUFFER_FLAG_DISCONT flag, or GST_CLOCK_TIME_NONE. The DTS at the last discont or GST_CLOCK_TIME_NONE. a #GstAdapter Flushes the first @flush bytes in the @adapter. The caller must ensure that at least this many bytes are available. See also: gst_adapter_map(), gst_adapter_unmap() a #GstAdapter the number of bytes to flush Returns a #GstBuffer containing the first @nbytes of the @adapter, but does not flush them from the adapter. See gst_adapter_take_buffer() for details. Caller owns a reference to the returned buffer. gst_buffer_unref() after usage. Free-function: gst_buffer_unref a #GstBuffer containing the first @nbytes of the adapter, or %NULL if @nbytes bytes are not available. gst_buffer_unref() when no longer needed. a #GstAdapter the number of bytes to get Returns a #GstBuffer containing the first @nbytes of the @adapter, but does not flush them from the adapter. See gst_adapter_take_buffer_fast() for details. Caller owns a reference to the returned buffer. gst_buffer_unref() after usage. Free-function: gst_buffer_unref a #GstBuffer containing the first @nbytes of the adapter, or %NULL if @nbytes bytes are not available. gst_buffer_unref() when no longer needed. a #GstAdapter the number of bytes to get Returns a #GstBufferList of buffers containing the first @nbytes bytes of the @adapter but does not flush them from the adapter. See gst_adapter_take_buffer_list() for details. Caller owns the returned list. Call gst_buffer_list_unref() to free the list after usage. a #GstBufferList of buffers containing the first @nbytes of the adapter, or %NULL if @nbytes bytes are not available a #GstAdapter the number of bytes to get Returns a #GList of buffers containing the first @nbytes bytes of the @adapter, but does not flush them from the adapter. See gst_adapter_take_list() for details. Caller owns returned list and contained buffers. gst_buffer_unref() each buffer in the list before freeing the list after usage. a #GList of buffers containing the first @nbytes of the adapter, or %NULL if @nbytes bytes are not available a #GstAdapter the number of bytes to get Gets the first @size bytes stored in the @adapter. The returned pointer is valid until the next function is called on the adapter. Note that setting the returned pointer as the data of a #GstBuffer is incorrect for general-purpose plugins. The reason is that if a downstream element stores the buffer so that it has access to it outside of the bounds of its chain function, the buffer will have an invalid data pointer after your element flushes the bytes. In that case you should use gst_adapter_take(), which returns a freshly-allocated buffer that you can set as #GstBuffer memory or the potentially more performant gst_adapter_take_buffer(). Returns %NULL if @size bytes are not available. a pointer to the first @size bytes of data, or %NULL a #GstAdapter the number of bytes to map/peek Scan for pattern @pattern with applied mask @mask in the adapter data, starting from offset @offset. 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 adapter 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 adapter. This function calls gst_adapter_masked_scan_uint32_peek() passing %NULL for value. offset of the first match, or -1 if no match was found. Example: |[ // Assume the adapter contains 0x00 0x01 0x02 ... 0xfe 0xff gst_adapter_masked_scan_uint32 (adapter, 0xffffffff, 0x00010203, 0, 256); // -> returns 0 gst_adapter_masked_scan_uint32 (adapter, 0xffffffff, 0x00010203, 1, 255); // -> returns -1 gst_adapter_masked_scan_uint32 (adapter, 0xffffffff, 0x01020304, 1, 255); // -> returns 1 gst_adapter_masked_scan_uint32 (adapter, 0xffff, 0x0001, 0, 256); // -> returns -1 gst_adapter_masked_scan_uint32 (adapter, 0xffff, 0x0203, 0, 256); // -> returns 0 gst_adapter_masked_scan_uint32 (adapter, 0xffff0000, 0x02030000, 0, 256); // -> returns 2 gst_adapter_masked_scan_uint32 (adapter, 0xffff0000, 0x02030000, 0, 4); // -> returns -1 ]| a #GstAdapter mask to apply to data before matching against @pattern pattern to match (after mask is applied) offset into the adapter data from which to start scanning, returns the last scanned position. number of bytes to scan from offset Scan for pattern @pattern with applied mask @mask in the adapter data, starting from offset @offset. If a match is found, the value that matched is returned through @value, otherwise @value is left untouched. 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 adapter 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 adapter. offset of the first match, or -1 if no match was found. a #GstAdapter mask to apply to data before matching against @pattern pattern to match (after mask is applied) offset into the adapter data from which to start scanning, returns the last scanned position. number of bytes to scan from offset pointer to uint32 to return matching data Get the offset that was on the last buffer with the GST_BUFFER_FLAG_DISCONT flag, or GST_BUFFER_OFFSET_NONE. The offset at the last discont or GST_BUFFER_OFFSET_NONE. a #GstAdapter Get the dts that was before the current byte in the adapter. When @distance is given, the amount of bytes between the dts and the current position is returned. The dts is reset to GST_CLOCK_TIME_NONE and the distance is set to 0 when the adapter is first created or when it is cleared. This also means that before the first byte with a dts is removed from the adapter, the dts and distance returned are GST_CLOCK_TIME_NONE and 0 respectively. The previously seen dts. a #GstAdapter pointer to location for distance, or %NULL Get the dts that was before the byte at offset @offset in the adapter. When @distance is given, the amount of bytes between the dts and the current position is returned. The dts is reset to GST_CLOCK_TIME_NONE and the distance is set to 0 when the adapter is first created or when it is cleared. This also means that before the first byte with a dts is removed from the adapter, the dts and distance returned are GST_CLOCK_TIME_NONE and 0 respectively. The previously seen dts at given offset. a #GstAdapter the offset in the adapter at which to get timestamp pointer to location for distance, or %NULL Get the offset that was before the current byte in the adapter. When @distance is given, the amount of bytes between the offset and the current position is returned. The offset is reset to GST_BUFFER_OFFSET_NONE and the distance is set to 0 when the adapter is first created or when it is cleared. This also means that before the first byte with an offset is removed from the adapter, the offset and distance returned are GST_BUFFER_OFFSET_NONE and 0 respectively. The previous seen offset. a #GstAdapter pointer to a location for distance, or %NULL Get the pts that was before the current byte in the adapter. When @distance is given, the amount of bytes between the pts and the current position is returned. The pts is reset to GST_CLOCK_TIME_NONE and the distance is set to 0 when the adapter is first created or when it is cleared. This also means that before the first byte with a pts is removed from the adapter, the pts and distance returned are GST_CLOCK_TIME_NONE and 0 respectively. The previously seen pts. a #GstAdapter pointer to location for distance, or %NULL Get the pts that was before the byte at offset @offset in the adapter. When @distance is given, the amount of bytes between the pts and the current position is returned. The pts is reset to GST_CLOCK_TIME_NONE and the distance is set to 0 when the adapter is first created or when it is cleared. This also means that before the first byte with a pts is removed from the adapter, the pts and distance returned are GST_CLOCK_TIME_NONE and 0 respectively. The previously seen pts at given offset. a #GstAdapter the offset in the adapter at which to get timestamp pointer to location for distance, or %NULL Get the PTS that was on the last buffer with the GST_BUFFER_FLAG_DISCONT flag, or GST_CLOCK_TIME_NONE. The PTS at the last discont or GST_CLOCK_TIME_NONE. a #GstAdapter Adds the data from @buf to the data stored inside @adapter and takes ownership of the buffer. a #GstAdapter a #GstBuffer to add to queue in the adapter Returns a freshly allocated buffer containing the first @nbytes bytes of the @adapter. The returned bytes will be flushed from the adapter. Caller owns returned value. g_free after usage. Free-function: g_free oven-fresh hot data, or %NULL if @nbytes bytes are not available a #GstAdapter the number of bytes to take Returns a #GstBuffer containing the first @nbytes bytes of the @adapter. The returned bytes will be flushed from the adapter. This function is potentially more performant than gst_adapter_take() since it can reuse the memory in pushed buffers by subbuffering or merging. This function will always return a buffer with a single memory region. Note that no assumptions should be made as to whether certain buffer flags such as the DISCONT flag are set on the returned buffer, or not. The caller needs to explicitly set or unset flags that should be set or unset. Since 1.6 this will also copy over all GstMeta of the input buffers except for meta with the %GST_META_FLAG_POOLED flag or with the "memory" tag. Caller owns a reference to the returned buffer. gst_buffer_unref() after usage. Free-function: gst_buffer_unref a #GstBuffer containing the first @nbytes of the adapter, or %NULL if @nbytes bytes are not available. gst_buffer_unref() when no longer needed. a #GstAdapter the number of bytes to take Returns a #GstBuffer containing the first @nbytes of the @adapter. The returned bytes will be flushed from the adapter. This function is potentially more performant than gst_adapter_take_buffer() since it can reuse the memory in pushed buffers by subbuffering or merging. Unlike gst_adapter_take_buffer(), the returned buffer may be composed of multiple non-contiguous #GstMemory objects, no copies are made. Note that no assumptions should be made as to whether certain buffer flags such as the DISCONT flag are set on the returned buffer, or not. The caller needs to explicitly set or unset flags that should be set or unset. This will also copy over all GstMeta of the input buffers except for meta with the %GST_META_FLAG_POOLED flag or with the "memory" tag. This function can return buffer up to the return value of gst_adapter_available() without making copies if possible. Caller owns a reference to the returned buffer. gst_buffer_unref() after usage. Free-function: gst_buffer_unref a #GstBuffer containing the first @nbytes of the adapter, or %NULL if @nbytes bytes are not available. gst_buffer_unref() when no longer needed. a #GstAdapter the number of bytes to take Returns a #GstBufferList of buffers containing the first @nbytes bytes of the @adapter. The returned bytes will be flushed from the adapter. When the caller can deal with individual buffers, this function is more performant because no memory should be copied. Caller owns the returned list. Call gst_buffer_list_unref() to free the list after usage. a #GstBufferList of buffers containing the first @nbytes of the adapter, or %NULL if @nbytes bytes are not available a #GstAdapter the number of bytes to take Returns a #GList of buffers containing the first @nbytes bytes of the @adapter. The returned bytes will be flushed from the adapter. When the caller can deal with individual buffers, this function is more performant because no memory should be copied. Caller owns returned list and contained buffers. gst_buffer_unref() each buffer in the list before freeing the list after usage. a #GList of buffers containing the first @nbytes of the adapter, or %NULL if @nbytes bytes are not available a #GstAdapter the number of bytes to take Releases the memory obtained with the last gst_adapter_map(). a #GstAdapter Manages a set of pads with the purpose of aggregating their buffers. Control is given to the subclass when all pads have data. * Base class for mixers and muxers. Subclasses should at least implement the #GstAggregatorClass.aggregate() virtual method. * Installs a #GstPadChainFunction, a #GstPadEventFullFunction and a #GstPadQueryFunction to queue all serialized data packets per sink pad. Subclasses should not overwrite those, but instead implement #GstAggregatorClass.sink_event() and #GstAggregatorClass.sink_query() as needed. * When data is queued on all pads, the aggregate vmethod is called. * One can peek at the data on any given GstAggregatorPad with the gst_aggregator_pad_peek_buffer() method, and remove it from the pad with the gst_aggregator_pad_pop_buffer () method. When a buffer has been taken with pop_buffer (), a new buffer can be queued on that pad. * If the subclass wishes to push a buffer downstream in its aggregate implementation, it should do so through the gst_aggregator_finish_buffer() method. This method will take care of sending and ordering mandatory events such as stream start, caps and segment. Buffer lists can also be pushed out with gst_aggregator_finish_buffer_list(). * Same goes for EOS events, which should not be pushed directly by the subclass, it should instead return GST_FLOW_EOS in its aggregate implementation. * Note that the aggregator logic regarding gap event handling is to turn these into gap buffers with matching PTS and duration. It will also flag these buffers with GST_BUFFER_FLAG_GAP and GST_BUFFER_FLAG_DROPPABLE to ease their identification and subsequent processing. * Subclasses must use (a subclass of) #GstAggregatorPad for both their sink and source pads. See gst_element_class_add_static_pad_template_with_gtype(). This class used to live in gst-plugins-bad and was moved to core. This method will push the provided output buffer downstream. If needed, mandatory events such as stream-start, caps, and segment events will be sent before pushing the buffer. The #GstAggregator the #GstBuffer to push. This method will push the provided output buffer list downstream. If needed, mandatory events such as stream-start, caps, and segment events will be sent before pushing the buffer. The #GstAggregator the #GstBufferList to push. Negotiates src pad caps with downstream elements. Unmarks GST_PAD_FLAG_NEED_RECONFIGURE in any case. But marks it again if #GstAggregatorClass.negotiate() fails. %TRUE if the negotiation succeeded, else %FALSE. a #GstAggregator Use this function to determine what input buffers will be aggregated to produce the next output buffer. This should only be called from a #GstAggregator::samples-selected handler, and can be used to precisely control aggregating parameters for a given set of input samples. The sample that is about to be aggregated. It may hold a #GstBuffer or a #GstBufferList. The contents of its info structure is subclass-dependent, and documented on a subclass basis. The buffers held by the sample are not writable. This method will push the provided output buffer downstream. If needed, mandatory events such as stream-start, caps, and segment events will be sent before pushing the buffer. The #GstAggregator the #GstBuffer to push. This method will push the provided output buffer list downstream. If needed, mandatory events such as stream-start, caps, and segment events will be sent before pushing the buffer. The #GstAggregator the #GstBufferList to push. Lets #GstAggregator sub-classes get the memory @allocator acquired by the base class and its @params. Unref the @allocator after use it. a #GstAggregator the #GstAllocator used the #GstAllocationParams of @allocator the instance of the #GstBufferPool used by @trans; free it after use it a #GstAggregator Retrieves the latency values reported by @self in response to the latency query, or %GST_CLOCK_TIME_NONE if there is not live source connected and the element will not wait for the clock. Typically only called by subclasses. The latency or %GST_CLOCK_TIME_NONE if the element does not sync a #GstAggregator Negotiates src pad caps with downstream elements. Unmarks GST_PAD_FLAG_NEED_RECONFIGURE in any case. But marks it again if #GstAggregatorClass.negotiate() fails. %TRUE if the negotiation succeeded, else %FALSE. a #GstAggregator Use this function to determine what input buffers will be aggregated to produce the next output buffer. This should only be called from a #GstAggregator::samples-selected handler, and can be used to precisely control aggregating parameters for a given set of input samples. The sample that is about to be aggregated. It may hold a #GstBuffer or a #GstBufferList. The contents of its info structure is subclass-dependent, and documented on a subclass basis. The buffers held by the sample are not writable. Subclasses should call this when they have prepared the buffers they will aggregate for each of their sink pads, but before using any of the properties of the pads that govern *how* aggregation should be performed, for example z-index for video aggregators. If gst_aggregator_update_segment() is used by the subclass, it MUST be called before gst_aggregator_selected_samples(). The presentation timestamp of the next output buffer The decoding timestamp of the next output buffer The duration of the next output buffer a #GstStructure containing additional information Lets #GstAggregator sub-classes tell the baseclass what their internal latency is. Will also post a LATENCY message on the bus so the pipeline can reconfigure its global latency. a #GstAggregator minimum latency maximum latency Sets the caps to be used on the src pad. The #GstAggregator The #GstCaps to set on the src pad. This is a simple #GstAggregatorClass.get_next_time() implementation that just looks at the #GstSegment on the srcpad of the aggregator and bases the next time on the running time there. This is the desired behaviour in most cases where you have a live source and you have a dead line based aggregator subclass. The running time based on the position A #GstAggregator Subclasses should use this to update the segment on their source pad, instead of directly pushing new segment events downstream. Subclasses MUST call this before gst_aggregator_selected_samples(), if it is used at all. Enables the emission of signals such as #GstAggregator::samples-selected Force minimum upstream latency (in nanoseconds). When sources with a higher latency are expected to be plugged in dynamically after the aggregator has started playing, this allows overriding the minimum latency reported by the initial source(s). This is only taken into account when larger than the actually reported minimum latency. the aggregator's source pad Signals that the #GstAggregator subclass has selected the next set of input samples it will aggregate. Handlers may call gst_aggregator_peek_next_sample() at that point. The aggregator base class will handle in a thread-safe way all manners of concurrent flushes, seeks, pad additions and removals, leaving to the subclass the responsibility of clipping buffers, and aggregating buffers in the way the implementor sees fit. It will also take care of event ordering (stream-start, segment, eos). Basically, a simple implementation will override @aggregate, and call _finish_buffer from inside that function. The #GstAggregator the #GstBuffer to push. %TRUE if the negotiation succeeded, else %FALSE. a #GstAggregator The #GstAggregator the #GstBufferList to push. The sample that is about to be aggregated. It may hold a #GstBuffer or a #GstBufferList. The contents of its info structure is subclass-dependent, and documented on a subclass basis. The buffers held by the sample are not writable. Pads managed by a #GstAggregator subclass. This class used to live in gst-plugins-bad and was moved to core. Drop the buffer currently queued in @pad. TRUE if there was a buffer queued in @pad, or FALSE if not. the pad where to drop any pending buffer This checks if a pad has a buffer available that will be returned by a call to gst_aggregator_pad_peek_buffer() or gst_aggregator_pad_pop_buffer(). %TRUE if the pad has a buffer available as the next thing. the pad to check the buffer on %TRUE if the pad is EOS, otherwise %FALSE. an aggregator pad A reference to the buffer in @pad or NULL if no buffer was queued. You should unref the buffer after usage. the pad to get buffer from Steal the ref to the buffer currently queued in @pad. The buffer in @pad or NULL if no buffer was queued. You should unref the buffer after usage. the pad to get buffer from Enables the emission of signals such as #GstAggregatorPad::buffer-consumed last segment received. Start at running time 0. Start at the running time of the first buffer that is received. Start at the running time selected by the `start-time` property. Obtains current drain status (ie. whether EOS has been received and the parser is now processing the frames at the end of the stream) base parse instance Obtains current sync status. base parse instance Gives the pointer to the sink #GstPad object of the element. base parse instance Gives the pointer to the source #GstPad object of the element. base parse instance Gives the pointer to the #GstPad object of the element. base sink instance Gives the pointer to the #GstPad object of the element. base source instance The name of the templates for the sink pad. Gives the pointer to the sink #GstPad object of the element. base transform instance The name of the templates for the source pad. Gives the pointer to the source #GstPad object of the element. base transform instance A #GstBitReader 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_bit_reader_init(). Data from which the #GstBitReader should read Size of @data in bytes 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(). Data from which the #GstByteReader should read Size of @data in bytes This base class is for parser elements that process data and splits it into separate audio/video/whatever frames. It provides for: * provides one sink pad and one source pad * handles state changes * can operate in pull mode or push mode * handles seeking in both modes * handles events (SEGMENT/EOS/FLUSH) * handles queries (POSITION/DURATION/SEEKING/FORMAT/CONVERT) * handles flushing The purpose of this base class is to provide the basic functionality of a parser and share a lot of rather complex code. # Description of the parsing mechanism: ## Set-up phase * #GstBaseParse calls #GstBaseParseClass.start() to inform subclass that data processing is about to start now. * #GstBaseParse class calls #GstBaseParseClass.set_sink_caps() to inform the subclass about incoming sinkpad caps. Subclass could already set the srcpad caps accordingly, but this might be delayed until calling gst_base_parse_finish_frame() with a non-queued frame. * At least at this point subclass needs to tell the #GstBaseParse class how big data chunks it wants to receive (minimum frame size ). It can do this with gst_base_parse_set_min_frame_size(). * #GstBaseParse class sets up appropriate data passing mode (pull/push) and starts to process the data. ## Parsing phase * #GstBaseParse gathers at least min_frame_size bytes of data either by pulling it from upstream or collecting buffers in an internal #GstAdapter. * A buffer of (at least) min_frame_size bytes is passed to subclass with #GstBaseParseClass.handle_frame(). Subclass checks the contents and can optionally return #GST_FLOW_OK along with an amount of data to be skipped to find a valid frame (which will result in a subsequent DISCONT). If, otherwise, the buffer does not hold a complete frame, #GstBaseParseClass.handle_frame() can merely return and will be called again when additional data is available. In push mode this amounts to an additional input buffer (thus minimal additional latency), in pull mode this amounts to some arbitrary reasonable buffer size increase. Of course, gst_base_parse_set_min_frame_size() could also be used if a very specific known amount of additional data is required. If, however, the buffer holds a complete valid frame, it can pass the size of this frame to gst_base_parse_finish_frame(). If acting as a converter, it can also merely indicate consumed input data while simultaneously providing custom output data. Note that baseclass performs some processing (such as tracking overall consumed data rate versus duration) for each finished frame, but other state is only updated upon each call to #GstBaseParseClass.handle_frame() (such as tracking upstream input timestamp). Subclass is also responsible for setting the buffer metadata (e.g. buffer timestamp and duration, or keyframe if applicable). (although the latter can also be done by #GstBaseParse if it is appropriately configured, see below). Frame is provided with timestamp derived from upstream (as much as generally possible), duration obtained from configuration (see below), and offset if meaningful (in pull mode). Note that #GstBaseParseClass.handle_frame() might receive any small amount of input data when leftover data is being drained (e.g. at EOS). * As part of finish frame processing, just prior to actually pushing the buffer in question, it is passed to #GstBaseParseClass.pre_push_frame() which gives subclass yet one last chance to examine buffer metadata, or to send some custom (tag) events, or to perform custom (segment) filtering. * During the parsing process #GstBaseParseClass will handle both srcpad and sinkpad events. They will be passed to subclass if #GstBaseParseClass.sink_event() or #GstBaseParseClass.src_event() implementations have been provided. ## Shutdown phase * #GstBaseParse class calls #GstBaseParseClass.stop() to inform the subclass that data parsing will be stopped. Subclass is responsible for providing pad template caps for source and sink pads. The pads need to be named "sink" and "src". It also needs to set the fixed caps on srcpad, when the format is ensured (e.g. when base class calls subclass' #GstBaseParseClass.set_sink_caps() function). This base class uses %GST_FORMAT_DEFAULT as a meaning of frames. So, subclass conversion routine needs to know that conversion from %GST_FORMAT_TIME to %GST_FORMAT_DEFAULT must return the frame number that can be found from the given byte position. #GstBaseParse uses subclasses conversion methods also for seeking (or otherwise uses its own default one, see also below). Subclass @start and @stop functions will be called to inform the beginning and end of data processing. Things that subclass need to take care of: * Provide pad templates * Fixate the source pad caps when appropriate * Inform base class how big data chunks should be retrieved. This is done with gst_base_parse_set_min_frame_size() function. * Examine data chunks passed to subclass with #GstBaseParseClass.handle_frame() and pass proper frame(s) to gst_base_parse_finish_frame(), and setting src pad caps and timestamps on frame. * Provide conversion functions * Update the duration information with gst_base_parse_set_duration() * Optionally passthrough using gst_base_parse_set_passthrough() * Configure various baseparse parameters using gst_base_parse_set_average_bitrate(), gst_base_parse_set_syncable() and gst_base_parse_set_frame_rate(). * In particular, if subclass is unable to determine a duration, but parsing (or specs) yields a frames per seconds rate, then this can be provided to #GstBaseParse to enable it to cater for buffer time metadata (which will be taken from upstream as much as possible). Internally keeping track of frame durations and respective sizes that have been pushed provides #GstBaseParse with an estimated bitrate. A default #GstBaseParseClass.convert() (used if not overridden) will then use these rates to perform obvious conversions. These rates are also used to update (estimated) duration at regular frame intervals. Adds an entry to the index associating @offset to @ts. It is recommended to only add keyframe entries. @force allows to bypass checks, such as whether the stream is (upstream) seekable, another entry is already "close" to the new entry, etc. #gboolean indicating whether entry was added #GstBaseParse. offset of entry timestamp associated with offset whether entry refers to keyframe add entry disregarding sanity checks Default implementation of #GstBaseParseClass.convert(). %TRUE if conversion was successful. #GstBaseParse. #GstFormat describing the source format. Source value to be converted. #GstFormat defining the converted format. Pointer where the conversion result will be put. Drains the adapter until it is empty. It decreases the min_frame_size to match the current adapter size and calls chain method until the adapter is emptied or chain returns with error. a #GstBaseParse Collects parsed data and pushes this downstream. Source pad caps must be set when this is called. If @frame's out_buffer is set, that will be used as subsequent frame data. Otherwise, @size samples will be taken from the input and used for output, and the output's metadata (timestamps etc) will be taken as (optionally) set by the subclass on @frame's (input) buffer (which is otherwise ignored for any but the above purpose/information). Note that the latter buffer is invalidated by this call, whereas the caller retains ownership of @frame. a #GstFlowReturn that should be escalated to caller (of caller) a #GstBaseParse a #GstBaseParseFrame consumed input data represented by frame Sets the parser subclass's tags and how they should be merged with any upstream stream tags. This will override any tags previously-set with gst_base_parse_merge_tags(). Note that this is provided for convenience, and the subclass is not required to use this and can still do tag handling on its own. a #GstBaseParse a #GstTagList to merge, or NULL to unset previously-set tags the #GstTagMergeMode to use, usually #GST_TAG_MERGE_REPLACE Pushes the frame's buffer downstream, sends any pending events and does some timestamp and segment handling. Takes ownership of frame's buffer, though caller retains ownership of @frame. This must be called with sinkpad STREAM_LOCK held. #GstFlowReturn #GstBaseParse. a #GstBaseParseFrame Optionally sets the average bitrate detected in media (if non-zero), e.g. based on metadata, as it will be posted to the application. By default, announced average bitrate is estimated. The average bitrate is used to estimate the total duration of the stream and to estimate a seek position, if there's no index and the format is syncable (see gst_base_parse_set_syncable()). #GstBaseParse. average bitrate in bits/second Sets the duration of the currently playing media. Subclass can use this when it is able to determine duration and/or notices a change in the media duration. Alternatively, if @interval is non-zero (default), then stream duration is determined based on estimated bitrate, and updated every @interval frames. #GstBaseParse. #GstFormat. duration value. how often to update the duration estimate based on bitrate, or 0. If frames per second is configured, parser can take care of buffer duration and timestamping. When performing segment clipping, or seeking to a specific location, a corresponding decoder might need an initial @lead_in and a following @lead_out number of frames to ensure the desired segment is entirely filled upon decoding. the #GstBaseParse to set frames per second (numerator). frames per second (denominator). frames needed before a segment for subsequent decode frames needed after a segment Set if frames carry timing information which the subclass can (generally) parse and provide. In particular, intrinsic (rather than estimated) time can be obtained following a seek. a #GstBaseParse whether frames carry timing information By default, the base class might try to infer PTS from DTS and vice versa. While this is generally correct for audio data, it may not be otherwise. Sub-classes implementing such formats should disable timestamp inferring. a #GstBaseParse %TRUE if parser should infer DTS/PTS from each other Sets the minimum and maximum (which may likely be equal) latency introduced by the parsing process. If there is such a latency, which depends on the particular parsing of the format, it typically corresponds to 1 frame duration. a #GstBaseParse minimum parse latency maximum parse latency Subclass can use this function to tell the base class that it needs to be given buffers of at least @min_size bytes. #GstBaseParse. Minimum size in bytes of the data that this base class should give to subclass. Set if the nature of the format or configuration does not allow (much) parsing, and the parser should operate in passthrough mode (which only applies when operating in push mode). That is, incoming buffers are pushed through unmodified, i.e. no #GstBaseParseClass.handle_frame() will be invoked, but #GstBaseParseClass.pre_push_frame() will still be invoked, so subclass can perform as much or as little is appropriate for passthrough semantics in #GstBaseParseClass.pre_push_frame(). a #GstBaseParse %TRUE if parser should run in passthrough mode By default, the base class will guess PTS timestamps using a simple interpolation (previous timestamp + duration), which is incorrect for data streams with reordering, where PTS can go backward. Sub-classes implementing such formats should disable PTS interpolation. a #GstBaseParse %TRUE if parser should interpolate PTS timestamps Set if frame starts can be identified. This is set by default and determines whether seeking based on bitrate averages is possible for a format/stream. a #GstBaseParse set if frame starts can be identified This function should only be called from a @handle_frame implementation. #GstBaseParse creates initial timestamps for frames by using the last timestamp seen in the stream before the frame starts. In certain cases, the correct timestamps will occur in the stream after the start of the frame, but before the start of the actual picture data. This function can be used to set the timestamps based on the offset into the frame data that the picture starts. a #GstBaseParse offset into current buffer If set to %TRUE, baseparse will unconditionally force parsing of the incoming data. This can be required in the rare cases where the incoming side-data (caps, pts, dts, ...) is not trusted by the user and wants to force validation and parsing of the incoming data. If set to %FALSE, decision of whether to parse the data or not is up to the implementation (standard behaviour). the parent element. Subclasses can override any of the available virtual methods or not, as needed. At minimum @handle_frame needs to be overridden. the parent class Frame (context) data passed to each frame parsing virtual methods. In addition to providing the data to be checked for a valid frame or an already identified frame, it conveys additional metadata or control information from and to the subclass w.r.t. the particular frame in question (rather than global parameters). Some of these may apply to each parsing stage, others only to some a particular one. These parameters are effectively zeroed at start of each frame's processing, i.e. parsing virtual method invocation sequence. input data to be parsed for frames. output data. a combination of input and output #GstBaseParseFrameFlags that convey additional context to subclass or allow subclass to tune subsequent #GstBaseParse actions. media specific offset of input frame Note that a converter may have a different one on the frame's buffer. subclass can set this to indicates the metadata overhead for the given frame, which is then used to enable more accurate bitrate computations. If this is -1, it is assumed that this frame should be skipped in bitrate calculation. Allocates a new #GstBaseParseFrame. This function is mainly for bindings, elements written in C should usually allocate the frame on the stack and then use gst_base_parse_frame_init() to initialise it. a newly-allocated #GstBaseParseFrame. Free with gst_base_parse_frame_free() when no longer needed. a #GstBuffer the flags number of bytes in this frame which should be counted as metadata overhead, ie. not used to calculate the average bitrate. Set to -1 to mark the entire frame as metadata. If in doubt, set to 0. Copies a #GstBaseParseFrame. A copy of @frame a #GstBaseParseFrame Frees the provided @frame. A #GstBaseParseFrame Sets a #GstBaseParseFrame to initial state. Currently this means all public fields are zero-ed and a private flag is set to make sure gst_base_parse_frame_free() only frees the contents but not the actual frame. Use this function to initialise a #GstBaseParseFrame allocated on the stack. #GstBaseParseFrame. Flags to be used in a #GstBaseParseFrame. no flag set by baseclass if current frame is passed for processing to the subclass for the first time (and not set on subsequent calls with same data). set to indicate this buffer should not be counted as frame, e.g. if this frame is dependent on a previous one. As it is not counted as a frame, bitrate increases but frame to time conversions are maintained. @pre_push_frame can set this to indicate that regular segment clipping can still be performed (as opposed to any custom one having been done). indicates to @finish_frame that the the frame should be dropped (and might be handled internally by subclass) indicates to @finish_frame that the the frame should be queued for now and processed fully later when the first non-queued frame is finished #GstBaseSink is the base class for sink elements in GStreamer, such as xvimagesink or filesink. It is a layer on top of #GstElement that provides a simplified interface to plugin writers. #GstBaseSink handles many details for you, for example: preroll, clock synchronization, state changes, activation in push or pull mode, and queries. In most cases, when writing sink elements, there is no need to implement class methods from #GstElement or to set functions on pads, because the #GstBaseSink infrastructure should be sufficient. #GstBaseSink provides support for exactly one sink pad, which should be named "sink". A sink implementation (subclass of #GstBaseSink) should install a pad template in its class_init function, like so: |[<!-- language="C" --> static void my_element_class_init (GstMyElementClass *klass) { GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass); // sinktemplate should be a #GstStaticPadTemplate with direction // %GST_PAD_SINK and name "sink" gst_element_class_add_static_pad_template (gstelement_class, &amp;sinktemplate); gst_element_class_set_static_metadata (gstelement_class, "Sink name", "Sink", "My Sink element", "The author <my.sink@my.email>"); } ]| #GstBaseSink will handle the prerolling correctly. This means that it will return %GST_STATE_CHANGE_ASYNC from a state change to PAUSED until the first buffer arrives in this element. The base class will call the #GstBaseSinkClass.preroll() vmethod with this preroll buffer and will then commit the state change to the next asynchronously pending state. When the element is set to PLAYING, #GstBaseSink will synchronise on the clock using the times returned from #GstBaseSinkClass.get_times(). If this function returns %GST_CLOCK_TIME_NONE for the start time, no synchronisation will be done. Synchronisation can be disabled entirely by setting the object #GstBaseSink:sync property to %FALSE. After synchronisation the virtual method #GstBaseSinkClass.render() will be called. Subclasses should minimally implement this method. Subclasses that synchronise on the clock in the #GstBaseSinkClass.render() method are supported as well. These classes typically receive a buffer in the render method and can then potentially block on the clock while rendering. A typical example is an audiosink. These subclasses can use gst_base_sink_wait_preroll() to perform the blocking wait. Upon receiving the EOS event in the PLAYING state, #GstBaseSink will wait for the clock to reach the time indicated by the stop time of the last #GstBaseSinkClass.get_times() call before posting an EOS message. When the element receives EOS in PAUSED, preroll completes, the event is queued and an EOS message is posted when going to PLAYING. #GstBaseSink will internally use the %GST_EVENT_SEGMENT events to schedule synchronisation and clipping of buffers. Buffers that fall completely outside of the current segment are dropped. Buffers that fall partially in the segment are rendered (and prerolled). Subclasses should do any subbuffer clipping themselves when needed. #GstBaseSink will by default report the current playback position in %GST_FORMAT_TIME based on the current clock time and segment information. If no clock has been set on the element, the query will be forwarded upstream. The #GstBaseSinkClass.set_caps() function will be called when the subclass should configure itself to process a specific media type. The #GstBaseSinkClass.start() and #GstBaseSinkClass.stop() virtual methods will be called when resources should be allocated. Any #GstBaseSinkClass.preroll(), #GstBaseSinkClass.render() and #GstBaseSinkClass.set_caps() function will be called between the #GstBaseSinkClass.start() and #GstBaseSinkClass.stop() calls. The #GstBaseSinkClass.event() virtual method will be called when an event is received by #GstBaseSink. Normally this method should only be overridden by very specific elements (such as file sinks) which need to handle the newsegment event specially. The #GstBaseSinkClass.unlock() method is called when the elements should unblock any blocking operations they perform in the #GstBaseSinkClass.render() method. This is mostly useful when the #GstBaseSinkClass.render() method performs a blocking write on a file descriptor, for example. The #GstBaseSink:max-lateness property affects how the sink deals with buffers that arrive too late in the sink. A buffer arrives too late in the sink when the presentation time (as a combination of the last segment, buffer timestamp and element base_time) plus the duration is before the current time of the clock. If the frame is later than max-lateness, the sink will drop the buffer without calling the render method. This feature is disabled if sync is disabled, the #GstBaseSinkClass.get_times() method does not return a valid start time or max-lateness is set to -1 (the default). Subclasses can use gst_base_sink_set_max_lateness() to configure the max-lateness value. The #GstBaseSink:qos property will enable the quality-of-service features of the basesink which gather statistics about the real-time performance of the clock synchronisation. For each buffer received in the sink, statistics are gathered and a QOS event is sent upstream with these numbers. This information can then be used by upstream elements to reduce their processing rate, for example. The #GstBaseSink:async property can be used to instruct the sink to never perform an ASYNC state change. This feature is mostly usable when dealing with non-synchronized streams or sparse streams. If the @sink spawns its own thread for pulling buffers from upstream it should call this method after it has pulled a buffer. If the element needed to preroll, this function will perform the preroll and will then block until the element state is changed. This function should be called with the PREROLL_LOCK held. %GST_FLOW_OK if the preroll completed and processing can continue. Any other return value should be returned from the render vmethod. the sink the mini object that caused the preroll Get the number of bytes that the sink will pull when it is operating in pull mode. the number of bytes @sink will pull in pull mode. a #GstBaseSink Checks if @sink is currently configured to drop buffers which are outside the current segment %TRUE if the sink is configured to drop buffers outside the current segment. the sink Get the last sample that arrived in the sink and was used for preroll or for rendering. This property can be used to generate thumbnails. The #GstCaps on the sample can be used to determine the type of the buffer. Free-function: gst_sample_unref a #GstSample. gst_sample_unref() after usage. This function returns %NULL when no buffer has arrived in the sink yet or when the sink is not in PAUSED or PLAYING. the sink Get the currently configured latency. The configured latency. the sink Get the maximum amount of bits per second that the sink will render. the maximum number of bits per second @sink will render. a #GstBaseSink Gets the max lateness value. See gst_base_sink_set_max_lateness() for more details. The maximum time in nanoseconds that a buffer can be late before it is dropped and not rendered. A value of -1 means an unlimited time. the sink Get the processing deadline of @sink. see gst_base_sink_set_processing_deadline() for more information about the processing deadline. the processing deadline a #GstBaseSink Get the render delay of @sink. see gst_base_sink_set_render_delay() for more information about the render delay. the render delay of @sink. a #GstBaseSink Return various #GstBaseSink statistics. This function returns a #GstStructure with name `application/x-gst-base-sink-stats` with the following fields: - "average-rate" G_TYPE_DOUBLE average frame rate - "dropped" G_TYPE_UINT64 Number of dropped frames - "rendered" G_TYPE_UINT64 Number of rendered frames pointer to #GstStructure #GstBaseSink Checks if @sink is currently configured to synchronize against the clock. %TRUE if the sink is configured to synchronize against the clock. the sink Get the time that will be inserted between frames to control the maximum buffers per second. the number of nanoseconds @sink will put between frames. a #GstBaseSink Get the synchronisation offset of @sink. The synchronisation offset. the sink Checks if @sink is currently configured to perform asynchronous state changes to PAUSED. %TRUE if the sink is configured to perform asynchronous state changes. the sink Checks if @sink is currently configured to store the last received sample in the last-sample property. %TRUE if the sink is configured to store the last received sample. the sink Checks if @sink is currently configured to send Quality-of-Service events upstream. %TRUE if the sink is configured to perform Quality-of-Service. the sink Query the sink for the latency parameters. The latency will be queried from the upstream elements. @live will be %TRUE if @sink is configured to synchronize against the clock. @upstream_live will be %TRUE if an upstream element is live. If both @live and @upstream_live are %TRUE, the sink will want to compensate for the latency introduced by the upstream elements by setting the @min_latency to a strictly positive value. This function is mostly used by subclasses. %TRUE if the query succeeded. the sink if the sink is live if an upstream element is live the min latency of the upstream elements the max latency of the upstream elements Configures @sink to perform all state changes asynchronously. When async is disabled, the sink will immediately go to PAUSED instead of waiting for a preroll buffer. This feature is useful if the sink does not synchronize against the clock or when it is dealing with sparse streams. the sink the new async value. Set the number of bytes that the sink will pull when it is operating in pull mode. a #GstBaseSink the blocksize in bytes Configure @sink to drop buffers which are outside the current segment the sink drop buffers outside the segment Configures @sink to store the last received sample in the last-sample property. the sink the new enable-last-sample value. Set the maximum amount of bits per second that the sink will render. a #GstBaseSink the max_bitrate in bits per second Sets the new max lateness value to @max_lateness. This value is used to decide if a buffer should be dropped or not based on the buffer timestamp and the current clock time. A value of -1 means an unlimited time. the sink the new max lateness value. Maximum amount of time (in nanoseconds) that the pipeline can take for processing the buffer. This is added to the latency of live pipelines. This function is usually called by subclasses. a #GstBaseSink the new processing deadline in nanoseconds. Configures @sink to send Quality-of-Service events upstream. the sink the new qos value. Set the render delay in @sink to @delay. The render delay is the time between actual rendering of a buffer and its synchronisation time. Some devices might delay media rendering which can be compensated for with this function. After calling this function, this sink will report additional latency and other sinks will adjust their latency to delay the rendering of their media. This function is usually called by subclasses. a #GstBaseSink the new delay Configures @sink to synchronize on the clock or not. When @sync is %FALSE, incoming samples will be played as fast as possible. If @sync is %TRUE, the timestamps of the incoming buffers will be used to schedule the exact render time of its contents. the sink the new sync value. Set the time that will be inserted between rendered buffers. This can be used to control the maximum buffers per second that the sink will render. a #GstBaseSink the throttle time in nanoseconds Adjust the synchronisation of @sink with @offset. A negative value will render buffers earlier than their timestamp. A positive value will delay rendering. This function can be used to fix playback of badly timestamped buffers. the sink the new offset This function will wait for preroll to complete and will then block until @time is reached. It is usually called by subclasses that use their own internal synchronisation but want to let some synchronization (like EOS) be handled by the base class. This function should only be called with the PREROLL_LOCK held (like when receiving an EOS event in the ::event vmethod or when handling buffers in ::render). The @time argument should be the running_time of when the timeout should happen and will be adjusted with any latency and offset configured in the sink. #GstFlowReturn the sink the running_time to be reached the jitter to be filled with time diff, or %NULL This function will block until @time is reached. It is usually called by subclasses that use their own internal synchronisation. If @time is not valid, no synchronisation is done and %GST_CLOCK_BADTIME is returned. Likewise, if synchronisation is disabled in the element or there is no clock, no synchronisation is done and %GST_CLOCK_BADTIME is returned. This function should only be called with the PREROLL_LOCK held, like when receiving an EOS event in the #GstBaseSinkClass.event() vmethod or when receiving a buffer in the #GstBaseSinkClass.render() vmethod. The @time argument should be the running_time of when this method should return and is not adjusted with any latency or offset configured in the sink. #GstClockReturn the sink the running_time to be reached the jitter to be filled with time diff, or %NULL If the #GstBaseSinkClass.render() method performs its own synchronisation against the clock it must unblock when going from PLAYING to the PAUSED state and call this method before continuing to render the remaining data. If the #GstBaseSinkClass.render() method can block on something else than the clock, it must also be ready to unblock immediately on the #GstBaseSinkClass.unlock() method and cause the #GstBaseSinkClass.render() method to immediately call this function. In this case, the subclass must be prepared to continue rendering where it left off if this function returns %GST_FLOW_OK. This function will block until a state change to PLAYING happens (in which case this function returns %GST_FLOW_OK) or the processing must be stopped due to a state change to READY or a FLUSH event (in which case this function returns %GST_FLOW_FLUSHING). This function should only be called with the PREROLL_LOCK held, like in the render function. %GST_FLOW_OK if the preroll completed and processing can continue. Any other return value should be returned from the render vmethod. the sink If set to %TRUE, the basesink will perform asynchronous state changes. When set to %FALSE, the sink will not signal the parent when it prerolls. Use this option when dealing with sparse streams or when synchronisation is not required. The amount of bytes to pull when operating in pull mode. Enable the last-sample property. If %FALSE, basesink doesn't keep a reference to the last buffer arrived and the last-sample property is always set to %NULL. This can be useful if you need buffers to be released as soon as possible, eg. if you're using a buffer pool. The last buffer that arrived in the sink and was used for preroll or for rendering. This property can be used to generate thumbnails. This property can be %NULL when the sink has not yet received a buffer. Control the maximum amount of bits that will be rendered per second. Setting this property to a value bigger than 0 will make the sink delay rendering of the buffers when it would exceed to max-bitrate. Maximum amount of time (in nanoseconds) that the pipeline can take for processing the buffer. This is added to the latency of live pipelines. The additional delay between synchronisation and actual rendering of the media. This property will add additional latency to the device in order to make other sinks compensate for the delay. Various #GstBaseSink statistics. This property returns a #GstStructure with name `application/x-gst-base-sink-stats` with the following fields: - "average-rate" G_TYPE_DOUBLE average frame rate - "dropped" G_TYPE_UINT64 Number of dropped frames - "rendered" G_TYPE_UINT64 Number of rendered frames The time to insert between buffers. This property can be used to control the maximum amount of buffers per second to render. Setting this property to a value bigger than 0 will make the sink create THROTTLE QoS events. Controls the final synchronisation, a negative value will render the buffer earlier while a positive value delays playback. This property can be used to fix synchronisation in bad files. Subclasses can override any of the available virtual methods or not, as needed. At the minimum, the @render method should be overridden to output/present buffers. Element parent class This is a generic base class for source elements. The following types of sources are supported: * random access sources like files * seekable sources * live sources The source can be configured to operate in any #GstFormat with the gst_base_src_set_format() method. The currently set format determines the format of the internal #GstSegment and any %GST_EVENT_SEGMENT events. The default format for #GstBaseSrc is %GST_FORMAT_BYTES. #GstBaseSrc always supports push mode scheduling. If the following conditions are met, it also supports pull mode scheduling: * The format is set to %GST_FORMAT_BYTES (default). * #GstBaseSrcClass.is_seekable() returns %TRUE. If all the conditions are met for operating in pull mode, #GstBaseSrc is automatically seekable in push mode as well. The following conditions must be met to make the element seekable in push mode when the format is not %GST_FORMAT_BYTES: * #GstBaseSrcClass.is_seekable() returns %TRUE. * #GstBaseSrcClass.query() can convert all supported seek formats to the internal format as set with gst_base_src_set_format(). * #GstBaseSrcClass.do_seek() is implemented, performs the seek and returns %TRUE. When the element does not meet the requirements to operate in pull mode, the offset and length in the #GstBaseSrcClass.create() method should be ignored. It is recommended to subclass #GstPushSrc instead, in this situation. If the element can operate in pull mode but only with specific offsets and lengths, it is allowed to generate an error when the wrong values are passed to the #GstBaseSrcClass.create() function. #GstBaseSrc has support for live sources. Live sources are sources that when paused discard data, such as audio or video capture devices. A typical live source also produces data at a fixed rate and thus provides a clock to publish this rate. Use gst_base_src_set_live() to activate the live source mode. A live source does not produce data in the PAUSED state. This means that the #GstBaseSrcClass.create() method will not be called in PAUSED but only in PLAYING. To signal the pipeline that the element will not produce data, the return value from the READY to PAUSED state will be %GST_STATE_CHANGE_NO_PREROLL. A typical live source will timestamp the buffers it creates with the current running time of the pipeline. This is one reason why a live source can only produce data in the PLAYING state, when the clock is actually distributed and running. Live sources that synchronize and block on the clock (an audio source, for example) can use gst_base_src_wait_playing() when the #GstBaseSrcClass.create() function was interrupted by a state change to PAUSED. The #GstBaseSrcClass.get_times() method can be used to implement pseudo-live sources. It only makes sense to implement the #GstBaseSrcClass.get_times() function if the source is a live source. The #GstBaseSrcClass.get_times() function should return timestamps starting from 0, as if it were a non-live source. The base class will make sure that the timestamps are transformed into the current running_time. The base source will then wait for the calculated running_time before pushing out the buffer. For live sources, the base class will by default report a latency of 0. For pseudo live sources, the base class will by default measure the difference between the first buffer timestamp and the start time of get_times and will report this value as the latency. Subclasses should override the query function when this behaviour is not acceptable. There is only support in #GstBaseSrc for exactly one source pad, which should be named "src". A source implementation (subclass of #GstBaseSrc) should install a pad template in its class_init function, like so: |[<!-- language="C" --> static void my_element_class_init (GstMyElementClass *klass) { GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass); // srctemplate should be a #GstStaticPadTemplate with direction // %GST_PAD_SRC and name "src" gst_element_class_add_static_pad_template (gstelement_class, &amp;srctemplate); gst_element_class_set_static_metadata (gstelement_class, "Source name", "Source", "My Source element", "The author <my.sink@my.email>"); } ]| ## Controlled shutdown of live sources in applications Applications that record from a live source may want to stop recording in a controlled way, so that the recording is stopped, but the data already in the pipeline is processed to the end (remember that many live sources would go on recording forever otherwise). For that to happen the application needs to make the source stop recording and send an EOS event down the pipeline. The application would then wait for an EOS message posted on the pipeline's bus to know when all data has been processed and the pipeline can safely be stopped. An application may send an EOS event to a source element to make it perform the EOS logic (send EOS event downstream or post a %GST_MESSAGE_SEGMENT_DONE on the bus). This can typically be done with the gst_element_send_event() function on the element or its parent bin. After the EOS has been sent to the element, the application should wait for an EOS message to be posted on the pipeline's bus. Once this EOS message is received, it may safely shut down the entire pipeline. Ask the subclass to create a buffer with @offset and @size, the default implementation will call alloc and fill. Called to get the caps to report. Given @buffer, return @start and @end time when it should be pushed out. The base class will sync on the clock using these times. Negotiates src pad caps with downstream elements. Unmarks GST_PAD_FLAG_NEED_RECONFIGURE in any case. But marks it again if #GstBaseSrcClass.negotiate() fails. Do not call this in the #GstBaseSrcClass.fill() vmethod. Call this in #GstBaseSrcClass.create() or in #GstBaseSrcClass.alloc(), _before_ any buffer is allocated. %TRUE if the negotiation succeeded, else %FALSE. base source instance Set new caps on the basesrc source pad. %TRUE if the caps could be set a #GstBaseSrc a #GstCaps Lets #GstBaseSrc sub-classes to know the memory @allocator used by the base class and its @params. Unref the @allocator after usage. a #GstBaseSrc the #GstAllocator used the #GstAllocationParams of @allocator Get the number of bytes that @src will push out with each buffer. the number of bytes pushed with each buffer. the source the instance of the #GstBufferPool used by the src; unref it after usage. a #GstBaseSrc Query if @src timestamps outgoing buffers based on the current running_time. %TRUE if the base class will automatically timestamp outgoing buffers. the source Get the current async behaviour of @src. See also gst_base_src_set_async(). %TRUE if @src is operating in async mode. base source instance Check if an element is in live mode. %TRUE if element is in live mode. base source instance Negotiates src pad caps with downstream elements. Unmarks GST_PAD_FLAG_NEED_RECONFIGURE in any case. But marks it again if #GstBaseSrcClass.negotiate() fails. Do not call this in the #GstBaseSrcClass.fill() vmethod. Call this in #GstBaseSrcClass.create() or in #GstBaseSrcClass.alloc(), _before_ any buffer is allocated. %TRUE if the negotiation succeeded, else %FALSE. base source instance Prepare a new seamless segment for emission downstream. This function must only be called by derived sub-classes, and only from the #GstBaseSrcClass::create function, as the stream-lock needs to be held. The format for the new segment will be the current format of the source, as configured with gst_base_src_set_format() Use gst_base_src_new_segment() %TRUE if preparation of the seamless segment succeeded. The source The new start value for the segment Stop value for the new segment The new time value for the start of the new segment Prepare a new segment for emission downstream. This function must only be called by derived sub-classes, and only from the #GstBaseSrcClass::create function, as the stream-lock needs to be held. The format for the @segment must be identical with the current format of the source, as configured with gst_base_src_set_format(). The format of @src must not be %GST_FORMAT_UNDEFINED and the format should be configured via gst_base_src_set_format() before calling this method. %TRUE if preparation of new segment succeeded. a #GstBaseSrc a pointer to a #GstSegment Query the source for the latency parameters. @live will be %TRUE when @src is configured as a live source. @min_latency and @max_latency will be set to the difference between the running time and the timestamp of the first buffer. This function is mostly used by subclasses. %TRUE if the query succeeded. the source if the source is live the min latency of the source the max latency of the source Configure async behaviour in @src, no state change will block. The open, close, start, stop, play and pause virtual methods will be executed in a different thread and are thus allowed to perform blocking operations. Any blocking operation should be unblocked with the unlock vmethod. base source instance new async mode If @automatic_eos is %TRUE, @src will automatically go EOS if a buffer after the total size is returned. By default this is %TRUE but sources that can't return an authoritative size and only know that they're EOS when trying to read more should set this to %FALSE. When @src operates in %GST_FORMAT_TIME, #GstBaseSrc will send an EOS when a buffer outside of the currently configured segment is pushed if @automatic_eos is %TRUE. Since 1.16, if @automatic_eos is %FALSE an EOS will be pushed only when the #GstBaseSrcClass.create() implementation returns %GST_FLOW_EOS. base source instance automatic eos Set the number of bytes that @src will push out with each buffer. When @blocksize is set to -1, a default length will be used. the source the new blocksize in bytes Set new caps on the basesrc source pad. %TRUE if the caps could be set a #GstBaseSrc a #GstCaps Configure @src to automatically timestamp outgoing buffers based on the current running_time of the pipeline. This property is mostly useful for live sources. the source enable or disable timestamping If not @dynamic, size is only updated when needed, such as when trying to read past current tracked size. Otherwise, size is checked for upon each read. base source instance new dynamic size mode Sets the default format of the source. This will be the format used for sending SEGMENT events and for performing seeks. If a format of GST_FORMAT_BYTES is set, the element will be able to operate in pull mode if the #GstBaseSrcClass.is_seekable() returns %TRUE. This function must only be called in states < %GST_STATE_PAUSED. base source instance the format to use If the element listens to a live source, @live should be set to %TRUE. A live source will not produce data in the PAUSED state and will therefore not be able to participate in the PREROLL phase of a pipeline. To signal this fact to the application and the pipeline, the state change return value of the live source will be GST_STATE_CHANGE_NO_PREROLL. base source instance new live-mode Complete an asynchronous start operation. When the subclass overrides the start method, it should call gst_base_src_start_complete() when the start operation completes either from the same thread or from an asynchronous helper thread. base source instance a #GstFlowReturn Wait until the start operation completes. a #GstFlowReturn. base source instance Subclasses can call this from their create virtual method implementation to submit a buffer list to be pushed out later. This is useful in cases where the create function wants to produce multiple buffers to be pushed out in one go in form of a #GstBufferList, which can reduce overhead drastically, especially for packetised inputs (for data streams where the packetisation/chunking is not important it is usually more efficient to return larger buffers instead). Subclasses that use this function from their create function must return %GST_FLOW_OK and no buffer from their create virtual method implementation. If a buffer is returned after a buffer list has also been submitted via this function the behaviour is undefined. Subclasses must only call this function once per create function call and subclasses must only call this function when the source operates in push mode. a #GstBaseSrc a #GstBufferList If the #GstBaseSrcClass.create() method performs its own synchronisation against the clock it must unblock when going from PLAYING to the PAUSED state and call this method before continuing to produce the remaining data. This function will block until a state change to PLAYING happens (in which case this function returns %GST_FLOW_OK) or the processing must be stopped due to a state change to READY or a FLUSH event (in which case this function returns %GST_FLOW_FLUSHING). %GST_FLOW_OK if @src is PLAYING and processing can continue. Any other return value should be returned from the create vmethod. the src Subclasses can override any of the available virtual methods or not, as needed. At the minimum, the @create method should be overridden to produce buffers. Element parent class %TRUE if the negotiation succeeded, else %FALSE. base source instance %TRUE if the caps could be set a #GstBaseSrc a #GstCaps The #GstElement flags that a basesrc element may have. has source is starting has source been started offset to define more flags This base class is for filter elements that process data. Elements that are suitable for implementation using #GstBaseTransform are ones where the size and caps of the output is known entirely from the input caps and buffer sizes. These include elements that directly transform one buffer into another, modify the contents of a buffer in-place, as well as elements that collate multiple input buffers into one output buffer, or that expand one input buffer into multiple output buffers. See below for more concrete use cases. It provides for: * one sinkpad and one srcpad * Possible formats on sink and source pad implemented with custom transform_caps function. By default uses same format on sink and source. * Handles state changes * Does flushing * Push mode * Pull mode if the sub-class transform can operate on arbitrary data # Use Cases ## Passthrough mode * Element has no interest in modifying the buffer. It may want to inspect it, in which case the element should have a transform_ip function. If there is no transform_ip function in passthrough mode, the buffer is pushed intact. * The #GstBaseTransformClass.passthrough_on_same_caps variable will automatically set/unset passthrough based on whether the element negotiates the same caps on both pads. * #GstBaseTransformClass.passthrough_on_same_caps on an element that doesn't implement a transform_caps function is useful for elements that only inspect data (such as level) * Example elements * Level * Videoscale, audioconvert, videoconvert, audioresample in certain modes. ## Modifications in-place - input buffer and output buffer are the same thing. * The element must implement a transform_ip function. * Output buffer size must <= input buffer size * If the always_in_place flag is set, non-writable buffers will be copied and passed to the transform_ip function, otherwise a new buffer will be created and the transform function called. * Incoming writable buffers will be passed to the transform_ip function immediately. * only implementing transform_ip and not transform implies always_in_place = %TRUE * Example elements: * Volume * Audioconvert in certain modes (signed/unsigned conversion) * videoconvert in certain modes (endianness swapping) ## Modifications only to the caps/metadata of a buffer * The element does not require writable data, but non-writable buffers should be subbuffered so that the meta-information can be replaced. * Elements wishing to operate in this mode should replace the prepare_output_buffer method to create subbuffers of the input buffer and set always_in_place to %TRUE * Example elements * Capsfilter when setting caps on outgoing buffers that have none. * identity when it is going to re-timestamp buffers by datarate. ## Normal mode * always_in_place flag is not set, or there is no transform_ip function * Element will receive an input buffer and output buffer to operate on. * Output buffer is allocated by calling the prepare_output_buffer function. * Example elements: * Videoscale, videoconvert, audioconvert when doing scaling/conversions ## Special output buffer allocations * Elements which need to do special allocation of their output buffers beyond allocating output buffers via the negotiated allocator or buffer pool should implement the prepare_output_buffer method. * Example elements: * efence # Sub-class settable flags on GstBaseTransform * passthrough * Implies that in the current configuration, the sub-class is not interested in modifying the buffers. * Elements which are always in passthrough mode whenever the same caps has been negotiated on both pads can set the class variable passthrough_on_same_caps to have this behaviour automatically. * always_in_place * Determines whether a non-writable buffer will be copied before passing to the transform_ip function. * Implied %TRUE if no transform function is implemented. * Implied %FALSE if ONLY transform function is implemented. Lets #GstBaseTransform sub-classes know the memory @allocator used by the base class and its @params. Unref the @allocator after use. a #GstBaseTransform the #GstAllocator used the #GstAllocationParams of @allocator the instance of the #GstBufferPool used by @trans; free it after use a #GstBaseTransform See if @trans is configured as a in_place transform. %TRUE if the transform is configured in in_place mode. MT safe. the #GstBaseTransform to query See if @trans is configured as a passthrough transform. %TRUE if the transform is configured in passthrough mode. MT safe. the #GstBaseTransform to query Queries if the transform will handle QoS. %TRUE if QoS is enabled. MT safe. a #GstBaseTransform Negotiates src pad caps with downstream elements if the source pad is marked as needing reconfiguring. Unmarks GST_PAD_FLAG_NEED_RECONFIGURE in any case. But marks it again if negotiation fails. Do not call this in the #GstBaseTransformClass.transform() or #GstBaseTransformClass.transform_ip() vmethod. Call this in #GstBaseTransformClass.submit_input_buffer(), #GstBaseTransformClass.prepare_output_buffer() or in #GstBaseTransformClass.generate_output() _before_ any output buffer is allocated. It will be default be called when handling an ALLOCATION query or at the very beginning of the default #GstBaseTransformClass.submit_input_buffer() implementation. %TRUE if the negotiation succeeded, else %FALSE. the #GstBaseTransform to set Instructs @trans to request renegotiation upstream. This function is typically called after properties on the transform were set that influence the input format. a #GstBaseTransform Instructs @trans to renegotiate a new downstream transform on the next buffer. This function is typically called after properties on the transform were set that influence the output format. a #GstBaseTransform If @gap_aware is %FALSE (the default), output buffers will have the %GST_BUFFER_FLAG_GAP flag unset. If set to %TRUE, the element must handle output buffers with this flag set correctly, i.e. it can assume that the buffer contains neutral data but must unset the flag if the output is no neutral data. MT safe. a #GstBaseTransform New state Determines whether a non-writable buffer will be copied before passing to the transform_ip function. * Always %TRUE if no transform function is implemented. * Always %FALSE if ONLY transform function is implemented. MT safe. the #GstBaseTransform to modify Boolean value indicating that we would like to operate on in_place buffers. Set passthrough mode for this filter by default. This is mostly useful for filters that do not care about negotiation. Always %TRUE for filters which don't implement either a transform or transform_ip or generate_output method. MT safe. the #GstBaseTransform to set boolean indicating passthrough mode. If @prefer_passthrough is %TRUE (the default), @trans will check and prefer passthrough caps from the list of caps returned by the transform_caps vmethod. If set to %FALSE, the element must order the caps returned from the transform_caps function in such a way that the preferred format is first in the list. This can be interesting for transforms that can do passthrough transforms but prefer to do something else, like a capsfilter. MT safe. a #GstBaseTransform New state Enable or disable QoS handling in the transform. MT safe. a #GstBaseTransform new state Set the QoS parameters in the transform. This function is called internally when a QOS event is received but subclasses can provide custom information when needed. MT safe. a #GstBaseTransform the proportion the diff against the clock the timestamp of the buffer generating the QoS expressed in running_time. Updates the srcpad caps and sends the caps downstream. This function can be used by subclasses when they have already negotiated their caps but found a change in them (or computed new information). This way, they can notify downstream about that change without losing any buffer. %TRUE if the caps could be sent downstream %FALSE otherwise a #GstBaseTransform An updated version of the srcpad caps to be pushed downstream Subclasses can override any of the available virtual methods or not, as needed. At minimum either @transform or @transform_ip need to be overridden. If the element can overwrite the input data with the results (data is of the same type and quantity) it should provide @transform_ip. Element parent class If set to %TRUE, passthrough mode will be automatically enabled if the caps are the same. Set to %FALSE by default. If set to %TRUE, @transform_ip will be called in passthrough mode. The passed buffer might not be writable. When %FALSE, neither @transform nor @transform_ip will be called in passthrough mode. Set to %TRUE by default. #GstBitReader provides a bit reader that can read any number of bits from a memory buffer. It provides functions for reading any number of bits into 8, 16, 32 and 64 bit variables. Data from which the bit reader will read Size of @data in bytes Current byte position Bit position in the current byte Frees a #GstBitReader instance, which was previously allocated by gst_bit_reader_new(). a #GstBitReader instance Read @nbits bits into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstBitReader instance Pointer to a #guint16 to store the result number of bits to read Read @nbits bits into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstBitReader instance Pointer to a #guint32 to store the result number of bits to read Read @nbits bits into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstBitReader instance Pointer to a #guint64 to store the result number of bits to read Read @nbits bits into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstBitReader instance Pointer to a #guint8 to store the result number of bits to read Returns the current position of a #GstBitReader instance in bits. The current position of @reader in bits. a #GstBitReader instance Returns the remaining number of bits of a #GstBitReader instance. The remaining number of bits of @reader instance. a #GstBitReader instance Returns the total number of bits of a #GstBitReader instance. The total number of bits of @reader instance. a #GstBitReader instance Initializes a #GstBitReader instance to read from @data. This function can be called on already initialized instances. a #GstBitReader instance data from which the bit reader should read Size of @data in bytes Read @nbits bits into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstBitReader instance Pointer to a #guint16 to store the result number of bits to read Read @nbits bits into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstBitReader instance Pointer to a #guint32 to store the result number of bits to read Read @nbits bits into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstBitReader instance Pointer to a #guint64 to store the result number of bits to read Read @nbits bits into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstBitReader instance Pointer to a #guint8 to store the result number of bits to read Sets the new position of a #GstBitReader instance to @pos in bits. %TRUE if the position could be set successfully, %FALSE otherwise. a #GstBitReader instance The new position in bits Skips @nbits bits of the #GstBitReader instance. %TRUE if @nbits bits could be skipped, %FALSE otherwise. a #GstBitReader instance the number of bits to skip Skips until the next byte. %TRUE if successful, %FALSE otherwise. a #GstBitReader instance Create a new #GstBitReader instance, which will read from @data. Free-function: gst_bit_reader_free a new #GstBitReader instance Data from which the #GstBitReader should read Size of @data in bytes #GstBitWriter provides a bit writer that can write any number of bits into a memory buffer. It provides functions for writing any number of bits into 8, 16, 32 and 64 bit variables. Allocated @data for bit writer to write Size of written @data in bits Write trailing bit to align last byte of @data. @trailing_bit can only be 1 or 0. %TRUE if successful, %FALSE otherwise. a #GstBitWriter instance trailing bits of last byte, 0 or 1 Frees @bitwriter and the allocated data inside. #GstBitWriter instance Frees @bitwriter without destroying the internal data, which is returned as #GstBuffer. Free-function: gst_buffer_unref a new allocated #GstBuffer wrapping the data inside. gst_buffer_unref() after usage. #GstBitWriter instance Frees @bitwriter without destroying the internal data, which is returned. Free-function: g_free the current data. g_free() after usage. #GstBitWriter instance Get written data pointer data pointer a #GstBitWriter instance Get size of written @data size of bits written in @data a #GstBitWriter instance Initializes @bitwriter to an empty instance. #GstBitWriter instance Initializes @bitwriter with the given memory area @data. IF @initialized is %TRUE it is possible to read @size bits from the #GstBitWriter from the beginning. #GstBitWriter instance Memory area for writing Size of @data in bytes If %TRUE the complete data can be read from the beginning Initializes a #GstBitWriter instance and allocates the given data @size. #GstBitWriter instance the size on bytes to allocate for data If %TRUE the data can't be reallocated Write @nbits bits of @value to #GstBitWriter. %TRUE if successful, %FALSE otherwise. a #GstBitWriter instance value of #guint16 to write number of bits to write Write @nbits bits of @value to #GstBitWriter. %TRUE if successful, %FALSE otherwise. a #GstBitWriter instance value of #guint32 to write number of bits to write Write @nbits bits of @value to #GstBitWriter. %TRUE if successful, %FALSE otherwise. a #GstBitWriter instance value of #guint64 to write number of bits to write Write @nbits bits of @value to #GstBitWriter. %TRUE if successful, %FALSE otherwise. a #GstBitWriter instance value of #guint8 to write number of bits to write Write @nbytes bytes of @data to #GstBitWriter. %TRUE if successful, %FALSE otherwise. a #GstBitWriter instance pointer of data to write number of bytes to write Resets @bitwriter and frees the data if it's owned by @bitwriter. #GstBitWriter instance Resets @bitwriter and returns the current data as #GstBuffer. Free-function: gst_buffer_unref a new allocated #GstBuffer wrapping the current data. gst_buffer_unref() after usage. a #GstBitWriter instance Resets @bitwriter and returns the current data. Free-function: g_free the current data. g_free() after usage. a #GstBitWriter instance Creates a new, empty #GstBitWriter instance. Free-function: gst_bit_writer_free a new, empty #GstByteWriter instance Creates a new #GstBitWriter instance with the given memory area. If @initialized is %TRUE it is possible to read @size bits from the #GstBitWriter from the beginning. Free-function: gst_bit_writer_free a new #GstBitWriter instance Memory area for writing Size of @data in bytes if %TRUE the complete data can be read from the beginning Creates a #GstBitWriter instance with the given initial data size. Free-function: gst_bit_writer_free a new #GstBitWriter instance Initial size of data in bytes If %TRUE the data can't be reallocated #GstByteReader provides a byte reader that can read different integer and floating point types from a memory buffer. It provides functions for 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 read NUL-terminated strings in various character encodings. Data from which the bit reader will read Size of @data in bytes Current byte position 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. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Size in bytes address of a #guint8 pointer variable in which to store the result 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. %TRUE if a string could be read, %FALSE otherwise. The string put into @str must be freed with g_free() when no longer needed. a #GstByteReader instance address of a #guint16 pointer variable in which to store the result 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. %TRUE if a string could be read, %FALSE otherwise. The string put into @str must be freed with g_free() when no longer needed. a #GstByteReader instance address of a #guint32 pointer variable in which to store the result 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. %TRUE if a string could be read into @str, %FALSE otherwise. The string put into @str must be freed with g_free() when no longer needed. a #GstByteReader instance address of a #gchar pointer variable in which to store the result Frees a #GstByteReader instance, which was previously allocated by gst_byte_reader_new(). a #GstByteReader instance Returns a constant pointer to the current data position if at least @size bytes are left and updates the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Size in bytes address of a #guint8 pointer variable in which to store the result Read a 32 bit big endian floating point value into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gfloat to store the result Read a 32 bit little endian floating point value into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gfloat to store the result Read a 64 bit big endian floating point value into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gdouble to store the result Read a 64 bit little endian floating point value into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gdouble to store the result Read a signed 16 bit big endian integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint16 to store the result Read a signed 16 bit little endian integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint16 to store the result Read a signed 24 bit big endian integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint32 to store the result Read a signed 24 bit little endian integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint32 to store the result Read a signed 32 bit big endian integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint32 to store the result Read a signed 32 bit little endian integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint32 to store the result Read a signed 64 bit big endian integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint64 to store the result Read a signed 64 bit little endian integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint64 to store the result Read a signed 8 bit integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint8 to store the result Returns the current position of a #GstByteReader instance in bytes. The current position of @reader in bytes. a #GstByteReader instance Returns the remaining number of bytes of a #GstByteReader instance. The remaining number of bytes of @reader instance. a #GstByteReader instance Returns the total number of bytes of a #GstByteReader instance. The total number of bytes of @reader instance. a #GstByteReader instance 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. %TRUE if a string could be found, %FALSE otherwise. a #GstByteReader instance address of a #gchar pointer variable in which to store the result 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. FALSE on error or if @reader does not contain @size more bytes from the current position, and otherwise TRUE an existing and initialized #GstByteReader instance a #GstByteReader instance to initialize as sub-reader size of @sub_reader in bytes Read an unsigned 16 bit big endian integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint16 to store the result Read an unsigned 16 bit little endian integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint16 to store the result Read an unsigned 24 bit big endian integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint32 to store the result Read an unsigned 24 bit little endian integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint32 to store the result Read an unsigned 32 bit big endian integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint32 to store the result Read an unsigned 32 bit little endian integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint32 to store the result Read an unsigned 64 bit big endian integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint64 to store the result Read an unsigned 64 bit little endian integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint64 to store the result Read an unsigned 8 bit integer into @val and update the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint8 to store the result Initializes a #GstByteReader instance to read from @data. This function can be called on already initialized instances. a #GstByteReader instance data from which the #GstByteReader should read Size of @data in bytes 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. offset of the first match, or -1 if no match was found. Example: |[ // 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 ]| a #GstByteReader mask to apply to data before matching against @pattern pattern to match (after mask is applied) offset from which to start scanning, relative to the current position number of bytes to scan from offset 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. offset of the first match, or -1 if no match was found. a #GstByteReader mask to apply to data before matching against @pattern pattern to match (after mask is applied) offset from which to start scanning, relative to the current position number of bytes to scan from offset pointer to uint32 to return matching data Returns a constant pointer to the current data position if at least @size bytes are left and keeps the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Size in bytes address of a #guint8 pointer variable in which to store the result Read a 32 bit big endian floating point value into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gfloat to store the result Read a 32 bit little endian floating point value into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gfloat to store the result Read a 64 bit big endian floating point value into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gdouble to store the result Read a 64 bit little endian floating point value into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gdouble to store the result Read a signed 16 bit big endian integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint16 to store the result Read a signed 16 bit little endian integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint16 to store the result Read a signed 24 bit big endian integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint32 to store the result Read a signed 24 bit little endian integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint32 to store the result Read a signed 32 bit big endian integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint32 to store the result Read a signed 32 bit little endian integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint32 to store the result Read a signed 64 bit big endian integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint64 to store the result Read a signed 64 bit little endian integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint64 to store the result Read a signed 8 bit integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #gint8 to store the result 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. %TRUE if a string could be skipped, %FALSE otherwise. a #GstByteReader instance address of a #gchar pointer variable in which to store the result 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. FALSE on error or if @reader does not contain @size more bytes from the current position, and otherwise TRUE an existing and initialized #GstByteReader instance a #GstByteReader instance to initialize as sub-reader size of @sub_reader in bytes Read an unsigned 16 bit big endian integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint16 to store the result Read an unsigned 16 bit little endian integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint16 to store the result Read an unsigned 24 bit big endian integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint32 to store the result Read an unsigned 24 bit little endian integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint32 to store the result Read an unsigned 32 bit big endian integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint32 to store the result Read an unsigned 32 bit little endian integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint32 to store the result Read an unsigned 64 bit big endian integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint64 to store the result Read an unsigned 64 bit little endian integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint64 to store the result Read an unsigned 8 bit integer into @val but keep the current position. %TRUE if successful, %FALSE otherwise. a #GstByteReader instance Pointer to a #guint8 to store the result Sets the new position of a #GstByteReader instance to @pos in bytes. %TRUE if the position could be set successfully, %FALSE otherwise. a #GstByteReader instance The new position in bytes Skips @nbytes bytes of the #GstByteReader instance. %TRUE if @nbytes bytes could be skipped, %FALSE otherwise. a #GstByteReader instance the number of bytes to skip 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. %TRUE if a string could be skipped, %FALSE otherwise. a #GstByteReader instance 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. %TRUE if a string could be skipped, %FALSE otherwise. a #GstByteReader instance 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. %TRUE if a string could be skipped, %FALSE otherwise. a #GstByteReader instance Create a new #GstByteReader instance, which will read from @data. Free-function: gst_byte_reader_free a new #GstByteReader instance data from which the #GstByteReader should read Size of @data in bytes #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. #GstByteReader parent Allocation size of the data If %TRUE no reallocations are allowed If %FALSE no reallocations are allowed and copies of data are returned Checks if enough free space from the current write cursor is available and reallocates if necessary. %TRUE if at least @size bytes are still available #GstByteWriter instance Number of bytes that should be available Writes @size bytes containing @value to @writer. %TRUE if the value could be written #GstByteWriter instance Value to be written Number of bytes to be written Frees @writer and all memory allocated by it. #GstByteWriter instance Frees @writer and all memory allocated by it except the current data, which is returned as #GstBuffer. Free-function: gst_buffer_unref the current data as buffer. gst_buffer_unref() after usage. #GstByteWriter instance Frees @writer and all memory allocated by it except the current data, which is returned. Free-function: g_free the current data. g_free() after usage. #GstByteWriter instance Returns the remaining size of data that can still be written. If -1 is returned the remaining size is only limited by system resources. the remaining size of data that can still be written #GstByteWriter instance Initializes @writer to an empty instance #GstByteWriter instance Initializes @writer with the given memory area. If @initialized is %TRUE it is possible to read @size bytes from the #GstByteWriter from the beginning. #GstByteWriter instance Memory area for writing Size of @data in bytes If %TRUE the complete data can be read from the beginning Initializes @writer with the given initial data size. #GstByteWriter instance Initial size of data If %TRUE the data can't be reallocated Writes @size bytes of @data to @writer. %TRUE if the data could be written #GstByteWriter instance source #GstBuffer offset to copy from total size to copy. If -1, all data is copied Writes @size bytes of @data to @writer. %TRUE if the value could be written #GstByteWriter instance Data to write Size of @data in bytes Writes a big endian 32 bit float to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a little endian 32 bit float to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a big endian 64 bit float to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a little endian 64 bit float to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a signed big endian 16 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a signed little endian 16 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a signed big endian 24 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a signed little endian 24 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a signed big endian 32 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a signed little endian 32 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a signed big endian 64 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a signed little endian 64 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a signed 8 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a NUL-terminated UTF16 string to @writer (including the terminator). %TRUE if the value could be written #GstByteWriter instance UTF16 string to write Writes a NUL-terminated UTF32 string to @writer (including the terminator). %TRUE if the value could be written #GstByteWriter instance UTF32 string to write Writes a NUL-terminated UTF8 string to @writer (including the terminator). %TRUE if the value could be written #GstByteWriter instance UTF8 string to write Writes a unsigned big endian 16 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a unsigned little endian 16 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a unsigned big endian 24 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a unsigned little endian 24 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a unsigned big endian 32 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a unsigned little endian 32 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a unsigned big endian 64 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a unsigned little endian 64 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Writes a unsigned 8 bit integer to @writer. %TRUE if the value could be written #GstByteWriter instance Value to write Resets @writer and frees the data if it's owned by @writer. #GstByteWriter instance Resets @writer and returns the current data as buffer. Free-function: gst_buffer_unref the current data as buffer. gst_buffer_unref() after usage. #GstByteWriter instance Resets @writer and returns the current data. Free-function: g_free the current data. g_free() after usage. #GstByteWriter instance Creates a new, empty #GstByteWriter instance Free-function: gst_byte_writer_free a new, empty #GstByteWriter instance 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 a new #GstByteWriter instance Memory area for writing Size of @data in bytes If %TRUE the complete data can be read from the beginning Creates a new #GstByteWriter instance with the given initial data size. Free-function: gst_byte_writer_free a new #GstByteWriter instance Initial size of data If %TRUE the data can't be reallocated Returns the DTS that has been converted to running time when using gst_collect_pads_clip_running_time(). Unlike the value saved into the buffer, this value is of type gint64 and may be negative. This allow properly handling streams with frame reordering where the first DTS may be negative. If the initial DTS was not set, this value will be set to %G_MININT64. A #GstCollectData. Check if running DTS value store is valid. A #GstCollectData. Get the stream lock of @pads. The stream lock is used to coordinate and serialize execution among the various streams being collected, and in protecting the resources used to accomplish this. a #GstCollectPads A flags word containing #GstCollectPadsStateFlags flags set on this collected pad. a #GstCollectData. Gives the status of a specific flag on a collected pad. a #GstCollectData. the #GstCollectPadsStateFlags to check. Sets a state flag on a collected pad. a #GstCollectData. the #GstCollectPadsStateFlags to set. Clears a state flag on a collected pad. a #GstCollectData. the #GstCollectPadsStateFlags to clear. Lock the stream lock of @pads. a #GstCollectPads Unlock the stream lock of @pads. a #GstCollectPads Structure used by the collect_pads. owner #GstCollectPads #GstPad managed by this data currently queued buffer. position in the buffer last segment received. A function that will be called when the #GstCollectData will be freed. It is passed the pointer to the structure and should free any custom memory and resources allocated for it. the #GstCollectData that will be freed Manages a set of pads that operate in collect mode. This means that control is given to the manager of this object when all pads have data. * Collectpads are created with gst_collect_pads_new(). A callback should then be installed with gst_collect_pads_set_function (). * Pads are added to the collection with gst_collect_pads_add_pad()/ gst_collect_pads_remove_pad(). The pad has to be a sinkpad. When added, the chain, event and query functions of the pad are overridden. The element_private of the pad is used to store private information for the collectpads. * For each pad, data is queued in the _chain function or by performing a pull_range. * When data is queued on all pads in waiting mode, the callback function is called. * Data can be dequeued from the pad with the gst_collect_pads_pop() method. One can peek at the data with the gst_collect_pads_peek() function. These functions will return %NULL if the pad received an EOS event. When all pads return %NULL from a gst_collect_pads_peek(), the element can emit an EOS event itself. * Data can also be dequeued in byte units using the gst_collect_pads_available(), gst_collect_pads_read_buffer() and gst_collect_pads_flush() calls. * Elements should call gst_collect_pads_start() and gst_collect_pads_stop() in their state change functions to start and stop the processing of the collectpads. The gst_collect_pads_stop() call should be called before calling the parent element state change function in the PAUSED_TO_READY state change to ensure no pad is blocked and the element can finish streaming. * gst_collect_pads_set_waiting() sets a pad to waiting or non-waiting mode. CollectPads element is not waiting for data to be collected on non-waiting pads. Thus these pads may but need not have data when the callback is called. All pads are in waiting mode by default. Create a new instance of #GstCollectPads. MT safe. a new #GstCollectPads, or %NULL in case of an error. Add a pad to the collection of collect pads. The pad has to be a sinkpad. The refcount of the pad is incremented. Use gst_collect_pads_remove_pad() to remove the pad from the collection again. You specify a size for the returned #GstCollectData structure so that you can use it to store additional information. You can also specify a #GstCollectDataDestroyNotify that will be called just before the #GstCollectData structure is freed. It is passed the pointer to the structure and should free any custom memory and resources allocated for it. Keeping a pad locked in waiting state is only relevant when using the default collection algorithm (providing the oldest buffer). It ensures a buffer must be available on this pad for a collection to take place. This is of typical use to a muxer element where non-subtitle streams should always be in waiting state, e.g. to assure that caps information is available on all these streams when initial headers have to be written. The pad will be automatically activated in push mode when @pads is started. MT safe. a new #GstCollectData to identify the new pad. Or %NULL if wrong parameters are supplied. the collectpads to use the pad to add the size of the returned #GstCollectData structure function to be called before the returned #GstCollectData structure is freed whether to lock this pad in usual waiting state Query how much bytes can be read from each queued buffer. This means that the result of this call is the maximum number of bytes that can be read from each of the pads. This function should be called with @pads STREAM_LOCK held, such as in the callback. MT safe. The maximum number of bytes queued on all pads. This function returns 0 if a pad has no queued buffer. the collectpads to query Convenience clipping function that converts incoming buffer's timestamp to running time, or clips the buffer if outside configured segment. Since 1.6, this clipping function also sets the DTS parameter of the GstCollectData structure. This version of the running time DTS can be negative. G_MININT64 is used to indicate invalid value. the collectpads to use collect data of corresponding pad buffer being clipped output buffer with running time, or NULL if clipped user data (unused) Default #GstCollectPads event handling that elements should always chain up to to ensure proper operation. Element might however indicate event should not be forwarded downstream. the collectpads to use collect data of corresponding pad event being processed process but do not send event downstream Flush @size bytes from the pad @data. This function should be called with @pads STREAM_LOCK held, such as in the callback. MT safe. The number of bytes flushed This can be less than @size and is 0 if the pad was end-of-stream. the collectpads to query the data to use the number of bytes to flush Peek at the buffer currently queued in @data. This function should be called with the @pads STREAM_LOCK held, such as in the callback handler. MT safe. The buffer in @data or %NULL if no buffer is queued. should unref the buffer after usage. the collectpads to peek the data to use Pop the buffer currently queued in @data. This function should be called with the @pads STREAM_LOCK held, such as in the callback handler. MT safe. The buffer in @data or %NULL if no buffer was queued. You should unref the buffer after usage. the collectpads to pop the data to use Default #GstCollectPads query handling that elements should always chain up to to ensure proper operation. Element might however indicate query should not be forwarded downstream. the collectpads to use collect data of corresponding pad query being processed process but do not send event downstream Get a subbuffer of @size bytes from the given pad @data. This function should be called with @pads STREAM_LOCK held, such as in the callback. MT safe. A sub buffer. The size of the buffer can be less that requested. A return of %NULL signals that the pad is end-of-stream. Unref the buffer after use. the collectpads to query the data to use the number of bytes to read Remove a pad from the collection of collect pads. This function will also free the #GstCollectData and all the resources that were allocated with gst_collect_pads_add_pad(). The pad will be deactivated automatically when @pads is stopped. MT safe. %TRUE if the pad could be removed. the collectpads to use the pad to remove Set the callback function and user data that will be called with the oldest buffer when all pads have been collected, or %NULL on EOS. If a buffer is passed, the callback owns a reference and must unref it. MT safe. the collectpads to use the function to set user data passed to the function Install a clipping function that is called right after a buffer is received on a pad managed by @pads. See #GstCollectPadsClipFunction for more info. the collectpads to use clip function to install user data to pass to @clip_func Set the timestamp comparison function. MT safe. the pads to use the function to set user data passed to the function Set the event callback function and user data that will be called when collectpads has received an event originating from one of the collected pads. If the event being processed is a serialized one, this callback is called with @pads STREAM_LOCK held, otherwise not. As this lock should be held when calling a number of CollectPads functions, it should be acquired if so (unusually) needed. MT safe. the collectpads to use the function to set user data passed to the function Install a flush function that is called when the internal state of all pads should be flushed as part of flushing seek handling. See #GstCollectPadsFlushFunction for more info. the collectpads to use flush function to install user data to pass to @func Change the flushing state of all the pads in the collection. No pad is able to accept anymore data when @flushing is %TRUE. Calling this function with @flushing %FALSE makes @pads accept data again. Caller must ensure that downstream streaming (thread) is not blocked, e.g. by sending a FLUSH_START downstream. MT safe. the collectpads to use desired state of the pads CollectPads provides a default collection algorithm that will determine the oldest buffer available on all of its pads, and then delegate to a configured callback. However, if circumstances are more complicated and/or more control is desired, this sets a callback that will be invoked instead when all the pads added to the collection have buffers queued. Evidently, this callback is not compatible with gst_collect_pads_set_buffer_function() callback. If this callback is set, the former will be unset. MT safe. the collectpads to use the function to set user data passed to the function Set the query callback function and user data that will be called after collectpads has received a query originating from one of the collected pads. If the query being processed is a serialized one, this callback is called with @pads STREAM_LOCK held, otherwise not. As this lock should be held when calling a number of CollectPads functions, it should be acquired if so (unusually) needed. MT safe. the collectpads to use the function to set user data passed to the function Sets a pad to waiting or non-waiting mode, if at least this pad has not been created with locked waiting state, in which case nothing happens. This function should be called with @pads STREAM_LOCK held, such as in the callback. MT safe. the collectpads the data to use boolean indicating whether this pad should operate in waiting or non-waiting mode Default #GstCollectPads event handling for the src pad of elements. Elements can chain up to this to let flushing seek event handling be done by #GstCollectPads. the #GstCollectPads to use src #GstPad that received the event event being processed Starts the processing of data in the collect_pads. MT safe. the collectpads to use Stops the processing of data in the collect_pads. this function will also unblock any blocking operations. MT safe. the collectpads to use Get a subbuffer of @size bytes from the given pad @data. Flushes the amount of read bytes. This function should be called with @pads STREAM_LOCK held, such as in the callback. MT safe. A sub buffer. The size of the buffer can be less that requested. A return of %NULL signals that the pad is end-of-stream. Unref the buffer after use. the collectpads to query the data to use the number of bytes to read #GList of #GstCollectData managed by this #GstCollectPads. A function that will be called when a (considered oldest) buffer can be muxed. If all pads have reached EOS, this function is called with %NULL @buffer and %NULL @data. %GST_FLOW_OK for success the #GstCollectPads that triggered the callback the #GstCollectData of pad that has received the buffer the #GstBuffer user data passed to gst_collect_pads_set_buffer_function() A function that will be called when @inbuffer is received on the pad managed by @data in the collectpad object @pads. The function should use the segment of @data and the negotiated media type on the pad to perform clipping of @inbuffer. This function takes ownership of @inbuffer and should output a buffer in @outbuffer or return %NULL in @outbuffer if the buffer should be dropped. a #GstFlowReturn that corresponds to the result of clipping. a #GstCollectPads a #GstCollectData the input #GstBuffer the output #GstBuffer user data A function for comparing two timestamps of buffers or newsegments collected on one pad. Integer less than zero when first timestamp is deemed older than the second one. Zero if the timestamps are deemed equally old. Integer greater than zero when second timestamp is deemed older than the first one. the #GstCollectPads that is comparing the timestamps the first #GstCollectData the first timestamp the second #GstCollectData the second timestamp user data passed to gst_collect_pads_set_compare_function() A function that will be called while processing an event. It takes ownership of the event and is responsible for chaining up (to gst_collect_pads_event_default()) or dropping events (such typical cases being handled by the default handler). %TRUE if the pad could handle the event the #GstCollectPads that triggered the callback the #GstPad that received an event the #GstEvent received user data passed to gst_collect_pads_set_event_function() A function that will be called while processing a flushing seek event. The function should flush any internal state of the element and the state of all the pads. It should clear only the state not directly managed by the @pads object. It is therefore not necessary to call gst_collect_pads_set_flushing nor gst_collect_pads_clear from this function. a #GstCollectPads user data A function that will be called when all pads have received data. %GST_FLOW_OK for success the #GstCollectPads that triggered the callback user data passed to gst_collect_pads_set_function() A function that will be called while processing a query. It takes ownership of the query and is responsible for chaining up (to events downstream (with gst_pad_event_default()). %TRUE if the pad could handle the event the #GstCollectPads that triggered the callback the #GstPad that received an event the #GstEvent received user data passed to gst_collect_pads_set_query_function() Set if collectdata's pad is EOS. Set if collectdata's pad is flushing. Set if collectdata's pad received a new_segment event. Set if collectdata's pad must be waited for when collecting. Set collectdata's pad WAITING state must not be changed. #GstCollectPadsStateFlags indicate private state of a collectdata('s pad). #GstDataQueue is an object that handles threadsafe queueing of objects. It also provides size-related functionality. This object should be used for any #GstElement that wishes to provide some sort of queueing functionality. Creates a new #GstDataQueue. If @fullcallback or @emptycallback are supplied, then the #GstDataQueue will call the respective callback to signal full or empty condition. If the callbacks are NULL the #GstDataQueue will instead emit 'full' and 'empty' signals. a new #GstDataQueue. the callback used to tell if the element considers the queue full or not. the callback which will be called when the queue is considered full. the callback which will be called when the queue is considered empty. a #gpointer that will be passed to the @checkfull, @fullcallback, and @emptycallback callbacks. Pop and unref the head-most #GstMiniObject with the given #GType. %TRUE if an element was removed. The #GstDataQueue to drop an item from. The #GType of the item to drop. Flushes all the contents of the @queue. Any call to #gst_data_queue_push and #gst_data_queue_pop will be released. MT safe. a #GstDataQueue. Get the current level of the queue. The #GstDataQueue the location to store the result Queries if there are any items in the @queue. MT safe. %TRUE if @queue is empty. a #GstDataQueue. Queries if @queue is full. This check will be done using the #GstDataQueueCheckFullFunction registered with @queue. MT safe. %TRUE if @queue is full. a #GstDataQueue. Inform the queue that the limits for the fullness check have changed and that any blocking gst_data_queue_push() should be unblocked to recheck the limits. The #GstDataQueue Retrieves the first @item available on the @queue without removing it. If the queue is currently empty, the call will block until at least one item is available, OR the @queue is set to the flushing state. MT safe. %TRUE if an @item was successfully retrieved from the @queue. a #GstDataQueue. pointer to store the returned #GstDataQueueItem. Retrieves the first @item available on the @queue. If the queue is currently empty, the call will block until at least one item is available, OR the @queue is set to the flushing state. MT safe. %TRUE if an @item was successfully retrieved from the @queue. a #GstDataQueue. pointer to store the returned #GstDataQueueItem. Pushes a #GstDataQueueItem (or a structure that begins with the same fields) on the @queue. If the @queue is full, the call will block until space is available, OR the @queue is set to flushing state. MT safe. Note that this function has slightly different semantics than gst_pad_push() and gst_pad_push_event(): this function only takes ownership of @item and the #GstMiniObject contained in @item if the push was successful. If %FALSE is returned, the caller is responsible for freeing @item and its contents. %TRUE if the @item was successfully pushed on the @queue. a #GstDataQueue. a #GstDataQueueItem. Pushes a #GstDataQueueItem (or a structure that begins with the same fields) on the @queue. It ignores if the @queue is full or not and forces the @item to be pushed anyway. MT safe. Note that this function has slightly different semantics than gst_pad_push() and gst_pad_push_event(): this function only takes ownership of @item and the #GstMiniObject contained in @item if the push was successful. If %FALSE is returned, the caller is responsible for freeing @item and its contents. %TRUE if the @item was successfully pushed on the @queue. a #GstDataQueue. a #GstDataQueueItem. Sets the queue to flushing state if @flushing is %TRUE. If set to flushing state, any incoming data on the @queue will be discarded. Any call currently blocking on #gst_data_queue_push or #gst_data_queue_pop will return straight away with a return value of %FALSE. While the @queue is in flushing state, all calls to those two functions will return %FALSE. MT Safe. a #GstDataQueue. a #gboolean stating if the queue will be flushing or not. the parent structure Reports that the queue became empty (empty). A queue is empty if the total amount of visible items inside it (num-visible, time, size) is lower than the boundary values which can be set through the GObject properties. Reports that the queue became full (full). A queue is full if the total amount of data inside it (num-visible, time, size) is higher than the boundary values which can be set through the GObject properties. The prototype of the function used to inform the queue that it should be considered as full. %TRUE if the queue should be considered full. a #GstDataQueue. The number of visible items currently in the queue. The amount of bytes currently in the queue. The accumulated duration of the items currently in the queue. The #gpointer registered when the #GstDataQueue was created. Structure used by #GstDataQueue. You can supply a different structure, as long as the top of the structure is identical to this structure. the #GstMiniObject to queue. the size in bytes of the miniobject. the duration in #GstClockTime of the miniobject. Can not be %GST_CLOCK_TIME_NONE. %TRUE if @object should be considered as a visible object. The #GDestroyNotify function to use to free the #GstDataQueueItem. This function should also drop the reference to @object the owner of the #GstDataQueueItem is assumed to hold. Structure describing the size of a queue. number of buffers number of bytes amount of time Utility struct to help handling #GstFlowReturn combination. Useful for #GstElement<!-- -->s that have multiple source pads and need to combine the different #GstFlowReturn for those pads. #GstFlowCombiner works by using the last #GstFlowReturn for all #GstPad it has in its list and computes the combined return value and provides it to the caller. To add a new pad to the #GstFlowCombiner use gst_flow_combiner_add_pad(). The new #GstPad is stored with a default value of %GST_FLOW_OK. In case you want a #GstPad to be removed, use gst_flow_combiner_remove_pad(). Please be aware that this struct isn't thread safe as its designed to be used by demuxers, those usually will have a single thread operating it. These functions will take refs on the passed #GstPad<!-- -->s. Aside from reducing the user's code size, the main advantage of using this helper struct is to follow the standard rules for #GstFlowReturn combination. These rules are: * %GST_FLOW_EOS: only if all returns are EOS too * %GST_FLOW_NOT_LINKED: only if all returns are NOT_LINKED too * %GST_FLOW_ERROR or below: if at least one returns an error return * %GST_FLOW_NOT_NEGOTIATED: if at least one returns a not-negotiated return * %GST_FLOW_FLUSHING: if at least one returns flushing * %GST_FLOW_OK: otherwise %GST_FLOW_ERROR or below, GST_FLOW_NOT_NEGOTIATED and GST_FLOW_FLUSHING are returned immediately from the gst_flow_combiner_update_flow() function. Creates a new #GstFlowCombiner, use gst_flow_combiner_free() to free it. A new #GstFlowCombiner Adds a new #GstPad to the #GstFlowCombiner. the #GstFlowCombiner the #GstPad that is being added Removes all pads from a #GstFlowCombiner and resets it to its initial state. the #GstFlowCombiner to clear Frees a #GstFlowCombiner struct and all its internal data. the #GstFlowCombiner to free Increments the reference count on the #GstFlowCombiner. the #GstFlowCombiner. the #GstFlowCombiner to add a reference to. Removes a #GstPad from the #GstFlowCombiner. the #GstFlowCombiner the #GstPad to remove Reset flow combiner and all pads to their initial state without removing pads. the #GstFlowCombiner to clear Decrements the reference count on the #GstFlowCombiner. the #GstFlowCombiner to unreference. Computes the combined flow return for the pads in it. The #GstFlowReturn parameter should be the last flow return update for a pad in this #GstFlowCombiner. It will use this value to be able to shortcut some combinations and avoid looking over all pads again. e.g. The last combined return is the same as the latest obtained #GstFlowReturn. The combined #GstFlowReturn the #GstFlowCombiner the latest #GstFlowReturn received for a pad in this #GstFlowCombiner Sets the provided pad's last flow return to provided value and computes the combined flow return for the pads in it. The #GstFlowReturn parameter should be the last flow return update for a pad in this #GstFlowCombiner. It will use this value to be able to shortcut some combinations and avoid looking over all pads again. e.g. The last combined return is the same as the latest obtained #GstFlowReturn. The combined #GstFlowReturn the #GstFlowCombiner the #GstPad whose #GstFlowReturn to update the latest #GstFlowReturn received for a pad in this #GstFlowCombiner This class is mostly useful for elements that cannot do random access, or at least very slowly. The source usually prefers to push out a fixed size buffer. Subclasses usually operate in a format that is different from the default GST_FORMAT_BYTES format of #GstBaseSrc. Classes extending this base class will usually be scheduled in a push based mode. If the peer accepts to operate without offsets and within the limits of the allowed block size, this class can operate in getrange based mode automatically. To make this possible, the subclass should implement and override the SCHEDULING query. The subclass should extend the methods from the baseclass in addition to the ::create method. Seeking, flushing, scheduling and sync is all handled by this base class. Subclasses can override any of the available virtual methods or not, as needed. At the minimum, the @fill method should be overridden to produce buffers. Element parent class #GstQueueArray is an object that provides standard queue functionality based on an array instead of linked lists. This reduces the overhead caused by memory management by a large factor. Clears queue @array and frees all memory associated to it. a #GstQueueArray object Drops the queue element at position @idx from queue @array. the dropped element a #GstQueueArray object index to drop Drops the queue element at position @idx from queue @array and copies the data of the element or structure that was removed into @p_struct if @p_struct is set (not NULL). TRUE on success, or FALSE on error a #GstQueueArray object index to drop address into which to store the data of the dropped structure, or NULL Finds an element in the queue @array, either by comparing every element with @func or by looking up @data if no compare function @func is provided, and returning the index of the found element. Index of the found element or -1 if nothing was found. a #GstQueueArray object comparison function, or %NULL to find @data by value data for comparison function Frees queue @array and all memory associated to it. a #GstQueueArray object Returns the length of the queue @array the length of the queue @array. a #GstQueueArray object Checks if the queue @array is empty. %TRUE if the queue @array is empty a #GstQueueArray object Returns the head of the queue @array and does not remove it from the queue. The head of the queue a #GstQueueArray object Returns the head of the queue @array without removing it from the queue. pointer to element or struct, or NULL if @array was empty. The data pointed to by the returned pointer stays valid only as long as the queue array is not modified further! a #GstQueueArray object Returns the item at @idx in @array, but does not remove it from the queue. The item, or %NULL if @idx was out of bounds Returns the item at @idx in @array, but does not remove it from the queue. The item, or %NULL if @idx was out of bounds Returns the tail of the queue @array, but does not remove it from the queue. The tail of the queue a #GstQueueArray object Returns the tail of the queue @array, but does not remove it from the queue. The tail of the queue a #GstQueueArray object Returns and head of the queue @array and removes it from the queue. The head of the queue a #GstQueueArray object Returns the head of the queue @array and removes it from the queue. pointer to element or struct, or NULL if @array was empty. The data pointed to by the returned pointer stays valid only as long as the queue array is not modified further! a #GstQueueArray object Returns the tail of the queue @array and removes it from the queue. The tail of the queue a #GstQueueArray object Returns the tail of the queue @array and removes it from the queue. The tail of the queue a #GstQueueArray object Pushes @data to the tail of the queue @array. a #GstQueueArray object object to push Sets a function to clear an element of @array. The @clear_func will be called when an element in the array data segment is removed and when the array is freed and data segment is deallocated as well. @clear_func will be passed a pointer to the element to clear, rather than the element itself. Note that in contrast with other uses of #GDestroyNotify functions, @clear_func is expected to clear the contents of the array element it is given, but not free the element itself. a #GstQueueArray object a function to clear an element of @array Allocates a new #GstQueueArray object with an initial queue size of @initial_size. a new #GstQueueArray object Initial size of the new queue Allocates a new #GstQueueArray object for elements (e.g. structures) of size @struct_size, with an initial queue size of @initial_size. a new #GstQueueArray object Size of each element (e.g. structure) in the array Initial size of the new queue This function will be called by gst_type_find_helper_get_range() when typefinding functions request to peek at the data of a stream at certain offsets. If this function returns GST_FLOW_OK, the result buffer will be stored in @buffer. The contents of @buffer is invalid for any other return value. This function is supposed to behave exactly like a #GstPadGetRangeFunction. GST_FLOW_OK for success a #GstObject that will handle the getrange request the parent of @obj or %NULL the offset of the range the length of the range a memory location to hold the result buffer Create a new #GstBitReader instance, which will read from @data. Free-function: gst_bit_reader_free a new #GstBitReader instance Data from which the #GstBitReader should read Size of @data in bytes Creates a new, empty #GstBitWriter instance. Free-function: gst_bit_writer_free a new, empty #GstByteWriter instance Creates a new #GstBitWriter instance with the given memory area. If @initialized is %TRUE it is possible to read @size bits from the #GstBitWriter from the beginning. Free-function: gst_bit_writer_free a new #GstBitWriter instance Memory area for writing Size of @data in bytes if %TRUE the complete data can be read from the beginning Creates a #GstBitWriter instance with the given initial data size. Free-function: gst_bit_writer_free a new #GstBitWriter instance Initial size of data in bytes If %TRUE the data can't be reallocated Create a new #GstByteReader instance, which will read from @data. Free-function: gst_byte_reader_free a new #GstByteReader instance data from which the #GstByteReader should read Size of @data in bytes 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. a #GstByteReader instance address of a #gchar pointer variable in which to store the result 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. a #GstByteReader instance Creates a new, empty #GstByteWriter instance Free-function: gst_byte_writer_free a new, empty #GstByteWriter instance 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 a new #GstByteWriter instance Memory area for writing Size of @data in bytes If %TRUE the complete data can be read from the beginning Creates a new #GstByteWriter instance with the given initial data size. Free-function: gst_byte_writer_free a new #GstByteWriter instance Initial size of data If %TRUE the data can't be reallocated 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). #GstByteWriter instance Null terminated string Allocates a new #GstQueueArray object with an initial queue size of @initial_size. a new #GstQueueArray object Initial size of the new queue Allocates a new #GstQueueArray object for elements (e.g. structures) of size @struct_size, with an initial queue size of @initial_size. a new #GstQueueArray object Size of each element (e.g. structure) in the array Initial size of the new queue Tries to find what type of data is flowing from the given source #GstPad. Free-function: gst_caps_unref the #GstCaps corresponding to the data stream. Returns %NULL if no #GstCaps matches the data stream. A source #GstPad The length in bytes Tries to find what type of data is contained in the given #GstBuffer, the assumption being that the buffer represents the beginning of the stream or file. All available typefinders will be called on the data in order of rank. If a typefinding function returns a probability of %GST_TYPE_FIND_MAXIMUM, typefinding is stopped immediately and the found caps will be returned right away. Otherwise, all available typefind functions will the tried, and the caps with the highest probability will be returned, or %NULL if the content of the buffer could not be identified. Free-function: gst_caps_unref the #GstCaps corresponding to the data, or %NULL if no type could be found. The caller should free the caps returned with gst_caps_unref(). object doing the typefinding, or %NULL (used for logging) a #GstBuffer with data to typefind location to store the probability of the found caps, or %NULL Tries to find what type of data is contained in the given #GstBuffer, the assumption being that the buffer represents the beginning of the stream or file. All available typefinders will be called on the data in order of rank. If a typefinding function returns a probability of %GST_TYPE_FIND_MAXIMUM, typefinding is stopped immediately and the found caps will be returned right away. Otherwise, all available typefind functions will the tried, and the caps with the highest probability will be returned, or %NULL if the content of the buffer could not be identified. When @extension is not %NULL, this function will first try the typefind functions for the given extension, which might speed up the typefinding in many cases. Free-function: gst_caps_unref the #GstCaps corresponding to the data, or %NULL if no type could be found. The caller should free the caps returned with gst_caps_unref(). object doing the typefinding, or %NULL (used for logging) a #GstBuffer with data to typefind extension of the media, or %NULL location to store the probability of the found caps, or %NULL Tries to find what type of data is contained in the given @data, the assumption being that the data represents the beginning of the stream or file. All available typefinders will be called on the data in order of rank. If a typefinding function returns a probability of %GST_TYPE_FIND_MAXIMUM, typefinding is stopped immediately and the found caps will be returned right away. Otherwise, all available typefind functions will the tried, and the caps with the highest probability will be returned, or %NULL if the content of @data could not be identified. Free-function: gst_caps_unref the #GstCaps corresponding to the data, or %NULL if no type could be found. The caller should free the caps returned with gst_caps_unref(). object doing the typefinding, or %NULL (used for logging) * a pointer with data to typefind the size of @data location to store the probability of the found caps, or %NULL Tries to find what type of data is contained in the given @data, the assumption being that the data represents the beginning of the stream or file. All available typefinders will be called on the data in order of rank. If a typefinding function returns a probability of %GST_TYPE_FIND_MAXIMUM, typefinding is stopped immediately and the found caps will be returned right away. Otherwise, all available typefind functions will the tried, and the caps with the highest probability will be returned, or %NULL if the content of @data could not be identified. When @extension is not %NULL, this function will first try the typefind functions for the given extension, which might speed up the typefinding in many cases. Free-function: gst_caps_unref the #GstCaps corresponding to the data, or %NULL if no type could be found. The caller should free the caps returned with gst_caps_unref(). object doing the typefinding, or %NULL (used for logging) * a pointer with data to typefind the size of @data extension of the media, or %NULL location to store the probability of the found caps, or %NULL Tries to find the best #GstCaps associated with @extension. All available typefinders will be checked against the extension in order of rank. The caps of the first typefinder that can handle @extension will be returned. Free-function: gst_caps_unref the #GstCaps corresponding to @extension, or %NULL if no type could be found. The caller should free the caps returned with gst_caps_unref(). object doing the typefinding, or %NULL (used for logging) an extension Utility function to do pull-based typefinding. Unlike gst_type_find_helper() however, this function will use the specified function @func to obtain the data needed by the typefind functions, rather than operating on a given source pad. This is useful mostly for elements like tag demuxers which strip off data at the beginning and/or end of a file and want to typefind the stripped data stream before adding their own source pad (the specified callback can then call the upstream peer pad with offsets adjusted for the tag size, for example). When @extension is not %NULL, this function will first try the typefind functions for the given extension, which might speed up the typefinding in many cases. Free-function: gst_caps_unref the #GstCaps corresponding to the data stream. Returns %NULL if no #GstCaps matches the data stream. A #GstObject that will be passed as first argument to @func the parent of @obj or %NULL A generic #GstTypeFindHelperGetRangeFunction that will be used to access data at random offsets when doing the typefinding The length in bytes extension of the media, or %NULL location to store the probability of the found caps, or %NULL Utility function to do pull-based typefinding. Unlike gst_type_find_helper() however, this function will use the specified function @func to obtain the data needed by the typefind functions, rather than operating on a given source pad. This is useful mostly for elements like tag demuxers which strip off data at the beginning and/or end of a file and want to typefind the stripped data stream before adding their own source pad (the specified callback can then call the upstream peer pad with offsets adjusted for the tag size, for example). When @extension is not %NULL, this function will first try the typefind functions for the given extension, which might speed up the typefinding in many cases. the last %GstFlowReturn from pulling a buffer or %GST_FLOW_OK if typefinding was successful. A #GstObject that will be passed as first argument to @func the parent of @obj or %NULL A generic #GstTypeFindHelperGetRangeFunction that will be used to access data at random offsets when doing the typefinding The length in bytes extension of the media, or %NULL returned caps location to store the probability of the found caps, or %NULL