l$      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRST U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^ Creates a new , use   to free it.  Adds a new  to the . Removes all pads from a $ and resets it to its initial state. Frees a " struct and all its internal data. Removes a  from the .NReset flow combiner and all pads to their initial state without removing pads.5Computes the combined flow return for the pads in it.The C parameter should be the last flow return update for a pad in this . 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 .tSets the provided pad's last flow return to provided value and computes the combined flow return for the pads in it.The C parameter should be the last flow return update for a pad in this . 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 .( Returns: A new  combiner: the  pad: the  that is being added combiner: the  to clear combiner: the  to free combiner: the  pad: the  to remove combiner: the  to clear combiner: the  fret : the latest  received for a pad in this  Returns: The combined  combiner: the  pad: the  whose  to update fret : the latest  received for a pad in this  Returns: The combined       ' 7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^1 Construct a / struct initialized to zero.<Frees a /- instance, which was previously allocated by gst_bit_reader_new().=Read nbits bits into val! and update the current position.>Read nbits bits into val! and update the current position.?Read nbits bits into val! and update the current position.@Read nbits bits into val! and update the current position.A"Returns the current position of a / instance in bits.B*Returns the remaining number of bits of a / instance.C&Returns the total number of bits of a / instance.DInitializes a / instance to read from data?. This function can be called on already initialized instances.ERead nbits bits into val but keep the current position.FRead nbits bits into val but keep the current position.GRead nbits bits into val but keep the current position.HRead nbits bits into val but keep the current position.ISets the new position of a / instance to pos in bits.JSkips nbits bits of the / instance.KSkips until the next byte.Z !"#$%&'()*+,-./0123456789:;<reader: a / instance =reader: a / instance nbits: number of bits to read Returns:  if successful,  otherwise. >reader: a / instance nbits: number of bits to read Returns:  if successful,  otherwise. ?reader: a / instance nbits: number of bits to read Returns:  if successful,  otherwise. @reader: a / instance nbits: number of bits to read Returns:  if successful,  otherwise. Areader: a / instance Returns: The current position of reader in bits. Breader: a / instance Returns:! The remaining number of bits of reader instance. Creader: a / instance Returns: The total number of bits of reader instance. Dreader: a / instance data-: data from which the bit reader should read Ereader: a / instance nbits: number of bits to read Returns:  if successful,  otherwise. Freader: a / instance nbits: number of bits to read Returns:  if successful,  otherwise. Greader: a / instance nbits: number of bits to read Returns:  if successful,  otherwise. Hreader: a / instance nbits: number of bits to read Returns:  if successful,  otherwise. Ireader: a / instance pos: The new position in bits Returns: , if the position could be set successfully,  otherwise. Jreader: a / instance nbits: the number of bits to skip Returns:  if nbits bits could be skipped,  otherwise. Kreader: a / instance Returns:  if successful,  otherwise. LMNOPQRSTUVWXYZ[\]^_`abc- !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK-/012.<-=,>+?*@)A(B'C&D%E$F#G"H!I JK;9:867534Y !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^hijklmnopqrstuvwxyz{|}~hijklmnopqrstulmknojspitqhurhijklmnopqrstuvwxyz{|}~7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^ Construct a  struct initialized to zero.&%7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^Lets  sub-classes to know the memory  allocator used by the base class and its params. Unref the  allocator after use it.3No description available in the introspection data.See if trans' is configured as a in_place transform.See if trans* is configured as a passthrough transform.)Queries if the transform will handle QoS. Instructs trans to request renegotiation upstream. This function is typically called after properties on the transform were set that influence the input format. 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.If gapAware is - (the default), output buffers will have the  flag unset. If set to , 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.Determines whether a non-writable buffer will be copied before passing to the transform_ip function. <itemizedlist> <listitem>Always H if no transform function is implemented.</listitem> <listitem>Always F if ONLY transform function is implemented.</listitem> </itemizedlist>MT safe.vSet passthrough mode for this filter by default. This is mostly useful for filters that do not care about negotiation.Always M for filters which don't implement either a transform or transform_ip method.MT safe.If preferPassthrough is  (the default), transe will check and prefer passthrough caps from the list of caps returned by the transform_caps vmethod. If set to , 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.0Enable or disable QoS handling in the transform.MT safe.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.Updates the srcpad caps and send 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 informations). This way, they can notify downstream about that change without loosing any buffer.Ptrans: a  trans: a  Returns: the instance of the  used by trans; free it after use it trans: the  to query Returns: 1 is the transform is configured in in_place mode. MT safe. trans: the  to query Returns: 4 is the transform is configured in passthrough mode. MT safe. trans: a  Returns:  if QoS is enabled. MT safe. trans: a  trans: a  trans: a  gapAware : New state trans: the  to modify inPlaceN: Boolean value indicating that we would like to operate on in_place buffers. trans: the  to set  passthrough': boolean indicating passthrough mode. trans: a  preferPassthrough : New state trans: a  enabled : new state trans: a   proportion: the proportion diff: the diff against the clock  timestampL: the timestamp of the buffer generating the QoS expressed in running_time. trans: a   updatedCaps@: An updated version of the srcpad caps to be pushed downstream Returns: & if the caps could be send downstream  otherwise &&O7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^!Lets   sub-classes to know the memory  allocator used by the base class and its params. Unref the  allocator after usage."Get the number of bytes that src will push out with each buffer.#3No description available in the introspection data.$ Query if src? timestamps outgoing buffers based on the current running_time.%#Get the current async behaviour of src . See also ).&$Check if an element is in live mode.'Prepare a new seamless segment for emission downstream. This function must only be called by derived sub-classes, and only from the 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 /(-Query the source for the latency parameters. live will be  when src! is configured as a live source.  minLatency and  maxLatency^ will be set to the difference between the running time and the timestamp of the first buffer.+This function is mostly used by subclasses.)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.*If  automaticEos is , src\ will automatically go EOS if a buffer after the total size is returned. By default this is  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 .+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.,'Set new caps on the basesrc source pad.- Configure src to automatically timestamp outgoing buffers based on the current running_time of the pipeline. This property is mostly useful for live sources..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./xSets 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 . is_seekable () returns ..This function must only be called in states < .0)If the element listens to a live source, live should be set to .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.1gComplete an asynchronous start operation. When the subclass overrides the start method, it should call 1f when the start operation completes either from the same thread or from an asynchronous helper thread.2)Wait until the start operation completes.3If the .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.fThis function will block until a state change to PLAYING happens (in which case this function returns y) or the processing must be stopped due to a state change to READY or a FLUSH event (in which case this function returns ).v      !src: a   "src : the source Returns:. the number of bytes pushed with each buffer. #src: a   Returns: the instance of the ( used by the src; unref it after usage. $src : the source Returns: B if the base class will automatically timestamp outgoing buffers. %src: base source instance Returns:  if src is operating in async mode. &src: base source instance Returns:  if element is in live mode. 'src : The source start&: The new start value for the segment stop!: Stop value for the new segment time6: The new time value for the start of the new segment Returns: 3 if preparation of the seamless segment succeeded. (src : the source Returns:  if the query succeeded. )src: base source instance async: new async mode *src: base source instance  automaticEos: automatic eos +src : the source  blocksize: the new blocksize in bytes ,src: a   caps: a   Returns:  if the caps could be set -src : the source  timestamp!: enable or disable timestamping .src: base source instance dynamic: new dynamic size mode /src: base source instance format: the format to use 0src: base source instance live: new live-mode 1basesrc: base source instance ret: a  2basesrc: base source instance Returns: a . 3src : the src Returns:  if srcl is PLAYING and processing can continue. Any other return value should be returned from the create vmethod. 456789:;<=>?@ABCDEFGHIJKLMNOPQRS?      !"#$%&'()*+,-./0123?  !"#$%&'()*+,-./0123    u      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS 7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^TUVWXYZ[\]^_`abTUVWXUVTWXTUVWXYZ[\]^_`ab 7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^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.RGet the number of bytes that the sink will pull when it is operating in pull mode.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  ? on the sample can be used to determine the type of the buffer.Free-function: gst_sample_unref%Get the currently configured latency.DGet the maximum amount of bits per second that the sink will render.QGets the max lateness value. See gst_base_sink_set_max_lateness for more details.Get the render delay of sink. see - for more information about the render delay. Checks if sink: is currently configured to synchronize against the clock.\Get the time that will be inserted between frames to control the maximum buffers per second."Get the synchronisation offset of sink. Checks if sinkI is currently configured to perform asynchronous state changes to PAUSED. Checks if sinkW is currently configured to store the last received sample in the last-sample property. Checks if sinkD is currently configured to send Quality-of-Service events upstream.cQuery the sink for the latency parameters. The latency will be queried from the upstream elements. live will be  if sink1 is configured to synchronize against the clock.  upstreamLive will be  if an upstream element is live.If both live and  upstreamLive are f, the sink will want to compensate for the latency introduced by the upstream elements by setting the  minLatency to a strictly positive value.+This function is mostly used by subclasses. 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.RSet the number of bytes that the sink will pull when it is operating in pull mode. Configures sink? to store the last received sample in the last-sample property.DSet the maximum amount of bits per second that the sink will render.#Sets the new max lateness value to  maxLateness. 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. Configures sink, to send Quality-of-Service events upstream.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. Configures sink* to synchronize on the clock or not. When sync is :, incoming samples will be played as fast as possible. If sync is h, the timestamps of the incoming buffers will be used to schedule the exact render time of its contents.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.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.JThis 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.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 !{ is returned. Likewise, if synchronisation is disabled in the element or there is no clock, no synchronisation is done and ! is returned.hThis function should only be called with the PREROLL_LOCK held, like when receiving an EOS event in the "#.event-() vmethod or when receiving a buffer in the "#.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.If the "#.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.fThis function will block until a state change to PLAYING happens (in which case this function returns y) or the processing must be stopped due to a state change to READY or a FLUSH event (in which case this function returns ).\This function should only be called with the PREROLL_LOCK held, like in the render function.cdefghijklmnopqrstuvwxyz{|}~  sink : the sink obj*: the mini object that caused the preroll Returns: z if the preroll completed and processing can continue. Any other return value should be returned from the render vmethod. sink: a  Returns: the number of bytes sink will pull in pull mode. sink : the sink Returns: a $%. gst_sample_unref()) after usage. This function returns  ^ when no buffer has arrived in the sink yet or when the sink is not in PAUSED or PLAYING. sink : the sink Returns: The configured latency. sink: a  Returns:' the maximum number of bits per second sink will render. sink : the sink Returns: 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. sink: a  Returns: the render delay of sink. sink : the sink Returns: = if the sink is configured to synchronize against the clock. sink: a  Returns: the number of nanoseconds sink will put between frames. sink : the sink Returns: The synchronisation offset. sink : the sink Returns: B if the sink is configured to perform asynchronous state changes. sink : the sink Returns: > if the sink is configured to store the last received sample. sink : the sink Returns: : if the sink is configured to perform Quality-of-Service. sink : the sink Returns:  if the query succeeded. sink : the sink enabled: the new async value. sink: a   blocksize: the blocksize in bytes sink : the sink enabled$: the new enable-last-sample value. sink: a   maxBitrate%: the max_bitrate in bits per second sink : the sink  maxLateness: the new max lateness value. sink : the sink enabled: the new qos value. sink: a  delay: the new delay sink : the sink sync: the new sync value. sink: a  throttle#: the throttle time in nanoseconds sink : the sink offset: the new offset sink : the sink time!: the running_time to be reached Returns:  sink : the sink time!: the running_time to be reached Returns: & sink : the sink Returns: z if the preroll completed and processing can continue. Any other return value should be returned from the render vmethod. pcdefghijklmnopqrstuvwxyz{|}~p}|{zyxwvutsrqponmlkjihgfedc~cdefghijklmnopqrstuvwxyz{|}~   7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^'Adds an entry to the index associating offset to ts4. 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./Default implementation of "convert" vmethod in  class.aCollects parsed data and pushes this downstream. Source pad caps must be set when this is called.If frameM'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 frameY's (input) buffer (which is otherwise ignored for any but the above purpose/information).aNote that the latter buffer is invalidated by this call, whereas the caller retains ownership of 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 .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. 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.2This must be called with sinkpad STREAM_LOCK held.!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 *)."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 intervali is non-zero (default), then stream duration is determined based on estimated bitrate, and updated every interval frames.#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 leadIn and a following leadOutQ number of frames to ensure the desired segment is entirely filled upon decoding.$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.%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.&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.'USubclass can use this function to tell the base class that it needs to give at least min_size buffers.(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 checkValidFrame or  parseFrame callbacks will be invoked, but  prePushFrameq will still be invoked, so subclass can perform as much or as little is appropriate for passthrough semantics in  prePushFrame.) 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.*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.++This function should only be called from a  handleFrame implementation.q 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.X       parse: . offset: offset of entry ts#: timestamp associated with offset key#: whether entry refers to keyframe force': add entry disregarding sanity checks Returns:  $ indicating whether entry was added parse: .  srcFormat: ' describing the source format. srcValue : Source value to be converted.  destFormat: ' defining the converted format.  destValue3: Pointer where the conversion result will be put. Returns:  if conversion was successful. parse: a  frame: a ( size+: consumed input data represented by frame Returns: a 0 that should be escalated to caller (of caller) parse: a  tags: a )*4 to merge, or NULL to unset previously-set tags mode: the + to use, usually GST_TAG_MERGE_REPLACE  parse: . frame: a ( Returns:  !parse: . bitrate!: average bitrate in bits/second "parse: . fmt: '. duration: duration value. intervalD: how often to update the duration estimate based on bitrate, or 0. #parse: the  to set fpsNum!: frames per second (numerator). fpsDen#: frames per second (denominator). leadIn7: frames needed before a segment for subsequent decode leadOut : frames needed after a segment $parse: a   hasTiming*: whether frames carry timing information %parse: a  inferTs: 0 if parser should infer DTS/PTS from each other &parse: a   minLatency: minimum parse latency  maxLatency: maximum parse latency 'parse: . minSizeT: Minimum size of the data that this base class should give to subclass. (parse: a   passthrough: * if parser should run in passthrough mode )parse: a  ptsInterpolate: - if parser should interpolate PTS timestamps *parse: a  syncable(: set if frame starts can be identified +parse: a  offset: offset into current buffer ,-./0123456789:;<=>?@ABCDE*      !"#$%&'()*+*   ! " # $%&'()*+W        !"#$%&'()*+,-./0123456789:;<=>?@ABCDE 7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^gCreates a new c . Free with ,-.hiGets the maximum amount of bytes available, that is it returns the maximum value that can be supplied to s! without that function returning  .iGets the maximum number of bytes that are immediately available without requiring any expensive operations (like copying the data into a temporary buffer).jRemoves all buffers from adapter.kFSimilar to gst_adapter_copy, but more suitable for language bindings. size bytes of data starting at offset0 will be copied out of the buffers contained in adapter and into a new ./< structure which is returned. Depending on the value of the size argument an empty ./ structure may be returned.l3No description available in the introspection data.m fGet the DTS that was on the last buffer with the GST_BUFFER_FLAG_DISCONT flag, or GST_CLOCK_TIME_NONE.nFlushes the first flush bytes in the adapterE. The caller must ensure that at least this many bytes are available. See also: s, o Returns a 01 containing the first nbytes of the adapter0, but does not flush them from the adapter. See  for details.0Caller owns a reference to the returned buffer. gst_buffer_unref() after usage.Free-function: gst_buffer_unrefp Returns a 01 containing the first nbytes of the adapter0, but does not flush them from the adapter. See  for details.0Caller owns a reference to the returned buffer. gst_buffer_unref() after usage.Free-function: gst_buffer_unrefq Returns a 23! of buffers containing the first nbytes bytes of the adapter/ but does not flush them from the adapter. See  for details.$Caller owns the returned list. Call gst_buffer_list_unref() to free the list after usage.r Returns a 45! of buffers containing the first nbytes bytes of the adapter0, but does not flush them from the adapter. See  for details.1Caller owns returned list and contained buffers. gst_buffer_unref()= each buffer in the list before freeing the list after usage.sGets the first size bytes stored in the adapterQ. The returned pointer is valid until the next function is called on the adapter.8Note that setting the returned pointer as the data of a 01 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 ~?, which returns a freshly-allocated buffer that you can set as 01+ memory or the potentially more performant .Returns   if size bytes are not available.tScan 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.vIt is an error to call this function without making sure that there is enough data (offset+size bytes) in the adapter.This function calls u passing   for value.uScan for pattern pattern with applied mask mask+ in the adapter data, starting from offset offsetC. 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.vIt is an error to call this function without making sure that there is enough data (offset+size bytes) in the adapter.v lGet the offset that was on the last buffer with the GST_BUFFER_FLAG_DISCONT flag, or GST_BUFFER_OFFSET_NONE.wBGet the dts that was before the current byte in the adapter. When distanceT 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.x/Get the dts that was before the byte at offset offset in the adapter. When distanceT 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.y EGet the offset that was before the current byte in the adapter. When distanceW 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.zBGet the pts that was before the current byte in the adapter. When distanceT 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.{/Get the pts that was before the byte at offset offset in the adapter. When distanceT 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.| fGet the PTS that was on the last buffer with the GST_BUFFER_FLAG_DISCONT flag, or GST_CLOCK_TIME_NONE.}Adds the data from buf to the data stored inside adapter# and takes ownership of the buffer.~8Returns a freshly allocated buffer containing the first nbytes bytes of the adapter6. The returned bytes will be flushed from the adapter./Caller owns returned value. g_free after usage.Free-function: g_free Returns a 01 containing the first nbytes bytes of the adapteri. The returned bytes will be flushed from the adapter. This function is potentially more performant than ~ 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 6 flag or with the "memory" tag.0Caller owns a reference to the returned buffer. gst_buffer_unref() after usage.Free-function: gst_buffer_unref Returns a 01 containing the first nbytes of the adapterj. The returned bytes will be flushed from the adapter. This function is potentially more performant than T since it can reuse the memory in pushed buffers by subbuffering or merging. Unlike A, the returned buffer may be composed of multiple non-contiguous 78 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.SThis will also copy over all GstMeta of the input buffers except for meta with the 6 flag or with the "memory" tag.:This function can return buffer up to the return value of h# without making copies if possible.0Caller owns a reference to the returned buffer. gst_buffer_unref() after usage.Free-function: gst_buffer_unref Returns a 23! 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. Returns a 45! 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.1Caller owns returned list and contained buffers. gst_buffer_unref()= each buffer in the list before freeing the list after usage.+Releases the memory obtained with the last s.FGHIJKLMNOPQRSTUVWXYZ[\]^_`a!"#bcd$%&'()*+,-./0123456789:;<=>?@AefgReturns: a new c hadapter: a c Returns: number of bytes available in adapter iadapter: a c Returns:' number of bytes that are available in adapter without expensive operations jadapter: a c kadapter: a c offset0: the bytes offset in the adapter to start from size: the number of bytes to copy Returns: A new ./' structure containing the copied data. lmadapter: a c Returns:5 The DTS at the last discont or GST_CLOCK_TIME_NONE. nadapter: a c flush: the number of bytes to flush oadapter: a c nbytes: the number of bytes to get Returns: a 01 containing the first nbytes of the adapter, or   if nbytes bytes are not available. gst_buffer_unref() when no longer needed. padapter: a c nbytes: the number of bytes to get Returns: a 01 containing the first nbytes of the adapter, or   if nbytes bytes are not available. gst_buffer_unref() when no longer needed. qadapter: a c nbytes: the number of bytes to get Returns: a 23% of buffers containing the first nbytes of the adapter, or   if nbytes bytes are not available radapter: a c nbytes: the number of bytes to get Returns: a 45% of buffers containing the first nbytes of the adapter, or   if nbytes bytes are not available sadapter: a c Returns: a pointer to the first size bytes of data, or   tadapter: a c mask0: mask to apply to data before matching against pattern pattern+: pattern to match (after mask is applied) offseti: offset into the adapter data from which to start scanning, returns the last scanned position. size&: number of bytes to scan from offset Returns:8 offset of the first match, or -1 if no match was found.UExample: <programlisting> // Assume the adapter contains 0x00 0x01 0x02 ... 0xfe 0xffygst_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 </programlisting> uadapter: a c mask0: mask to apply to data before matching against pattern pattern+: pattern to match (after mask is applied) offseti: offset into the adapter data from which to start scanning, returns the last scanned position. size&: number of bytes to scan from offset Returns:9 offset of the first match, or -1 if no match was found. vadapter: a c Returns:; The offset at the last discont or GST_BUFFER_OFFSET_NONE. wadapter: a c Returns: The previously seen dts. xadapter: a c offset6: the offset in the adapter at which to get timestamp Returns:* The previously seen dts at given offset. yadapter: a c Returns: The previous seen offset. zadapter: a c Returns: The previously seen pts. {adapter: a c offset6: the offset in the adapter at which to get timestamp Returns:* The previously seen pts at given offset. |adapter: a c Returns:5 The PTS at the last discont or GST_CLOCK_TIME_NONE. }adapter: a c buf: a 01 to add to queue in the adapter ~adapter: a c Returns: oven-fresh hot data, or   if nbytes bytes are not available adapter: a c nbytes: the number of bytes to take Returns: a 01 containing the first nbytes of the adapter, or   if nbytes bytes are not available. gst_buffer_unref() when no longer needed. adapter: a c nbytes: the number of bytes to take Returns: a 01 containing the first nbytes of the adapter, or   if nbytes bytes are not available. gst_buffer_unref() when no longer needed. adapter: a c nbytes: the number of bytes to take Returns: a 23% of buffers containing the first nbytes of the adapter, or   if nbytes bytes are not available adapter: a c nbytes: the number of bytes to take Returns: a 45% of buffers containing the first nbytes of the adapter, or   if nbytes bytes are not available adapter: a c >FGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~>cdbefah`i_j^k]l\m[nZoYpXqWrVsUtTugSvRwQxPyOzN{M|L}K~JIHGFFGHIJKLMNOPQRSTUVWXYZ[\]^_`a!"#bcd$%&'()*+,-./0123456789:;<=>?@Aefghijklmnopqrstuvwxyz{|}~ 7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^Flags to be used in a (.The 9:' flags that a basesrc element may have.3No description available in the introspection data.no flagset 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. prePushFrame can set this to indicate that regular segment clipping can still be performed (as opposed to any custom one having been done). indicates to  finishFrameZ that the the frame should be dropped (and might be handled internally by subclass) indicates to  finishFrame that the the frame should be queued for now and processed fully later when the first non-queued frame is finishedCatch-all for unknown valueshas source is startinghas source been startedoffset to define more flagsCatch-all for unknown values Set if collectdata's pad is EOS.%Set if collectdata's pad is flushing._Set if collectdata's pad received a new_segment event.eSet if collectdata's pad must be waited for when collecting.fSet collectdata's pad WAITING state must not be changed. 1 indicate private state of a collectdata('s pad).Catch-all for unknown values 7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^ Construct a f struct initialized to zero.Allocates a new fz. This function is mainly for bindings, elements written in C should usually allocate the frame on the stack and then use  to initialise it.3No description available in the introspection data.Sets a fn to initial state. Currently this means all public fields are zero-ed and a private flag is set to make sure U only frees the contents but not the actual frame. Use this function to initialise a f allocated on the stack.1defgBCDEFGHIJKLbuffer: a 01 flags : the flags overhead: 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. Returns: a newly-allocated f. Free with  when no longer needed. frame: f. defgfged0defgBCDEFGHIJKL;7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^n  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKdefg7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None$*,9:;<=DRT^b3No description available in the introspection data.3No description available in the introspection data.+The name of the templates for the sink pad.-The name of the templates for the source pad.7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^m     MNOPQRSTUVWobj: a <=' that will handle the getrange request parent: the parent of obj or   offset: the offset of the range length: the length of the range buffer.: a memory location to hold the result buffer Returns: GST_FLOW_OK for success  !"#$pads: the > that triggered the callback pad: the  that received an event query: the ?@ received userData: user data passed to A Returns: # if the pad could handle the event %&'()*pads: the > that triggered the callback userData: user data passed to B Returns:  for success +,-./0pads: a > userData : user data 123456pads: the > that triggered the callback pad: the  that received an event event: the ?@ received userData: user data passed to C Returns: # if the pad could handle the event 789:;<pads: the >" that is comparing the timestamps data1 : the first D  timestamp1: the first timestamp data2 : the second D  timestamp2: the second timestamp userData: user data passed to E Returns: 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. =>?@ABpads: a > data: a D inbuffer : the input 01  outbuffer : the output 01 userData : user data Returns: a - that corresponds to the result of clipping. CDEFGHpads: the > that triggered the callback data: the D% of pad that has received the buffer buffer: the 01 userData: user data passed to F Returns:  for success IJKLMNdata: the D that will be freed OPQb      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQbNP OQKHLIJMEBFCDG?<@=>A96:78;304125-*.+,/'$(%&) "!#    m     MNOPQRSTUVW !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^R6Utility function to do pull-based typefinding. Unlike V8 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  , 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_unrefSTries to find the best   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_unrefT:Tries to find what type of data is contained in the given dataT, the assumption being that the data represents the beginning of the stream or file.zAll available typefinders will be called on the data in order of rank. If a typefinding function returns a probability of G, 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   if the content of data could not be identified.Free-function: gst_caps_unrefU:Tries to find what type of data is contained in the given 01V, the assumption being that the buffer represents the beginning of the stream or file.zAll available typefinders will be called on the data in order of rank. If a typefinding function returns a probability of G, 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  6 if the content of the buffer could not be identified.Free-function: gst_caps_unrefVATries to find what type of data is flowing from the given source .Free-function: gst_caps_unref XYZ[\Robj: A <=* that will be passed as first argument to func parent: the parent of obj or   func : A generic HV that will be used to access data at random offsets when doing the typefinding size: The length in bytes  extension: extension of the media Returns: the  0 corresponding to the data stream. Returns   if no   matches the data stream. Sobj#: object doing the typefinding, or   (used for logging)  extension: an extension Returns: the   corresponding to  extension, or  N if no type could be found. The caller should free the caps returned with gst_caps_unref(). Tobj#: object doing the typefinding, or   (used for logging) data": a pointer with data to typefind size: the size of data Returns: the  # corresponding to the data, or  N if no type could be found. The caller should free the caps returned with gst_caps_unref(). Uobj#: object doing the typefinding, or   (used for logging) buf: a 01 with data to typefind Returns: the  # corresponding to the data, or  N if no type could be found. The caller should free the caps returned with gst_caps_unref(). Vsrc : A source  size: The length in bytes Returns: the  0 corresponding to the data stream. Returns   if no   matches the data stream. RSTUVVUTSR XYZ[\RSTUV7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^YCreate a new instance of .MT safe.ZvAdd a pad to the collection of collect pads. The pad has to be a sinkpad. The refcount of the pad is incremented. Use c- to remove the pad from the collection again.$You specify a size for the returned DB structure so that you can use it to store additional information.You can also specify a I% that will be called just before the D 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.[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.\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.]Default  event handling that elements should always chain up to to ensure proper operation. Element might however indicate event should not be forwarded 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._'Peek at the buffer currently queued in data*. This function should be called with the pads3 STREAM_LOCK held, such as in the callback handler.MT safe.`#Pop the buffer currently queued in data*. This function should be called with the pads3 STREAM_LOCK held, such as in the callback handler.MT safe.aDefault  query handling that elements should always chain up to to ensure proper operation. Element might however indicate query should not be forwarded downstream.bGet 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.cSRemove a pad from the collection of collect pads. This function will also free the D0 and all the resources that were allocated with Z./The pad will be deactivated automatically when pads is stopped.MT safe.dySet the callback function and user data that will be called with the oldest buffer when all pads have been collected, or  P on EOS. If a buffer is passed, the callback owns a reference and must unref it.MT safe.e`Install a clipping function that is called right after a buffer is received on a pad managed by pads. See J for more info.f&Set the timestamp comparison function.MT safe.gSet 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.hInstall a flush function that is called when the internal state of all pads should be flushed as part of flushing seek handling. See K for more info.ihChange the flushing state of all the pads in the collection. No pad is able to accept anymore data when flushing is . Calling this function with flushing  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.jCollectPads 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 d= callback. If this callback is set, the former will be unset.MT safe.kSet 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.lSets 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.mDefault z event handling for the src pad of elements. Elements can chain up to this to let flushing seek event handling be done by .n2Starts the processing of data in the collect_pads.MT safe.ojStops the processing of data in the collect_pads. this function will also unblock any blocking operations.MT safe.pGet 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.o]^_`abcdefghijklmnopqrstuvwxWXYReturns: a new , or   in case of an error. Zpads: the collectpads to use pad: the pad to add size: the size of the returned D structure  destroyNotify.: function to be called before the returned D structure is freed lock2: whether to lock this pad in usual waiting state Returns: a new D to identify the new pad. Or  # if wrong parameters are supplied. [pads: the collectpads to query Returns:h The maximum number of bytes queued on all pads. This function returns 0 if a pad has no queued buffer. \pads: the collectpads to use cdata$: collect data of corresponding pad buf: buffer being clipped outbuf6: output buffer with running time, or NULL if clipped userData: user data (unused) ]pads: the collectpads to use data$: collect data of corresponding pad event: event being processed discard+: process but do not send event downstream ^pads: the collectpads to query data: the data to use size: the number of bytes to flush Returns:3 The number of bytes flushed This can be less than size( and is 0 if the pad was end-of-stream. _pads: the collectpads to peek data: the data to use Returns: The buffer in data or  > if no buffer is queued. should unref the buffer after usage. `pads: the collectpads to pop data: the data to use Returns: The buffer in data or  C if no buffer was queued. You should unref the buffer after usage. apads: the collectpads to use data$: collect data of corresponding pad query: query being processed discard+: process but do not send event downstream bpads: the collectpads to query data: the data to use size: the number of bytes to read Returns:N A sub buffer. The size of the buffer can be less that requested. A return of  D signals that the pad is end-of-stream. Unref the buffer after use. cpads: the collectpads to use pad: the pad to remove Returns:  if the pad could be removed. dpads: the collectpads to use func: the function to set epads: the collectpads to use clipfunc: clip function to install fpads: the pads to use func: the function to set gpads: the collectpads to use func: the function to set hpads: the collectpads to use func: flush function to install ipads: the collectpads to use flushing: desired state of the pads jpads: the collectpads to use func: the function to set kpads: the collectpads to use func: the function to set lpads: the collectpads data: the data to use waiting^: boolean indicating whether this pad should operate in waiting or non-waiting mode mpads: the  to use pad: src  that received the event event: event being processed npads: the collectpads to use opads: the collectpads to use ppads: the collectpads to query data: the data to use size: the number of bytes to read Returns:N A sub buffer. The size of the buffer can be less that requested. A return of  D signals that the pad is end-of-stream. Unref the buffer after use. qrstuvwxyz{|}~4WXYZ[\]^_`abcdefghijklmnop4WXZ[\]^Y_`abcdefghijklmnopn]^_`abcdefghijklmnopqrstuvwxWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~L7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^hijklmnopqrstu      !"#$%&'()*+,-./0123TUVWXcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+FGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~WXYZ[\]^_`abcdefghijklmnopM7Will Thompson, Iaki Garca Etxebarria and Jonas PlatteLGPL-2.1+Iaki Garca Etxebarria (garetxe@gmail.com)None*,9:;<=DRT^{yz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKdefghijklmnopqrstu      !"#$%&'()*+,-./0123TUVWXcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+FGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopSafe*,9:;<=DRT^NOPQRSTUUVWXYZ[\]^_`abcdefghiDDjklmnopqrstuvwxyzz{|}~_`((_`>>_`      !"#$%&'()*_`+,-./0123456789:;<=>?@ABCDEFGHIIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~_`       _ `                                                                                                                                                 ! " # $ % & ' ( ) * + , - . _ ` / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o _ ` p q r s t u v w x y z { | } ~                                                                                   _ `                                           _` IJ !"#$%&'K()*+,-./012H3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~FECBA_`                        ! " # $ % & ' ( ) * + ,-./ 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B CD E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d efghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:9;9<9=9>9?9@9A9B9C9D9E9F9G9H9IJKJLJMJNJNOPOPOQOROSOSOTOTOUOVOWOXOYOZO[O\O]O^O_O`OaObOcOdOeOfOgOhOiOjOkOlOmOnOoOpOqOrOsOtOuOvOwOxOyOzO{O|O}O~OOOOOOOOOOOOO99(gi-gstbase-1.0.13-3wJ6qjGevVRFu8kw0xfA2KGI.GstBase.Structs.FlowCombinerGI.GstBase.Structs.CollectDataGI.GstBase.Structs.BitReader!GI.GstBase.Structs.BaseParseFrameGI.GstBase.Objects.DataQueueGI.GstBase.Objects.CollectPads GI.GstBase.Objects.BaseTransformGI.GstBase.Objects.BaseSrcGI.GstBase.Objects.PushSrcGI.GstBase.Objects.BaseSinkGI.GstBase.Objects.BaseParseGI.GstBase.Objects.AdapterGI.GstBase.FlagsGI.GstBase.ConstantsGI.GstBase.CallbacksGI.GstBase.FunctionsGI.GstBase.PkgInfoGI.Gst.Objects.PadPad GI.Gst.Enums FlowReturn GI.Gst.FlagsBufferFlagsGapGI.Gst.Objects.BufferPool BufferPoolGI.GstBase.Structs.BaseSrcClass BaseSrcClass StatePaused FlowReturnOkFlowReturnFlushingGI.Gst.Structs.CapsCapsClockReturnBadtime GI.GstBase.Structs.BaseSinkClass BaseSinkClassGI.Gst.Structs.SampleSample ClockReturnFormatBaseParseFrameGI.Gst.Structs.TagListTagList TagMergeModeGI.GObject.Objects.Object objectUnrefGI.GLib.Structs.BytesBytesGI.Gst.Structs.BufferBufferGI.Gst.Structs.BufferList BufferListGI.GLib.Structs.ListListMetaFlagsPooledGI.Gst.Structs.MemoryMemoryGI.Gst.Objects.ElementElementGI.GstBase.StructsGI.Gst.Objects.ObjectObject CollectPadsGI.Gst.Structs.EventEventcollectPadsSetQueryFunctioncollectPadsSetFunctioncollectPadsSetEventFunction CollectDatacollectPadsSetCompareFunctioncollectPadsSetBufferFunctionTypeFindProbabilityMaximumTypeFindHelperGetRangeFunctionCollectDataDestroyNotifyCollectPadsClipFunctionCollectPadsFlushFunctionGI.GstBase.Objects GI.GstBase#FlowCombinerUpdatePadFlowMethodInfo FlowCombinerUpdateFlowMethodInfoFlowCombinerResetMethodInfoFlowCombinerRemovePadMethodInfoFlowCombinerFreeMethodInfoFlowCombinerClearMethodInfoFlowCombinerAddPadMethodInfo FlowCombinernoFlowCombinerflowCombinerNewflowCombinerAddPadflowCombinerClearflowCombinerFreeflowCombinerRemovePadflowCombinerResetflowCombinerUpdateFlowflowCombinerUpdatePadFlow$fIsLabelt(->)$fIsLabelProxyt(->)H$fMethodInfoTYPEFlowCombinerUpdatePadFlowMethodInfoFlowCombinersignatureE$fMethodInfoTYPEFlowCombinerUpdateFlowMethodInfoFlowCombinersignature@$fMethodInfoTYPEFlowCombinerResetMethodInfoFlowCombinersignatureD$fMethodInfoTYPEFlowCombinerRemovePadMethodInfoFlowCombinersignature?$fMethodInfoTYPEFlowCombinerFreeMethodInfoFlowCombinersignature@$fMethodInfoTYPEFlowCombinerClearMethodInfoFlowCombinersignatureA$fMethodInfoTYPEFlowCombinerAddPadMethodInfoFlowCombinersignature"$fHasAttributeListTYPEFlowCombiner$fBoxedObjectFlowCombinerBitReaderSkipToByteMethodInfoBitReaderSkipMethodInfoBitReaderSetPosMethodInfo BitReaderPeekBitsUint8MethodInfo!BitReaderPeekBitsUint64MethodInfo!BitReaderPeekBitsUint32MethodInfo!BitReaderPeekBitsUint16MethodInfoBitReaderInitMethodInfoBitReaderGetSizeMethodInfoBitReaderGetRemainingMethodInfoBitReaderGetPosMethodInfoBitReaderGetBitsUint8MethodInfo BitReaderGetBitsUint64MethodInfo BitReaderGetBitsUint32MethodInfo BitReaderGetBitsUint16MethodInfoBitReaderFreeMethodInfo BitReadernewZeroBitReader noBitReadergetBitReaderSizesetBitReaderSizebitReader_sizegetBitReaderBytesetBitReaderBytebitReader_bytegetBitReaderBitsetBitReaderBit bitReader_bit bitReaderFreebitReaderGetBitsUint16bitReaderGetBitsUint32bitReaderGetBitsUint64bitReaderGetBitsUint8bitReaderGetPosbitReaderGetRemainingbitReaderGetSize bitReaderInitbitReaderPeekBitsUint16bitReaderPeekBitsUint32bitReaderPeekBitsUint64bitReaderPeekBitsUint8bitReaderSetPos bitReaderSkipbitReaderSkipToByte?$fMethodInfoTYPEBitReaderSkipToByteMethodInfoBitReadersignature9$fMethodInfoTYPEBitReaderSkipMethodInfoBitReadersignature;$fMethodInfoTYPEBitReaderSetPosMethodInfoBitReadersignatureB$fMethodInfoTYPEBitReaderPeekBitsUint8MethodInfoBitReadersignatureC$fMethodInfoTYPEBitReaderPeekBitsUint64MethodInfoBitReadersignatureC$fMethodInfoTYPEBitReaderPeekBitsUint32MethodInfoBitReadersignatureC$fMethodInfoTYPEBitReaderPeekBitsUint16MethodInfoBitReadersignature9$fMethodInfoTYPEBitReaderInitMethodInfoBitReadersignature<$fMethodInfoTYPEBitReaderGetSizeMethodInfoBitReadersignatureA$fMethodInfoTYPEBitReaderGetRemainingMethodInfoBitReadersignature;$fMethodInfoTYPEBitReaderGetPosMethodInfoBitReadersignatureA$fMethodInfoTYPEBitReaderGetBitsUint8MethodInfoBitReadersignatureB$fMethodInfoTYPEBitReaderGetBitsUint64MethodInfoBitReadersignatureB$fMethodInfoTYPEBitReaderGetBitsUint32MethodInfoBitReadersignatureB$fMethodInfoTYPEBitReaderGetBitsUint16MethodInfoBitReadersignature9$fMethodInfoTYPEBitReaderFreeMethodInfoBitReadersignature$fHasAttributeListTYPEBitReader$fAttrInfoBitReaderBitFieldInfo $fAttrInfoBitReaderByteFieldInfo $fAttrInfoBitReaderSizeFieldInfo$fConstructibleBitReadertag$fWrappedPtrBitReaderBaseParseFrameInitMethodInfoBaseParseFrameFreeMethodInfo(DataQueueCurrentLevelVisiblePropertyInfo%DataQueueCurrentLevelTimePropertyInfo&DataQueueCurrentLevelBytesPropertyInfo IsDataQueue DataQueue toDataQueue noDataQueuegetDataQueueCurrentLevelBytesgetDataQueueCurrentLevelTimegetDataQueueCurrentLevelVisibledataQueueCurrentLevelBytesdataQueueCurrentLevelTimedataQueueCurrentLevelVisible$fHasAttributeListTYPEDataQueue2$fAttrInfoDataQueueCurrentLevelVisiblePropertyInfo/$fAttrInfoDataQueueCurrentLevelTimePropertyInfo0$fAttrInfoDataQueueCurrentLevelBytesPropertyInfo$fIsObjectDataQueue$fIsDataQueueDataQueue$fIsDataQueuea$fGObjectDataQueueCollectPadsTakeBufferMethodInfoCollectPadsStopMethodInfoCollectPadsStartMethodInfo$CollectPadsSrcEventDefaultMethodInfoCollectPadsSetWaitingMethodInfo%CollectPadsSetQueryFunctionMethodInfo CollectPadsSetFunctionMethodInfo CollectPadsSetFlushingMethodInfo%CollectPadsSetFlushFunctionMethodInfo%CollectPadsSetEventFunctionMethodInfo'CollectPadsSetCompareFunctionMethodInfo$CollectPadsSetClipFunctionMethodInfo&CollectPadsSetBufferFunctionMethodInfoCollectPadsRemovePadMethodInfoCollectPadsReadBufferMethodInfo!CollectPadsQueryDefaultMethodInfoCollectPadsPopMethodInfoCollectPadsPeekMethodInfoCollectPadsFlushMethodInfo!CollectPadsEventDefaultMethodInfo$CollectPadsClipRunningTimeMethodInfoCollectPadsAvailableMethodInfoCollectPadsAddPadMethodInfo IsCollectPadsnewZeroCollectData noCollectDatagetCollectDataCollectsetCollectDataCollectclearCollectDataCollectcollectData_collectgetCollectDataPadsetCollectDataPadclearCollectDataPadcollectData_padgetCollectDataBuffersetCollectDataBufferclearCollectDataBuffercollectData_buffergetCollectDataPossetCollectDataPoscollectData_posgetCollectDataSegmentcollectData_segment!$fHasAttributeListTYPECollectData%$fAttrInfoCollectDataSegmentFieldInfo!$fAttrInfoCollectDataPosFieldInfo$$fAttrInfoCollectDataBufferFieldInfo!$fAttrInfoCollectDataPadFieldInfo%$fAttrInfoCollectDataCollectFieldInfo$fConstructibleCollectDatatag$fWrappedPtrCollectData$BaseTransformUpdateSrcCapsMethodInfo BaseTransformUpdateQosMethodInfo$BaseTransformSetQosEnabledMethodInfo+BaseTransformSetPreferPassthroughMethodInfo%BaseTransformSetPassthroughMethodInfo!BaseTransformSetInPlaceMethodInfo"BaseTransformSetGapAwareMethodInfo%BaseTransformReconfigureSrcMethodInfo&BaseTransformReconfigureSinkMethodInfo#BaseTransformIsQosEnabledMethodInfo$BaseTransformIsPassthroughMethodInfo BaseTransformIsInPlaceMethodInfo$BaseTransformGetBufferPoolMethodInfo#BaseTransformGetAllocatorMethodInfoBaseTransformQosPropertyInfoIsBaseTransform BaseTransformtoBaseTransformnoBaseTransformgetBaseTransformQossetBaseTransformQosconstructBaseTransformQosbaseTransformQosbaseTransformGetAllocatorbaseTransformGetBufferPoolbaseTransformIsInPlacebaseTransformIsPassthroughbaseTransformIsQosEnabledbaseTransformReconfigureSinkbaseTransformReconfigureSrcbaseTransformSetGapAwarebaseTransformSetInPlacebaseTransformSetPassthrough!baseTransformSetPreferPassthroughbaseTransformSetQosEnabledbaseTransformUpdateQosbaseTransformUpdateSrcCaps>$fMethodInfoTYPEBaseTransformUpdateSrcCapsMethodInfoasignature:$fMethodInfoTYPEBaseTransformUpdateQosMethodInfoasignature>$fMethodInfoTYPEBaseTransformSetQosEnabledMethodInfoasignatureE$fMethodInfoTYPEBaseTransformSetPreferPassthroughMethodInfoasignature?$fMethodInfoTYPEBaseTransformSetPassthroughMethodInfoasignature;$fMethodInfoTYPEBaseTransformSetInPlaceMethodInfoasignature<$fMethodInfoTYPEBaseTransformSetGapAwareMethodInfoasignature?$fMethodInfoTYPEBaseTransformReconfigureSrcMethodInfoasignature@$fMethodInfoTYPEBaseTransformReconfigureSinkMethodInfoasignature=$fMethodInfoTYPEBaseTransformIsQosEnabledMethodInfoasignature>$fMethodInfoTYPEBaseTransformIsPassthroughMethodInfoasignature:$fMethodInfoTYPEBaseTransformIsInPlaceMethodInfoasignature>$fMethodInfoTYPEBaseTransformGetBufferPoolMethodInfoasignature=$fMethodInfoTYPEBaseTransformGetAllocatorMethodInfoasignature#$fHasAttributeListTYPEBaseTransform&$fAttrInfoBaseTransformQosPropertyInfo$fIsObjectBaseTransform$fIsObjectBaseTransform0$fIsElementBaseTransform$fIsBaseTransformBaseTransform$fIsBaseTransforma$fGObjectBaseTransformBaseSrcWaitPlayingMethodInfoBaseSrcStartWaitMethodInfoBaseSrcStartCompleteMethodInfoBaseSrcSetLiveMethodInfoBaseSrcSetFormatMethodInfoBaseSrcSetDynamicSizeMethodInfoBaseSrcSetDoTimestampMethodInfoBaseSrcSetCapsMethodInfoBaseSrcSetBlocksizeMethodInfo BaseSrcSetAutomaticEosMethodInfoBaseSrcSetAsyncMethodInfoBaseSrcQueryLatencyMethodInfo#BaseSrcNewSeamlessSegmentMethodInfoBaseSrcIsLiveMethodInfoBaseSrcIsAsyncMethodInfoBaseSrcGetDoTimestampMethodInfoBaseSrcGetBufferPoolMethodInfoBaseSrcGetBlocksizeMethodInfoBaseSrcGetAllocatorMethodInfoBaseSrcTypefindPropertyInfoBaseSrcNumBuffersPropertyInfoBaseSrcDoTimestampPropertyInfoBaseSrcBlocksizePropertyInfo IsBaseSrcBaseSrc toBaseSrc noBaseSrcgetBaseSrcBlocksizesetBaseSrcBlocksizeconstructBaseSrcBlocksizegetBaseSrcDoTimestampsetBaseSrcDoTimestampconstructBaseSrcDoTimestampgetBaseSrcNumBufferssetBaseSrcNumBuffersconstructBaseSrcNumBuffersgetBaseSrcTypefindsetBaseSrcTypefindconstructBaseSrcTypefindbaseSrcBlocksizebaseSrcDoTimestampbaseSrcNumBuffersbaseSrcTypefindbaseSrcGetAllocatorbaseSrcGetBlocksizebaseSrcGetBufferPoolbaseSrcGetDoTimestampbaseSrcIsAsync baseSrcIsLivebaseSrcNewSeamlessSegmentbaseSrcQueryLatencybaseSrcSetAsyncbaseSrcSetAutomaticEosbaseSrcSetBlocksizebaseSrcSetCapsbaseSrcSetDoTimestampbaseSrcSetDynamicSizebaseSrcSetFormatbaseSrcSetLivebaseSrcStartCompletebaseSrcStartWaitbaseSrcWaitPlaying6$fMethodInfoTYPEBaseSrcWaitPlayingMethodInfoasignature4$fMethodInfoTYPEBaseSrcStartWaitMethodInfoasignature8$fMethodInfoTYPEBaseSrcStartCompleteMethodInfoasignature2$fMethodInfoTYPEBaseSrcSetLiveMethodInfoasignature4$fMethodInfoTYPEBaseSrcSetFormatMethodInfoasignature9$fMethodInfoTYPEBaseSrcSetDynamicSizeMethodInfoasignature9$fMethodInfoTYPEBaseSrcSetDoTimestampMethodInfoasignature2$fMethodInfoTYPEBaseSrcSetCapsMethodInfoasignature7$fMethodInfoTYPEBaseSrcSetBlocksizeMethodInfoasignature:$fMethodInfoTYPEBaseSrcSetAutomaticEosMethodInfoasignature3$fMethodInfoTYPEBaseSrcSetAsyncMethodInfoasignature7$fMethodInfoTYPEBaseSrcQueryLatencyMethodInfoasignature=$fMethodInfoTYPEBaseSrcNewSeamlessSegmentMethodInfoasignature1$fMethodInfoTYPEBaseSrcIsLiveMethodInfoasignature2$fMethodInfoTYPEBaseSrcIsAsyncMethodInfoasignature9$fMethodInfoTYPEBaseSrcGetDoTimestampMethodInfoasignature8$fMethodInfoTYPEBaseSrcGetBufferPoolMethodInfoasignature7$fMethodInfoTYPEBaseSrcGetBlocksizeMethodInfoasignature7$fMethodInfoTYPEBaseSrcGetAllocatorMethodInfoasignature$fHasAttributeListTYPEBaseSrc%$fAttrInfoBaseSrcTypefindPropertyInfo'$fAttrInfoBaseSrcNumBuffersPropertyInfo($fAttrInfoBaseSrcDoTimestampPropertyInfo&$fAttrInfoBaseSrcBlocksizePropertyInfo$fIsObjectBaseSrc$fIsObjectBaseSrc0$fIsElementBaseSrc$fIsBaseSrcBaseSrc $fIsBaseSrca$fGObjectBaseSrc IsPushSrcPushSrc toPushSrc noPushSrc$fHasAttributeListTYPEPushSrc$fIsObjectPushSrc$fIsObjectPushSrc0$fIsElementPushSrc$fIsBaseSrcPushSrc$fIsPushSrcPushSrc $fIsPushSrca$fGObjectPushSrcBaseSinkWaitPrerollMethodInfoBaseSinkWaitClockMethodInfoBaseSinkWaitMethodInfoBaseSinkSetTsOffsetMethodInfo!BaseSinkSetThrottleTimeMethodInfoBaseSinkSetSyncMethodInfo BaseSinkSetRenderDelayMethodInfoBaseSinkSetQosEnabledMethodInfo BaseSinkSetMaxLatenessMethodInfoBaseSinkSetMaxBitrateMethodInfo&BaseSinkSetLastSampleEnabledMethodInfoBaseSinkSetBlocksizeMethodInfo!BaseSinkSetAsyncEnabledMethodInfoBaseSinkQueryLatencyMethodInfoBaseSinkIsQosEnabledMethodInfo%BaseSinkIsLastSampleEnabledMethodInfo BaseSinkIsAsyncEnabledMethodInfoBaseSinkGetTsOffsetMethodInfo!BaseSinkGetThrottleTimeMethodInfoBaseSinkGetSyncMethodInfo BaseSinkGetRenderDelayMethodInfo BaseSinkGetMaxLatenessMethodInfoBaseSinkGetMaxBitrateMethodInfoBaseSinkGetLatencyMethodInfoBaseSinkGetLastSampleMethodInfoBaseSinkGetBlocksizeMethodInfoBaseSinkDoPrerollMethodInfoBaseSinkTsOffsetPropertyInfo BaseSinkThrottleTimePropertyInfoBaseSinkSyncPropertyInfoBaseSinkRenderDelayPropertyInfoBaseSinkQosPropertyInfoBaseSinkMaxLatenessPropertyInfoBaseSinkMaxBitratePropertyInfoBaseSinkLastSamplePropertyInfo$BaseSinkEnableLastSamplePropertyInfoBaseSinkBlocksizePropertyInfoBaseSinkAsyncPropertyInfo IsBaseSinkBaseSink toBaseSink noBaseSinkgetBaseSinkAsyncsetBaseSinkAsyncconstructBaseSinkAsyncgetBaseSinkBlocksizesetBaseSinkBlocksizeconstructBaseSinkBlocksizegetBaseSinkEnableLastSamplesetBaseSinkEnableLastSample!constructBaseSinkEnableLastSamplegetBaseSinkLastSamplegetBaseSinkMaxBitratesetBaseSinkMaxBitrateconstructBaseSinkMaxBitrategetBaseSinkMaxLatenesssetBaseSinkMaxLatenessconstructBaseSinkMaxLatenessgetBaseSinkQossetBaseSinkQosconstructBaseSinkQosgetBaseSinkRenderDelaysetBaseSinkRenderDelayconstructBaseSinkRenderDelaygetBaseSinkSyncsetBaseSinkSyncconstructBaseSinkSyncgetBaseSinkThrottleTimesetBaseSinkThrottleTimeconstructBaseSinkThrottleTimegetBaseSinkTsOffsetsetBaseSinkTsOffsetconstructBaseSinkTsOffset baseSinkAsyncbaseSinkBlocksizebaseSinkEnableLastSamplebaseSinkLastSamplebaseSinkMaxBitratebaseSinkMaxLateness baseSinkQosbaseSinkRenderDelay baseSinkSyncbaseSinkThrottleTimebaseSinkTsOffsetbaseSinkDoPrerollbaseSinkGetBlocksizebaseSinkGetLastSamplebaseSinkGetLatencybaseSinkGetMaxBitratebaseSinkGetMaxLatenessbaseSinkGetRenderDelaybaseSinkGetSyncbaseSinkGetThrottleTimebaseSinkGetTsOffsetbaseSinkIsAsyncEnabledbaseSinkIsLastSampleEnabledbaseSinkIsQosEnabledbaseSinkQueryLatencybaseSinkSetAsyncEnabledbaseSinkSetBlocksizebaseSinkSetLastSampleEnabledbaseSinkSetMaxBitratebaseSinkSetMaxLatenessbaseSinkSetQosEnabledbaseSinkSetRenderDelaybaseSinkSetSyncbaseSinkSetThrottleTimebaseSinkSetTsOffset baseSinkWaitbaseSinkWaitClockbaseSinkWaitPreroll7$fMethodInfoTYPEBaseSinkWaitPrerollMethodInfoasignature5$fMethodInfoTYPEBaseSinkWaitClockMethodInfoasignature0$fMethodInfoTYPEBaseSinkWaitMethodInfoasignature7$fMethodInfoTYPEBaseSinkSetTsOffsetMethodInfoasignature;$fMethodInfoTYPEBaseSinkSetThrottleTimeMethodInfoasignature3$fMethodInfoTYPEBaseSinkSetSyncMethodInfoasignature:$fMethodInfoTYPEBaseSinkSetRenderDelayMethodInfoasignature9$fMethodInfoTYPEBaseSinkSetQosEnabledMethodInfoasignature:$fMethodInfoTYPEBaseSinkSetMaxLatenessMethodInfoasignature9$fMethodInfoTYPEBaseSinkSetMaxBitrateMethodInfoasignature@$fMethodInfoTYPEBaseSinkSetLastSampleEnabledMethodInfoasignature8$fMethodInfoTYPEBaseSinkSetBlocksizeMethodInfoasignature;$fMethodInfoTYPEBaseSinkSetAsyncEnabledMethodInfoasignature8$fMethodInfoTYPEBaseSinkQueryLatencyMethodInfoasignature8$fMethodInfoTYPEBaseSinkIsQosEnabledMethodInfoasignature?$fMethodInfoTYPEBaseSinkIsLastSampleEnabledMethodInfoasignature:$fMethodInfoTYPEBaseSinkIsAsyncEnabledMethodInfoasignature7$fMethodInfoTYPEBaseSinkGetTsOffsetMethodInfoasignature;$fMethodInfoTYPEBaseSinkGetThrottleTimeMethodInfoasignature3$fMethodInfoTYPEBaseSinkGetSyncMethodInfoasignature:$fMethodInfoTYPEBaseSinkGetRenderDelayMethodInfoasignature:$fMethodInfoTYPEBaseSinkGetMaxLatenessMethodInfoasignature9$fMethodInfoTYPEBaseSinkGetMaxBitrateMethodInfoasignature6$fMethodInfoTYPEBaseSinkGetLatencyMethodInfoasignature9$fMethodInfoTYPEBaseSinkGetLastSampleMethodInfoasignature8$fMethodInfoTYPEBaseSinkGetBlocksizeMethodInfoasignature5$fMethodInfoTYPEBaseSinkDoPrerollMethodInfoasignature$fHasAttributeListTYPEBaseSink&$fAttrInfoBaseSinkTsOffsetPropertyInfo*$fAttrInfoBaseSinkThrottleTimePropertyInfo"$fAttrInfoBaseSinkSyncPropertyInfo)$fAttrInfoBaseSinkRenderDelayPropertyInfo!$fAttrInfoBaseSinkQosPropertyInfo)$fAttrInfoBaseSinkMaxLatenessPropertyInfo($fAttrInfoBaseSinkMaxBitratePropertyInfo($fAttrInfoBaseSinkLastSamplePropertyInfo.$fAttrInfoBaseSinkEnableLastSamplePropertyInfo'$fAttrInfoBaseSinkBlocksizePropertyInfo#$fAttrInfoBaseSinkAsyncPropertyInfo$fIsObjectBaseSink$fIsObjectBaseSink0$fIsElementBaseSink$fIsBaseSinkBaseSink $fIsBaseSinka$fGObjectBaseSink BaseParseSetTsAtOffsetMethodInfoBaseParseSetSyncableMethodInfo&BaseParseSetPtsInterpolationMethodInfo!BaseParseSetPassthroughMethodInfo"BaseParseSetMinFrameSizeMethodInfoBaseParseSetLatencyMethodInfoBaseParseSetInferTsMethodInfo#BaseParseSetHasTimingInfoMethodInfoBaseParseSetFrameRateMethodInfoBaseParseSetDurationMethodInfo$BaseParseSetAverageBitrateMethodInfoBaseParsePushFrameMethodInfoBaseParseMergeTagsMethodInfoBaseParseFinishFrameMethodInfo!BaseParseConvertDefaultMethodInfo BaseParseAddIndexEntryMethodInfo'BaseParseDisablePassthroughPropertyInfo IsBaseParse BaseParse toBaseParse noBaseParsegetBaseParseDisablePassthroughsetBaseParseDisablePassthrough$constructBaseParseDisablePassthroughbaseParseDisablePassthroughbaseParseAddIndexEntrybaseParseConvertDefaultbaseParseFinishFramebaseParseMergeTagsbaseParsePushFramebaseParseSetAverageBitratebaseParseSetDurationbaseParseSetFrameRatebaseParseSetHasTimingInfobaseParseSetInferTsbaseParseSetLatencybaseParseSetMinFrameSizebaseParseSetPassthroughbaseParseSetPtsInterpolationbaseParseSetSyncablebaseParseSetTsAtOffset:$fMethodInfoTYPEBaseParseSetTsAtOffsetMethodInfoasignature8$fMethodInfoTYPEBaseParseSetSyncableMethodInfoasignature@$fMethodInfoTYPEBaseParseSetPtsInterpolationMethodInfoasignature;$fMethodInfoTYPEBaseParseSetPassthroughMethodInfoasignature<$fMethodInfoTYPEBaseParseSetMinFrameSizeMethodInfoasignature7$fMethodInfoTYPEBaseParseSetLatencyMethodInfoasignature7$fMethodInfoTYPEBaseParseSetInferTsMethodInfoasignature=$fMethodInfoTYPEBaseParseSetHasTimingInfoMethodInfoasignature9$fMethodInfoTYPEBaseParseSetFrameRateMethodInfoasignature8$fMethodInfoTYPEBaseParseSetDurationMethodInfoasignature>$fMethodInfoTYPEBaseParseSetAverageBitrateMethodInfoasignature6$fMethodInfoTYPEBaseParsePushFrameMethodInfoasignature6$fMethodInfoTYPEBaseParseMergeTagsMethodInfoasignature8$fMethodInfoTYPEBaseParseFinishFrameMethodInfoasignature;$fMethodInfoTYPEBaseParseConvertDefaultMethodInfoasignature:$fMethodInfoTYPEBaseParseAddIndexEntryMethodInfoasignature$fHasAttributeListTYPEBaseParse1$fAttrInfoBaseParseDisablePassthroughPropertyInfo$fIsObjectBaseParse$fIsObjectBaseParse0$fIsElementBaseParse$fIsBaseParseBaseParse$fIsBaseParsea$fGObjectBaseParseAdapterUnmapMethodInfoAdapterTakeListMethodInfoAdapterTakeBufferListMethodInfoAdapterTakeBufferFastMethodInfoAdapterTakeBufferMethodInfoAdapterTakeMethodInfoAdapterPushMethodInfoAdapterPtsAtDiscontMethodInfo AdapterPrevPtsAtOffsetMethodInfoAdapterPrevPtsMethodInfoAdapterPrevOffsetMethodInfo AdapterPrevDtsAtOffsetMethodInfoAdapterPrevDtsMethodInfo AdapterOffsetAtDiscontMethodInfo%AdapterMaskedScanUint32PeekMethodInfo!AdapterMaskedScanUint32MethodInfoAdapterMapMethodInfoAdapterGetListMethodInfoAdapterGetBufferListMethodInfoAdapterGetBufferFastMethodInfoAdapterGetBufferMethodInfoAdapterFlushMethodInfoAdapterDtsAtDiscontMethodInfo$AdapterDistanceFromDiscontMethodInfoAdapterCopyMethodInfoAdapterClearMethodInfoAdapterAvailableFastMethodInfoAdapterAvailableMethodInfo IsAdapterAdapter toAdapter noAdapter adapterNewadapterAvailableadapterAvailableFast adapterClear adapterCopyadapterDistanceFromDiscontadapterDtsAtDiscont adapterFlushadapterGetBufferadapterGetBufferFastadapterGetBufferListadapterGetList adapterMapadapterMaskedScanUint32adapterMaskedScanUint32PeekadapterOffsetAtDiscontadapterPrevDtsadapterPrevDtsAtOffsetadapterPrevOffsetadapterPrevPtsadapterPrevPtsAtOffsetadapterPtsAtDiscont adapterPush adapterTakeadapterTakeBufferadapterTakeBufferFastadapterTakeBufferListadapterTakeList adapterUnmap0$fMethodInfoTYPEAdapterUnmapMethodInfoasignature3$fMethodInfoTYPEAdapterTakeListMethodInfoasignature9$fMethodInfoTYPEAdapterTakeBufferListMethodInfoasignature9$fMethodInfoTYPEAdapterTakeBufferFastMethodInfoasignature5$fMethodInfoTYPEAdapterTakeBufferMethodInfoasignature/$fMethodInfoTYPEAdapterTakeMethodInfoasignature/$fMethodInfoTYPEAdapterPushMethodInfoasignature7$fMethodInfoTYPEAdapterPtsAtDiscontMethodInfoasignature:$fMethodInfoTYPEAdapterPrevPtsAtOffsetMethodInfoasignature2$fMethodInfoTYPEAdapterPrevPtsMethodInfoasignature5$fMethodInfoTYPEAdapterPrevOffsetMethodInfoasignature:$fMethodInfoTYPEAdapterPrevDtsAtOffsetMethodInfoasignature2$fMethodInfoTYPEAdapterPrevDtsMethodInfoasignature:$fMethodInfoTYPEAdapterOffsetAtDiscontMethodInfoasignature?$fMethodInfoTYPEAdapterMaskedScanUint32PeekMethodInfoasignature;$fMethodInfoTYPEAdapterMaskedScanUint32MethodInfoasignature.$fMethodInfoTYPEAdapterMapMethodInfoasignature2$fMethodInfoTYPEAdapterGetListMethodInfoasignature8$fMethodInfoTYPEAdapterGetBufferListMethodInfoasignature8$fMethodInfoTYPEAdapterGetBufferFastMethodInfoasignature4$fMethodInfoTYPEAdapterGetBufferMethodInfoasignature0$fMethodInfoTYPEAdapterFlushMethodInfoasignature7$fMethodInfoTYPEAdapterDtsAtDiscontMethodInfoasignature>$fMethodInfoTYPEAdapterDistanceFromDiscontMethodInfoasignature/$fMethodInfoTYPEAdapterCopyMethodInfoasignature0$fMethodInfoTYPEAdapterClearMethodInfoasignature8$fMethodInfoTYPEAdapterAvailableFastMethodInfoasignature4$fMethodInfoTYPEAdapterAvailableMethodInfoasignature$fHasAttributeListTYPEAdapter$fIsObjectAdapter$fIsAdapterAdapter $fIsAdaptera$fGObjectAdapterBaseParseFrameFlags BaseSrcFlagsCollectPadsStateFlagsBaseParseFrameFlagsNoneBaseParseFrameFlagsNewFrameBaseParseFrameFlagsNoFrameBaseParseFrameFlagsClipBaseParseFrameFlagsDropBaseParseFrameFlagsQueueAnotherBaseParseFrameFlagsBaseSrcFlagsStartingBaseSrcFlagsStartedBaseSrcFlagsLastAnotherBaseSrcFlagsCollectPadsStateFlagsEosCollectPadsStateFlagsFlushingCollectPadsStateFlagsNewSegmentCollectPadsStateFlagsWaitingCollectPadsStateFlagsLockedAnotherCollectPadsStateFlags$fIsGFlagBaseParseFrameFlags$fOrdBaseParseFrameFlags$fEnumBaseParseFrameFlags$fIsGFlagBaseSrcFlags$fOrdBaseSrcFlags$fEnumBaseSrcFlags$fIsGFlagCollectPadsStateFlags$fOrdCollectPadsStateFlags$fEnumCollectPadsStateFlags$fShowCollectPadsStateFlags$fEqCollectPadsStateFlags$fShowBaseSrcFlags$fEqBaseSrcFlags$fShowBaseParseFrameFlags$fEqBaseParseFrameFlagsnewZeroBaseParseFramenoBaseParseFramegetBaseParseFrameBuffersetBaseParseFrameBufferclearBaseParseFrameBufferbaseParseFrame_buffergetBaseParseFrameOutBuffersetBaseParseFrameOutBufferclearBaseParseFrameOutBufferbaseParseFrame_outBuffergetBaseParseFrameFlagssetBaseParseFrameFlagsbaseParseFrame_flagsgetBaseParseFrameOffsetsetBaseParseFrameOffsetbaseParseFrame_offsetgetBaseParseFrameOverheadsetBaseParseFrameOverheadbaseParseFrame_overheadbaseParseFrameNewbaseParseFrameFreebaseParseFrameInitC$fMethodInfoTYPEBaseParseFrameInitMethodInfoBaseParseFramesignatureC$fMethodInfoTYPEBaseParseFrameFreeMethodInfoBaseParseFramesignature$$fHasAttributeListTYPEBaseParseFrame)$fAttrInfoBaseParseFrameOverheadFieldInfo'$fAttrInfoBaseParseFrameOffsetFieldInfo&$fAttrInfoBaseParseFrameFlagsFieldInfo*$fAttrInfoBaseParseFrameOutBufferFieldInfo'$fAttrInfoBaseParseFrameBufferFieldInfo $fConstructibleBaseParseFrametag$fBoxedObjectBaseParseFrameBASE_PARSE_FLAG_DRAININGBASE_PARSE_FLAG_LOST_SYNCBASE_TRANSFORM_SINK_NAMEBASE_TRANSFORM_SRC_NAMEC_CollectDataDestroyNotify&CollectPadsBufferFunction_WithClosuresCollectPadsBufferFunctionC_CollectPadsBufferFunction$CollectPadsClipFunction_WithClosuresC_CollectPadsClipFunction'CollectPadsCompareFunction_WithClosuresCollectPadsCompareFunctionC_CollectPadsCompareFunction%CollectPadsEventFunction_WithClosuresCollectPadsEventFunctionC_CollectPadsEventFunction%CollectPadsFlushFunction_WithClosuresC_CollectPadsFlushFunction CollectPadsFunction_WithClosuresCollectPadsFunctionC_CollectPadsFunction%CollectPadsQueryFunction_WithClosuresCollectPadsQueryFunctionC_CollectPadsQueryFunctionDataQueueEmptyCallbackC_DataQueueEmptyCallbackDataQueueFullCallbackC_DataQueueFullCallback C_TypeFindHelperGetRangeFunctionmk_CollectDataDestroyNotifymk_CollectPadsBufferFunctionmk_CollectPadsClipFunctionmk_CollectPadsCompareFunctionmk_CollectPadsEventFunctionmk_CollectPadsFlushFunctionmk_CollectPadsFunctionmk_CollectPadsQueryFunctionmk_DataQueueEmptyCallbackmk_DataQueueFullCallback!mk_TypeFindHelperGetRangeFunction&dynamic_TypeFindHelperGetRangeFunction noTypeFindHelperGetRangeFunction)genClosure_TypeFindHelperGetRangeFunction#wrap_TypeFindHelperGetRangeFunctiondynamic_DataQueueFullCallbacknoDataQueueFullCallback genClosure_DataQueueFullCallbackwrap_DataQueueFullCallbackdynamic_DataQueueEmptyCallbacknoDataQueueEmptyCallback!genClosure_DataQueueEmptyCallbackwrap_DataQueueEmptyCallback dynamic_CollectPadsQueryFunctionnoCollectPadsQueryFunction'noCollectPadsQueryFunction_WithClosures&drop_closures_CollectPadsQueryFunction#genClosure_CollectPadsQueryFunctionwrap_CollectPadsQueryFunctiondynamic_CollectPadsFunctionnoCollectPadsFunction"noCollectPadsFunction_WithClosures!drop_closures_CollectPadsFunctiongenClosure_CollectPadsFunctionwrap_CollectPadsFunction dynamic_CollectPadsFlushFunctionnoCollectPadsFlushFunction'noCollectPadsFlushFunction_WithClosures&drop_closures_CollectPadsFlushFunction#genClosure_CollectPadsFlushFunctionwrap_CollectPadsFlushFunction dynamic_CollectPadsEventFunctionnoCollectPadsEventFunction'noCollectPadsEventFunction_WithClosures&drop_closures_CollectPadsEventFunction#genClosure_CollectPadsEventFunctionwrap_CollectPadsEventFunction"dynamic_CollectPadsCompareFunctionnoCollectPadsCompareFunction)noCollectPadsCompareFunction_WithClosures(drop_closures_CollectPadsCompareFunction%genClosure_CollectPadsCompareFunctionwrap_CollectPadsCompareFunctiondynamic_CollectPadsClipFunctionnoCollectPadsClipFunction&noCollectPadsClipFunction_WithClosures%drop_closures_CollectPadsClipFunction"genClosure_CollectPadsClipFunctionwrap_CollectPadsClipFunction!dynamic_CollectPadsBufferFunctionnoCollectPadsBufferFunction(noCollectPadsBufferFunction_WithClosures'drop_closures_CollectPadsBufferFunction$genClosure_CollectPadsBufferFunctionwrap_CollectPadsBufferFunction dynamic_CollectDataDestroyNotifynoCollectDataDestroyNotify#genClosure_CollectDataDestroyNotifywrap_CollectDataDestroyNotifytypeFindHelperGetRangetypeFindHelperForExtensiontypeFindHelperForDatatypeFindHelperForBuffertypeFindHelper toCollectPads noCollectPadscollectPadsNewcollectPadsAddPadcollectPadsAvailablecollectPadsClipRunningTimecollectPadsEventDefaultcollectPadsFlushcollectPadsPeekcollectPadsPopcollectPadsQueryDefaultcollectPadsReadBuffercollectPadsRemovePadcollectPadsSetClipFunctioncollectPadsSetFlushFunctioncollectPadsSetFlushingcollectPadsSetWaitingcollectPadsSrcEventDefaultcollectPadsStartcollectPadsStopcollectPadsTakeBuffer9$fMethodInfoTYPECollectPadsTakeBufferMethodInfoasignature3$fMethodInfoTYPECollectPadsStopMethodInfoasignature4$fMethodInfoTYPECollectPadsStartMethodInfoasignature>$fMethodInfoTYPECollectPadsSrcEventDefaultMethodInfoasignature9$fMethodInfoTYPECollectPadsSetWaitingMethodInfoasignature?$fMethodInfoTYPECollectPadsSetQueryFunctionMethodInfoasignature:$fMethodInfoTYPECollectPadsSetFunctionMethodInfoasignature:$fMethodInfoTYPECollectPadsSetFlushingMethodInfoasignature?$fMethodInfoTYPECollectPadsSetFlushFunctionMethodInfoasignature?$fMethodInfoTYPECollectPadsSetEventFunctionMethodInfoasignatureA$fMethodInfoTYPECollectPadsSetCompareFunctionMethodInfoasignature>$fMethodInfoTYPECollectPadsSetClipFunctionMethodInfoasignature@$fMethodInfoTYPECollectPadsSetBufferFunctionMethodInfoasignature8$fMethodInfoTYPECollectPadsRemovePadMethodInfoasignature9$fMethodInfoTYPECollectPadsReadBufferMethodInfoasignature;$fMethodInfoTYPECollectPadsQueryDefaultMethodInfoasignature2$fMethodInfoTYPECollectPadsPopMethodInfoasignature3$fMethodInfoTYPECollectPadsPeekMethodInfoasignature4$fMethodInfoTYPECollectPadsFlushMethodInfoasignature;$fMethodInfoTYPECollectPadsEventDefaultMethodInfoasignature>$fMethodInfoTYPECollectPadsClipRunningTimeMethodInfoasignature8$fMethodInfoTYPECollectPadsAvailableMethodInfoasignature5$fMethodInfoTYPECollectPadsAddPadMethodInfoasignature!$fHasAttributeListTYPECollectPads$fIsObjectCollectPads$fIsObjectCollectPads0$fIsCollectPadsCollectPads$fIsCollectPadsa$fGObjectCollectPadspkgConfigVersionsflagsResolveFlowCombinerMethodFlowCombinerAttributeList!gst_flow_combiner_update_pad_flowgst_flow_combiner_update_flowgst_flow_combiner_resetgst_flow_combiner_remove_padgst_flow_combiner_freegst_flow_combiner_cleargst_flow_combiner_add_padgst_flow_combiner_newc_gst_flow_combiner_get_typeResolveBitReaderMethodBitReaderAttributeListBitReaderBitFieldInfoBitReaderByteFieldInfoBitReaderSizeFieldInfogst_bit_reader_skip_to_bytegst_bit_reader_skipgst_bit_reader_set_posgst_bit_reader_peek_bits_uint8gst_bit_reader_peek_bits_uint64gst_bit_reader_peek_bits_uint32gst_bit_reader_peek_bits_uint16gst_bit_reader_initgst_bit_reader_get_sizegst_bit_reader_get_remaininggst_bit_reader_get_posgst_bit_reader_get_bits_uint8gst_bit_reader_get_bits_uint64gst_bit_reader_get_bits_uint32gst_bit_reader_get_bits_uint16gst_bit_reader_freeghc-prim GHC.TypesTrueFalseDataQueueSignalListDataQueueAttributeListResolveDataQueueMethodc_gst_data_queue_get_typeResolveCollectDataMethodCollectDataAttributeListCollectDataSegmentFieldInfoCollectDataPosFieldInfoCollectDataBufferFieldInfoCollectDataPadFieldInfoCollectDataCollectFieldInfoBaseTransformSignalListBaseTransformAttributeListResolveBaseTransformMethod"gst_base_transform_update_src_capsgst_base_transform_update_qos"gst_base_transform_set_qos_enabled)gst_base_transform_set_prefer_passthrough"gst_base_transform_set_passthroughgst_base_transform_set_in_place gst_base_transform_set_gap_aware"gst_base_transform_reconfigure_src#gst_base_transform_reconfigure_sink!gst_base_transform_is_qos_enabled!gst_base_transform_is_passthroughgst_base_transform_is_in_place"gst_base_transform_get_buffer_pool gst_base_transform_get_allocatorc_gst_base_transform_get_typeBaseSrcSignalListBaseSrcAttributeListResolveBaseSrcMethodgst_base_src_wait_playinggst_base_src_start_waitgst_base_src_start_completegst_base_src_set_livegst_base_src_set_formatgst_base_src_set_dynamic_sizegst_base_src_set_do_timestampgst_base_src_set_capsgst_base_src_set_blocksizegst_base_src_set_automatic_eosgst_base_src_set_asyncgst_base_src_query_latency!gst_base_src_new_seamless_segmentgst_base_src_is_livegst_base_src_is_asyncgst_base_src_get_do_timestampgst_base_src_get_buffer_poolgst_base_src_get_blocksizegst_base_src_get_allocatorc_gst_base_src_get_typePushSrcSignalListPushSrcAttributeListResolvePushSrcMethodc_gst_push_src_get_typeBaseSinkSignalListBaseSinkAttributeListResolveBaseSinkMethodgst_base_sink_wait_prerollgst_base_sink_wait_clockgst_base_sink_waitgst_base_sink_set_ts_offsetgst_base_sink_set_throttle_timegst_base_sink_set_syncgst_base_sink_set_render_delaygst_base_sink_set_qos_enabledgst_base_sink_set_max_latenessgst_base_sink_set_max_bitrate%gst_base_sink_set_last_sample_enabledgst_base_sink_set_blocksizegst_base_sink_set_async_enabledgst_base_sink_query_latencygst_base_sink_is_qos_enabled$gst_base_sink_is_last_sample_enabledgst_base_sink_is_async_enabledgst_base_sink_get_ts_offsetgst_base_sink_get_throttle_timegst_base_sink_get_syncgst_base_sink_get_render_delaygst_base_sink_get_max_latenessgst_base_sink_get_max_bitrategst_base_sink_get_latencygst_base_sink_get_last_samplegst_base_sink_get_blocksizegst_base_sink_do_prerollc_gst_base_sink_get_typebaseGHC.BaseNothingBaseParseSignalListBaseParseAttributeListResolveBaseParseMethodgst_base_parse_set_ts_at_offsetgst_base_parse_set_syncable$gst_base_parse_set_pts_interpolationgst_base_parse_set_passthrough!gst_base_parse_set_min_frame_sizegst_base_parse_set_latencygst_base_parse_set_infer_ts"gst_base_parse_set_has_timing_infogst_base_parse_set_frame_rategst_base_parse_set_duration"gst_base_parse_set_average_bitrategst_base_parse_push_framegst_base_parse_merge_tagsgst_base_parse_finish_framegst_base_parse_convert_defaultgst_base_parse_add_index_entryc_gst_base_parse_get_typeBoolAdapterSignalListAdapterAttributeListResolveAdapterMethodgst_adapter_unmapgst_adapter_take_listgst_adapter_take_buffer_listgst_adapter_take_buffer_fastgst_adapter_take_buffergst_adapter_takegst_adapter_pushgst_adapter_pts_at_discontgst_adapter_prev_pts_at_offsetgst_adapter_prev_ptsgst_adapter_prev_offsetgst_adapter_prev_dts_at_offsetgst_adapter_prev_dtsgst_adapter_offset_at_discont#gst_adapter_masked_scan_uint32_peekgst_adapter_masked_scan_uint32gst_adapter_mapgst_adapter_get_listgst_adapter_get_buffer_listgst_adapter_get_buffer_fastgst_adapter_get_buffergst_adapter_flushgst_adapter_dts_at_discont!gst_adapter_distance_from_discontgst_adapter_copy_bytesgst_adapter_cleargst_adapter_available_fastgst_adapter_availablegst_adapter_newc_gst_adapter_get_typeResolveBaseParseFrameMethodBaseParseFrameAttributeListBaseParseFrameOverheadFieldInfoBaseParseFrameOffsetFieldInfoBaseParseFrameFlagsFieldInfo BaseParseFrameOutBufferFieldInfoBaseParseFrameBufferFieldInfogst_base_parse_frame_initgst_base_parse_frame_freegst_base_parse_frame_newc_gst_base_parse_frame_get_type$__dynamic_C_CollectDataDestroyNotify%__dynamic_C_CollectPadsBufferFunction#__dynamic_C_CollectPadsClipFunction&__dynamic_C_CollectPadsCompareFunction$__dynamic_C_CollectPadsEventFunction$__dynamic_C_CollectPadsFlushFunction__dynamic_C_CollectPadsFunction$__dynamic_C_CollectPadsQueryFunction"__dynamic_C_DataQueueEmptyCallback!__dynamic_C_DataQueueFullCallback*__dynamic_C_TypeFindHelperGetRangeFunctiongst_type_find_helpergst_type_find_helper_for_buffergst_type_find_helper_for_data"gst_type_find_helper_for_extensiongst_type_find_helper_get_rangeCollectPadsSignalListCollectPadsAttributeListResolveCollectPadsMethodgst_collect_pads_take_buffergst_collect_pads_stopgst_collect_pads_start"gst_collect_pads_src_event_defaultgst_collect_pads_set_waiting#gst_collect_pads_set_query_functiongst_collect_pads_set_functiongst_collect_pads_set_flushing#gst_collect_pads_set_flush_function#gst_collect_pads_set_event_function%gst_collect_pads_set_compare_function"gst_collect_pads_set_clip_function$gst_collect_pads_set_buffer_functiongst_collect_pads_remove_padgst_collect_pads_read_buffergst_collect_pads_query_defaultgst_collect_pads_popgst_collect_pads_peekgst_collect_pads_flushgst_collect_pads_event_default"gst_collect_pads_clip_running_timegst_collect_pads_availablegst_collect_pads_add_padgst_collect_pads_newc_gst_collect_pads_get_type-haskell-gi-base-0.20.2-KKTR4b0yOZMBKoDPQkkICnData.GI.Base.GTypeCGType gtypeName gtypeString gtypePointergtypeInt gtypeUInt gtypeLong gtypeULong gtypeInt64 gtypeUInt64 gtypeFloat gtypeDouble gtypeBoolean gtypeBoxed gtypeObject gtypeInvalid gtypeVariant gtypeGType gtypeStrvgtypeByteArrayData.GI.Base.BasicTypesGDestroyNotify PtrWrapped unwrapPtrGSListGList GHashTable GByteArray GPtrArrayGArrayIsGFlag GParamSpec NullToNothing nullToNothingUnexpectedNullPointerReturnnullPtrErrorMsgGObject gobjectType WrappedPtrwrappedPtrCallocwrappedPtrCopywrappedPtrFree BoxedFlagsboxedFlagsType BoxedEnum boxedEnumType BoxedObject boxedTypeManagedPtrNewtype ManagedPtrmanagedForeignPtrmanagedPtrIsDisowned g_slist_free g_list_freeData.GI.Base.GHashTable GEqualFunc GHashFunc gStrEqualgStrHash gDirectEqual gDirectHash ptrPackPtr ptrUnpackPtrcstringPackPtrcstringUnpackPtrData.GI.Base.ManagedPtr newManagedPtrnewManagedPtr'disownManagedPtrwithManagedPtrmaybeWithManagedPtrwithManagedPtrList withTransientunsafeManagedPtrGetPtrunsafeManagedPtrCastPtrtouchManagedPtrcastTo unsafeCastTo newObject wrapObject unrefObject disownObjectnewBoxed wrapBoxed copyBoxed copyBoxedPtr freeBoxed disownBoxedwrapPtrnewPtr copyBytesData.GI.Base.ClosureClosure noClosure newCClosureData.GI.Base.BasicConversionsunrefGHashTableunrefGByteArray unrefPtrArray unrefGArray gflagsToWord wordToGFlags packGList unpackGList packGSList unpackGSList packGArray unpackGArray packGPtrArrayunpackGPtrArraypackGByteArrayunpackGByteArraypackGHashTableunpackGHashTablepackByteStringpackZeroTerminatedByteStringunpackByteStringWithLengthunpackZeroTerminatedByteStringpackStorableArraypackZeroTerminatedStorableArrayunpackStorableArrayWithLength!unpackZeroTerminatedStorableArraypackMapStorableArray"packMapZeroTerminatedStorableArray unpackMapStorableArrayWithLength$unpackMapZeroTerminatedStorableArraypackUTF8CArraypackZeroTerminatedUTF8CArrayunpackZeroTerminatedUTF8CArrayunpackUTF8CArrayWithLengthpackFileNameArraypackZeroTerminatedFileNameArray!unpackZeroTerminatedFileNameArrayunpackFileNameArrayWithLengthstringToCStringcstringToString textToCStringwithTextCString cstringToTextbyteStringToCStringcstringToByteString packPtrArraypackZeroTerminatedPtrArrayunpackPtrArrayWithLengthunpackZeroTerminatedPtrArraymapZeroTerminatedCArraypackBlockArrayunpackBlockArrayWithLengthunpackBoxedArrayWithLengthmapCArrayWithLength mapGArray mapPtrArraymapGList mapGSListData.GI.Base.GError GErrorClassgerrorClassDomain GErrorMessage GErrorCode GErrorDomain gerrorNew gerrorDomain gerrorCode gerrorMessagecatchGErrorJustcatchGErrorJustDomainhandleGErrorJusthandleGErrorJustDomainpropagateGError checkGErrormaybePokeGErrorData.GI.Base.GValueIsGValuetoGValue fromGValueGValueData.GI.Base.GVariantGVariantDictEntryGVariantSignatureGVariantObjectPathGVariantHandleGVariantSingletIsGVariantBasicType IsGVariant toGVariant fromGVarianttoGVariantFormatString noGVariantgvariantGetTypeStringwrapGVariantPtrnewGVariantFromPtr unrefGVariantdisownGVariantgvariantFromBoolgvariantToBoolgvariantFromWord8gvariantToWord8gvariantFromInt16gvariantToInt16gvariantFromWord16gvariantToWord16gvariantFromInt32gvariantToInt32gvariantFromWord32gvariantToWord32gvariantFromInt64gvariantToInt64gvariantFromWord64gvariantToWord64gvariantFromHandlegvariantToHandlegvariantFromDoublegvariantToDoublegvariantToTextgvariantFromTextnewGVariantObjectPathgvariantObjectPathToTextgvariantFromObjectPathgvariantToObjectPathnewGVariantSignaturegvariantSignatureToTextgvariantFromSignaturegvariantToSignaturegvariantFromGVariantgvariantToGVariantgvariantToBytestringgvariantFromBytestringgvariantFromMaybegvariantToMaybegvariantFromDictEntrygvariantToDictEntrygvariantFromMap gvariantToMapgvariantFromListgvariantToListgvariantFromTuplegvariantToTupleData.GI.Base.AttributesAttrOp:=:=>:~:~>::=::~setgetData.GI.Base.GObjectnew'Data.GI.Base.Signals SignalProxyPropertyNotifyonafterGType gtypeToCGTypeGErrorGVariantData.GI.Base.Constructiblenew