<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Index of new API in 1.2.3: GStreamer 1.0 Core Reference Manual</title>
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="index.html" title="GStreamer 1.0 Core Reference Manual">
<link rel="up" href="index.html" title="GStreamer 1.0 Core Reference Manual">
<link rel="prev" href="ix04.html" title="Index of new API in 1.4">
<link rel="next" href="ix06.html" title="Index of new API in 1.2">
<meta name="generator" content="GTK-Doc V1.25 (XML mode)">
<link rel="stylesheet" href="style.css" type="text/css">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" id="top" width="100%" summary="Navigation header" cellpadding="2" cellspacing="5"><tr valign="middle">
<td width="100%" align="left" class="shortcuts"></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="16" height="16" border="0" alt="Home"></a></td>
<td><img src="up-insensitive.png" width="16" height="16" border="0"></td>
<td><a accesskey="p" href="ix04.html"><img src="left.png" width="16" height="16" border="0" alt="Prev"></a></td>
<td><a accesskey="n" href="ix06.html"><img src="right.png" width="16" height="16" border="0" alt="Next"></a></td>
</tr></table>
<div class="index">
<div class="titlepage"><div><div><h1 class="title">
<a name="id-1.11"></a>Index of new API in 1.2.3</h1></div></div></div>
<div xmlns:xlink="http://www.w3.org/1999/xlink" class="index"><div class="indexdiv">
<h3>G</h3>
<dl>
<dt id="ientry-idm39667">GDOUBLE_FROM_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GDOUBLE-FROM-BE:CAPS">GDOUBLE_FROM_BE()</a>
</dt>
<dt id="ientry-idm39672">GDOUBLE_FROM_LE, <a class="indexterm" href="gstreamer-GstUtils.html#GDOUBLE-FROM-LE:CAPS">GDOUBLE_FROM_LE()</a>
</dt>
<dt id="ientry-idm39677">GDOUBLE_SWAP_LE_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GDOUBLE-SWAP-LE-BE:CAPS">GDOUBLE_SWAP_LE_BE ()</a>
</dt>
<dt id="ientry-idm39687">GDOUBLE_TO_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GDOUBLE-TO-BE:CAPS">GDOUBLE_TO_BE()</a>
</dt>
<dt id="ientry-idm39692">GDOUBLE_TO_LE, <a class="indexterm" href="gstreamer-GstUtils.html#GDOUBLE-TO-LE:CAPS">GDOUBLE_TO_LE()</a>
</dt>
<dt id="ientry-idm39697">GFLOAT_FROM_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GFLOAT-FROM-BE:CAPS">GFLOAT_FROM_BE()</a>
</dt>
<dt id="ientry-idm39702">GFLOAT_FROM_LE, <a class="indexterm" href="gstreamer-GstUtils.html#GFLOAT-FROM-LE:CAPS">GFLOAT_FROM_LE()</a>
</dt>
<dt id="ientry-idm39707">GFLOAT_SWAP_LE_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GFLOAT-SWAP-LE-BE:CAPS">GFLOAT_SWAP_LE_BE ()</a>
</dt>
<dt id="ientry-idm39717">GFLOAT_TO_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GFLOAT-TO-BE:CAPS">GFLOAT_TO_BE()</a>
</dt>
<dt id="ientry-idm39722">GFLOAT_TO_LE, <a class="indexterm" href="gstreamer-GstUtils.html#GFLOAT-TO-LE:CAPS">GFLOAT_TO_LE()</a>
</dt>
<dt id="ientry-idm812">GstAllocationParams, <a class="indexterm" href="GstAllocator.html#GstAllocationParams-struct">struct GstAllocationParams</a>
</dt>
<dt id="ientry-idm780">GstAllocator, <a class="indexterm" href="GstAllocator.html#GstAllocator-struct">GstAllocator</a>
</dt>
<dt id="ientry-idm785">GstAllocatorClass, <a class="indexterm" href="GstAllocator.html#GstAllocatorClass">struct GstAllocatorClass</a>
</dt>
<dt id="ientry-idm790">GstAllocatorFlags, <a class="indexterm" href="GstAllocator.html#GstAllocatorFlags">enum GstAllocatorFlags</a>
</dt>
<dt id="ientry-idm979">GstAtomicQueue, <a class="indexterm" href="gstreamer-GstAtomicQueue.html#GstAtomicQueue">GstAtomicQueue</a>
</dt>
<dt id="ientry-idm1472">GstBin, <a class="indexterm" href="GstBin.html#GstBin-struct">struct GstBin</a>
</dt>
<dt id="ientry-idm1531">GstBin::deep-element-added, <a class="indexterm" href="GstBin.html#GstBin-deep-element-added">The “deep-element-added” signal</a>
</dt>
<dt id="ientry-idm1549">GstBin::deep-element-removed, <a class="indexterm" href="GstBin.html#GstBin-deep-element-removed">The “deep-element-removed” signal</a>
</dt>
<dt id="ientry-idm1567">GstBin::do-latency, <a class="indexterm" href="GstBin.html#GstBin-do-latency">The “do-latency” signal</a>
</dt>
<dt id="ientry-idm1581">GstBin::element-added, <a class="indexterm" href="GstBin.html#GstBin-element-added">The “element-added” signal</a>
</dt>
<dt id="ientry-idm1597">GstBin::element-removed, <a class="indexterm" href="GstBin.html#GstBin-element-removed">The “element-removed” signal</a>
</dt>
<dt id="ientry-idm1507">GstBin:async-handling, <a class="indexterm" href="GstBin.html#GstBin--async-handling">The “async-handling” property</a>
</dt>
<dt id="ientry-idm1518">GstBin:message-forward, <a class="indexterm" href="GstBin.html#GstBin--message-forward">The “message-forward” property</a>
</dt>
<dt id="ientry-idm1477">GstBinClass, <a class="indexterm" href="GstBin.html#GstBinClass">struct GstBinClass</a>
</dt>
<dt id="ientry-idm1482">GstBinFlags, <a class="indexterm" href="GstBin.html#GstBinFlags">enum GstBinFlags</a>
</dt>
<dt id="ientry-idm3025">GstBuffer, <a class="indexterm" href="GstBuffer.html#GstBuffer-struct">struct GstBuffer</a>
</dt>
<dt id="ientry-idm3112">GstBufferCopyFlags, <a class="indexterm" href="GstBuffer.html#GstBufferCopyFlags">enum GstBufferCopyFlags</a>
</dt>
<dt id="ientry-idm3030">GstBufferFlags, <a class="indexterm" href="GstBuffer.html#GstBufferFlags">enum GstBufferFlags</a>
</dt>
<dt id="ientry-idm2971">GstBufferForeachMetaFunc, <a class="indexterm" href="GstBuffer.html#GstBufferForeachMetaFunc">GstBufferForeachMetaFunc ()</a>
</dt>
<dt id="ientry-idm29921">GstBufferingMode, <a class="indexterm" href="GstQuery.html#GstBufferingMode">enum GstBufferingMode</a>
</dt>
<dt id="ientry-idm3478">GstBufferList, <a class="indexterm" href="GstBufferList.html#GstBufferList-struct">GstBufferList</a>
</dt>
<dt id="ientry-idm3429">GstBufferListFunc, <a class="indexterm" href="GstBufferList.html#GstBufferListFunc">GstBufferListFunc ()</a>
</dt>
<dt id="ientry-idm3949">GstBufferPool, <a class="indexterm" href="GstBufferPool.html#GstBufferPool-struct">GstBufferPool</a>
</dt>
<dt id="ientry-idm3959">GstBufferPoolAcquireFlags, <a class="indexterm" href="GstBufferPool.html#GstBufferPoolAcquireFlags">enum GstBufferPoolAcquireFlags</a>
</dt>
<dt id="ientry-idm3996">GstBufferPoolAcquireParams, <a class="indexterm" href="GstBufferPool.html#GstBufferPoolAcquireParams">struct GstBufferPoolAcquireParams</a>
</dt>
<dt id="ientry-idm3954">GstBufferPoolClass, <a class="indexterm" href="GstBufferPool.html#GstBufferPoolClass">struct GstBufferPoolClass</a>
</dt>
<dt id="ientry-idm4585">GstBus, <a class="indexterm" href="GstBus.html#GstBus-struct">struct GstBus</a>
</dt>
<dt id="ientry-idm4655">GstBus::message, <a class="indexterm" href="GstBus.html#GstBus-message">The “message” signal</a>
</dt>
<dt id="ientry-idm4671">GstBus::sync-message, <a class="indexterm" href="GstBus.html#GstBus-sync-message">The “sync-message” signal</a>
</dt>
<dt id="ientry-idm4642">GstBus:enable-async, <a class="indexterm" href="GstBus.html#GstBus--enable-async">The “enable-async” property</a>
</dt>
<dt id="ientry-idm4590">GstBusFlags, <a class="indexterm" href="GstBus.html#GstBusFlags">enum GstBusFlags</a>
</dt>
<dt id="ientry-idm4262">GstBusFunc, <a class="indexterm" href="GstBus.html#GstBusFunc">GstBusFunc ()</a>
</dt>
<dt id="ientry-idm4280">GstBusSyncHandler, <a class="indexterm" href="GstBus.html#GstBusSyncHandler">GstBusSyncHandler ()</a>
</dt>
<dt id="ientry-idm4612">GstBusSyncReply, <a class="indexterm" href="GstBus.html#GstBusSyncReply">enum GstBusSyncReply</a>
</dt>
<dt id="ientry-idm5949">GstCaps, <a class="indexterm" href="GstCaps.html#GstCaps-struct">struct GstCaps</a>
</dt>
<dt id="ientry-idm6480">GstCapsFeatures, <a class="indexterm" href="GstCapsFeatures.html#GstCapsFeatures-struct">GstCapsFeatures</a>
</dt>
<dt id="ientry-idm5269">GstCapsFilterMapFunc, <a class="indexterm" href="GstCaps.html#GstCapsFilterMapFunc">GstCapsFilterMapFunc ()</a>
</dt>
<dt id="ientry-idm5981">GstCapsFlags, <a class="indexterm" href="GstCaps.html#GstCapsFlags">enum GstCapsFlags</a>
</dt>
<dt id="ientry-idm5233">GstCapsForeachFunc, <a class="indexterm" href="GstCaps.html#GstCapsForeachFunc">GstCapsForeachFunc ()</a>
</dt>
<dt id="ientry-idm5959">GstCapsIntersectMode, <a class="indexterm" href="GstCaps.html#GstCapsIntersectMode">enum GstCapsIntersectMode</a>
</dt>
<dt id="ientry-idm5251">GstCapsMapFunc, <a class="indexterm" href="GstCaps.html#GstCapsMapFunc">GstCapsMapFunc ()</a>
</dt>
<dt id="ientry-idm7067">GstChildProxy, <a class="indexterm" href="GstChildProxy.html#GstChildProxy-struct">GstChildProxy</a>
</dt>
<dt id="ientry-idm7080">GstChildProxy::child-added, <a class="indexterm" href="GstChildProxy.html#GstChildProxy-child-added">The “child-added” signal</a>
</dt>
<dt id="ientry-idm7098">GstChildProxy::child-removed, <a class="indexterm" href="GstChildProxy.html#GstChildProxy-child-removed">The “child-removed” signal</a>
</dt>
<dt id="ientry-idm7072">GstChildProxyInterface, <a class="indexterm" href="GstChildProxy.html#GstChildProxyInterface">struct GstChildProxyInterface</a>
</dt>
<dt id="ientry-idm8126">GstClock, <a class="indexterm" href="GstClock.html#GstClock-struct">struct GstClock</a>
</dt>
<dt id="ientry-idm8352">GstClock::synced, <a class="indexterm" href="GstClock.html#GstClock-synced">The “synced” signal</a>
</dt>
<dt id="ientry-idm8315">GstClock:timeout, <a class="indexterm" href="GstClock.html#GstClock--timeout">The “timeout” property</a>
</dt>
<dt id="ientry-idm8326">GstClock:window-size, <a class="indexterm" href="GstClock.html#GstClock--window-size">The “window-size” property</a>
</dt>
<dt id="ientry-idm8338">GstClock:window-threshold, <a class="indexterm" href="GstClock.html#GstClock--window-threshold">The “window-threshold” property</a>
</dt>
<dt id="ientry-idm7624">GstClockCallback, <a class="indexterm" href="GstClock.html#GstClockCallback">GstClockCallback ()</a>
</dt>
<dt id="ientry-idm8131">GstClockClass, <a class="indexterm" href="GstClock.html#GstClockClass">struct GstClockClass</a>
</dt>
<dt id="ientry-idm8181">GstClockEntry, <a class="indexterm" href="GstClock.html#GstClockEntry">struct GstClockEntry</a>
</dt>
<dt id="ientry-idm8186">GstClockEntryType, <a class="indexterm" href="GstClock.html#GstClockEntryType">enum GstClockEntryType</a>
</dt>
<dt id="ientry-idm8260">GstClockFlags, <a class="indexterm" href="GstClock.html#GstClockFlags">enum GstClockFlags</a>
</dt>
<dt id="ientry-idm8146">GstClockID, <a class="indexterm" href="GstClock.html#GstClockID">GstClockID</a>
</dt>
<dt id="ientry-idm8208">GstClockReturn, <a class="indexterm" href="GstClock.html#GstClockReturn">enum GstClockReturn</a>
</dt>
<dt id="ientry-idm8136">GstClockTime, <a class="indexterm" href="GstClock.html#GstClockTime">GstClockTime</a>
</dt>
<dt id="ientry-idm8141">GstClockTimeDiff, <a class="indexterm" href="GstClock.html#GstClockTimeDiff">GstClockTimeDiff</a>
</dt>
<dt id="ientry-idm33083">GstClockType, <a class="indexterm" href="GstSystemClock.html#GstClockType">enum GstClockType</a>
</dt>
<dt id="ientry-idm8685">GstContext, <a class="indexterm" href="GstContext.html#GstContext-struct">GstContext</a>
</dt>
<dt id="ientry-idm8901">GstControlBinding, <a class="indexterm" href="GstControlBinding.html#GstControlBinding-struct">struct GstControlBinding</a>
</dt>
<dt id="ientry-idm8914">GstControlBinding:name, <a class="indexterm" href="GstControlBinding.html#GstControlBinding--name">The “name” property</a>
</dt>
<dt id="ientry-idm8925">GstControlBinding:object, <a class="indexterm" href="GstControlBinding.html#GstControlBinding--object">The “object” property</a>
</dt>
<dt id="ientry-idm8906">GstControlBindingClass, <a class="indexterm" href="GstControlBinding.html#GstControlBindingClass">struct GstControlBindingClass</a>
</dt>
<dt id="ientry-idm9107">GstControlSource, <a class="indexterm" href="GstControlSource.html#GstControlSource-struct">struct GstControlSource</a>
</dt>
<dt id="ientry-idm9112">GstControlSourceClass, <a class="indexterm" href="GstControlSource.html#GstControlSourceClass">struct GstControlSourceClass</a>
</dt>
<dt id="ientry-idm9020">GstControlSourceGetValue, <a class="indexterm" href="GstControlSource.html#GstControlSourceGetValue">GstControlSourceGetValue ()</a>
</dt>
<dt id="ientry-idm9038">GstControlSourceGetValueArray, <a class="indexterm" href="GstControlSource.html#GstControlSourceGetValueArray">GstControlSourceGetValueArray ()</a>
</dt>
<dt id="ientry-idm12541">GstCoreError, <a class="indexterm" href="gstreamer-GstGError.html#GstCoreError">enum GstCoreError</a>
</dt>
<dt id="ientry-idm9682">GstDateTime, <a class="indexterm" href="GstDateTime.html#GstDateTime-struct">GstDateTime</a>
</dt>
<dt id="ientry-idm44466">GstDebugCategory, <a class="indexterm" href="gstreamer-GstInfo.html#GstDebugCategory">struct GstDebugCategory</a>
</dt>
<dt id="ientry-idm44337">GstDebugColorFlags, <a class="indexterm" href="gstreamer-GstInfo.html#GstDebugColorFlags">enum GstDebugColorFlags</a>
</dt>
<dt id="ientry-idm44439">GstDebugColorMode, <a class="indexterm" href="gstreamer-GstInfo.html#GstDebugColorMode">enum GstDebugColorMode</a>
</dt>
<dt id="ientry-idm44471">GstDebugGraphDetails, <a class="indexterm" href="gstreamer-GstInfo.html#GstDebugGraphDetails">enum GstDebugGraphDetails</a>
</dt>
<dt id="ientry-idm44265">GstDebugLevel, <a class="indexterm" href="gstreamer-GstInfo.html#GstDebugLevel">enum GstDebugLevel</a>
</dt>
<dt id="ientry-idm42370">GstDevice, <a class="indexterm" href="gstreamer-GstDevice.html#GstDevice">struct GstDevice</a>
</dt>
<dt id="ientry-idm42375">GstDeviceClass, <a class="indexterm" href="gstreamer-GstDevice.html#GstDeviceClass">struct GstDeviceClass</a>
</dt>
<dt id="ientry-idm42173">GstDeviceMonitor, <a class="indexterm" href="gstreamer-GstDeviceMonitor.html#GstDeviceMonitor">struct GstDeviceMonitor</a>
</dt>
<dt id="ientry-idm42178">GstDeviceMonitorClass, <a class="indexterm" href="gstreamer-GstDeviceMonitor.html#GstDeviceMonitorClass">struct GstDeviceMonitorClass</a>
</dt>
<dt id="ientry-idm42711">GstDeviceProvider, <a class="indexterm" href="gstreamer-GstDeviceProvider.html#GstDeviceProvider">struct GstDeviceProvider</a>
</dt>
<dt id="ientry-idm42716">GstDeviceProviderClass, <a class="indexterm" href="gstreamer-GstDeviceProvider.html#GstDeviceProviderClass">struct GstDeviceProviderClass</a>
</dt>
<dt id="ientry-idm42933">GstDeviceProviderFactory, <a class="indexterm" href="GstDeviceProviderFactory.html#GstDeviceProviderFactory-struct">GstDeviceProviderFactory</a>
</dt>
<dt id="ientry-idm42938">GstDeviceProviderFactoryClass, <a class="indexterm" href="GstDeviceProviderFactory.html#GstDeviceProviderFactoryClass">GstDeviceProviderFactoryClass</a>
</dt>
<dt id="ientry-idm11561">GstElement, <a class="indexterm" href="GstElement.html#GstElement-struct">struct GstElement</a>
</dt>
<dt id="ientry-idm11762">GstElement::no-more-pads, <a class="indexterm" href="GstElement.html#GstElement-no-more-pads">The “no-more-pads” signal</a>
</dt>
<dt id="ientry-idm11776">GstElement::pad-added, <a class="indexterm" href="GstElement.html#GstElement-pad-added">The “pad-added” signal</a>
</dt>
<dt id="ientry-idm11792">GstElement::pad-removed, <a class="indexterm" href="GstElement.html#GstElement-pad-removed">The “pad-removed” signal</a>
</dt>
<dt id="ientry-idm11525">GstElementCallAsyncFunc, <a class="indexterm" href="GstElement.html#GstElementCallAsyncFunc">GstElementCallAsyncFunc ()</a>
</dt>
<dt id="ientry-idm11566">GstElementClass, <a class="indexterm" href="GstElement.html#GstElementClass">struct GstElementClass</a>
</dt>
<dt id="ientry-idm12324">GstElementFactory, <a class="indexterm" href="GstElementFactory.html#GstElementFactory-struct">GstElementFactory</a>
</dt>
<dt id="ientry-idm12329">GstElementFactoryListType, <a class="indexterm" href="GstElementFactory.html#GstElementFactoryListType">GstElementFactoryListType</a>
</dt>
<dt id="ientry-idm11571">GstElementFlags, <a class="indexterm" href="GstElement.html#GstElementFlags">enum GstElementFlags</a>
</dt>
<dt id="ientry-idm14359">GstEvent, <a class="indexterm" href="GstEvent.html#GstEvent-struct">struct GstEvent</a>
</dt>
<dt id="ientry-idm14406">GstEventType, <a class="indexterm" href="GstEvent.html#GstEventType">enum GstEventType</a>
</dt>
<dt id="ientry-idm14364">GstEventTypeFlags, <a class="indexterm" href="GstEvent.html#GstEventTypeFlags">enum GstEventTypeFlags</a>
</dt>
<dt id="ientry-idm24320">GstFlowReturn, <a class="indexterm" href="GstPad.html#GstFlowReturn">enum GstFlowReturn</a>
</dt>
<dt id="ientry-idm14892">GstFormat, <a class="indexterm" href="gstreamer-GstFormat.html#GstFormat">enum GstFormat</a>
</dt>
<dt id="ientry-idm14944">GstFormatDefinition, <a class="indexterm" href="gstreamer-GstFormat.html#GstFormatDefinition">struct GstFormatDefinition</a>
</dt>
<dt id="ientry-idm15307">GstGhostPad, <a class="indexterm" href="GstGhostPad.html#GstGhostPad-struct">struct GstGhostPad</a>
</dt>
<dt id="ientry-idm15842">GstIterator, <a class="indexterm" href="gstreamer-GstIterator.html#GstIterator">struct GstIterator</a>
</dt>
<dt id="ientry-idm15520">GstIteratorCopyFunction, <a class="indexterm" href="gstreamer-GstIterator.html#GstIteratorCopyFunction">GstIteratorCopyFunction ()</a>
</dt>
<dt id="ientry-idm15604">GstIteratorFoldFunction, <a class="indexterm" href="gstreamer-GstIterator.html#GstIteratorFoldFunction">GstIteratorFoldFunction ()</a>
</dt>
<dt id="ientry-idm15589">GstIteratorForeachFunction, <a class="indexterm" href="gstreamer-GstIterator.html#GstIteratorForeachFunction">GstIteratorForeachFunction ()</a>
</dt>
<dt id="ientry-idm15577">GstIteratorFreeFunction, <a class="indexterm" href="gstreamer-GstIterator.html#GstIteratorFreeFunction">GstIteratorFreeFunction ()</a>
</dt>
<dt id="ientry-idm15847">GstIteratorItem, <a class="indexterm" href="gstreamer-GstIterator.html#GstIteratorItem">enum GstIteratorItem</a>
</dt>
<dt id="ientry-idm15550">GstIteratorItemFunction, <a class="indexterm" href="gstreamer-GstIterator.html#GstIteratorItemFunction">GstIteratorItemFunction ()</a>
</dt>
<dt id="ientry-idm15535">GstIteratorNextFunction, <a class="indexterm" href="gstreamer-GstIterator.html#GstIteratorNextFunction">GstIteratorNextFunction ()</a>
</dt>
<dt id="ientry-idm15874">GstIteratorResult, <a class="indexterm" href="gstreamer-GstIterator.html#GstIteratorResult">enum GstIteratorResult</a>
</dt>
<dt id="ientry-idm15565">GstIteratorResyncFunction, <a class="indexterm" href="gstreamer-GstIterator.html#GstIteratorResyncFunction">GstIteratorResyncFunction ()</a>
</dt>
<dt id="ientry-idm12628">GstLibraryError, <a class="indexterm" href="gstreamer-GstGError.html#GstLibraryError">enum GstLibraryError</a>
</dt>
<dt id="ientry-idm19997">GstLockFlags, <a class="indexterm" href="gstreamer-GstMiniObject.html#GstLockFlags">enum GstLockFlags</a>
</dt>
<dt id="ientry-idm43540">GstLogFunction, <a class="indexterm" href="gstreamer-GstInfo.html#GstLogFunction">GstLogFunction ()</a>
</dt>
<dt id="ientry-idm16601">GstMapFlags, <a class="indexterm" href="GstMemory.html#GstMapFlags">enum GstMapFlags</a>
</dt>
<dt id="ientry-idm16633">GstMapInfo, <a class="indexterm" href="GstMemory.html#GstMapInfo">GstMapInfo</a>
</dt>
<dt id="ientry-idm16596">GstMemory, <a class="indexterm" href="GstMemory.html#GstMemory-struct">struct GstMemory</a>
</dt>
<dt id="ientry-idm16284">GstMemoryCopyFunction, <a class="indexterm" href="GstMemory.html#GstMemoryCopyFunction">GstMemoryCopyFunction ()</a>
</dt>
<dt id="ientry-idm16549">GstMemoryFlags, <a class="indexterm" href="GstMemory.html#GstMemoryFlags">enum GstMemoryFlags</a>
</dt>
<dt id="ientry-idm16320">GstMemoryIsSpanFunction, <a class="indexterm" href="GstMemory.html#GstMemoryIsSpanFunction">GstMemoryIsSpanFunction ()</a>
</dt>
<dt id="ientry-idm16239">GstMemoryMapFullFunction, <a class="indexterm" href="GstMemory.html#GstMemoryMapFullFunction">GstMemoryMapFullFunction ()</a>
</dt>
<dt id="ientry-idm16221">GstMemoryMapFunction, <a class="indexterm" href="GstMemory.html#GstMemoryMapFunction">GstMemoryMapFunction ()</a>
</dt>
<dt id="ientry-idm16302">GstMemoryShareFunction, <a class="indexterm" href="GstMemory.html#GstMemoryShareFunction">GstMemoryShareFunction ()</a>
</dt>
<dt id="ientry-idm16269">GstMemoryUnmapFullFunction, <a class="indexterm" href="GstMemory.html#GstMemoryUnmapFullFunction">GstMemoryUnmapFullFunction ()</a>
</dt>
<dt id="ientry-idm16257">GstMemoryUnmapFunction, <a class="indexterm" href="GstMemory.html#GstMemoryUnmapFunction">GstMemoryUnmapFunction ()</a>
</dt>
<dt id="ientry-idm18732">GstMessage, <a class="indexterm" href="GstMessage.html#GstMessage-struct">struct GstMessage</a>
</dt>
<dt id="ientry-idm18737">GstMessageType, <a class="indexterm" href="GstMessage.html#GstMessageType">enum GstMessageType</a>
</dt>
<dt id="ientry-idm19345">GstMeta, <a class="indexterm" href="gstreamer-GstMeta.html#GstMeta">struct GstMeta</a>
</dt>
<dt id="ientry-idm19350">GstMetaFlags, <a class="indexterm" href="gstreamer-GstMeta.html#GstMetaFlags">enum GstMetaFlags</a>
</dt>
<dt id="ientry-idm19228">GstMetaFreeFunction, <a class="indexterm" href="gstreamer-GstMeta.html#GstMetaFreeFunction">GstMetaFreeFunction ()</a>
</dt>
<dt id="ientry-idm19387">GstMetaInfo, <a class="indexterm" href="gstreamer-GstMeta.html#GstMetaInfo">struct GstMetaInfo</a>
</dt>
<dt id="ientry-idm19210">GstMetaInitFunction, <a class="indexterm" href="gstreamer-GstMeta.html#GstMetaInitFunction">GstMetaInitFunction ()</a>
</dt>
<dt id="ientry-idm19392">GstMetaTransformCopy, <a class="indexterm" href="gstreamer-GstMeta.html#GstMetaTransformCopy">GstMetaTransformCopy</a>
</dt>
<dt id="ientry-idm19243">GstMetaTransformFunction, <a class="indexterm" href="gstreamer-GstMeta.html#GstMetaTransformFunction">GstMetaTransformFunction ()</a>
</dt>
<dt id="ientry-idm19960">GstMiniObject, <a class="indexterm" href="gstreamer-GstMiniObject.html#GstMiniObject">struct GstMiniObject</a>
</dt>
<dt id="ientry-idm19648">GstMiniObjectCopyFunction, <a class="indexterm" href="gstreamer-GstMiniObject.html#GstMiniObjectCopyFunction">GstMiniObjectCopyFunction ()</a>
</dt>
<dt id="ientry-idm19660">GstMiniObjectDisposeFunction, <a class="indexterm" href="gstreamer-GstMiniObject.html#GstMiniObjectDisposeFunction">GstMiniObjectDisposeFunction ()</a>
</dt>
<dt id="ientry-idm19965">GstMiniObjectFlags, <a class="indexterm" href="gstreamer-GstMiniObject.html#GstMiniObjectFlags">enum GstMiniObjectFlags</a>
</dt>
<dt id="ientry-idm19672">GstMiniObjectFreeFunction, <a class="indexterm" href="gstreamer-GstMiniObject.html#GstMiniObjectFreeFunction">GstMiniObjectFreeFunction ()</a>
</dt>
<dt id="ientry-idm19684">GstMiniObjectNotify, <a class="indexterm" href="gstreamer-GstMiniObject.html#GstMiniObjectNotify">GstMiniObjectNotify ()</a>
</dt>
<dt id="ientry-idm20866">GstObject, <a class="indexterm" href="GstObject.html#GstObject-struct">struct GstObject</a>
</dt>
<dt id="ientry-idm20924">GstObject::deep-notify, <a class="indexterm" href="GstObject.html#GstObject-deep-notify">The “deep-notify” signal</a>
</dt>
<dt id="ientry-idm20901">GstObject:name, <a class="indexterm" href="GstObject.html#GstObject--name">The “name” property</a>
</dt>
<dt id="ientry-idm20912">GstObject:parent, <a class="indexterm" href="GstObject.html#GstObject--parent">The “parent” property</a>
</dt>
<dt id="ientry-idm20871">GstObjectClass, <a class="indexterm" href="GstObject.html#GstObjectClass">struct GstObjectClass</a>
</dt>
<dt id="ientry-idm20876">GstObjectFlags, <a class="indexterm" href="GstObject.html#GstObjectFlags">enum GstObjectFlags</a>
</dt>
<dt id="ientry-idm24122">GstPad, <a class="indexterm" href="GstPad.html#GstPad-struct">struct GstPad</a>
</dt>
<dt id="ientry-idm24636">GstPad::linked, <a class="indexterm" href="GstPad.html#GstPad-linked">The “linked” signal</a>
</dt>
<dt id="ientry-idm24652">GstPad::unlinked, <a class="indexterm" href="GstPad.html#GstPad-unlinked">The “unlinked” signal</a>
</dt>
<dt id="ientry-idm24591">GstPad:caps, <a class="indexterm" href="GstPad.html#GstPad--caps">The “caps” property</a>
</dt>
<dt id="ientry-idm24601">GstPad:direction, <a class="indexterm" href="GstPad.html#GstPad--direction">The “direction” property</a>
</dt>
<dt id="ientry-idm24612">GstPad:offset, <a class="indexterm" href="GstPad.html#GstPad--offset">The “offset” property</a>
</dt>
<dt id="ientry-idm24624">GstPad:template, <a class="indexterm" href="GstPad.html#GstPad--template">The “template” property</a>
</dt>
<dt id="ientry-idm23152">GstPadActivateFunction, <a class="indexterm" href="GstPad.html#GstPadActivateFunction">GstPadActivateFunction ()</a>
</dt>
<dt id="ientry-idm23191">GstPadActivateModeFunction, <a class="indexterm" href="GstPad.html#GstPadActivateModeFunction">GstPadActivateModeFunction ()</a>
</dt>
<dt id="ientry-idm22810">GstPadChainFunction, <a class="indexterm" href="GstPad.html#GstPadChainFunction">GstPadChainFunction ()</a>
</dt>
<dt id="ientry-idm22852">GstPadChainListFunction, <a class="indexterm" href="GstPad.html#GstPadChainListFunction">GstPadChainListFunction ()</a>
</dt>
<dt id="ientry-idm24127">GstPadDirection, <a class="indexterm" href="GstPad.html#GstPadDirection">enum GstPadDirection</a>
</dt>
<dt id="ientry-idm23003">GstPadEventFullFunction, <a class="indexterm" href="GstPad.html#GstPadEventFullFunction">GstPadEventFullFunction ()</a>
</dt>
<dt id="ientry-idm22961">GstPadEventFunction, <a class="indexterm" href="GstPad.html#GstPadEventFunction">GstPadEventFunction ()</a>
</dt>
<dt id="ientry-idm24154">GstPadFlags, <a class="indexterm" href="GstPad.html#GstPadFlags">enum GstPadFlags</a>
</dt>
<dt id="ientry-idm23746">GstPadForwardFunction, <a class="indexterm" href="GstPad.html#GstPadForwardFunction">GstPadForwardFunction ()</a>
</dt>
<dt id="ientry-idm22913">GstPadGetRangeFunction, <a class="indexterm" href="GstPad.html#GstPadGetRangeFunction">GstPadGetRangeFunction ()</a>
</dt>
<dt id="ientry-idm23613">GstPadIterIntLinkFunction, <a class="indexterm" href="GstPad.html#GstPadIterIntLinkFunction">GstPadIterIntLinkFunction ()</a>
</dt>
<dt id="ientry-idm24283">GstPadLinkCheck, <a class="indexterm" href="GstPad.html#GstPadLinkCheck">enum GstPadLinkCheck</a>
</dt>
<dt id="ientry-idm23045">GstPadLinkFunction, <a class="indexterm" href="GstPad.html#GstPadLinkFunction">GstPadLinkFunction ()</a>
</dt>
<dt id="ientry-idm24236">GstPadLinkReturn, <a class="indexterm" href="GstPad.html#GstPadLinkReturn">enum GstPadLinkReturn</a>
</dt>
<dt id="ientry-idm24397">GstPadMode, <a class="indexterm" href="GstPad.html#GstPadMode">enum GstPadMode</a>
</dt>
<dt id="ientry-idm24939">GstPadPresence, <a class="indexterm" href="GstPadTemplate.html#GstPadPresence">enum GstPadPresence</a>
</dt>
<dt id="ientry-idm22651">GstPadProbeCallback, <a class="indexterm" href="GstPad.html#GstPadProbeCallback">GstPadProbeCallback ()</a>
</dt>
<dt id="ientry-idm24583">GstPadProbeInfo, <a class="indexterm" href="GstPad.html#GstPadProbeInfo">struct GstPadProbeInfo</a>
</dt>
<dt id="ientry-idm24424">GstPadProbeReturn, <a class="indexterm" href="GstPad.html#GstPadProbeReturn">enum GstPadProbeReturn</a>
</dt>
<dt id="ientry-idm24461">GstPadProbeType, <a class="indexterm" href="GstPad.html#GstPadProbeType">enum GstPadProbeType</a>
</dt>
<dt id="ientry-idm23571">GstPadQueryFunction, <a class="indexterm" href="GstPad.html#GstPadQueryFunction">GstPadQueryFunction ()</a>
</dt>
<dt id="ientry-idm22507">GstPadStickyEventsForeachFunction, <a class="indexterm" href="GstPad.html#GstPadStickyEventsForeachFunction">GstPadStickyEventsForeachFunction ()</a>
</dt>
<dt id="ientry-idm24917">GstPadTemplate, <a class="indexterm" href="GstPadTemplate.html#GstPadTemplate-struct">struct GstPadTemplate</a>
</dt>
<dt id="ientry-idm25014">GstPadTemplate::pad-created, <a class="indexterm" href="GstPadTemplate.html#GstPadTemplate-pad-created">The “pad-created” signal</a>
</dt>
<dt id="ientry-idm24969">GstPadTemplate:caps, <a class="indexterm" href="GstPadTemplate.html#GstPadTemplate--caps">The “caps” property</a>
</dt>
<dt id="ientry-idm24979">GstPadTemplate:direction, <a class="indexterm" href="GstPadTemplate.html#GstPadTemplate--direction">The “direction” property</a>
</dt>
<dt id="ientry-idm24990">GstPadTemplate:name-template, <a class="indexterm" href="GstPadTemplate.html#GstPadTemplate--name-template">The “name-template” property</a>
</dt>
<dt id="ientry-idm25001">GstPadTemplate:presence, <a class="indexterm" href="GstPadTemplate.html#GstPadTemplate--presence">The “presence” property</a>
</dt>
<dt id="ientry-idm24922">GstPadTemplateFlags, <a class="indexterm" href="GstPadTemplate.html#GstPadTemplateFlags">enum GstPadTemplateFlags</a>
</dt>
<dt id="ientry-idm23087">GstPadUnlinkFunction, <a class="indexterm" href="GstPad.html#GstPadUnlinkFunction">GstPadUnlinkFunction ()</a>
</dt>
<dt id="ientry-idm25153">GstParamSpecFraction, <a class="indexterm" href="gstreamer-GstParamSpec.html#GstParamSpecFraction">struct GstParamSpecFraction</a>
</dt>
<dt id="ientry-idm3169">GstParentBufferMeta, <a class="indexterm" href="GstBuffer.html#GstParentBufferMeta">struct GstParentBufferMeta</a>
</dt>
<dt id="ientry-idm25478">GstParseContext, <a class="indexterm" href="gstreamer-GstParse.html#GstParseContext-struct">GstParseContext</a>
</dt>
<dt id="ientry-idm25426">GstParseError, <a class="indexterm" href="gstreamer-GstParse.html#GstParseError">enum GstParseError</a>
</dt>
<dt id="ientry-idm25483">GstParseFlags, <a class="indexterm" href="gstreamer-GstParse.html#GstParseFlags">enum GstParseFlags</a>
</dt>
<dt id="ientry-idm25836">GstPipeline, <a class="indexterm" href="GstPipeline.html#GstPipeline-struct">struct GstPipeline</a>
</dt>
<dt id="ientry-idm25866">GstPipeline:auto-flush-bus, <a class="indexterm" href="GstPipeline.html#GstPipeline--auto-flush-bus">The “auto-flush-bus” property</a>
</dt>
<dt id="ientry-idm25877">GstPipeline:delay, <a class="indexterm" href="GstPipeline.html#GstPipeline--delay">The “delay” property</a>
</dt>
<dt id="ientry-idm25888">GstPipeline:latency, <a class="indexterm" href="GstPipeline.html#GstPipeline--latency">The “latency” property</a>
</dt>
<dt id="ientry-idm25841">GstPipelineFlags, <a class="indexterm" href="GstPipeline.html#GstPipelineFlags">enum GstPipelineFlags</a>
</dt>
<dt id="ientry-idm26540">GstPlugin, <a class="indexterm" href="GstPlugin.html#GstPlugin-struct">GstPlugin</a>
</dt>
<dt id="ientry-idm26577">GstPluginDependencyFlags, <a class="indexterm" href="GstPlugin.html#GstPluginDependencyFlags">enum GstPluginDependencyFlags</a>
</dt>
<dt id="ientry-idm26545">GstPluginDesc, <a class="indexterm" href="GstPlugin.html#GstPluginDesc">struct GstPluginDesc</a>
</dt>
<dt id="ientry-idm26513">GstPluginError, <a class="indexterm" href="GstPlugin.html#GstPluginError">enum GstPluginError</a>
</dt>
<dt id="ientry-idm26892">GstPluginFeature, <a class="indexterm" href="GstPluginFeature.html#GstPluginFeature-struct">GstPluginFeature</a>
</dt>
<dt id="ientry-idm26755">GstPluginFeatureFilter, <a class="indexterm" href="GstPluginFeature.html#GstPluginFeatureFilter">GstPluginFeatureFilter ()</a>
</dt>
<dt id="ientry-idm26204">GstPluginFilter, <a class="indexterm" href="GstPlugin.html#GstPluginFilter">GstPluginFilter ()</a>
</dt>
<dt id="ientry-idm26555">GstPluginFlags, <a class="indexterm" href="GstPlugin.html#GstPluginFlags">enum GstPluginFlags</a>
</dt>
<dt id="ientry-idm26174">GstPluginInitFullFunc, <a class="indexterm" href="GstPlugin.html#GstPluginInitFullFunc">GstPluginInitFullFunc ()</a>
</dt>
<dt id="ientry-idm26162">GstPluginInitFunc, <a class="indexterm" href="GstPlugin.html#GstPluginInitFunc">GstPluginInitFunc ()</a>
</dt>
<dt id="ientry-idm27356">GstPoll, <a class="indexterm" href="gstreamer-GstPoll.html#GstPoll">GstPoll</a>
</dt>
<dt id="ientry-idm27361">GstPollFD, <a class="indexterm" href="gstreamer-GstPoll.html#GstPollFD">GstPollFD</a>
</dt>
<dt id="ientry-idm27634">GstPreset, <a class="indexterm" href="GstPreset.html#GstPreset-struct">GstPreset</a>
</dt>
<dt id="ientry-idm27639">GstPresetInterface, <a class="indexterm" href="GstPreset.html#GstPresetInterface">struct GstPresetInterface</a>
</dt>
<dt id="ientry-idm19013">GstProgressType, <a class="indexterm" href="GstMessage.html#GstProgressType">enum GstProgressType</a>
</dt>
<dt id="ientry-idm27730">GstProtectionMeta, <a class="indexterm" href="gstreamer-GstProtectionMeta.html#GstProtectionMeta">struct GstProtectionMeta</a>
</dt>
<dt id="ientry-idm15302">GstProxyPad, <a class="indexterm" href="GstGhostPad.html#GstProxyPad-struct">struct GstProxyPad</a>
</dt>
<dt id="ientry-idm14595">GstQOSType, <a class="indexterm" href="GstEvent.html#GstQOSType">enum GstQOSType</a>
</dt>
<dt id="ientry-idm29777">GstQuery, <a class="indexterm" href="GstQuery.html#GstQuery-struct">struct GstQuery</a>
</dt>
<dt id="ientry-idm29814">GstQueryType, <a class="indexterm" href="GstQuery.html#GstQueryType">enum GstQueryType</a>
</dt>
<dt id="ientry-idm29782">GstQueryTypeFlags, <a class="indexterm" href="GstQuery.html#GstQueryTypeFlags">enum GstQueryTypeFlags</a>
</dt>
<dt id="ientry-idm26897">GstRank, <a class="indexterm" href="GstPluginFeature.html#GstRank">enum GstRank</a>
</dt>
<dt id="ientry-idm30439">GstRegistry, <a class="indexterm" href="GstRegistry.html#GstRegistry-struct">struct GstRegistry</a>
</dt>
<dt id="ientry-idm30447">GstRegistry::feature-added, <a class="indexterm" href="GstRegistry.html#GstRegistry-feature-added">The “feature-added” signal</a>
</dt>
<dt id="ientry-idm30463">GstRegistry::plugin-added, <a class="indexterm" href="GstRegistry.html#GstRegistry-plugin-added">The “plugin-added” signal</a>
</dt>
<dt id="ientry-idm12675">GstResourceError, <a class="indexterm" href="gstreamer-GstGError.html#GstResourceError">enum GstResourceError</a>
</dt>
<dt id="ientry-idm6722">GstSample, <a class="indexterm" href="GstSample.html#GstSample-struct">GstSample</a>
</dt>
<dt id="ientry-idm29953">GstSchedulingFlags, <a class="indexterm" href="GstQuery.html#GstSchedulingFlags">enum GstSchedulingFlags</a>
</dt>
<dt id="ientry-idm40072">GstSearchMode, <a class="indexterm" href="gstreamer-GstUtils.html#GstSearchMode">enum GstSearchMode</a>
</dt>
<dt id="ientry-idm14649">GstSeekFlags, <a class="indexterm" href="GstEvent.html#GstSeekFlags">enum GstSeekFlags</a>
</dt>
<dt id="ientry-idm14622">GstSeekType, <a class="indexterm" href="GstEvent.html#GstSeekType">enum GstSeekType</a>
</dt>
<dt id="ientry-idm30973">GstSegment, <a class="indexterm" href="GstSegment.html#GstSegment-struct">struct GstSegment</a>
</dt>
<dt id="ientry-idm30978">GstSegmentFlags, <a class="indexterm" href="GstSegment.html#GstSegmentFlags">enum GstSegmentFlags</a>
</dt>
<dt id="ientry-idm11618">GstState, <a class="indexterm" href="GstElement.html#GstState">enum GstState</a>
</dt>
<dt id="ientry-idm11655">GstStateChange, <a class="indexterm" href="GstElement.html#GstStateChange">enum GstStateChange</a>
</dt>
<dt id="ientry-idm11697">GstStateChangeReturn, <a class="indexterm" href="GstElement.html#GstStateChangeReturn">enum GstStateChangeReturn</a>
</dt>
<dt id="ientry-idm5954">GstStaticCaps, <a class="indexterm" href="GstCaps.html#GstStaticCaps">struct GstStaticCaps</a>
</dt>
<dt id="ientry-idm24912">GstStaticPadTemplate, <a class="indexterm" href="GstPadTemplate.html#GstStaticPadTemplate">struct GstStaticPadTemplate</a>
</dt>
<dt id="ientry-idm31276">GstStream, <a class="indexterm" href="gstreamer-GstStream.html#GstStream">struct GstStream</a>
</dt>
<dt id="ientry-idm31281">GstStreamClass, <a class="indexterm" href="gstreamer-GstStream.html#GstStreamClass">struct GstStreamClass</a>
</dt>
<dt id="ientry-idm31453">GstStreamCollection, <a class="indexterm" href="gstreamer-GstStreamCollection.html#GstStreamCollection">struct GstStreamCollection</a>
</dt>
<dt id="ientry-idm31458">GstStreamCollectionClass, <a class="indexterm" href="gstreamer-GstStreamCollection.html#GstStreamCollectionClass">struct GstStreamCollectionClass</a>
</dt>
<dt id="ientry-idm12767">GstStreamError, <a class="indexterm" href="gstreamer-GstGError.html#GstStreamError">enum GstStreamError</a>
</dt>
<dt id="ientry-idm14563">GstStreamFlags, <a class="indexterm" href="GstEvent.html#GstStreamFlags">enum GstStreamFlags</a>
</dt>
<dt id="ientry-idm18966">GstStreamStatusType, <a class="indexterm" href="GstMessage.html#GstStreamStatusType">enum GstStreamStatusType</a>
</dt>
<dt id="ientry-idm31286">GstStreamType, <a class="indexterm" href="gstreamer-GstStream.html#GstStreamType">enum GstStreamType</a>
</dt>
<dt id="ientry-idm32980">GstStructure, <a class="indexterm" href="GstStructure.html#GstStructure-struct">struct GstStructure</a>
</dt>
<dt id="ientry-idm18944">GstStructureChangeType, <a class="indexterm" href="GstMessage.html#GstStructureChangeType">enum GstStructureChangeType</a>
</dt>
<dt id="ientry-idm32026">GstStructureFilterMapFunc, <a class="indexterm" href="GstStructure.html#GstStructureFilterMapFunc">GstStructureFilterMapFunc ()</a>
</dt>
<dt id="ientry-idm31990">GstStructureForeachFunc, <a class="indexterm" href="GstStructure.html#GstStructureForeachFunc">GstStructureForeachFunc ()</a>
</dt>
<dt id="ientry-idm32008">GstStructureMapFunc, <a class="indexterm" href="GstStructure.html#GstStructureMapFunc">GstStructureMapFunc ()</a>
</dt>
<dt id="ientry-idm33110">GstSystemClock, <a class="indexterm" href="GstSystemClock.html#GstSystemClock-struct">struct GstSystemClock</a>
</dt>
<dt id="ientry-idm33118">GstSystemClock:clock-type, <a class="indexterm" href="GstSystemClock.html#GstSystemClock--clock-type">The “clock-type” property</a>
</dt>
<dt id="ientry-idm35005">GstTagFlag, <a class="indexterm" href="GstTagList.html#GstTagFlag">enum GstTagFlag</a>
</dt>
<dt id="ientry-idm33974">GstTagForeachFunc, <a class="indexterm" href="GstTagList.html#GstTagForeachFunc">GstTagForeachFunc ()</a>
</dt>
<dt id="ientry-idm34948">GstTagList, <a class="indexterm" href="GstTagList.html#GstTagList-struct">struct GstTagList</a>
</dt>
<dt id="ientry-idm33992">GstTagMergeFunc, <a class="indexterm" href="GstTagList.html#GstTagMergeFunc">GstTagMergeFunc ()</a>
</dt>
<dt id="ientry-idm34953">GstTagMergeMode, <a class="indexterm" href="GstTagList.html#GstTagMergeMode">enum GstTagMergeMode</a>
</dt>
<dt id="ientry-idm35042">GstTagScope, <a class="indexterm" href="GstTagList.html#GstTagScope">enum GstTagScope</a>
</dt>
<dt id="ientry-idm35752">GstTagSetter, <a class="indexterm" href="GstTagSetter.html#GstTagSetter-struct">GstTagSetter</a>
</dt>
<dt id="ientry-idm35757">GstTagSetterInterface, <a class="indexterm" href="GstTagSetter.html#GstTagSetterInterface">struct GstTagSetterInterface</a>
</dt>
<dt id="ientry-idm36171">GstTask, <a class="indexterm" href="GstTask.html#GstTask-struct">struct GstTask</a>
</dt>
<dt id="ientry-idm35947">GstTaskFunction, <a class="indexterm" href="GstTask.html#GstTaskFunction">GstTaskFunction ()</a>
</dt>
<dt id="ientry-idm36371">GstTaskPool, <a class="indexterm" href="GstTaskPool.html#GstTaskPool-struct">struct GstTaskPool</a>
</dt>
<dt id="ientry-idm36376">GstTaskPoolClass, <a class="indexterm" href="GstTaskPool.html#GstTaskPoolClass">struct GstTaskPoolClass</a>
</dt>
<dt id="ientry-idm36293">GstTaskPoolFunction, <a class="indexterm" href="GstTaskPool.html#GstTaskPoolFunction">GstTaskPoolFunction ()</a>
</dt>
<dt id="ientry-idm36176">GstTaskState, <a class="indexterm" href="GstTask.html#GstTaskState">enum GstTaskState</a>
</dt>
<dt id="ientry-idm36041">GstTaskThreadFunc, <a class="indexterm" href="GstTask.html#GstTaskThreadFunc">GstTaskThreadFunc ()</a>
</dt>
<dt id="ientry-idm9117">GstTimedValue, <a class="indexterm" href="GstControlSource.html#GstTimedValue">struct GstTimedValue</a>
</dt>
<dt id="ientry-idm37039">GstToc, <a class="indexterm" href="GstToc.html#GstToc-struct">GstToc</a>
</dt>
<dt id="ientry-idm37066">GstTocEntry, <a class="indexterm" href="GstToc.html#GstTocEntry-struct">GstTocEntry</a>
</dt>
<dt id="ientry-idm37071">GstTocEntryType, <a class="indexterm" href="GstToc.html#GstTocEntryType">enum GstTocEntryType</a>
</dt>
<dt id="ientry-idm37118">GstTocLoopType, <a class="indexterm" href="GstToc.html#GstTocLoopType">enum GstTocLoopType</a>
</dt>
<dt id="ientry-idm37044">GstTocScope, <a class="indexterm" href="GstToc.html#GstTocScope">enum GstTocScope</a>
</dt>
<dt id="ientry-idm37248">GstTocSetter, <a class="indexterm" href="gstreamer-GstTocSetter.html#GstTocSetter">GstTocSetter</a>
</dt>
<dt id="ientry-idm37253">GstTocSetterInterface, <a class="indexterm" href="gstreamer-GstTocSetter.html#GstTocSetterInterface">struct GstTocSetterInterface</a>
</dt>
<dt id="ientry-idm45484">GstTracer, <a class="indexterm" href="GstTracer.html#GstTracer-struct">struct GstTracer</a>
</dt>
<dt id="ientry-idm45492">GstTracer:params, <a class="indexterm" href="GstTracer.html#GstTracer--params">The “params” property</a>
</dt>
<dt id="ientry-idm45564">GstTracerFactory, <a class="indexterm" href="GstTracerFactory.html#GstTracerFactory-struct">GstTracerFactory</a>
</dt>
<dt id="ientry-idm44894">GstTracerHookBinAddPost, <a class="indexterm" href="GstTracer.html#GstTracerHookBinAddPost">GstTracerHookBinAddPost ()</a>
</dt>
<dt id="ientry-idm44918">GstTracerHookBinAddPre, <a class="indexterm" href="GstTracer.html#GstTracerHookBinAddPre">GstTracerHookBinAddPre ()</a>
</dt>
<dt id="ientry-idm44939">GstTracerHookBinRemovePost, <a class="indexterm" href="GstTracer.html#GstTracerHookBinRemovePost">GstTracerHookBinRemovePost ()</a>
</dt>
<dt id="ientry-idm44960">GstTracerHookBinRemovePre, <a class="indexterm" href="GstTracer.html#GstTracerHookBinRemovePre">GstTracerHookBinRemovePre ()</a>
</dt>
<dt id="ientry-idm44981">GstTracerHookElementAddPad, <a class="indexterm" href="GstTracer.html#GstTracerHookElementAddPad">GstTracerHookElementAddPad ()</a>
</dt>
<dt id="ientry-idm45002">GstTracerHookElementChangeStatePost, <a class="indexterm" href="GstTracer.html#GstTracerHookElementChangeStatePost">GstTracerHookElementChangeStatePost ()</a>
</dt>
<dt id="ientry-idm45026">GstTracerHookElementChangeStatePre, <a class="indexterm" href="GstTracer.html#GstTracerHookElementChangeStatePre">GstTracerHookElementChangeStatePre ()</a>
</dt>
<dt id="ientry-idm45047">GstTracerHookElementNew, <a class="indexterm" href="GstTracer.html#GstTracerHookElementNew">GstTracerHookElementNew ()</a>
</dt>
<dt id="ientry-idm45065">GstTracerHookElementPostMessagePost, <a class="indexterm" href="GstTracer.html#GstTracerHookElementPostMessagePost">GstTracerHookElementPostMessagePost ()</a>
</dt>
<dt id="ientry-idm45086">GstTracerHookElementPostMessagePre, <a class="indexterm" href="GstTracer.html#GstTracerHookElementPostMessagePre">GstTracerHookElementPostMessagePre ()</a>
</dt>
<dt id="ientry-idm45107">GstTracerHookElementQueryPost, <a class="indexterm" href="GstTracer.html#GstTracerHookElementQueryPost">GstTracerHookElementQueryPost ()</a>
</dt>
<dt id="ientry-idm45131">GstTracerHookElementQueryPre, <a class="indexterm" href="GstTracer.html#GstTracerHookElementQueryPre">GstTracerHookElementQueryPre ()</a>
</dt>
<dt id="ientry-idm45152">GstTracerHookElementRemovePad, <a class="indexterm" href="GstTracer.html#GstTracerHookElementRemovePad">GstTracerHookElementRemovePad ()</a>
</dt>
<dt id="ientry-idm45173">GstTracerHookPadLinkPost, <a class="indexterm" href="GstTracer.html#GstTracerHookPadLinkPost">GstTracerHookPadLinkPost ()</a>
</dt>
<dt id="ientry-idm45197">GstTracerHookPadLinkPre, <a class="indexterm" href="GstTracer.html#GstTracerHookPadLinkPre">GstTracerHookPadLinkPre ()</a>
</dt>
<dt id="ientry-idm45218">GstTracerHookPadPullRangePost, <a class="indexterm" href="GstTracer.html#GstTracerHookPadPullRangePost">GstTracerHookPadPullRangePost ()</a>
</dt>
<dt id="ientry-idm45242">GstTracerHookPadPullRangePre, <a class="indexterm" href="GstTracer.html#GstTracerHookPadPullRangePre">GstTracerHookPadPullRangePre ()</a>
</dt>
<dt id="ientry-idm45266">GstTracerHookPadPushEventPost, <a class="indexterm" href="GstTracer.html#GstTracerHookPadPushEventPost">GstTracerHookPadPushEventPost ()</a>
</dt>
<dt id="ientry-idm45287">GstTracerHookPadPushEventPre, <a class="indexterm" href="GstTracer.html#GstTracerHookPadPushEventPre">GstTracerHookPadPushEventPre ()</a>
</dt>
<dt id="ientry-idm45308">GstTracerHookPadPushListPost, <a class="indexterm" href="GstTracer.html#GstTracerHookPadPushListPost">GstTracerHookPadPushListPost ()</a>
</dt>
<dt id="ientry-idm45329">GstTracerHookPadPushListPre, <a class="indexterm" href="GstTracer.html#GstTracerHookPadPushListPre">GstTracerHookPadPushListPre ()</a>
</dt>
<dt id="ientry-idm45350">GstTracerHookPadPushPost, <a class="indexterm" href="GstTracer.html#GstTracerHookPadPushPost">GstTracerHookPadPushPost ()</a>
</dt>
<dt id="ientry-idm45371">GstTracerHookPadPushPre, <a class="indexterm" href="GstTracer.html#GstTracerHookPadPushPre">GstTracerHookPadPushPre ()</a>
</dt>
<dt id="ientry-idm45392">GstTracerHookPadQueryPost, <a class="indexterm" href="GstTracer.html#GstTracerHookPadQueryPost">GstTracerHookPadQueryPost ()</a>
</dt>
<dt id="ientry-idm45416">GstTracerHookPadQueryPre, <a class="indexterm" href="GstTracer.html#GstTracerHookPadQueryPre">GstTracerHookPadQueryPre ()</a>
</dt>
<dt id="ientry-idm45437">GstTracerHookPadUnlinkPost, <a class="indexterm" href="GstTracer.html#GstTracerHookPadUnlinkPost">GstTracerHookPadUnlinkPost ()</a>
</dt>
<dt id="ientry-idm45461">GstTracerHookPadUnlinkPre, <a class="indexterm" href="GstTracer.html#GstTracerHookPadUnlinkPre">GstTracerHookPadUnlinkPre ()</a>
</dt>
<dt id="ientry-idm45660">GstTracerRecord, <a class="indexterm" href="GstTracerRecord.html#GstTracerRecord-struct">GstTracerRecord</a>
</dt>
<dt id="ientry-idm45665">GstTracerValueFlags, <a class="indexterm" href="GstTracerRecord.html#GstTracerValueFlags">enum GstTracerValueFlags</a>
</dt>
<dt id="ientry-idm45692">GstTracerValueScope, <a class="indexterm" href="GstTracerRecord.html#GstTracerValueScope">enum GstTracerValueScope</a>
</dt>
<dt id="ientry-idm37449">GstTypeFind, <a class="indexterm" href="gstreamer-GstTypeFind.html#GstTypeFind">struct GstTypeFind</a>
</dt>
<dt id="ientry-idm37629">GstTypeFindFactory, <a class="indexterm" href="GstTypeFindFactory.html#GstTypeFindFactory-struct">GstTypeFindFactory</a>
</dt>
<dt id="ientry-idm37339">GstTypeFindFunction, <a class="indexterm" href="gstreamer-GstTypeFind.html#GstTypeFindFunction">GstTypeFindFunction ()</a>
</dt>
<dt id="ientry-idm37454">GstTypeFindProbability, <a class="indexterm" href="gstreamer-GstTypeFind.html#GstTypeFindProbability">enum GstTypeFindProbability</a>
</dt>
<dt id="ientry-idm38505">GstUri, <a class="indexterm" href="gstreamer-GstUri.html#GstUri">GstUri</a>
</dt>
<dt id="ientry-idm38878">GstURIError, <a class="indexterm" href="gstreamer-GstUriHandler.html#GstURIError">enum GstURIError</a>
</dt>
<dt id="ientry-idm38841">GstURIHandler, <a class="indexterm" href="gstreamer-GstUriHandler.html#GstURIHandler-struct">GstURIHandler</a>
</dt>
<dt id="ientry-idm38846">GstURIHandlerInterface, <a class="indexterm" href="gstreamer-GstUriHandler.html#GstURIHandlerInterface">struct GstURIHandlerInterface</a>
</dt>
<dt id="ientry-idm38851">GstURIType, <a class="indexterm" href="gstreamer-GstUriHandler.html#GstURIType">enum GstURIType</a>
</dt>
<dt id="ientry-idm9102">GstValueArray, <a class="indexterm" href="GstControlSource.html#GstValueArray">GstValueArray</a>
</dt>
<dt id="ientry-idm41426">GstValueCompareFunc, <a class="indexterm" href="gstreamer-GstValue.html#GstValueCompareFunc">GstValueCompareFunc ()</a>
</dt>
<dt id="ientry-idm41453">GstValueDeserializeFunc, <a class="indexterm" href="gstreamer-GstValue.html#GstValueDeserializeFunc">GstValueDeserializeFunc ()</a>
</dt>
<dt id="ientry-idm41441">GstValueSerializeFunc, <a class="indexterm" href="gstreamer-GstValue.html#GstValueSerializeFunc">GstValueSerializeFunc ()</a>
</dt>
<dt id="ientry-idm41812">GstValueTable, <a class="indexterm" href="gstreamer-GstValue.html#GstValueTable">struct GstValueTable</a>
</dt>
<dt id="ientry-idm696">gst_allocation_params_copy, <a class="indexterm" href="GstAllocator.html#gst-allocation-params-copy">gst_allocation_params_copy ()</a>
</dt>
<dt id="ientry-idm706">gst_allocation_params_free, <a class="indexterm" href="GstAllocator.html#gst-allocation-params-free">gst_allocation_params_free ()</a>
</dt>
<dt id="ientry-idm686">gst_allocation_params_init, <a class="indexterm" href="GstAllocator.html#gst-allocation-params-init">gst_allocation_params_init ()</a>
</dt>
<dt id="ientry-idm716">gst_allocator_alloc, <a class="indexterm" href="GstAllocator.html#gst-allocator-alloc">gst_allocator_alloc ()</a>
</dt>
<dt id="ientry-idm653">gst_allocator_find, <a class="indexterm" href="GstAllocator.html#gst-allocator-find">gst_allocator_find ()</a>
</dt>
<dt id="ientry-idm732">gst_allocator_free, <a class="indexterm" href="GstAllocator.html#gst-allocator-free">gst_allocator_free ()</a>
</dt>
<dt id="ientry-idm663">gst_allocator_register, <a class="indexterm" href="GstAllocator.html#gst-allocator-register">gst_allocator_register ()</a>
</dt>
<dt id="ientry-idm676">gst_allocator_set_default, <a class="indexterm" href="GstAllocator.html#gst-allocator-set-default">gst_allocator_set_default ()</a>
</dt>
<dt id="ientry-idm817">GST_ALLOCATOR_SYSMEM, <a class="indexterm" href="GstAllocator.html#GST-ALLOCATOR-SYSMEM:CAPS">GST_ALLOCATOR_SYSMEM</a>
</dt>
<dt id="ientry-idm967">gst_atomic_queue_length, <a class="indexterm" href="gstreamer-GstAtomicQueue.html#gst-atomic-queue-length">gst_atomic_queue_length ()</a>
</dt>
<dt id="ientry-idm904">gst_atomic_queue_new, <a class="indexterm" href="gstreamer-GstAtomicQueue.html#gst-atomic-queue-new">gst_atomic_queue_new ()</a>
</dt>
<dt id="ientry-idm947">gst_atomic_queue_peek, <a class="indexterm" href="gstreamer-GstAtomicQueue.html#gst-atomic-queue-peek">gst_atomic_queue_peek ()</a>
</dt>
<dt id="ientry-idm957">gst_atomic_queue_pop, <a class="indexterm" href="gstreamer-GstAtomicQueue.html#gst-atomic-queue-pop">gst_atomic_queue_pop ()</a>
</dt>
<dt id="ientry-idm934">gst_atomic_queue_push, <a class="indexterm" href="gstreamer-GstAtomicQueue.html#gst-atomic-queue-push">gst_atomic_queue_push ()</a>
</dt>
<dt id="ientry-idm914">gst_atomic_queue_ref, <a class="indexterm" href="gstreamer-GstAtomicQueue.html#gst-atomic-queue-ref">gst_atomic_queue_ref ()</a>
</dt>
<dt id="ientry-idm924">gst_atomic_queue_unref, <a class="indexterm" href="gstreamer-GstAtomicQueue.html#gst-atomic-queue-unref">gst_atomic_queue_unref ()</a>
</dt>
<dt id="ientry-idm1261">gst_bin_add, <a class="indexterm" href="GstBin.html#gst-bin-add">gst_bin_add ()</a>
</dt>
<dt id="ientry-idm1399">gst_bin_add_many, <a class="indexterm" href="GstBin.html#gst-bin-add-many">gst_bin_add_many ()</a>
</dt>
<dt id="ientry-idm1455">GST_BIN_CHILDREN, <a class="indexterm" href="GstBin.html#GST-BIN-CHILDREN:CAPS">GST_BIN_CHILDREN()</a>
</dt>
<dt id="ientry-idm1460">GST_BIN_CHILDREN_COOKIE, <a class="indexterm" href="GstBin.html#GST-BIN-CHILDREN-COOKIE:CAPS">GST_BIN_CHILDREN_COOKIE()</a>
</dt>
<dt id="ientry-idm1427">gst_bin_find_unlinked_pad, <a class="indexterm" href="GstBin.html#gst-bin-find-unlinked-pad">gst_bin_find_unlinked_pad ()</a>
</dt>
<dt id="ientry-idm1313">gst_bin_get_by_interface, <a class="indexterm" href="GstBin.html#gst-bin-get-by-interface">gst_bin_get_by_interface ()</a>
</dt>
<dt id="ientry-idm1287">gst_bin_get_by_name, <a class="indexterm" href="GstBin.html#gst-bin-get-by-name">gst_bin_get_by_name ()</a>
</dt>
<dt id="ientry-idm1300">gst_bin_get_by_name_recurse_up, <a class="indexterm" href="GstBin.html#gst-bin-get-by-name-recurse-up">gst_bin_get_by_name_recurse_up ()</a>
</dt>
<dt id="ientry-idm1450">GST_BIN_IS_NO_RESYNC, <a class="indexterm" href="GstBin.html#GST-BIN-IS-NO-RESYNC:CAPS">GST_BIN_IS_NO_RESYNC()</a>
</dt>
<dt id="ientry-idm1376">gst_bin_iterate_all_by_interface, <a class="indexterm" href="GstBin.html#gst-bin-iterate-all-by-interface">gst_bin_iterate_all_by_interface ()</a>
</dt>
<dt id="ientry-idm1326">gst_bin_iterate_elements, <a class="indexterm" href="GstBin.html#gst-bin-iterate-elements">gst_bin_iterate_elements ()</a>
</dt>
<dt id="ientry-idm1336">gst_bin_iterate_recurse, <a class="indexterm" href="GstBin.html#gst-bin-iterate-recurse">gst_bin_iterate_recurse ()</a>
</dt>
<dt id="ientry-idm1346">gst_bin_iterate_sinks, <a class="indexterm" href="GstBin.html#gst-bin-iterate-sinks">gst_bin_iterate_sinks ()</a>
</dt>
<dt id="ientry-idm1356">gst_bin_iterate_sorted, <a class="indexterm" href="GstBin.html#gst-bin-iterate-sorted">gst_bin_iterate_sorted ()</a>
</dt>
<dt id="ientry-idm1366">gst_bin_iterate_sources, <a class="indexterm" href="GstBin.html#gst-bin-iterate-sources">gst_bin_iterate_sources ()</a>
</dt>
<dt id="ientry-idm1251">gst_bin_new, <a class="indexterm" href="GstBin.html#gst-bin-new">gst_bin_new ()</a>
</dt>
<dt id="ientry-idm1465">GST_BIN_NUMCHILDREN, <a class="indexterm" href="GstBin.html#GST-BIN-NUMCHILDREN:CAPS">GST_BIN_NUMCHILDREN()</a>
</dt>
<dt id="ientry-idm1389">gst_bin_recalculate_latency, <a class="indexterm" href="GstBin.html#gst-bin-recalculate-latency">gst_bin_recalculate_latency ()</a>
</dt>
<dt id="ientry-idm1274">gst_bin_remove, <a class="indexterm" href="GstBin.html#gst-bin-remove">gst_bin_remove ()</a>
</dt>
<dt id="ientry-idm1413">gst_bin_remove_many, <a class="indexterm" href="GstBin.html#gst-bin-remove-many">gst_bin_remove_many ()</a>
</dt>
<dt id="ientry-idm1440">gst_bin_sync_children_states, <a class="indexterm" href="GstBin.html#gst-bin-sync-children-states">gst_bin_sync_children_states ()</a>
</dt>
<dt id="ientry-idm2929">gst_buffer_add_meta, <a class="indexterm" href="GstBuffer.html#gst-buffer-add-meta">gst_buffer_add_meta ()</a>
</dt>
<dt id="ientry-idm3005">gst_buffer_add_parent_buffer_meta, <a class="indexterm" href="GstBuffer.html#gst-buffer-add-parent-buffer-meta">gst_buffer_add_parent_buffer_meta ()</a>
</dt>
<dt id="ientry-idm27700">gst_buffer_add_protection_meta, <a class="indexterm" href="gstreamer-GstProtectionMeta.html#gst-buffer-add-protection-meta">gst_buffer_add_protection_meta ()</a>
</dt>
<dt id="ientry-idm2884">gst_buffer_append, <a class="indexterm" href="GstBuffer.html#gst-buffer-append">gst_buffer_append ()</a>
</dt>
<dt id="ientry-idm2537">gst_buffer_append_memory, <a class="indexterm" href="GstBuffer.html#gst-buffer-append-memory">gst_buffer_append_memory ()</a>
</dt>
<dt id="ientry-idm2897">gst_buffer_append_region, <a class="indexterm" href="GstBuffer.html#gst-buffer-append-region">gst_buffer_append_region ()</a>
</dt>
<dt id="ientry-idm2800">gst_buffer_copy, <a class="indexterm" href="GstBuffer.html#gst-buffer-copy">gst_buffer_copy ()</a>
</dt>
<dt id="ientry-idm3164">GST_BUFFER_COPY_ALL, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-COPY-ALL:CAPS">GST_BUFFER_COPY_ALL</a>
</dt>
<dt id="ientry-idm2851">gst_buffer_copy_deep, <a class="indexterm" href="GstBuffer.html#gst-buffer-copy-deep">gst_buffer_copy_deep ()</a>
</dt>
<dt id="ientry-idm2810">gst_buffer_copy_into, <a class="indexterm" href="GstBuffer.html#gst-buffer-copy-into">gst_buffer_copy_into ()</a>
</dt>
<dt id="ientry-idm3159">GST_BUFFER_COPY_METADATA, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-COPY-METADATA:CAPS">GST_BUFFER_COPY_METADATA</a>
</dt>
<dt id="ientry-idm2832">gst_buffer_copy_region, <a class="indexterm" href="GstBuffer.html#gst-buffer-copy-region">gst_buffer_copy_region ()</a>
</dt>
<dt id="ientry-idm2160">GST_BUFFER_DTS, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-DTS:CAPS">GST_BUFFER_DTS()</a>
</dt>
<dt id="ientry-idm2195">GST_BUFFER_DTS_IS_VALID, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-DTS-IS-VALID:CAPS">GST_BUFFER_DTS_IS_VALID()</a>
</dt>
<dt id="ientry-idm2165">GST_BUFFER_DTS_OR_PTS, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-DTS-OR-PTS:CAPS">GST_BUFFER_DTS_OR_PTS()</a>
</dt>
<dt id="ientry-idm2170">GST_BUFFER_DURATION, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-DURATION:CAPS">GST_BUFFER_DURATION()</a>
</dt>
<dt id="ientry-idm2185">GST_BUFFER_DURATION_IS_VALID, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-DURATION-IS-VALID:CAPS">GST_BUFFER_DURATION_IS_VALID()</a>
</dt>
<dt id="ientry-idm2721">gst_buffer_extract, <a class="indexterm" href="GstBuffer.html#gst-buffer-extract">gst_buffer_extract ()</a>
</dt>
<dt id="ientry-idm2740">gst_buffer_extract_dup, <a class="indexterm" href="GstBuffer.html#gst-buffer-extract-dup">gst_buffer_extract_dup ()</a>
</dt>
<dt id="ientry-idm2762">gst_buffer_fill, <a class="indexterm" href="GstBuffer.html#gst-buffer-fill">gst_buffer_fill ()</a>
</dt>
<dt id="ientry-idm2499">gst_buffer_find_memory, <a class="indexterm" href="GstBuffer.html#gst-buffer-find-memory">gst_buffer_find_memory ()</a>
</dt>
<dt id="ientry-idm2135">GST_BUFFER_FLAGS, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-FLAGS:CAPS">GST_BUFFER_FLAGS()</a>
</dt>
<dt id="ientry-idm2140">GST_BUFFER_FLAG_IS_SET, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-FLAG-IS-SET:CAPS">GST_BUFFER_FLAG_IS_SET()</a>
</dt>
<dt id="ientry-idm2145">GST_BUFFER_FLAG_SET, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-FLAG-SET:CAPS">GST_BUFFER_FLAG_SET()</a>
</dt>
<dt id="ientry-idm2150">GST_BUFFER_FLAG_UNSET, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-FLAG-UNSET:CAPS">GST_BUFFER_FLAG_UNSET()</a>
</dt>
<dt id="ientry-idm2989">gst_buffer_foreach_meta, <a class="indexterm" href="GstBuffer.html#gst-buffer-foreach-meta">gst_buffer_foreach_meta ()</a>
</dt>
<dt id="ientry-idm2592">gst_buffer_get_all_memory, <a class="indexterm" href="GstBuffer.html#gst-buffer-get-all-memory">gst_buffer_get_all_memory ()</a>
</dt>
<dt id="ientry-idm2400">gst_buffer_get_max_memory, <a class="indexterm" href="GstBuffer.html#gst-buffer-get-max-memory">gst_buffer_get_max_memory ()</a>
</dt>
<dt id="ientry-idm2579">gst_buffer_get_memory, <a class="indexterm" href="GstBuffer.html#gst-buffer-get-memory">gst_buffer_get_memory ()</a>
</dt>
<dt id="ientry-idm2467">gst_buffer_get_memory_range, <a class="indexterm" href="GstBuffer.html#gst-buffer-get-memory-range">gst_buffer_get_memory_range ()</a>
</dt>
<dt id="ientry-idm2916">gst_buffer_get_meta, <a class="indexterm" href="GstBuffer.html#gst-buffer-get-meta">gst_buffer_get_meta ()</a>
</dt>
<dt id="ientry-idm3018">gst_buffer_get_parent_buffer_meta, <a class="indexterm" href="GstBuffer.html#gst-buffer-get-parent-buffer-meta">gst_buffer_get_parent_buffer_meta()</a>
</dt>
<dt id="ientry-idm27713">gst_buffer_get_protection_meta, <a class="indexterm" href="gstreamer-GstProtectionMeta.html#gst-buffer-get-protection-meta">gst_buffer_get_protection_meta()</a>
</dt>
<dt id="ientry-idm2317">gst_buffer_get_size, <a class="indexterm" href="GstBuffer.html#gst-buffer-get-size">gst_buffer_get_size ()</a>
</dt>
<dt id="ientry-idm2301">gst_buffer_get_sizes, <a class="indexterm" href="GstBuffer.html#gst-buffer-get-sizes">gst_buffer_get_sizes ()</a>
</dt>
<dt id="ientry-idm2327">gst_buffer_get_sizes_range, <a class="indexterm" href="GstBuffer.html#gst-buffer-get-sizes-range">gst_buffer_get_sizes_range ()</a>
</dt>
<dt id="ientry-idm2432">gst_buffer_insert_memory, <a class="indexterm" href="GstBuffer.html#gst-buffer-insert-memory">gst_buffer_insert_memory ()</a>
</dt>
<dt id="ientry-idm2625">gst_buffer_is_all_memory_writable, <a class="indexterm" href="GstBuffer.html#gst-buffer-is-all-memory-writable">gst_buffer_is_all_memory_writable ()</a>
</dt>
<dt id="ientry-idm2210">GST_BUFFER_IS_DISCONT, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-IS-DISCONT:CAPS">GST_BUFFER_IS_DISCONT()</a>
</dt>
<dt id="ientry-idm2635">gst_buffer_is_memory_range_writable, <a class="indexterm" href="GstBuffer.html#gst-buffer-is-memory-range-writable">gst_buffer_is_memory_range_writable ()</a>
</dt>
<dt id="ientry-idm2861">gst_buffer_is_writable, <a class="indexterm" href="GstBuffer.html#gst-buffer-is-writable">gst_buffer_is_writable()</a>
</dt>
<dt id="ientry-idm2958">gst_buffer_iterate_meta, <a class="indexterm" href="GstBuffer.html#gst-buffer-iterate-meta">gst_buffer_iterate_meta ()</a>
</dt>
<dt id="ientry-idm3342">gst_buffer_list_add, <a class="indexterm" href="GstBufferList.html#gst-buffer-list-add">gst_buffer_list_add()</a>
</dt>
<dt id="ientry-idm3399">gst_buffer_list_copy, <a class="indexterm" href="GstBufferList.html#gst-buffer-list-copy">gst_buffer_list_copy ()</a>
</dt>
<dt id="ientry-idm3409">gst_buffer_list_copy_deep, <a class="indexterm" href="GstBufferList.html#gst-buffer-list-copy-deep">gst_buffer_list_copy_deep ()</a>
</dt>
<dt id="ientry-idm3447">gst_buffer_list_foreach, <a class="indexterm" href="GstBufferList.html#gst-buffer-list-foreach">gst_buffer_list_foreach ()</a>
</dt>
<dt id="ientry-idm3463">gst_buffer_list_get, <a class="indexterm" href="GstBufferList.html#gst-buffer-list-get">gst_buffer_list_get ()</a>
</dt>
<dt id="ientry-idm3347">gst_buffer_list_insert, <a class="indexterm" href="GstBufferList.html#gst-buffer-list-insert">gst_buffer_list_insert ()</a>
</dt>
<dt id="ientry-idm3419">gst_buffer_list_is_writable, <a class="indexterm" href="GstBufferList.html#gst-buffer-list-is-writable">gst_buffer_list_is_writable()</a>
</dt>
<dt id="ientry-idm3332">gst_buffer_list_length, <a class="indexterm" href="GstBufferList.html#gst-buffer-list-length">gst_buffer_list_length ()</a>
</dt>
<dt id="ientry-idm3424">gst_buffer_list_make_writable, <a class="indexterm" href="GstBufferList.html#gst-buffer-list-make-writable">gst_buffer_list_make_writable()</a>
</dt>
<dt id="ientry-idm3313">gst_buffer_list_new, <a class="indexterm" href="GstBufferList.html#gst-buffer-list-new">gst_buffer_list_new ()</a>
</dt>
<dt id="ientry-idm3322">gst_buffer_list_new_sized, <a class="indexterm" href="GstBufferList.html#gst-buffer-list-new-sized">gst_buffer_list_new_sized ()</a>
</dt>
<dt id="ientry-idm3379">gst_buffer_list_ref, <a class="indexterm" href="GstBufferList.html#gst-buffer-list-ref">gst_buffer_list_ref ()</a>
</dt>
<dt id="ientry-idm3363">gst_buffer_list_remove, <a class="indexterm" href="GstBufferList.html#gst-buffer-list-remove">gst_buffer_list_remove ()</a>
</dt>
<dt id="ientry-idm3389">gst_buffer_list_unref, <a class="indexterm" href="GstBufferList.html#gst-buffer-list-unref">gst_buffer_list_unref ()</a>
</dt>
<dt id="ientry-idm2866">gst_buffer_make_writable, <a class="indexterm" href="GstBuffer.html#gst-buffer-make-writable">gst_buffer_make_writable()</a>
</dt>
<dt id="ientry-idm2651">gst_buffer_map, <a class="indexterm" href="GstBuffer.html#gst-buffer-map">gst_buffer_map ()</a>
</dt>
<dt id="ientry-idm2667">gst_buffer_map_range, <a class="indexterm" href="GstBuffer.html#gst-buffer-map-range">gst_buffer_map_range ()</a>
</dt>
<dt id="ientry-idm2702">gst_buffer_memcmp, <a class="indexterm" href="GstBuffer.html#gst-buffer-memcmp">gst_buffer_memcmp ()</a>
</dt>
<dt id="ientry-idm2781">gst_buffer_memset, <a class="indexterm" href="GstBuffer.html#gst-buffer-memset">gst_buffer_memset ()</a>
</dt>
<dt id="ientry-idm2215">gst_buffer_new, <a class="indexterm" href="GstBuffer.html#gst-buffer-new">gst_buffer_new ()</a>
</dt>
<dt id="ientry-idm2224">gst_buffer_new_allocate, <a class="indexterm" href="GstBuffer.html#gst-buffer-new-allocate">gst_buffer_new_allocate ()</a>
</dt>
<dt id="ientry-idm2240">gst_buffer_new_wrapped, <a class="indexterm" href="GstBuffer.html#gst-buffer-new-wrapped">gst_buffer_new_wrapped ()</a>
</dt>
<dt id="ientry-idm2253">gst_buffer_new_wrapped_full, <a class="indexterm" href="GstBuffer.html#gst-buffer-new-wrapped-full">gst_buffer_new_wrapped_full ()</a>
</dt>
<dt id="ientry-idm2422">gst_buffer_n_memory, <a class="indexterm" href="GstBuffer.html#gst-buffer-n-memory">gst_buffer_n_memory ()</a>
</dt>
<dt id="ientry-idm2175">GST_BUFFER_OFFSET, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-OFFSET:CAPS">GST_BUFFER_OFFSET()</a>
</dt>
<dt id="ientry-idm2180">GST_BUFFER_OFFSET_END, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-OFFSET-END:CAPS">GST_BUFFER_OFFSET_END()</a>
</dt>
<dt id="ientry-idm2205">GST_BUFFER_OFFSET_END_IS_VALID, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-OFFSET-END-IS-VALID:CAPS">GST_BUFFER_OFFSET_END_IS_VALID()</a>
</dt>
<dt id="ientry-idm2200">GST_BUFFER_OFFSET_IS_VALID, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-OFFSET-IS-VALID:CAPS">GST_BUFFER_OFFSET_IS_VALID()</a>
</dt>
<dt id="ientry-idm3107">GST_BUFFER_OFFSET_NONE, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-OFFSET-NONE:CAPS">GST_BUFFER_OFFSET_NONE</a>
</dt>
<dt id="ientry-idm2409">gst_buffer_peek_memory, <a class="indexterm" href="GstBuffer.html#gst-buffer-peek-memory">gst_buffer_peek_memory ()</a>
</dt>
<dt id="ientry-idm3918">gst_buffer_pool_acquire_buffer, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-acquire-buffer">gst_buffer_pool_acquire_buffer ()</a>
</dt>
<dt id="ientry-idm3797">gst_buffer_pool_config_add_option, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-config-add-option">gst_buffer_pool_config_add_option ()</a>
</dt>
<dt id="ientry-idm3755">gst_buffer_pool_config_get_allocator, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-config-get-allocator">gst_buffer_pool_config_get_allocator ()</a>
</dt>
<dt id="ientry-idm3810">gst_buffer_pool_config_get_option, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-config-get-option">gst_buffer_pool_config_get_option ()</a>
</dt>
<dt id="ientry-idm3689">gst_buffer_pool_config_get_params, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-config-get-params">gst_buffer_pool_config_get_params ()</a>
</dt>
<dt id="ientry-idm3823">gst_buffer_pool_config_has_option, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-config-has-option">gst_buffer_pool_config_has_option ()</a>
</dt>
<dt id="ientry-idm3787">gst_buffer_pool_config_n_options, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-config-n-options">gst_buffer_pool_config_n_options ()</a>
</dt>
<dt id="ientry-idm3771">gst_buffer_pool_config_set_allocator, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-config-set-allocator">gst_buffer_pool_config_set_allocator ()</a>
</dt>
<dt id="ientry-idm3711">gst_buffer_pool_config_set_params, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-config-set-params">gst_buffer_pool_config_set_params ()</a>
</dt>
<dt id="ientry-idm3733">gst_buffer_pool_config_validate_params, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-config-validate-params">gst_buffer_pool_config_validate_params ()</a>
</dt>
<dt id="ientry-idm3859">gst_buffer_pool_get_config, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-get-config">gst_buffer_pool_get_config ()</a>
</dt>
<dt id="ientry-idm3836">gst_buffer_pool_get_options, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-get-options">gst_buffer_pool_get_options ()</a>
</dt>
<dt id="ientry-idm3846">gst_buffer_pool_has_option, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-has-option">gst_buffer_pool_has_option ()</a>
</dt>
<dt id="ientry-idm3895">gst_buffer_pool_is_active, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-is-active">gst_buffer_pool_is_active ()</a>
</dt>
<dt id="ientry-idm3675">GST_BUFFER_POOL_IS_FLUSHING, <a class="indexterm" href="GstBufferPool.html#GST-BUFFER-POOL-IS-FLUSHING:CAPS">GST_BUFFER_POOL_IS_FLUSHING()</a>
</dt>
<dt id="ientry-idm3680">gst_buffer_pool_new, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-new">gst_buffer_pool_new ()</a>
</dt>
<dt id="ientry-idm3934">gst_buffer_pool_release_buffer, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-release-buffer">gst_buffer_pool_release_buffer ()</a>
</dt>
<dt id="ientry-idm3882">gst_buffer_pool_set_active, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-set-active">gst_buffer_pool_set_active ()</a>
</dt>
<dt id="ientry-idm3869">gst_buffer_pool_set_config, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-set-config">gst_buffer_pool_set_config ()</a>
</dt>
<dt id="ientry-idm3905">gst_buffer_pool_set_flushing, <a class="indexterm" href="GstBufferPool.html#gst-buffer-pool-set-flushing">gst_buffer_pool_set_flushing ()</a>
</dt>
<dt id="ientry-idm2524">gst_buffer_prepend_memory, <a class="indexterm" href="GstBuffer.html#gst-buffer-prepend-memory">gst_buffer_prepend_memory ()</a>
</dt>
<dt id="ientry-idm2155">GST_BUFFER_PTS, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-PTS:CAPS">GST_BUFFER_PTS()</a>
</dt>
<dt id="ientry-idm2190">GST_BUFFER_PTS_IS_VALID, <a class="indexterm" href="GstBuffer.html#GST-BUFFER-PTS-IS-VALID:CAPS">GST_BUFFER_PTS_IS_VALID()</a>
</dt>
<dt id="ientry-idm2281">gst_buffer_ref, <a class="indexterm" href="GstBuffer.html#gst-buffer-ref">gst_buffer_ref ()</a>
</dt>
<dt id="ientry-idm2615">gst_buffer_remove_all_memory, <a class="indexterm" href="GstBuffer.html#gst-buffer-remove-all-memory">gst_buffer_remove_all_memory ()</a>
</dt>
<dt id="ientry-idm2602">gst_buffer_remove_memory, <a class="indexterm" href="GstBuffer.html#gst-buffer-remove-memory">gst_buffer_remove_memory ()</a>
</dt>
<dt id="ientry-idm2483">gst_buffer_remove_memory_range, <a class="indexterm" href="GstBuffer.html#gst-buffer-remove-memory-range">gst_buffer_remove_memory_range ()</a>
</dt>
<dt id="ientry-idm2945">gst_buffer_remove_meta, <a class="indexterm" href="GstBuffer.html#gst-buffer-remove-meta">gst_buffer_remove_meta ()</a>
</dt>
<dt id="ientry-idm2871">gst_buffer_replace, <a class="indexterm" href="GstBuffer.html#gst-buffer-replace">gst_buffer_replace ()</a>
</dt>
<dt id="ientry-idm2566">gst_buffer_replace_all_memory, <a class="indexterm" href="GstBuffer.html#gst-buffer-replace-all-memory">gst_buffer_replace_all_memory ()</a>
</dt>
<dt id="ientry-idm2550">gst_buffer_replace_memory, <a class="indexterm" href="GstBuffer.html#gst-buffer-replace-memory">gst_buffer_replace_memory ()</a>
</dt>
<dt id="ientry-idm2448">gst_buffer_replace_memory_range, <a class="indexterm" href="GstBuffer.html#gst-buffer-replace-memory-range">gst_buffer_replace_memory_range ()</a>
</dt>
<dt id="ientry-idm2371">gst_buffer_resize, <a class="indexterm" href="GstBuffer.html#gst-buffer-resize">gst_buffer_resize ()</a>
</dt>
<dt id="ientry-idm2349">gst_buffer_resize_range, <a class="indexterm" href="GstBuffer.html#gst-buffer-resize-range">gst_buffer_resize_range ()</a>
</dt>
<dt id="ientry-idm2387">gst_buffer_set_size, <a class="indexterm" href="GstBuffer.html#gst-buffer-set-size">gst_buffer_set_size ()</a>
</dt>
<dt id="ientry-idm2689">gst_buffer_unmap, <a class="indexterm" href="GstBuffer.html#gst-buffer-unmap">gst_buffer_unmap ()</a>
</dt>
<dt id="ientry-idm2291">gst_buffer_unref, <a class="indexterm" href="GstBuffer.html#gst-buffer-unref">gst_buffer_unref ()</a>
</dt>
<dt id="ientry-idm4534">gst_bus_add_signal_watch, <a class="indexterm" href="GstBus.html#gst-bus-add-signal-watch">gst_bus_add_signal_watch ()</a>
</dt>
<dt id="ientry-idm4544">gst_bus_add_signal_watch_full, <a class="indexterm" href="GstBus.html#gst-bus-add-signal-watch-full">gst_bus_add_signal_watch_full ()</a>
</dt>
<dt id="ientry-idm4472">gst_bus_add_watch, <a class="indexterm" href="GstBus.html#gst-bus-add-watch">gst_bus_add_watch ()</a>
</dt>
<dt id="ientry-idm4450">gst_bus_add_watch_full, <a class="indexterm" href="GstBus.html#gst-bus-add-watch-full">gst_bus_add_watch_full ()</a>
</dt>
<dt id="ientry-idm4518">gst_bus_async_signal_func, <a class="indexterm" href="GstBus.html#gst-bus-async-signal-func">gst_bus_async_signal_func ()</a>
</dt>
<dt id="ientry-idm4440">gst_bus_create_watch, <a class="indexterm" href="GstBus.html#gst-bus-create-watch">gst_bus_create_watch ()</a>
</dt>
<dt id="ientry-idm4498">gst_bus_disable_sync_message_emission, <a class="indexterm" href="GstBus.html#gst-bus-disable-sync-message-emission">gst_bus_disable_sync_message_emission ()</a>
</dt>
<dt id="ientry-idm4508">gst_bus_enable_sync_message_emission, <a class="indexterm" href="GstBus.html#gst-bus-enable-sync-message-emission">gst_bus_enable_sync_message_emission ()</a>
</dt>
<dt id="ientry-idm4320">gst_bus_have_pending, <a class="indexterm" href="GstBus.html#gst-bus-have-pending">gst_bus_have_pending ()</a>
</dt>
<dt id="ientry-idm4298">gst_bus_new, <a class="indexterm" href="GstBus.html#gst-bus-new">gst_bus_new ()</a>
</dt>
<dt id="ientry-idm4330">gst_bus_peek, <a class="indexterm" href="GstBus.html#gst-bus-peek">gst_bus_peek ()</a>
</dt>
<dt id="ientry-idm4567">gst_bus_poll, <a class="indexterm" href="GstBus.html#gst-bus-poll">gst_bus_poll ()</a>
</dt>
<dt id="ientry-idm4340">gst_bus_pop, <a class="indexterm" href="GstBus.html#gst-bus-pop">gst_bus_pop ()</a>
</dt>
<dt id="ientry-idm4350">gst_bus_pop_filtered, <a class="indexterm" href="GstBus.html#gst-bus-pop-filtered">gst_bus_pop_filtered ()</a>
</dt>
<dt id="ientry-idm4307">gst_bus_post, <a class="indexterm" href="GstBus.html#gst-bus-post">gst_bus_post ()</a>
</dt>
<dt id="ientry-idm4557">gst_bus_remove_signal_watch, <a class="indexterm" href="GstBus.html#gst-bus-remove-signal-watch">gst_bus_remove_signal_watch ()</a>
</dt>
<dt id="ientry-idm4488">gst_bus_remove_watch, <a class="indexterm" href="GstBus.html#gst-bus-remove-watch">gst_bus_remove_watch ()</a>
</dt>
<dt id="ientry-idm4392">gst_bus_set_flushing, <a class="indexterm" href="GstBus.html#gst-bus-set-flushing">gst_bus_set_flushing ()</a>
</dt>
<dt id="ientry-idm4405">gst_bus_set_sync_handler, <a class="indexterm" href="GstBus.html#gst-bus-set-sync-handler">gst_bus_set_sync_handler ()</a>
</dt>
<dt id="ientry-idm4424">gst_bus_sync_signal_handler, <a class="indexterm" href="GstBus.html#gst-bus-sync-signal-handler">gst_bus_sync_signal_handler ()</a>
</dt>
<dt id="ientry-idm4363">gst_bus_timed_pop, <a class="indexterm" href="GstBus.html#gst-bus-timed-pop">gst_bus_timed_pop ()</a>
</dt>
<dt id="ientry-idm4376">gst_bus_timed_pop_filtered, <a class="indexterm" href="GstBus.html#gst-bus-timed-pop-filtered">gst_bus_timed_pop_filtered ()</a>
</dt>
<dt id="ientry-idm39395">GST_CALL_PARENT, <a class="indexterm" href="gstreamer-GstUtils.html#GST-CALL-PARENT:CAPS">GST_CALL_PARENT()</a>
</dt>
<dt id="ientry-idm39400">GST_CALL_PARENT_WITH_DEFAULT, <a class="indexterm" href="gstreamer-GstUtils.html#GST-CALL-PARENT-WITH-DEFAULT:CAPS">GST_CALL_PARENT_WITH_DEFAULT()</a>
</dt>
<dt id="ientry-idm5998">GST_CAPS_ANY, <a class="indexterm" href="GstCaps.html#GST-CAPS-ANY:CAPS">GST_CAPS_ANY</a>
</dt>
<dt id="ientry-idm5401">gst_caps_append, <a class="indexterm" href="GstCaps.html#gst-caps-append">gst_caps_append ()</a>
</dt>
<dt id="ientry-idm5427">gst_caps_append_structure, <a class="indexterm" href="GstCaps.html#gst-caps-append-structure">gst_caps_append_structure ()</a>
</dt>
<dt id="ientry-idm5440">gst_caps_append_structure_full, <a class="indexterm" href="GstCaps.html#gst-caps-append-structure-full">gst_caps_append_structure_full ()</a>
</dt>
<dt id="ientry-idm5781">gst_caps_can_intersect, <a class="indexterm" href="GstCaps.html#gst-caps-can-intersect">gst_caps_can_intersect ()</a>
</dt>
<dt id="ientry-idm5358">gst_caps_copy, <a class="indexterm" href="GstCaps.html#gst-caps-copy">gst_caps_copy ()</a>
</dt>
<dt id="ientry-idm5368">gst_caps_copy_nth, <a class="indexterm" href="GstCaps.html#gst-caps-copy-nth">gst_caps_copy_nth ()</a>
</dt>
<dt id="ientry-idm6426">gst_caps_features_add, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-add">gst_caps_features_add ()</a>
</dt>
<dt id="ientry-idm6439">gst_caps_features_add_id, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-add-id">gst_caps_features_add_id ()</a>
</dt>
<dt id="ientry-idm6485">GST_CAPS_FEATURES_ANY, <a class="indexterm" href="GstCapsFeatures.html#GST-CAPS-FEATURES-ANY:CAPS">GST_CAPS_FEATURES_ANY</a>
</dt>
<dt id="ientry-idm6364">gst_caps_features_contains, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-contains">gst_caps_features_contains ()</a>
</dt>
<dt id="ientry-idm6377">gst_caps_features_contains_id, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-contains-id">gst_caps_features_contains_id ()</a>
</dt>
<dt id="ientry-idm6288">gst_caps_features_copy, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-copy">gst_caps_features_copy ()</a>
</dt>
<dt id="ientry-idm6298">gst_caps_features_free, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-free">gst_caps_features_free ()</a>
</dt>
<dt id="ientry-idm6308">gst_caps_features_from_string, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-from-string">gst_caps_features_from_string ()</a>
</dt>
<dt id="ientry-idm6400">gst_caps_features_get_nth, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-get-nth">gst_caps_features_get_nth ()</a>
</dt>
<dt id="ientry-idm6413">gst_caps_features_get_nth_id, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-get-nth-id">gst_caps_features_get_nth_id ()</a>
</dt>
<dt id="ientry-idm6390">gst_caps_features_get_size, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-get-size">gst_caps_features_get_size ()</a>
</dt>
<dt id="ientry-idm6354">gst_caps_features_is_any, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-is-any">gst_caps_features_is_any ()</a>
</dt>
<dt id="ientry-idm6341">gst_caps_features_is_equal, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-is-equal">gst_caps_features_is_equal ()</a>
</dt>
<dt id="ientry-idm6490">GST_CAPS_FEATURES_MEMORY_SYSTEM_MEMORY, <a class="indexterm" href="GstCapsFeatures.html#GST-CAPS-FEATURES-MEMORY-SYSTEM-MEMORY:CAPS">GST_CAPS_FEATURES_MEMORY_SYSTEM_MEMORY</a>
</dt>
<dt id="ientry-idm6222">gst_caps_features_new, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-new">gst_caps_features_new ()</a>
</dt>
<dt id="ientry-idm6242">gst_caps_features_new_any, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-new-any">gst_caps_features_new_any ()</a>
</dt>
<dt id="ientry-idm6233">gst_caps_features_new_empty, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-new-empty">gst_caps_features_new_empty ()</a>
</dt>
<dt id="ientry-idm6251">gst_caps_features_new_id, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-new-id">gst_caps_features_new_id ()</a>
</dt>
<dt id="ientry-idm6262">gst_caps_features_new_id_valist, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-new-id-valist">gst_caps_features_new_id_valist ()</a>
</dt>
<dt id="ientry-idm6275">gst_caps_features_new_valist, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-new-valist">gst_caps_features_new_valist ()</a>
</dt>
<dt id="ientry-idm6452">gst_caps_features_remove, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-remove">gst_caps_features_remove ()</a>
</dt>
<dt id="ientry-idm6465">gst_caps_features_remove_id, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-remove-id">gst_caps_features_remove_id ()</a>
</dt>
<dt id="ientry-idm6328">gst_caps_features_set_parent_refcount, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-set-parent-refcount">gst_caps_features_set_parent_refcount ()</a>
</dt>
<dt id="ientry-idm6318">gst_caps_features_to_string, <a class="indexterm" href="GstCapsFeatures.html#gst-caps-features-to-string">gst_caps_features_to_string ()</a>
</dt>
<dt id="ientry-idm6495">GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY, <a class="indexterm" href="GstCapsFeatures.html#GST-CAPS-FEATURE-MEMORY-SYSTEM-MEMORY:CAPS">GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY</a>
</dt>
<dt id="ientry-idm5641">gst_caps_filter_and_map_in_place, <a class="indexterm" href="GstCaps.html#gst-caps-filter-and-map-in-place">gst_caps_filter_and_map_in_place ()</a>
</dt>
<dt id="ientry-idm5917">gst_caps_fixate, <a class="indexterm" href="GstCaps.html#gst-caps-fixate">gst_caps_fixate ()</a>
</dt>
<dt id="ientry-idm5213">GST_CAPS_FLAGS, <a class="indexterm" href="GstCaps.html#GST-CAPS-FLAGS:CAPS">GST_CAPS_FLAGS()</a>
</dt>
<dt id="ientry-idm5218">GST_CAPS_FLAG_IS_SET, <a class="indexterm" href="GstCaps.html#GST-CAPS-FLAG-IS-SET:CAPS">GST_CAPS_FLAG_IS_SET()</a>
</dt>
<dt id="ientry-idm5223">GST_CAPS_FLAG_SET, <a class="indexterm" href="GstCaps.html#GST-CAPS-FLAG-SET:CAPS">GST_CAPS_FLAG_SET()</a>
</dt>
<dt id="ientry-idm5228">GST_CAPS_FLAG_UNSET, <a class="indexterm" href="GstCaps.html#GST-CAPS-FLAG-UNSET:CAPS">GST_CAPS_FLAG_UNSET()</a>
</dt>
<dt id="ientry-idm5609">gst_caps_foreach, <a class="indexterm" href="GstCaps.html#gst-caps-foreach">gst_caps_foreach ()</a>
</dt>
<dt id="ientry-idm5879">gst_caps_from_string, <a class="indexterm" href="GstCaps.html#gst-caps-from-string">gst_caps_from_string ()</a>
</dt>
<dt id="ientry-idm5534">gst_caps_get_features, <a class="indexterm" href="GstCaps.html#gst-caps-get-features">gst_caps_get_features ()</a>
</dt>
<dt id="ientry-idm5511">gst_caps_get_size, <a class="indexterm" href="GstCaps.html#gst-caps-get-size">gst_caps_get_size ()</a>
</dt>
<dt id="ientry-idm5521">gst_caps_get_structure, <a class="indexterm" href="GstCaps.html#gst-caps-get-structure">gst_caps_get_structure ()</a>
</dt>
<dt id="ientry-idm5794">gst_caps_intersect, <a class="indexterm" href="GstCaps.html#gst-caps-intersect">gst_caps_intersect ()</a>
</dt>
<dt id="ientry-idm5807">gst_caps_intersect_full, <a class="indexterm" href="GstCaps.html#gst-caps-intersect-full">gst_caps_intersect_full ()</a>
</dt>
<dt id="ientry-idm5726">gst_caps_is_always_compatible, <a class="indexterm" href="GstCaps.html#gst-caps-is-always-compatible">gst_caps_is_always_compatible ()</a>
</dt>
<dt id="ientry-idm5657">gst_caps_is_any, <a class="indexterm" href="GstCaps.html#gst-caps-is-any">gst_caps_is_any ()</a>
</dt>
<dt id="ientry-idm5667">gst_caps_is_empty, <a class="indexterm" href="GstCaps.html#gst-caps-is-empty">gst_caps_is_empty ()</a>
</dt>
<dt id="ientry-idm5687">gst_caps_is_equal, <a class="indexterm" href="GstCaps.html#gst-caps-is-equal">gst_caps_is_equal ()</a>
</dt>
<dt id="ientry-idm5700">gst_caps_is_equal_fixed, <a class="indexterm" href="GstCaps.html#gst-caps-is-equal-fixed">gst_caps_is_equal_fixed ()</a>
</dt>
<dt id="ientry-idm5677">gst_caps_is_fixed, <a class="indexterm" href="GstCaps.html#gst-caps-is-fixed">gst_caps_is_fixed ()</a>
</dt>
<dt id="ientry-idm5203">GST_CAPS_IS_SIMPLE, <a class="indexterm" href="GstCaps.html#GST-CAPS-IS-SIMPLE:CAPS">GST_CAPS_IS_SIMPLE()</a>
</dt>
<dt id="ientry-idm5713">gst_caps_is_strictly_equal, <a class="indexterm" href="GstCaps.html#gst-caps-is-strictly-equal">gst_caps_is_strictly_equal ()</a>
</dt>
<dt id="ientry-idm5739">gst_caps_is_subset, <a class="indexterm" href="GstCaps.html#gst-caps-is-subset">gst_caps_is_subset ()</a>
</dt>
<dt id="ientry-idm5752">gst_caps_is_subset_structure, <a class="indexterm" href="GstCaps.html#gst-caps-is-subset-structure">gst_caps_is_subset_structure ()</a>
</dt>
<dt id="ientry-idm5765">gst_caps_is_subset_structure_full, <a class="indexterm" href="GstCaps.html#gst-caps-is-subset-structure-full">gst_caps_is_subset_structure_full ()</a>
</dt>
<dt id="ientry-idm5353">gst_caps_is_writable, <a class="indexterm" href="GstCaps.html#gst-caps-is-writable">gst_caps_is_writable()</a>
</dt>
<dt id="ientry-idm5902">gst_caps_make_writable, <a class="indexterm" href="GstCaps.html#gst-caps-make-writable">gst_caps_make_writable()</a>
</dt>
<dt id="ientry-idm5625">gst_caps_map_in_place, <a class="indexterm" href="GstCaps.html#gst-caps-map-in-place">gst_caps_map_in_place ()</a>
</dt>
<dt id="ientry-idm5414">gst_caps_merge, <a class="indexterm" href="GstCaps.html#gst-caps-merge">gst_caps_merge ()</a>
</dt>
<dt id="ientry-idm5482">gst_caps_merge_structure, <a class="indexterm" href="GstCaps.html#gst-caps-merge-structure">gst_caps_merge_structure ()</a>
</dt>
<dt id="ientry-idm5495">gst_caps_merge_structure_full, <a class="indexterm" href="GstCaps.html#gst-caps-merge-structure-full">gst_caps_merge_structure_full ()</a>
</dt>
<dt id="ientry-idm5306">gst_caps_new_any, <a class="indexterm" href="GstCaps.html#gst-caps-new-any">gst_caps_new_any ()</a>
</dt>
<dt id="ientry-idm5287">gst_caps_new_empty, <a class="indexterm" href="GstCaps.html#gst-caps-new-empty">gst_caps_new_empty ()</a>
</dt>
<dt id="ientry-idm5296">gst_caps_new_empty_simple, <a class="indexterm" href="GstCaps.html#gst-caps-new-empty-simple">gst_caps_new_empty_simple ()</a>
</dt>
<dt id="ientry-idm5329">gst_caps_new_full, <a class="indexterm" href="GstCaps.html#gst-caps-new-full">gst_caps_new_full ()</a>
</dt>
<dt id="ientry-idm5340">gst_caps_new_full_valist, <a class="indexterm" href="GstCaps.html#gst-caps-new-full-valist">gst_caps_new_full_valist ()</a>
</dt>
<dt id="ientry-idm5315">gst_caps_new_simple, <a class="indexterm" href="GstCaps.html#gst-caps-new-simple">gst_caps_new_simple ()</a>
</dt>
<dt id="ientry-idm6003">GST_CAPS_NONE, <a class="indexterm" href="GstCaps.html#GST-CAPS-NONE:CAPS">GST_CAPS_NONE</a>
</dt>
<dt id="ientry-idm5823">gst_caps_normalize, <a class="indexterm" href="GstCaps.html#gst-caps-normalize">gst_caps_normalize ()</a>
</dt>
<dt id="ientry-idm5927">gst_caps_ref, <a class="indexterm" href="GstCaps.html#gst-caps-ref">gst_caps_ref ()</a>
</dt>
<dt id="ientry-idm5193">GST_CAPS_REFCOUNT, <a class="indexterm" href="GstCaps.html#GST-CAPS-REFCOUNT:CAPS">GST_CAPS_REFCOUNT()</a>
</dt>
<dt id="ientry-idm5198">GST_CAPS_REFCOUNT_VALUE, <a class="indexterm" href="GstCaps.html#GST-CAPS-REFCOUNT-VALUE:CAPS">GST_CAPS_REFCOUNT_VALUE()</a>
</dt>
<dt id="ientry-idm5456">gst_caps_remove_structure, <a class="indexterm" href="GstCaps.html#gst-caps-remove-structure">gst_caps_remove_structure ()</a>
</dt>
<dt id="ientry-idm5843">gst_caps_replace, <a class="indexterm" href="GstCaps.html#gst-caps-replace">gst_caps_replace ()</a>
</dt>
<dt id="ientry-idm5547">gst_caps_set_features, <a class="indexterm" href="GstCaps.html#gst-caps-set-features">gst_caps_set_features ()</a>
</dt>
<dt id="ientry-idm5579">gst_caps_set_simple, <a class="indexterm" href="GstCaps.html#gst-caps-set-simple">gst_caps_set_simple ()</a>
</dt>
<dt id="ientry-idm5593">gst_caps_set_simple_valist, <a class="indexterm" href="GstCaps.html#gst-caps-set-simple-valist">gst_caps_set_simple_valist ()</a>
</dt>
<dt id="ientry-idm5563">gst_caps_set_value, <a class="indexterm" href="GstCaps.html#gst-caps-set-value">gst_caps_set_value ()</a>
</dt>
<dt id="ientry-idm5833">gst_caps_simplify, <a class="indexterm" href="GstCaps.html#gst-caps-simplify">gst_caps_simplify ()</a>
</dt>
<dt id="ientry-idm5469">gst_caps_steal_structure, <a class="indexterm" href="GstCaps.html#gst-caps-steal-structure">gst_caps_steal_structure ()</a>
</dt>
<dt id="ientry-idm5889">gst_caps_subtract, <a class="indexterm" href="GstCaps.html#gst-caps-subtract">gst_caps_subtract ()</a>
</dt>
<dt id="ientry-idm5856">gst_caps_take, <a class="indexterm" href="GstCaps.html#gst-caps-take">gst_caps_take ()</a>
</dt>
<dt id="ientry-idm5869">gst_caps_to_string, <a class="indexterm" href="GstCaps.html#gst-caps-to-string">gst_caps_to_string ()</a>
</dt>
<dt id="ientry-idm5907">gst_caps_truncate, <a class="indexterm" href="GstCaps.html#gst-caps-truncate">gst_caps_truncate ()</a>
</dt>
<dt id="ientry-idm5937">gst_caps_unref, <a class="indexterm" href="GstCaps.html#gst-caps-unref">gst_caps_unref ()</a>
</dt>
<dt id="ientry-idm44029">GST_CAT_DEBUG, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-DEBUG:CAPS">GST_CAT_DEBUG()</a>
</dt>
<dt id="ientry-idm43989">GST_CAT_DEBUG_OBJECT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-DEBUG-OBJECT:CAPS">GST_CAT_DEBUG_OBJECT()</a>
</dt>
<dt id="ientry-idm44523">GST_CAT_DEFAULT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-DEFAULT:CAPS">GST_CAT_DEFAULT</a>
</dt>
<dt id="ientry-idm44014">GST_CAT_ERROR, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-ERROR:CAPS">GST_CAT_ERROR()</a>
</dt>
<dt id="ientry-idm43974">GST_CAT_ERROR_OBJECT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-ERROR-OBJECT:CAPS">GST_CAT_ERROR_OBJECT()</a>
</dt>
<dt id="ientry-idm44039">GST_CAT_FIXME, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-FIXME:CAPS">GST_CAT_FIXME()</a>
</dt>
<dt id="ientry-idm43999">GST_CAT_FIXME_OBJECT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-FIXME-OBJECT:CAPS">GST_CAT_FIXME_OBJECT()</a>
</dt>
<dt id="ientry-idm44024">GST_CAT_INFO, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-INFO:CAPS">GST_CAT_INFO()</a>
</dt>
<dt id="ientry-idm43984">GST_CAT_INFO_OBJECT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-INFO-OBJECT:CAPS">GST_CAT_INFO_OBJECT()</a>
</dt>
<dt id="ientry-idm43969">GST_CAT_LEVEL_LOG, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-LEVEL-LOG:CAPS">GST_CAT_LEVEL_LOG()</a>
</dt>
<dt id="ientry-idm44034">GST_CAT_LOG, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-LOG:CAPS">GST_CAT_LOG()</a>
</dt>
<dt id="ientry-idm43994">GST_CAT_LOG_OBJECT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-LOG-OBJECT:CAPS">GST_CAT_LOG_OBJECT()</a>
</dt>
<dt id="ientry-idm44049">GST_CAT_MEMDUMP, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-MEMDUMP:CAPS">GST_CAT_MEMDUMP()</a>
</dt>
<dt id="ientry-idm44009">GST_CAT_MEMDUMP_OBJECT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-MEMDUMP-OBJECT:CAPS">GST_CAT_MEMDUMP_OBJECT()</a>
</dt>
<dt id="ientry-idm44044">GST_CAT_TRACE, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-TRACE:CAPS">GST_CAT_TRACE()</a>
</dt>
<dt id="ientry-idm44004">GST_CAT_TRACE_OBJECT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-TRACE-OBJECT:CAPS">GST_CAT_TRACE_OBJECT()</a>
</dt>
<dt id="ientry-idm44019">GST_CAT_WARNING, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-WARNING:CAPS">GST_CAT_WARNING()</a>
</dt>
<dt id="ientry-idm43979">GST_CAT_WARNING_OBJECT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-CAT-WARNING-OBJECT:CAPS">GST_CAT_WARNING_OBJECT()</a>
</dt>
<dt id="ientry-idm41867">GST_CHECK_VERSION, <a class="indexterm" href="gstreamer-GstVersion.html#GST-CHECK-VERSION:CAPS">GST_CHECK_VERSION()</a>
</dt>
<dt id="ientry-idm7033">gst_child_proxy_child_added, <a class="indexterm" href="GstChildProxy.html#gst-child-proxy-child-added">gst_child_proxy_child_added ()</a>
</dt>
<dt id="ientry-idm7049">gst_child_proxy_child_removed, <a class="indexterm" href="GstChildProxy.html#gst-child-proxy-child-removed">gst_child_proxy_child_removed ()</a>
</dt>
<dt id="ientry-idm6973">gst_child_proxy_get, <a class="indexterm" href="GstChildProxy.html#gst-child-proxy-get">gst_child_proxy_get ()</a>
</dt>
<dt id="ientry-idm6886">gst_child_proxy_get_children_count, <a class="indexterm" href="GstChildProxy.html#gst-child-proxy-get-children-count">gst_child_proxy_get_children_count ()</a>
</dt>
<dt id="ientry-idm6909">gst_child_proxy_get_child_by_index, <a class="indexterm" href="GstChildProxy.html#gst-child-proxy-get-child-by-index">gst_child_proxy_get_child_by_index ()</a>
</dt>
<dt id="ientry-idm6896">gst_child_proxy_get_child_by_name, <a class="indexterm" href="GstChildProxy.html#gst-child-proxy-get-child-by-name">gst_child_proxy_get_child_by_name ()</a>
</dt>
<dt id="ientry-idm6941">gst_child_proxy_get_property, <a class="indexterm" href="GstChildProxy.html#gst-child-proxy-get-property">gst_child_proxy_get_property ()</a>
</dt>
<dt id="ientry-idm6957">gst_child_proxy_get_valist, <a class="indexterm" href="GstChildProxy.html#gst-child-proxy-get-valist">gst_child_proxy_get_valist ()</a>
</dt>
<dt id="ientry-idm6922">gst_child_proxy_lookup, <a class="indexterm" href="GstChildProxy.html#gst-child-proxy-lookup">gst_child_proxy_lookup ()</a>
</dt>
<dt id="ientry-idm7019">gst_child_proxy_set, <a class="indexterm" href="GstChildProxy.html#gst-child-proxy-set">gst_child_proxy_set ()</a>
</dt>
<dt id="ientry-idm6987">gst_child_proxy_set_property, <a class="indexterm" href="GstChildProxy.html#gst-child-proxy-set-property">gst_child_proxy_set_property ()</a>
</dt>
<dt id="ientry-idm7003">gst_child_proxy_set_valist, <a class="indexterm" href="GstChildProxy.html#gst-child-proxy-set-valist">gst_child_proxy_set_valist ()</a>
</dt>
<dt id="ientry-idm7680">gst_clock_add_observation, <a class="indexterm" href="GstClock.html#gst-clock-add-observation">gst_clock_add_observation ()</a>
</dt>
<dt id="ientry-idm7699">gst_clock_add_observation_unapplied, <a class="indexterm" href="GstClock.html#gst-clock-add-observation-unapplied">gst_clock_add_observation_unapplied ()</a>
</dt>
<dt id="ientry-idm7860">gst_clock_adjust_unlocked, <a class="indexterm" href="GstClock.html#gst-clock-adjust-unlocked">gst_clock_adjust_unlocked ()</a>
</dt>
<dt id="ientry-idm7886">gst_clock_adjust_with_calibration, <a class="indexterm" href="GstClock.html#gst-clock-adjust-with-calibration">gst_clock_adjust_with_calibration ()</a>
</dt>
<dt id="ientry-idm7599">GST_CLOCK_DIFF, <a class="indexterm" href="GstClock.html#GST-CLOCK-DIFF:CAPS">GST_CLOCK_DIFF()</a>
</dt>
<dt id="ientry-idm7645">GST_CLOCK_ENTRY, <a class="indexterm" href="GstClock.html#GST-CLOCK-ENTRY:CAPS">GST_CLOCK_ENTRY()</a>
</dt>
<dt id="ientry-idm7650">GST_CLOCK_ENTRY_CLOCK, <a class="indexterm" href="GstClock.html#GST-CLOCK-ENTRY-CLOCK:CAPS">GST_CLOCK_ENTRY_CLOCK()</a>
</dt>
<dt id="ientry-idm7665">GST_CLOCK_ENTRY_INTERVAL, <a class="indexterm" href="GstClock.html#GST-CLOCK-ENTRY-INTERVAL:CAPS">GST_CLOCK_ENTRY_INTERVAL()</a>
</dt>
<dt id="ientry-idm7670">GST_CLOCK_ENTRY_STATUS, <a class="indexterm" href="GstClock.html#GST-CLOCK-ENTRY-STATUS:CAPS">GST_CLOCK_ENTRY_STATUS()</a>
</dt>
<dt id="ientry-idm7660">GST_CLOCK_ENTRY_TIME, <a class="indexterm" href="GstClock.html#GST-CLOCK-ENTRY-TIME:CAPS">GST_CLOCK_ENTRY_TIME()</a>
</dt>
<dt id="ientry-idm7655">GST_CLOCK_ENTRY_TYPE, <a class="indexterm" href="GstClock.html#GST-CLOCK-ENTRY-TYPE:CAPS">GST_CLOCK_ENTRY_TYPE()</a>
</dt>
<dt id="ientry-idm7675">GST_CLOCK_FLAGS, <a class="indexterm" href="GstClock.html#GST-CLOCK-FLAGS:CAPS">GST_CLOCK_FLAGS()</a>
</dt>
<dt id="ientry-idm7936">gst_clock_get_calibration, <a class="indexterm" href="GstClock.html#gst-clock-get-calibration">gst_clock_get_calibration ()</a>
</dt>
<dt id="ientry-idm7850">gst_clock_get_internal_time, <a class="indexterm" href="GstClock.html#gst-clock-get-internal-time">gst_clock_get_internal_time ()</a>
</dt>
<dt id="ientry-idm7743">gst_clock_get_master, <a class="indexterm" href="GstClock.html#gst-clock-get-master">gst_clock_get_master ()</a>
</dt>
<dt id="ientry-idm7766">gst_clock_get_resolution, <a class="indexterm" href="GstClock.html#gst-clock-get-resolution">gst_clock_get_resolution ()</a>
</dt>
<dt id="ientry-idm7776">gst_clock_get_time, <a class="indexterm" href="GstClock.html#gst-clock-get-time">gst_clock_get_time ()</a>
</dt>
<dt id="ientry-idm7980">gst_clock_get_timeout, <a class="indexterm" href="GstClock.html#gst-clock-get-timeout">gst_clock_get_timeout ()</a>
</dt>
<dt id="ientry-idm8091">gst_clock_id_compare_func, <a class="indexterm" href="GstClock.html#gst-clock-id-compare-func">gst_clock_id_compare_func ()</a>
</dt>
<dt id="ientry-idm8039">gst_clock_id_get_time, <a class="indexterm" href="GstClock.html#gst-clock-id-get-time">gst_clock_id_get_time ()</a>
</dt>
<dt id="ientry-idm8104">gst_clock_id_ref, <a class="indexterm" href="GstClock.html#gst-clock-id-ref">gst_clock_id_ref ()</a>
</dt>
<dt id="ientry-idm8114">gst_clock_id_unref, <a class="indexterm" href="GstClock.html#gst-clock-id-unref">gst_clock_id_unref ()</a>
</dt>
<dt id="ientry-idm8081">gst_clock_id_unschedule, <a class="indexterm" href="GstClock.html#gst-clock-id-unschedule">gst_clock_id_unschedule ()</a>
</dt>
<dt id="ientry-idm8049">gst_clock_id_wait, <a class="indexterm" href="GstClock.html#gst-clock-id-wait">gst_clock_id_wait ()</a>
</dt>
<dt id="ientry-idm8062">gst_clock_id_wait_async, <a class="indexterm" href="GstClock.html#gst-clock-id-wait-async">gst_clock_id_wait_async ()</a>
</dt>
<dt id="ientry-idm8016">gst_clock_is_synced, <a class="indexterm" href="GstClock.html#gst-clock-is-synced">gst_clock_is_synced ()</a>
</dt>
<dt id="ientry-idm7799">gst_clock_new_periodic_id, <a class="indexterm" href="GstClock.html#gst-clock-new-periodic-id">gst_clock_new_periodic_id ()</a>
</dt>
<dt id="ientry-idm7786">gst_clock_new_single_shot_id, <a class="indexterm" href="GstClock.html#gst-clock-new-single-shot-id">gst_clock_new_single_shot_id ()</a>
</dt>
<dt id="ientry-idm7831">gst_clock_periodic_id_reinit, <a class="indexterm" href="GstClock.html#gst-clock-periodic-id-reinit">gst_clock_periodic_id_reinit ()</a>
</dt>
<dt id="ientry-idm7958">gst_clock_set_calibration, <a class="indexterm" href="GstClock.html#gst-clock-set-calibration">gst_clock_set_calibration ()</a>
</dt>
<dt id="ientry-idm7730">gst_clock_set_master, <a class="indexterm" href="GstClock.html#gst-clock-set-master">gst_clock_set_master ()</a>
</dt>
<dt id="ientry-idm7753">gst_clock_set_resolution, <a class="indexterm" href="GstClock.html#gst-clock-set-resolution">gst_clock_set_resolution ()</a>
</dt>
<dt id="ientry-idm8026">gst_clock_set_synced, <a class="indexterm" href="GstClock.html#gst-clock-set-synced">gst_clock_set_synced ()</a>
</dt>
<dt id="ientry-idm7990">gst_clock_set_timeout, <a class="indexterm" href="GstClock.html#gst-clock-set-timeout">gst_clock_set_timeout ()</a>
</dt>
<dt id="ientry-idm7815">gst_clock_single_shot_id_reinit, <a class="indexterm" href="GstClock.html#gst-clock-single-shot-id-reinit">gst_clock_single_shot_id_reinit ()</a>
</dt>
<dt id="ientry-idm7574">GST_CLOCK_STIME_IS_VALID, <a class="indexterm" href="GstClock.html#GST-CLOCK-STIME-IS-VALID:CAPS">GST_CLOCK_STIME_IS_VALID()</a>
</dt>
<dt id="ientry-idm8156">GST_CLOCK_STIME_NONE, <a class="indexterm" href="GstClock.html#GST-CLOCK-STIME-NONE:CAPS">GST_CLOCK_STIME_NONE</a>
</dt>
<dt id="ientry-idm7569">GST_CLOCK_TIME_IS_VALID, <a class="indexterm" href="GstClock.html#GST-CLOCK-TIME-IS-VALID:CAPS">GST_CLOCK_TIME_IS_VALID()</a>
</dt>
<dt id="ientry-idm8151">GST_CLOCK_TIME_NONE, <a class="indexterm" href="GstClock.html#GST-CLOCK-TIME-NONE:CAPS">GST_CLOCK_TIME_NONE</a>
</dt>
<dt id="ientry-idm7873">gst_clock_unadjust_unlocked, <a class="indexterm" href="GstClock.html#gst-clock-unadjust-unlocked">gst_clock_unadjust_unlocked ()</a>
</dt>
<dt id="ientry-idm7911">gst_clock_unadjust_with_calibration, <a class="indexterm" href="GstClock.html#gst-clock-unadjust-with-calibration">gst_clock_unadjust_with_calibration ()</a>
</dt>
<dt id="ientry-idm8003">gst_clock_wait_for_sync, <a class="indexterm" href="GstClock.html#gst-clock-wait-for-sync">gst_clock_wait_for_sync ()</a>
</dt>
<dt id="ientry-idm8597">gst_context_copy, <a class="indexterm" href="GstContext.html#gst-context-copy">gst_context_copy ()</a>
</dt>
<dt id="ientry-idm8607">gst_context_get_context_type, <a class="indexterm" href="GstContext.html#gst-context-get-context-type">gst_context_get_context_type ()</a>
</dt>
<dt id="ientry-idm8640">gst_context_get_structure, <a class="indexterm" href="GstContext.html#gst-context-get-structure">gst_context_get_structure ()</a>
</dt>
<dt id="ientry-idm8617">gst_context_has_context_type, <a class="indexterm" href="GstContext.html#gst-context-has-context-type">gst_context_has_context_type ()</a>
</dt>
<dt id="ientry-idm8630">gst_context_is_persistent, <a class="indexterm" href="GstContext.html#gst-context-is-persistent">gst_context_is_persistent ()</a>
</dt>
<dt id="ientry-idm8665">gst_context_is_writable, <a class="indexterm" href="GstContext.html#gst-context-is-writable">gst_context_is_writable()</a>
</dt>
<dt id="ientry-idm8660">gst_context_make_writable, <a class="indexterm" href="GstContext.html#gst-context-make-writable">gst_context_make_writable()</a>
</dt>
<dt id="ientry-idm8564">gst_context_new, <a class="indexterm" href="GstContext.html#gst-context-new">gst_context_new ()</a>
</dt>
<dt id="ientry-idm8577">gst_context_ref, <a class="indexterm" href="GstContext.html#gst-context-ref">gst_context_ref ()</a>
</dt>
<dt id="ientry-idm8670">gst_context_replace, <a class="indexterm" href="GstContext.html#gst-context-replace">gst_context_replace ()</a>
</dt>
<dt id="ientry-idm8587">gst_context_unref, <a class="indexterm" href="GstContext.html#gst-context-unref">gst_context_unref ()</a>
</dt>
<dt id="ientry-idm8650">gst_context_writable_structure, <a class="indexterm" href="GstContext.html#gst-context-writable-structure">gst_context_writable_structure ()</a>
</dt>
<dt id="ientry-idm8854">gst_control_binding_get_g_value_array, <a class="indexterm" href="GstControlBinding.html#gst-control-binding-get-g-value-array">gst_control_binding_get_g_value_array ()</a>
</dt>
<dt id="ientry-idm8819">gst_control_binding_get_value, <a class="indexterm" href="GstControlBinding.html#gst-control-binding-get-value">gst_control_binding_get_value ()</a>
</dt>
<dt id="ientry-idm8832">gst_control_binding_get_value_array, <a class="indexterm" href="GstControlBinding.html#gst-control-binding-get-value-array">gst_control_binding_get_value_array ()</a>
</dt>
<dt id="ientry-idm8889">gst_control_binding_is_disabled, <a class="indexterm" href="GstControlBinding.html#gst-control-binding-is-disabled">gst_control_binding_is_disabled ()</a>
</dt>
<dt id="ientry-idm8876">gst_control_binding_set_disabled, <a class="indexterm" href="GstControlBinding.html#gst-control-binding-set-disabled">gst_control_binding_set_disabled ()</a>
</dt>
<dt id="ientry-idm8800">gst_control_binding_sync_values, <a class="indexterm" href="GstControlBinding.html#gst-control-binding-sync-values">gst_control_binding_sync_values ()</a>
</dt>
<dt id="ientry-idm9062">gst_control_source_get_value, <a class="indexterm" href="GstControlSource.html#gst-control-source-get-value">gst_control_source_get_value ()</a>
</dt>
<dt id="ientry-idm9078">gst_control_source_get_value_array, <a class="indexterm" href="GstControlSource.html#gst-control-source-get-value-array">gst_control_source_get_value_array ()</a>
</dt>
<dt id="ientry-idm12849">GST_CORE_ERROR, <a class="indexterm" href="gstreamer-GstGError.html#GST-CORE-ERROR:CAPS">GST_CORE_ERROR</a>
</dt>
<dt id="ientry-idm9360">gst_date_time_get_day, <a class="indexterm" href="GstDateTime.html#gst-date-time-get-day">gst_date_time_get_day ()</a>
</dt>
<dt id="ientry-idm9380">gst_date_time_get_hour, <a class="indexterm" href="GstDateTime.html#gst-date-time-get-hour">gst_date_time_get_hour ()</a>
</dt>
<dt id="ientry-idm9390">gst_date_time_get_microsecond, <a class="indexterm" href="GstDateTime.html#gst-date-time-get-microsecond">gst_date_time_get_microsecond ()</a>
</dt>
<dt id="ientry-idm9400">gst_date_time_get_minute, <a class="indexterm" href="GstDateTime.html#gst-date-time-get-minute">gst_date_time_get_minute ()</a>
</dt>
<dt id="ientry-idm9370">gst_date_time_get_month, <a class="indexterm" href="GstDateTime.html#gst-date-time-get-month">gst_date_time_get_month ()</a>
</dt>
<dt id="ientry-idm9420">gst_date_time_get_second, <a class="indexterm" href="GstDateTime.html#gst-date-time-get-second">gst_date_time_get_second ()</a>
</dt>
<dt id="ientry-idm9410">gst_date_time_get_time_zone_offset, <a class="indexterm" href="GstDateTime.html#gst-date-time-get-time-zone-offset">gst_date_time_get_time_zone_offset ()</a>
</dt>
<dt id="ientry-idm9430">gst_date_time_get_year, <a class="indexterm" href="GstDateTime.html#gst-date-time-get-year">gst_date_time_get_year ()</a>
</dt>
<dt id="ientry-idm9590">gst_date_time_has_day, <a class="indexterm" href="GstDateTime.html#gst-date-time-has-day">gst_date_time_has_day ()</a>
</dt>
<dt id="ientry-idm9600">gst_date_time_has_month, <a class="indexterm" href="GstDateTime.html#gst-date-time-has-month">gst_date_time_has_month ()</a>
</dt>
<dt id="ientry-idm9610">gst_date_time_has_second, <a class="indexterm" href="GstDateTime.html#gst-date-time-has-second">gst_date_time_has_second ()</a>
</dt>
<dt id="ientry-idm9620">gst_date_time_has_time, <a class="indexterm" href="GstDateTime.html#gst-date-time-has-time">gst_date_time_has_time ()</a>
</dt>
<dt id="ientry-idm9630">gst_date_time_has_year, <a class="indexterm" href="GstDateTime.html#gst-date-time-has-year">gst_date_time_has_year ()</a>
</dt>
<dt id="ientry-idm9440">gst_date_time_new, <a class="indexterm" href="GstDateTime.html#gst-date-time-new">gst_date_time_new ()</a>
</dt>
<dt id="ientry-idm9660">gst_date_time_new_from_g_date_time, <a class="indexterm" href="GstDateTime.html#gst-date-time-new-from-g-date-time">gst_date_time_new_from_g_date_time ()</a>
</dt>
<dt id="ientry-idm9640">gst_date_time_new_from_iso8601_string, <a class="indexterm" href="GstDateTime.html#gst-date-time-new-from-iso8601-string">gst_date_time_new_from_iso8601_string ()</a>
</dt>
<dt id="ientry-idm9507">gst_date_time_new_from_unix_epoch_local_time, <a class="indexterm" href="GstDateTime.html#gst-date-time-new-from-unix-epoch-local-time">gst_date_time_new_from_unix_epoch_local_time ()</a>
</dt>
<dt id="ientry-idm9517">gst_date_time_new_from_unix_epoch_utc, <a class="indexterm" href="GstDateTime.html#gst-date-time-new-from-unix-epoch-utc">gst_date_time_new_from_unix_epoch_utc ()</a>
</dt>
<dt id="ientry-idm9527">gst_date_time_new_local_time, <a class="indexterm" href="GstDateTime.html#gst-date-time-new-local-time">gst_date_time_new_local_time ()</a>
</dt>
<dt id="ientry-idm9552">gst_date_time_new_now_local_time, <a class="indexterm" href="GstDateTime.html#gst-date-time-new-now-local-time">gst_date_time_new_now_local_time ()</a>
</dt>
<dt id="ientry-idm9561">gst_date_time_new_now_utc, <a class="indexterm" href="GstDateTime.html#gst-date-time-new-now-utc">gst_date_time_new_now_utc ()</a>
</dt>
<dt id="ientry-idm9497">gst_date_time_new_y, <a class="indexterm" href="GstDateTime.html#gst-date-time-new-y">gst_date_time_new_y ()</a>
</dt>
<dt id="ientry-idm9484">gst_date_time_new_ym, <a class="indexterm" href="GstDateTime.html#gst-date-time-new-ym">gst_date_time_new_ym ()</a>
</dt>
<dt id="ientry-idm9468">gst_date_time_new_ymd, <a class="indexterm" href="GstDateTime.html#gst-date-time-new-ymd">gst_date_time_new_ymd ()</a>
</dt>
<dt id="ientry-idm9570">gst_date_time_ref, <a class="indexterm" href="GstDateTime.html#gst-date-time-ref">gst_date_time_ref ()</a>
</dt>
<dt id="ientry-idm9670">gst_date_time_to_g_date_time, <a class="indexterm" href="GstDateTime.html#gst-date-time-to-g-date-time">gst_date_time_to_g_date_time ()</a>
</dt>
<dt id="ientry-idm9650">gst_date_time_to_iso8601_string, <a class="indexterm" href="GstDateTime.html#gst-date-time-to-iso8601-string">gst_date_time_to_iso8601_string ()</a>
</dt>
<dt id="ientry-idm9580">gst_date_time_unref, <a class="indexterm" href="GstDateTime.html#gst-date-time-unref">gst_date_time_unref ()</a>
</dt>
<dt id="ientry-idm44109">GST_DEBUG, <a class="indexterm" href="gstreamer-GstInfo.html#GST-DEBUG:CAPS">GST_DEBUG()</a>
</dt>
<dt id="ientry-idm43684">gst_debug_add_log_function, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-add-log-function">gst_debug_add_log_function ()</a>
</dt>
<dt id="ientry-idm44178">gst_debug_bin_to_dot_data, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-bin-to-dot-data">gst_debug_bin_to_dot_data ()</a>
</dt>
<dt id="ientry-idm44149">GST_DEBUG_BIN_TO_DOT_FILE, <a class="indexterm" href="gstreamer-GstInfo.html#GST-DEBUG-BIN-TO-DOT-FILE:CAPS">GST_DEBUG_BIN_TO_DOT_FILE()</a>
</dt>
<dt id="ientry-idm44191">gst_debug_bin_to_dot_file, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-bin-to-dot-file">gst_debug_bin_to_dot_file ()</a>
</dt>
<dt id="ientry-idm44154">GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS, <a class="indexterm" href="gstreamer-GstInfo.html#GST-DEBUG-BIN-TO-DOT-FILE-WITH-TS:CAPS">GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS()</a>
</dt>
<dt id="ientry-idm44207">gst_debug_bin_to_dot_file_with_ts, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-bin-to-dot-file-with-ts">gst_debug_bin_to_dot_file_with_ts ()</a>
</dt>
<dt id="ientry-idm43842">GST_DEBUG_CATEGORY, <a class="indexterm" href="gstreamer-GstInfo.html#GST-DEBUG-CATEGORY:CAPS">GST_DEBUG_CATEGORY()</a>
</dt>
<dt id="ientry-idm43847">GST_DEBUG_CATEGORY_EXTERN, <a class="indexterm" href="gstreamer-GstInfo.html#GST-DEBUG-CATEGORY-EXTERN:CAPS">GST_DEBUG_CATEGORY_EXTERN()</a>
</dt>
<dt id="ientry-idm43867">gst_debug_category_free, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-category-free">gst_debug_category_free ()</a>
</dt>
<dt id="ientry-idm43862">GST_DEBUG_CATEGORY_GET, <a class="indexterm" href="gstreamer-GstInfo.html#GST-DEBUG-CATEGORY-GET:CAPS">GST_DEBUG_CATEGORY_GET()</a>
</dt>
<dt id="ientry-idm43920">gst_debug_category_get_color, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-category-get-color">gst_debug_category_get_color ()</a>
</dt>
<dt id="ientry-idm43930">gst_debug_category_get_description, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-category-get-description">gst_debug_category_get_description ()</a>
</dt>
<dt id="ientry-idm43910">gst_debug_category_get_name, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-category-get-name">gst_debug_category_get_name ()</a>
</dt>
<dt id="ientry-idm43900">gst_debug_category_get_threshold, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-category-get-threshold">gst_debug_category_get_threshold ()</a>
</dt>
<dt id="ientry-idm43857">GST_DEBUG_CATEGORY_INIT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-DEBUG-CATEGORY-INIT:CAPS">GST_DEBUG_CATEGORY_INIT()</a>
</dt>
<dt id="ientry-idm43890">gst_debug_category_reset_threshold, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-category-reset-threshold">gst_debug_category_reset_threshold ()</a>
</dt>
<dt id="ientry-idm43877">gst_debug_category_set_threshold, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-category-set-threshold">gst_debug_category_set_threshold ()</a>
</dt>
<dt id="ientry-idm43852">GST_DEBUG_CATEGORY_STATIC, <a class="indexterm" href="gstreamer-GstInfo.html#GST-DEBUG-CATEGORY-STATIC:CAPS">GST_DEBUG_CATEGORY_STATIC()</a>
</dt>
<dt id="ientry-idm43949">gst_debug_construct_term_color, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-construct-term-color">gst_debug_construct_term_color ()</a>
</dt>
<dt id="ientry-idm43959">gst_debug_construct_win_color, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-construct-win-color">gst_debug_construct_win_color ()</a>
</dt>
<dt id="ientry-idm44139">GST_DEBUG_FUNCPTR, <a class="indexterm" href="gstreamer-GstInfo.html#GST-DEBUG-FUNCPTR:CAPS">GST_DEBUG_FUNCPTR()</a>
</dt>
<dt id="ientry-idm44144">GST_DEBUG_FUNCPTR_NAME, <a class="indexterm" href="gstreamer-GstInfo.html#GST-DEBUG-FUNCPTR-NAME:CAPS">GST_DEBUG_FUNCPTR_NAME()</a>
</dt>
<dt id="ientry-idm43940">gst_debug_get_all_categories, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-get-all-categories">gst_debug_get_all_categories ()</a>
</dt>
<dt id="ientry-idm43778">gst_debug_get_color_mode, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-get-color-mode">gst_debug_get_color_mode ()</a>
</dt>
<dt id="ientry-idm43810">gst_debug_get_default_threshold, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-get-default-threshold">gst_debug_get_default_threshold ()</a>
</dt>
<dt id="ientry-idm43730">gst_debug_is_active, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-is-active">gst_debug_is_active ()</a>
</dt>
<dt id="ientry-idm43769">gst_debug_is_colored, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-is-colored">gst_debug_is_colored ()</a>
</dt>
<dt id="ientry-idm43674">gst_debug_level_get_name, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-level-get-name">gst_debug_level_get_name ()</a>
</dt>
<dt id="ientry-idm43573">gst_debug_log, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-log">gst_debug_log ()</a>
</dt>
<dt id="ientry-idm43643">gst_debug_log_default, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-log-default">gst_debug_log_default ()</a>
</dt>
<dt id="ientry-idm43602">gst_debug_log_valist, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-log-valist">gst_debug_log_valist ()</a>
</dt>
<dt id="ientry-idm43633">gst_debug_message_get, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-message-get">gst_debug_message_get ()</a>
</dt>
<dt id="ientry-idm44069">GST_DEBUG_OBJECT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-DEBUG-OBJECT:CAPS">GST_DEBUG_OBJECT()</a>
</dt>
<dt id="ientry-idm43535">GST_DEBUG_PAD_NAME, <a class="indexterm" href="gstreamer-GstInfo.html#GST-DEBUG-PAD-NAME:CAPS">GST_DEBUG_PAD_NAME()</a>
</dt>
<dt id="ientry-idm44159">gst_debug_print_stack_trace, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-print-stack-trace">gst_debug_print_stack_trace ()</a>
</dt>
<dt id="ientry-idm44134">GST_DEBUG_REGISTER_FUNCPTR, <a class="indexterm" href="gstreamer-GstInfo.html#GST-DEBUG-REGISTER-FUNCPTR:CAPS">GST_DEBUG_REGISTER_FUNCPTR()</a>
</dt>
<dt id="ientry-idm43700">gst_debug_remove_log_function, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-remove-log-function">gst_debug_remove_log_function ()</a>
</dt>
<dt id="ientry-idm43710">gst_debug_remove_log_function_by_data, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-remove-log-function-by-data">gst_debug_remove_log_function_by_data ()</a>
</dt>
<dt id="ientry-idm43720">gst_debug_set_active, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-set-active">gst_debug_set_active ()</a>
</dt>
<dt id="ientry-idm43739">gst_debug_set_colored, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-set-colored">gst_debug_set_colored ()</a>
</dt>
<dt id="ientry-idm43749">gst_debug_set_color_mode, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-set-color-mode">gst_debug_set_color_mode ()</a>
</dt>
<dt id="ientry-idm43759">gst_debug_set_color_mode_from_string, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-set-color-mode-from-string">gst_debug_set_color_mode_from_string ()</a>
</dt>
<dt id="ientry-idm43787">gst_debug_set_default_threshold, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-set-default-threshold">gst_debug_set_default_threshold ()</a>
</dt>
<dt id="ientry-idm43819">gst_debug_set_threshold_for_name, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-set-threshold-for-name">gst_debug_set_threshold_for_name ()</a>
</dt>
<dt id="ientry-idm43797">gst_debug_set_threshold_from_string, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-set-threshold-from-string">gst_debug_set_threshold_from_string ()</a>
</dt>
<dt id="ientry-idm43832">gst_debug_unset_threshold_for_name, <a class="indexterm" href="gstreamer-GstInfo.html#gst-debug-unset-threshold-for-name">gst_debug_unset_threshold_for_name ()</a>
</dt>
<dt id="ientry-idm19739">GST_DEFINE_MINI_OBJECT_TYPE, <a class="indexterm" href="gstreamer-GstMiniObject.html#GST-DEFINE-MINI-OBJECT-TYPE:CAPS">GST_DEFINE_MINI_OBJECT_TYPE()</a>
</dt>
<dt id="ientry-idm439">gst_deinit, <a class="indexterm" href="gstreamer-Gst.html#gst-deinit">gst_deinit ()</a>
</dt>
<dt id="ientry-idm42276">gst_device_create_element, <a class="indexterm" href="gstreamer-GstDevice.html#gst-device-create-element">gst_device_create_element ()</a>
</dt>
<dt id="ientry-idm42289">gst_device_get_caps, <a class="indexterm" href="gstreamer-GstDevice.html#gst-device-get-caps">gst_device_get_caps ()</a>
</dt>
<dt id="ientry-idm42299">gst_device_get_device_class, <a class="indexterm" href="gstreamer-GstDevice.html#gst-device-get-device-class">gst_device_get_device_class ()</a>
</dt>
<dt id="ientry-idm42309">gst_device_get_display_name, <a class="indexterm" href="gstreamer-GstDevice.html#gst-device-get-display-name">gst_device_get_display_name ()</a>
</dt>
<dt id="ientry-idm42358">gst_device_get_properties, <a class="indexterm" href="gstreamer-GstDevice.html#gst-device-get-properties">gst_device_get_properties ()</a>
</dt>
<dt id="ientry-idm42319">gst_device_has_classes, <a class="indexterm" href="gstreamer-GstDevice.html#gst-device-has-classes">gst_device_has_classes ()</a>
</dt>
<dt id="ientry-idm42332">gst_device_has_classesv, <a class="indexterm" href="gstreamer-GstDevice.html#gst-device-has-classesv">gst_device_has_classesv ()</a>
</dt>
<dt id="ientry-idm42043">gst_device_monitor_add_filter, <a class="indexterm" href="gstreamer-GstDeviceMonitor.html#gst-device-monitor-add-filter">gst_device_monitor_add_filter ()</a>
</dt>
<dt id="ientry-idm42033">gst_device_monitor_get_bus, <a class="indexterm" href="gstreamer-GstDeviceMonitor.html#gst-device-monitor-get-bus">gst_device_monitor_get_bus ()</a>
</dt>
<dt id="ientry-idm42092">gst_device_monitor_get_devices, <a class="indexterm" href="gstreamer-GstDeviceMonitor.html#gst-device-monitor-get-devices">gst_device_monitor_get_devices ()</a>
</dt>
<dt id="ientry-idm42102">gst_device_monitor_get_providers, <a class="indexterm" href="gstreamer-GstDeviceMonitor.html#gst-device-monitor-get-providers">gst_device_monitor_get_providers ()</a>
</dt>
<dt id="ientry-idm42112">gst_device_monitor_get_show_all_devices, <a class="indexterm" href="gstreamer-GstDeviceMonitor.html#gst-device-monitor-get-show-all-devices">gst_device_monitor_get_show_all_devices ()</a>
</dt>
<dt id="ientry-idm42024">gst_device_monitor_new, <a class="indexterm" href="gstreamer-GstDeviceMonitor.html#gst-device-monitor-new">gst_device_monitor_new ()</a>
</dt>
<dt id="ientry-idm42059">gst_device_monitor_remove_filter, <a class="indexterm" href="gstreamer-GstDeviceMonitor.html#gst-device-monitor-remove-filter">gst_device_monitor_remove_filter ()</a>
</dt>
<dt id="ientry-idm42122">gst_device_monitor_set_show_all_devices, <a class="indexterm" href="gstreamer-GstDeviceMonitor.html#gst-device-monitor-set-show-all-devices">gst_device_monitor_set_show_all_devices ()</a>
</dt>
<dt id="ientry-idm42072">gst_device_monitor_start, <a class="indexterm" href="gstreamer-GstDeviceMonitor.html#gst-device-monitor-start">gst_device_monitor_start ()</a>
</dt>
<dt id="ientry-idm42082">gst_device_monitor_stop, <a class="indexterm" href="gstreamer-GstDeviceMonitor.html#gst-device-monitor-stop">gst_device_monitor_stop ()</a>
</dt>
<dt id="ientry-idm42515">gst_device_provider_can_monitor, <a class="indexterm" href="gstreamer-GstDeviceProvider.html#gst-device-provider-can-monitor">gst_device_provider_can_monitor ()</a>
</dt>
<dt id="ientry-idm42525">gst_device_provider_class_add_metadata, <a class="indexterm" href="gstreamer-GstDeviceProvider.html#gst-device-provider-class-add-metadata">gst_device_provider_class_add_metadata ()</a>
</dt>
<dt id="ientry-idm42541">gst_device_provider_class_add_static_metadata, <a class="indexterm" href="gstreamer-GstDeviceProvider.html#gst-device-provider-class-add-static-metadata">gst_device_provider_class_add_static_metadata ()</a>
</dt>
<dt id="ientry-idm42557">gst_device_provider_class_get_metadata, <a class="indexterm" href="gstreamer-GstDeviceProvider.html#gst-device-provider-class-get-metadata">gst_device_provider_class_get_metadata ()</a>
</dt>
<dt id="ientry-idm42570">gst_device_provider_class_set_metadata, <a class="indexterm" href="gstreamer-GstDeviceProvider.html#gst-device-provider-class-set-metadata">gst_device_provider_class_set_metadata ()</a>
</dt>
<dt id="ientry-idm42592">gst_device_provider_class_set_static_metadata, <a class="indexterm" href="gstreamer-GstDeviceProvider.html#gst-device-provider-class-set-static-metadata">gst_device_provider_class_set_static_metadata ()</a>
</dt>
<dt id="ientry-idm42614">gst_device_provider_device_add, <a class="indexterm" href="gstreamer-GstDeviceProvider.html#gst-device-provider-device-add">gst_device_provider_device_add ()</a>
</dt>
<dt id="ientry-idm42627">gst_device_provider_device_remove, <a class="indexterm" href="gstreamer-GstDeviceProvider.html#gst-device-provider-device-remove">gst_device_provider_device_remove ()</a>
</dt>
<dt id="ientry-idm42832">gst_device_provider_factory_find, <a class="indexterm" href="GstDeviceProviderFactory.html#gst-device-provider-factory-find">gst_device_provider_factory_find ()</a>
</dt>
<dt id="ientry-idm42842">gst_device_provider_factory_get, <a class="indexterm" href="GstDeviceProviderFactory.html#gst-device-provider-factory-get">gst_device_provider_factory_get ()</a>
</dt>
<dt id="ientry-idm42852">gst_device_provider_factory_get_by_name, <a class="indexterm" href="GstDeviceProviderFactory.html#gst-device-provider-factory-get-by-name">gst_device_provider_factory_get_by_name ()</a>
</dt>
<dt id="ientry-idm42862">gst_device_provider_factory_get_device_provider_type, <a class="indexterm" href="GstDeviceProviderFactory.html#gst-device-provider-factory-get-device-provider-type">gst_device_provider_factory_get_device_provider_type ()</a>
</dt>
<dt id="ientry-idm42872">gst_device_provider_factory_get_metadata, <a class="indexterm" href="GstDeviceProviderFactory.html#gst-device-provider-factory-get-metadata">gst_device_provider_factory_get_metadata ()</a>
</dt>
<dt id="ientry-idm42885">gst_device_provider_factory_get_metadata_keys, <a class="indexterm" href="GstDeviceProviderFactory.html#gst-device-provider-factory-get-metadata-keys">gst_device_provider_factory_get_metadata_keys ()</a>
</dt>
<dt id="ientry-idm42895">gst_device_provider_factory_has_classes, <a class="indexterm" href="GstDeviceProviderFactory.html#gst-device-provider-factory-has-classes">gst_device_provider_factory_has_classes ()</a>
</dt>
<dt id="ientry-idm42908">gst_device_provider_factory_has_classesv, <a class="indexterm" href="GstDeviceProviderFactory.html#gst-device-provider-factory-has-classesv">gst_device_provider_factory_has_classesv ()</a>
</dt>
<dt id="ientry-idm42921">gst_device_provider_factory_list_get_device_providers, <a class="indexterm" href="GstDeviceProviderFactory.html#gst-device-provider-factory-list-get-device-providers">gst_device_provider_factory_list_get_device_providers ()</a>
</dt>
<dt id="ientry-idm42640">gst_device_provider_get_bus, <a class="indexterm" href="gstreamer-GstDeviceProvider.html#gst-device-provider-get-bus">gst_device_provider_get_bus ()</a>
</dt>
<dt id="ientry-idm42650">gst_device_provider_get_devices, <a class="indexterm" href="gstreamer-GstDeviceProvider.html#gst-device-provider-get-devices">gst_device_provider_get_devices ()</a>
</dt>
<dt id="ientry-idm42660">gst_device_provider_get_factory, <a class="indexterm" href="gstreamer-GstDeviceProvider.html#gst-device-provider-get-factory">gst_device_provider_get_factory ()</a>
</dt>
<dt id="ientry-idm42135">gst_device_provider_get_hidden_providers, <a class="indexterm" href="gstreamer-GstDeviceMonitor.html#gst-device-provider-get-hidden-providers">gst_device_provider_get_hidden_providers ()</a>
</dt>
<dt id="ientry-idm42145">gst_device_provider_hide_provider, <a class="indexterm" href="gstreamer-GstDeviceMonitor.html#gst-device-provider-hide-provider">gst_device_provider_hide_provider ()</a>
</dt>
<dt id="ientry-idm42670">gst_device_provider_register, <a class="indexterm" href="gstreamer-GstDeviceProvider.html#gst-device-provider-register">gst_device_provider_register ()</a>
</dt>
<dt id="ientry-idm42689">gst_device_provider_start, <a class="indexterm" href="gstreamer-GstDeviceProvider.html#gst-device-provider-start">gst_device_provider_start ()</a>
</dt>
<dt id="ientry-idm42699">gst_device_provider_stop, <a class="indexterm" href="gstreamer-GstDeviceProvider.html#gst-device-provider-stop">gst_device_provider_stop ()</a>
</dt>
<dt id="ientry-idm42158">gst_device_provider_unhide_provider, <a class="indexterm" href="gstreamer-GstDeviceMonitor.html#gst-device-provider-unhide-provider">gst_device_provider_unhide_provider ()</a>
</dt>
<dt id="ientry-idm42345">gst_device_reconfigure_element, <a class="indexterm" href="gstreamer-GstDevice.html#gst-device-reconfigure-element">gst_device_reconfigure_element ()</a>
</dt>
<dt id="ientry-idm8431">GST_DISABLE_ALLOC_TRACE, <a class="indexterm" href="gstreamer-GstConfig.html#GST-DISABLE-ALLOC-TRACE:CAPS">GST_DISABLE_ALLOC_TRACE</a>
</dt>
<dt id="ientry-idm8416">GST_DISABLE_GST_DEBUG, <a class="indexterm" href="gstreamer-GstConfig.html#GST-DISABLE-GST-DEBUG:CAPS">GST_DISABLE_GST_DEBUG</a>
</dt>
<dt id="ientry-idm8421">GST_DISABLE_PARSE, <a class="indexterm" href="gstreamer-GstConfig.html#GST-DISABLE-PARSE:CAPS">GST_DISABLE_PARSE</a>
</dt>
<dt id="ientry-idm8441">GST_DISABLE_PLUGIN, <a class="indexterm" href="gstreamer-GstConfig.html#GST-DISABLE-PLUGIN:CAPS">GST_DISABLE_PLUGIN</a>
</dt>
<dt id="ientry-idm8436">GST_DISABLE_REGISTRY, <a class="indexterm" href="gstreamer-GstConfig.html#GST-DISABLE-REGISTRY:CAPS">GST_DISABLE_REGISTRY</a>
</dt>
<dt id="ientry-idm8426">GST_DISABLE_TRACE, <a class="indexterm" href="gstreamer-GstConfig.html#GST-DISABLE-TRACE:CAPS">GST_DISABLE_TRACE</a>
</dt>
<dt id="ientry-idm11227">gst_element_abort_state, <a class="indexterm" href="GstElement.html#gst-element-abort-state">gst_element_abort_state ()</a>
</dt>
<dt id="ientry-idm10663">gst_element_add_pad, <a class="indexterm" href="GstElement.html#gst-element-add-pad">gst_element_add_pad ()</a>
</dt>
<dt id="ientry-idm11496">gst_element_add_property_deep_notify_watch, <a class="indexterm" href="GstElement.html#gst-element-add-property-deep-notify-watch">gst_element_add_property_deep_notify_watch ()</a>
</dt>
<dt id="ientry-idm11480">gst_element_add_property_notify_watch, <a class="indexterm" href="GstElement.html#gst-element-add-property-notify-watch">gst_element_add_property_notify_watch ()</a>
</dt>
<dt id="ientry-idm10498">GST_ELEMENT_BUS, <a class="indexterm" href="GstElement.html#GST-ELEMENT-BUS:CAPS">GST_ELEMENT_BUS()</a>
</dt>
<dt id="ientry-idm11540">gst_element_call_async, <a class="indexterm" href="GstElement.html#gst-element-call-async">gst_element_call_async ()</a>
</dt>
<dt id="ientry-idm11290">gst_element_change_state, <a class="indexterm" href="GstElement.html#gst-element-change-state">gst_element_change_state ()</a>
</dt>
<dt id="ientry-idm10631">gst_element_class_add_metadata, <a class="indexterm" href="GstElement.html#gst-element-class-add-metadata">gst_element_class_add_metadata ()</a>
</dt>
<dt id="ientry-idm10538">gst_element_class_add_pad_template, <a class="indexterm" href="GstElement.html#gst-element-class-add-pad-template">gst_element_class_add_pad_template ()</a>
</dt>
<dt id="ientry-idm10647">gst_element_class_add_static_metadata, <a class="indexterm" href="GstElement.html#gst-element-class-add-static-metadata">gst_element_class_add_static_metadata ()</a>
</dt>
<dt id="ientry-idm10551">gst_element_class_add_static_pad_template, <a class="indexterm" href="GstElement.html#gst-element-class-add-static-pad-template">gst_element_class_add_static_pad_template ()</a>
</dt>
<dt id="ientry-idm10978">gst_element_class_get_metadata, <a class="indexterm" href="GstElement.html#gst-element-class-get-metadata">gst_element_class_get_metadata ()</a>
</dt>
<dt id="ientry-idm10564">gst_element_class_get_pad_template, <a class="indexterm" href="GstElement.html#gst-element-class-get-pad-template">gst_element_class_get_pad_template ()</a>
</dt>
<dt id="ientry-idm10577">gst_element_class_get_pad_template_list, <a class="indexterm" href="GstElement.html#gst-element-class-get-pad-template-list">gst_element_class_get_pad_template_list ()</a>
</dt>
<dt id="ientry-idm10587">gst_element_class_set_metadata, <a class="indexterm" href="GstElement.html#gst-element-class-set-metadata">gst_element_class_set_metadata ()</a>
</dt>
<dt id="ientry-idm10609">gst_element_class_set_static_metadata, <a class="indexterm" href="GstElement.html#gst-element-class-set-static-metadata">gst_element_class_set_static_metadata ()</a>
</dt>
<dt id="ientry-idm10503">GST_ELEMENT_CLOCK, <a class="indexterm" href="GstElement.html#GST-ELEMENT-CLOCK:CAPS">GST_ELEMENT_CLOCK()</a>
</dt>
<dt id="ientry-idm11237">gst_element_continue_state, <a class="indexterm" href="GstElement.html#gst-element-continue-state">gst_element_continue_state ()</a>
</dt>
<dt id="ientry-idm10676">gst_element_create_all_pads, <a class="indexterm" href="GstElement.html#gst-element-create-all-pads">gst_element_create_all_pads ()</a>
</dt>
<dt id="ientry-idm10518">GST_ELEMENT_ERROR, <a class="indexterm" href="GstElement.html#GST-ELEMENT-ERROR:CAPS">GST_ELEMENT_ERROR()</a>
</dt>
<dt id="ientry-idm12215">gst_element_factory_can_sink_all_caps, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-can-sink-all-caps">gst_element_factory_can_sink_all_caps ()</a>
</dt>
<dt id="ientry-idm12241">gst_element_factory_can_sink_any_caps, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-can-sink-any-caps">gst_element_factory_can_sink_any_caps ()</a>
</dt>
<dt id="ientry-idm12228">gst_element_factory_can_src_all_caps, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-can-src-all-caps">gst_element_factory_can_src_all_caps ()</a>
</dt>
<dt id="ientry-idm12254">gst_element_factory_can_src_any_caps, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-can-src-any-caps">gst_element_factory_can_src_any_caps ()</a>
</dt>
<dt id="ientry-idm12189">gst_element_factory_create, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-create">gst_element_factory_create ()</a>
</dt>
<dt id="ientry-idm12103">gst_element_factory_find, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-find">gst_element_factory_find ()</a>
</dt>
<dt id="ientry-idm12113">gst_element_factory_get_element_type, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-get-element-type">gst_element_factory_get_element_type ()</a>
</dt>
<dt id="ientry-idm12123">gst_element_factory_get_metadata, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-get-metadata">gst_element_factory_get_metadata ()</a>
</dt>
<dt id="ientry-idm12136">gst_element_factory_get_metadata_keys, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-get-metadata-keys">gst_element_factory_get_metadata_keys ()</a>
</dt>
<dt id="ientry-idm12146">gst_element_factory_get_num_pad_templates, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-get-num-pad-templates">gst_element_factory_get_num_pad_templates ()</a>
</dt>
<dt id="ientry-idm12267">gst_element_factory_get_static_pad_templates, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-get-static-pad-templates">gst_element_factory_get_static_pad_templates ()</a>
</dt>
<dt id="ientry-idm12166">gst_element_factory_get_uri_protocols, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-get-uri-protocols">gst_element_factory_get_uri_protocols ()</a>
</dt>
<dt id="ientry-idm12156">gst_element_factory_get_uri_type, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-get-uri-type">gst_element_factory_get_uri_type ()</a>
</dt>
<dt id="ientry-idm12176">gst_element_factory_has_interface, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-has-interface">gst_element_factory_has_interface ()</a>
</dt>
<dt id="ientry-idm12277">gst_element_factory_list_filter, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-list-filter">gst_element_factory_list_filter ()</a>
</dt>
<dt id="ientry-idm12296">gst_element_factory_list_get_elements, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-list-get-elements">gst_element_factory_list_get_elements ()</a>
</dt>
<dt id="ientry-idm12309">gst_element_factory_list_is_type, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-list-is-type">gst_element_factory_list_is_type ()</a>
</dt>
<dt id="ientry-idm12202">gst_element_factory_make, <a class="indexterm" href="GstElementFactory.html#gst-element-factory-make">gst_element_factory_make ()</a>
</dt>
<dt id="ientry-idm12334">GST_ELEMENT_FACTORY_TYPE_ANY, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-ANY:CAPS">GST_ELEMENT_FACTORY_TYPE_ANY</a>
</dt>
<dt id="ientry-idm12339">GST_ELEMENT_FACTORY_TYPE_AUDIOVIDEO_SINKS, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-AUDIOVIDEO-SINKS:CAPS">GST_ELEMENT_FACTORY_TYPE_AUDIOVIDEO_SINKS</a>
</dt>
<dt id="ientry-idm12344">GST_ELEMENT_FACTORY_TYPE_AUDIO_ENCODER, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-AUDIO-ENCODER:CAPS">GST_ELEMENT_FACTORY_TYPE_AUDIO_ENCODER</a>
</dt>
<dt id="ientry-idm12349">GST_ELEMENT_FACTORY_TYPE_DECODABLE, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-DECODABLE:CAPS">GST_ELEMENT_FACTORY_TYPE_DECODABLE</a>
</dt>
<dt id="ientry-idm12354">GST_ELEMENT_FACTORY_TYPE_DECODER, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-DECODER:CAPS">GST_ELEMENT_FACTORY_TYPE_DECODER</a>
</dt>
<dt id="ientry-idm12359">GST_ELEMENT_FACTORY_TYPE_DECRYPTOR, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-DECRYPTOR:CAPS">GST_ELEMENT_FACTORY_TYPE_DECRYPTOR</a>
</dt>
<dt id="ientry-idm12364">GST_ELEMENT_FACTORY_TYPE_DEMUXER, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-DEMUXER:CAPS">GST_ELEMENT_FACTORY_TYPE_DEMUXER</a>
</dt>
<dt id="ientry-idm12369">GST_ELEMENT_FACTORY_TYPE_DEPAYLOADER, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-DEPAYLOADER:CAPS">GST_ELEMENT_FACTORY_TYPE_DEPAYLOADER</a>
</dt>
<dt id="ientry-idm12374">GST_ELEMENT_FACTORY_TYPE_ENCODER, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-ENCODER:CAPS">GST_ELEMENT_FACTORY_TYPE_ENCODER</a>
</dt>
<dt id="ientry-idm12379">GST_ELEMENT_FACTORY_TYPE_ENCRYPTOR, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-ENCRYPTOR:CAPS">GST_ELEMENT_FACTORY_TYPE_ENCRYPTOR</a>
</dt>
<dt id="ientry-idm12384">GST_ELEMENT_FACTORY_TYPE_FORMATTER, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-FORMATTER:CAPS">GST_ELEMENT_FACTORY_TYPE_FORMATTER</a>
</dt>
<dt id="ientry-idm12389">GST_ELEMENT_FACTORY_TYPE_MAX_ELEMENTS, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-MAX-ELEMENTS:CAPS">GST_ELEMENT_FACTORY_TYPE_MAX_ELEMENTS</a>
</dt>
<dt id="ientry-idm12419">GST_ELEMENT_FACTORY_TYPE_MEDIA_ANY, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-MEDIA-ANY:CAPS">GST_ELEMENT_FACTORY_TYPE_MEDIA_ANY</a>
</dt>
<dt id="ientry-idm12394">GST_ELEMENT_FACTORY_TYPE_MEDIA_AUDIO, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-MEDIA-AUDIO:CAPS">GST_ELEMENT_FACTORY_TYPE_MEDIA_AUDIO</a>
</dt>
<dt id="ientry-idm12399">GST_ELEMENT_FACTORY_TYPE_MEDIA_IMAGE, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-MEDIA-IMAGE:CAPS">GST_ELEMENT_FACTORY_TYPE_MEDIA_IMAGE</a>
</dt>
<dt id="ientry-idm12404">GST_ELEMENT_FACTORY_TYPE_MEDIA_METADATA, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-MEDIA-METADATA:CAPS">GST_ELEMENT_FACTORY_TYPE_MEDIA_METADATA</a>
</dt>
<dt id="ientry-idm12409">GST_ELEMENT_FACTORY_TYPE_MEDIA_SUBTITLE, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-MEDIA-SUBTITLE:CAPS">GST_ELEMENT_FACTORY_TYPE_MEDIA_SUBTITLE</a>
</dt>
<dt id="ientry-idm12414">GST_ELEMENT_FACTORY_TYPE_MEDIA_VIDEO, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-MEDIA-VIDEO:CAPS">GST_ELEMENT_FACTORY_TYPE_MEDIA_VIDEO</a>
</dt>
<dt id="ientry-idm12424">GST_ELEMENT_FACTORY_TYPE_MUXER, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-MUXER:CAPS">GST_ELEMENT_FACTORY_TYPE_MUXER</a>
</dt>
<dt id="ientry-idm12429">GST_ELEMENT_FACTORY_TYPE_PARSER, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-PARSER:CAPS">GST_ELEMENT_FACTORY_TYPE_PARSER</a>
</dt>
<dt id="ientry-idm12434">GST_ELEMENT_FACTORY_TYPE_PAYLOADER, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-PAYLOADER:CAPS">GST_ELEMENT_FACTORY_TYPE_PAYLOADER</a>
</dt>
<dt id="ientry-idm12439">GST_ELEMENT_FACTORY_TYPE_SINK, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-SINK:CAPS">GST_ELEMENT_FACTORY_TYPE_SINK</a>
</dt>
<dt id="ientry-idm12444">GST_ELEMENT_FACTORY_TYPE_SRC, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-SRC:CAPS">GST_ELEMENT_FACTORY_TYPE_SRC</a>
</dt>
<dt id="ientry-idm12449">GST_ELEMENT_FACTORY_TYPE_VIDEO_ENCODER, <a class="indexterm" href="GstElementFactory.html#GST-ELEMENT-FACTORY-TYPE-VIDEO-ENCODER:CAPS">GST_ELEMENT_FACTORY_TYPE_VIDEO_ENCODER</a>
</dt>
<dt id="ientry-idm11004">gst_element_get_base_time, <a class="indexterm" href="GstElement.html#gst-element-get-base-time">gst_element_get_base_time ()</a>
</dt>
<dt id="ientry-idm11050">gst_element_get_bus, <a class="indexterm" href="GstElement.html#gst-element-get-bus">gst_element_get_bus ()</a>
</dt>
<dt id="ientry-idm11152">gst_element_get_clock, <a class="indexterm" href="GstElement.html#gst-element-get-clock">gst_element_get_clock ()</a>
</dt>
<dt id="ientry-idm10686">gst_element_get_compatible_pad, <a class="indexterm" href="GstElement.html#gst-element-get-compatible-pad">gst_element_get_compatible_pad ()</a>
</dt>
<dt id="ientry-idm10702">gst_element_get_compatible_pad_template, <a class="indexterm" href="GstElement.html#gst-element-get-compatible-pad-template">gst_element_get_compatible_pad_template ()</a>
</dt>
<dt id="ientry-idm11073">gst_element_get_context, <a class="indexterm" href="GstElement.html#gst-element-get-context">gst_element_get_context ()</a>
</dt>
<dt id="ientry-idm11099">gst_element_get_contexts, <a class="indexterm" href="GstElement.html#gst-element-get-contexts">gst_element_get_contexts ()</a>
</dt>
<dt id="ientry-idm11086">gst_element_get_context_unlocked, <a class="indexterm" href="GstElement.html#gst-element-get-context-unlocked">gst_element_get_context_unlocked ()</a>
</dt>
<dt id="ientry-idm11109">gst_element_get_factory, <a class="indexterm" href="GstElement.html#gst-element-get-factory">gst_element_get_factory ()</a>
</dt>
<dt id="ientry-idm11124">gst_element_get_name, <a class="indexterm" href="GstElement.html#gst-element-get-name">gst_element_get_name()</a>
</dt>
<dt id="ientry-idm11134">gst_element_get_parent, <a class="indexterm" href="GstElement.html#gst-element-get-parent">gst_element_get_parent()</a>
</dt>
<dt id="ientry-idm10715">gst_element_get_request_pad, <a class="indexterm" href="GstElement.html#gst-element-get-request-pad">gst_element_get_request_pad ()</a>
</dt>
<dt id="ientry-idm11027">gst_element_get_start_time, <a class="indexterm" href="GstElement.html#gst-element-get-start-time">gst_element_get_start_time ()</a>
</dt>
<dt id="ientry-idm11185">gst_element_get_state, <a class="indexterm" href="GstElement.html#gst-element-get-state">gst_element_get_state ()</a>
</dt>
<dt id="ientry-idm10728">gst_element_get_static_pad, <a class="indexterm" href="GstElement.html#gst-element-get-static-pad">gst_element_get_static_pad ()</a>
</dt>
<dt id="ientry-idm10528">GST_ELEMENT_INFO, <a class="indexterm" href="GstElement.html#GST-ELEMENT-INFO:CAPS">GST_ELEMENT_INFO()</a>
</dt>
<dt id="ientry-idm10533">GST_ELEMENT_IS_LOCKED_STATE, <a class="indexterm" href="GstElement.html#GST-ELEMENT-IS-LOCKED-STATE:CAPS">GST_ELEMENT_IS_LOCKED_STATE()</a>
</dt>
<dt id="ientry-idm11217">gst_element_is_locked_state, <a class="indexterm" href="GstElement.html#gst-element-is-locked-state">gst_element_is_locked_state ()</a>
</dt>
<dt id="ientry-idm10796">gst_element_iterate_pads, <a class="indexterm" href="GstElement.html#gst-element-iterate-pads">gst_element_iterate_pads ()</a>
</dt>
<dt id="ientry-idm10806">gst_element_iterate_sink_pads, <a class="indexterm" href="GstElement.html#gst-element-iterate-sink-pads">gst_element_iterate_sink_pads ()</a>
</dt>
<dt id="ientry-idm10816">gst_element_iterate_src_pads, <a class="indexterm" href="GstElement.html#gst-element-iterate-src-pads">gst_element_iterate_src_pads ()</a>
</dt>
<dt id="ientry-idm10826">gst_element_link, <a class="indexterm" href="GstElement.html#gst-element-link">gst_element_link ()</a>
</dt>
<dt id="ientry-idm10962">gst_element_link_filtered, <a class="indexterm" href="GstElement.html#gst-element-link-filtered">gst_element_link_filtered ()</a>
</dt>
<dt id="ientry-idm10852">gst_element_link_many, <a class="indexterm" href="GstElement.html#gst-element-link-many">gst_element_link_many ()</a>
</dt>
<dt id="ientry-idm10880">gst_element_link_pads, <a class="indexterm" href="GstElement.html#gst-element-link-pads">gst_element_link_pads ()</a>
</dt>
<dt id="ientry-idm10940">gst_element_link_pads_filtered, <a class="indexterm" href="GstElement.html#gst-element-link-pads-filtered">gst_element_link_pads_filtered ()</a>
</dt>
<dt id="ientry-idm10899">gst_element_link_pads_full, <a class="indexterm" href="GstElement.html#gst-element-link-pads-full">gst_element_link_pads_full ()</a>
</dt>
<dt id="ientry-idm11250">gst_element_lost_state, <a class="indexterm" href="GstElement.html#gst-element-lost-state">gst_element_lost_state ()</a>
</dt>
<dt id="ientry-idm38774">gst_element_make_from_uri, <a class="indexterm" href="gstreamer-GstUriHandler.html#gst-element-make-from-uri">gst_element_make_from_uri ()</a>
</dt>
<dt id="ientry-idm11303">gst_element_message_full, <a class="indexterm" href="GstElement.html#gst-element-message-full">gst_element_message_full ()</a>
</dt>
<dt id="ientry-idm11729">GST_ELEMENT_METADATA_AUTHOR, <a class="indexterm" href="GstElement.html#GST-ELEMENT-METADATA-AUTHOR:CAPS">GST_ELEMENT_METADATA_AUTHOR</a>
</dt>
<dt id="ientry-idm11734">GST_ELEMENT_METADATA_DESCRIPTION, <a class="indexterm" href="GstElement.html#GST-ELEMENT-METADATA-DESCRIPTION:CAPS">GST_ELEMENT_METADATA_DESCRIPTION</a>
</dt>
<dt id="ientry-idm11739">GST_ELEMENT_METADATA_DOC_URI, <a class="indexterm" href="GstElement.html#GST-ELEMENT-METADATA-DOC-URI:CAPS">GST_ELEMENT_METADATA_DOC_URI</a>
</dt>
<dt id="ientry-idm11744">GST_ELEMENT_METADATA_ICON_NAME, <a class="indexterm" href="GstElement.html#GST-ELEMENT-METADATA-ICON-NAME:CAPS">GST_ELEMENT_METADATA_ICON_NAME</a>
</dt>
<dt id="ientry-idm11749">GST_ELEMENT_METADATA_KLASS, <a class="indexterm" href="GstElement.html#GST-ELEMENT-METADATA-KLASS:CAPS">GST_ELEMENT_METADATA_KLASS</a>
</dt>
<dt id="ientry-idm11754">GST_ELEMENT_METADATA_LONGNAME, <a class="indexterm" href="GstElement.html#GST-ELEMENT-METADATA-LONGNAME:CAPS">GST_ELEMENT_METADATA_LONGNAME</a>
</dt>
<dt id="ientry-idm10488">GST_ELEMENT_NAME, <a class="indexterm" href="GstElement.html#GST-ELEMENT-NAME:CAPS">GST_ELEMENT_NAME()</a>
</dt>
<dt id="ientry-idm10760">gst_element_no_more_pads, <a class="indexterm" href="GstElement.html#gst-element-no-more-pads">gst_element_no_more_pads ()</a>
</dt>
<dt id="ientry-idm10508">GST_ELEMENT_PADS, <a class="indexterm" href="GstElement.html#GST-ELEMENT-PADS:CAPS">GST_ELEMENT_PADS()</a>
</dt>
<dt id="ientry-idm10493">GST_ELEMENT_PARENT, <a class="indexterm" href="GstElement.html#GST-ELEMENT-PARENT:CAPS">GST_ELEMENT_PARENT()</a>
</dt>
<dt id="ientry-idm11337">gst_element_post_message, <a class="indexterm" href="GstElement.html#gst-element-post-message">gst_element_post_message ()</a>
</dt>
<dt id="ientry-idm11162">gst_element_provide_clock, <a class="indexterm" href="GstElement.html#gst-element-provide-clock">gst_element_provide_clock ()</a>
</dt>
<dt id="ientry-idm11350">gst_element_query, <a class="indexterm" href="GstElement.html#gst-element-query">gst_element_query ()</a>
</dt>
<dt id="ientry-idm11363">gst_element_query_convert, <a class="indexterm" href="GstElement.html#gst-element-query-convert">gst_element_query_convert ()</a>
</dt>
<dt id="ientry-idm11401">gst_element_query_duration, <a class="indexterm" href="GstElement.html#gst-element-query-duration">gst_element_query_duration ()</a>
</dt>
<dt id="ientry-idm11385">gst_element_query_position, <a class="indexterm" href="GstElement.html#gst-element-query-position">gst_element_query_position ()</a>
</dt>
<dt id="ientry-idm12084">gst_element_register, <a class="indexterm" href="GstElementFactory.html#gst-element-register">gst_element_register ()</a>
</dt>
<dt id="ientry-idm10770">gst_element_release_request_pad, <a class="indexterm" href="GstElement.html#gst-element-release-request-pad">gst_element_release_request_pad ()</a>
</dt>
<dt id="ientry-idm10783">gst_element_remove_pad, <a class="indexterm" href="GstElement.html#gst-element-remove-pad">gst_element_remove_pad ()</a>
</dt>
<dt id="ientry-idm11512">gst_element_remove_property_notify_watch, <a class="indexterm" href="GstElement.html#gst-element-remove-property-notify-watch">gst_element_remove_property_notify_watch ()</a>
</dt>
<dt id="ientry-idm10741">gst_element_request_pad, <a class="indexterm" href="GstElement.html#gst-element-request-pad">gst_element_request_pad ()</a>
</dt>
<dt id="ientry-idm11449">gst_element_seek, <a class="indexterm" href="GstElement.html#gst-element-seek">gst_element_seek ()</a>
</dt>
<dt id="ientry-idm11430">gst_element_seek_simple, <a class="indexterm" href="GstElement.html#gst-element-seek-simple">gst_element_seek_simple ()</a>
</dt>
<dt id="ientry-idm11417">gst_element_send_event, <a class="indexterm" href="GstElement.html#gst-element-send-event">gst_element_send_event ()</a>
</dt>
<dt id="ientry-idm10991">gst_element_set_base_time, <a class="indexterm" href="GstElement.html#gst-element-set-base-time">gst_element_set_base_time ()</a>
</dt>
<dt id="ientry-idm11037">gst_element_set_bus, <a class="indexterm" href="GstElement.html#gst-element-set-bus">gst_element_set_bus ()</a>
</dt>
<dt id="ientry-idm11139">gst_element_set_clock, <a class="indexterm" href="GstElement.html#gst-element-set-clock">gst_element_set_clock ()</a>
</dt>
<dt id="ientry-idm11060">gst_element_set_context, <a class="indexterm" href="GstElement.html#gst-element-set-context">gst_element_set_context ()</a>
</dt>
<dt id="ientry-idm11204">gst_element_set_locked_state, <a class="indexterm" href="GstElement.html#gst-element-set-locked-state">gst_element_set_locked_state ()</a>
</dt>
<dt id="ientry-idm11119">gst_element_set_name, <a class="indexterm" href="GstElement.html#gst-element-set-name">gst_element_set_name()</a>
</dt>
<dt id="ientry-idm11129">gst_element_set_parent, <a class="indexterm" href="GstElement.html#gst-element-set-parent">gst_element_set_parent()</a>
</dt>
<dt id="ientry-idm11014">gst_element_set_start_time, <a class="indexterm" href="GstElement.html#gst-element-set-start-time">gst_element_set_start_time ()</a>
</dt>
<dt id="ientry-idm11172">gst_element_set_state, <a class="indexterm" href="GstElement.html#gst-element-set-state">gst_element_set_state ()</a>
</dt>
<dt id="ientry-idm10513">GST_ELEMENT_START_TIME, <a class="indexterm" href="GstElement.html#GST-ELEMENT-START-TIME:CAPS">GST_ELEMENT_START_TIME()</a>
</dt>
<dt id="ientry-idm11270">gst_element_state_change_return_get_name, <a class="indexterm" href="GstElement.html#gst-element-state-change-return-get-name">gst_element_state_change_return_get_name ()</a>
</dt>
<dt id="ientry-idm11260">gst_element_state_get_name, <a class="indexterm" href="GstElement.html#gst-element-state-get-name">gst_element_state_get_name ()</a>
</dt>
<dt id="ientry-idm11280">gst_element_sync_state_with_parent, <a class="indexterm" href="GstElement.html#gst-element-sync-state-with-parent">gst_element_sync_state_with_parent ()</a>
</dt>
<dt id="ientry-idm10839">gst_element_unlink, <a class="indexterm" href="GstElement.html#gst-element-unlink">gst_element_unlink ()</a>
</dt>
<dt id="ientry-idm10866">gst_element_unlink_many, <a class="indexterm" href="GstElement.html#gst-element-unlink-many">gst_element_unlink_many ()</a>
</dt>
<dt id="ientry-idm10921">gst_element_unlink_pads, <a class="indexterm" href="GstElement.html#gst-element-unlink-pads">gst_element_unlink_pads ()</a>
</dt>
<dt id="ientry-idm10523">GST_ELEMENT_WARNING, <a class="indexterm" href="GstElement.html#GST-ELEMENT-WARNING:CAPS">GST_ELEMENT_WARNING()</a>
</dt>
<dt id="ientry-idm44094">GST_ERROR, <a class="indexterm" href="gstreamer-GstInfo.html#GST-ERROR:CAPS">GST_ERROR()</a>
</dt>
<dt id="ientry-idm12526">gst_error_get_message, <a class="indexterm" href="gstreamer-GstGError.html#gst-error-get-message">gst_error_get_message ()</a>
</dt>
<dt id="ientry-idm44054">GST_ERROR_OBJECT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-ERROR-OBJECT:CAPS">GST_ERROR_OBJECT()</a>
</dt>
<dt id="ientry-idm12869">GST_ERROR_SYSTEM, <a class="indexterm" href="gstreamer-GstGError.html#GST-ERROR-SYSTEM:CAPS">GST_ERROR_SYSTEM</a>
</dt>
<dt id="ientry-idm13551">gst_event_copy, <a class="indexterm" href="GstEvent.html#gst-event-copy">gst_event_copy ()</a>
</dt>
<dt id="ientry-idm13880">gst_event_copy_segment, <a class="indexterm" href="GstEvent.html#gst-event-copy-segment">gst_event_copy_segment ()</a>
</dt>
<dt id="ientry-idm13663">gst_event_get_running_time_offset, <a class="indexterm" href="GstEvent.html#gst-event-get-running-time-offset">gst_event_get_running_time_offset ()</a>
</dt>
<dt id="ientry-idm13640">gst_event_get_seqnum, <a class="indexterm" href="GstEvent.html#gst-event-get-seqnum">gst_event_get_seqnum ()</a>
</dt>
<dt id="ientry-idm13617">gst_event_get_structure, <a class="indexterm" href="GstEvent.html#gst-event-get-structure">gst_event_get_structure ()</a>
</dt>
<dt id="ientry-idm13627">gst_event_has_name, <a class="indexterm" href="GstEvent.html#gst-event-has-name">gst_event_has_name ()</a>
</dt>
<dt id="ientry-idm13473">GST_EVENT_IS_DOWNSTREAM, <a class="indexterm" href="GstEvent.html#GST-EVENT-IS-DOWNSTREAM:CAPS">GST_EVENT_IS_DOWNSTREAM()</a>
</dt>
<dt id="ientry-idm13478">GST_EVENT_IS_SERIALIZED, <a class="indexterm" href="GstEvent.html#GST-EVENT-IS-SERIALIZED:CAPS">GST_EVENT_IS_SERIALIZED()</a>
</dt>
<dt id="ientry-idm13483">GST_EVENT_IS_STICKY, <a class="indexterm" href="GstEvent.html#GST-EVENT-IS-STICKY:CAPS">GST_EVENT_IS_STICKY()</a>
</dt>
<dt id="ientry-idm13468">GST_EVENT_IS_UPSTREAM, <a class="indexterm" href="GstEvent.html#GST-EVENT-IS-UPSTREAM:CAPS">GST_EVENT_IS_UPSTREAM()</a>
</dt>
<dt id="ientry-idm13584">gst_event_is_writable, <a class="indexterm" href="GstEvent.html#gst-event-is-writable">gst_event_is_writable()</a>
</dt>
<dt id="ientry-idm13443">GST_EVENT_MAKE_TYPE, <a class="indexterm" href="GstEvent.html#GST-EVENT-MAKE-TYPE:CAPS">GST_EVENT_MAKE_TYPE()</a>
</dt>
<dt id="ientry-idm13589">gst_event_make_writable, <a class="indexterm" href="GstEvent.html#gst-event-make-writable">gst_event_make_writable()</a>
</dt>
<dt id="ientry-idm13916">gst_event_new_buffer_size, <a class="indexterm" href="GstEvent.html#gst-event-new-buffer-size">gst_event_new_buffer_size ()</a>
</dt>
<dt id="ientry-idm14172">gst_event_new_caps, <a class="indexterm" href="GstEvent.html#gst-event-new-caps">gst_event_new_caps ()</a>
</dt>
<dt id="ientry-idm13604">gst_event_new_custom, <a class="indexterm" href="GstEvent.html#gst-event-new-custom">gst_event_new_custom ()</a>
</dt>
<dt id="ientry-idm13718">gst_event_new_eos, <a class="indexterm" href="GstEvent.html#gst-event-new-eos">gst_event_new_eos ()</a>
</dt>
<dt id="ientry-idm13686">gst_event_new_flush_start, <a class="indexterm" href="GstEvent.html#gst-event-new-flush-start">gst_event_new_flush_start ()</a>
</dt>
<dt id="ientry-idm13695">gst_event_new_flush_stop, <a class="indexterm" href="GstEvent.html#gst-event-new-flush-stop">gst_event_new_flush_stop ()</a>
</dt>
<dt id="ientry-idm13727">gst_event_new_gap, <a class="indexterm" href="GstEvent.html#gst-event-new-gap">gst_event_new_gap ()</a>
</dt>
<dt id="ientry-idm14067">gst_event_new_latency, <a class="indexterm" href="GstEvent.html#gst-event-new-latency">gst_event_new_latency ()</a>
</dt>
<dt id="ientry-idm14057">gst_event_new_navigation, <a class="indexterm" href="GstEvent.html#gst-event-new-navigation">gst_event_new_navigation ()</a>
</dt>
<dt id="ientry-idm14276">gst_event_new_protection, <a class="indexterm" href="GstEvent.html#gst-event-new-protection">gst_event_new_protection ()</a>
</dt>
<dt id="ientry-idm13957">gst_event_new_qos, <a class="indexterm" href="GstEvent.html#gst-event-new-qos">gst_event_new_qos ()</a>
</dt>
<dt id="ientry-idm14163">gst_event_new_reconfigure, <a class="indexterm" href="GstEvent.html#gst-event-new-reconfigure">gst_event_new_reconfigure ()</a>
</dt>
<dt id="ientry-idm13998">gst_event_new_seek, <a class="indexterm" href="GstEvent.html#gst-event-new-seek">gst_event_new_seek ()</a>
</dt>
<dt id="ientry-idm13857">gst_event_new_segment, <a class="indexterm" href="GstEvent.html#gst-event-new-segment">gst_event_new_segment ()</a>
</dt>
<dt id="ientry-idm14247">gst_event_new_segment_done, <a class="indexterm" href="GstEvent.html#gst-event-new-segment-done">gst_event_new_segment_done ()</a>
</dt>
<dt id="ientry-idm14311">gst_event_new_select_streams, <a class="indexterm" href="GstEvent.html#gst-event-new-select-streams">gst_event_new_select_streams ()</a>
</dt>
<dt id="ientry-idm14137">gst_event_new_sink_message, <a class="indexterm" href="GstEvent.html#gst-event-new-sink-message">gst_event_new_sink_message ()</a>
</dt>
<dt id="ientry-idm14090">gst_event_new_step, <a class="indexterm" href="GstEvent.html#gst-event-new-step">gst_event_new_step ()</a>
</dt>
<dt id="ientry-idm14334">gst_event_new_stream_collection, <a class="indexterm" href="GstEvent.html#gst-event-new-stream-collection">gst_event_new_stream_collection ()</a>
</dt>
<dt id="ientry-idm13756">gst_event_new_stream_start, <a class="indexterm" href="GstEvent.html#gst-event-new-stream-start">gst_event_new_stream_start ()</a>
</dt>
<dt id="ientry-idm13893">gst_event_new_tag, <a class="indexterm" href="GstEvent.html#gst-event-new-tag">gst_event_new_tag ()</a>
</dt>
<dt id="ientry-idm14195">gst_event_new_toc, <a class="indexterm" href="GstEvent.html#gst-event-new-toc">gst_event_new_toc ()</a>
</dt>
<dt id="ientry-idm14224">gst_event_new_toc_select, <a class="indexterm" href="GstEvent.html#gst-event-new-toc-select">gst_event_new_toc_select ()</a>
</dt>
<dt id="ientry-idm13935">gst_event_parse_buffer_size, <a class="indexterm" href="GstEvent.html#gst-event-parse-buffer-size">gst_event_parse_buffer_size ()</a>
</dt>
<dt id="ientry-idm14182">gst_event_parse_caps, <a class="indexterm" href="GstEvent.html#gst-event-parse-caps">gst_event_parse_caps ()</a>
</dt>
<dt id="ientry-idm13705">gst_event_parse_flush_stop, <a class="indexterm" href="GstEvent.html#gst-event-parse-flush-stop">gst_event_parse_flush_stop ()</a>
</dt>
<dt id="ientry-idm13740">gst_event_parse_gap, <a class="indexterm" href="GstEvent.html#gst-event-parse-gap">gst_event_parse_gap ()</a>
</dt>
<dt id="ientry-idm13818">gst_event_parse_group_id, <a class="indexterm" href="GstEvent.html#gst-event-parse-group-id">gst_event_parse_group_id ()</a>
</dt>
<dt id="ientry-idm14077">gst_event_parse_latency, <a class="indexterm" href="GstEvent.html#gst-event-parse-latency">gst_event_parse_latency ()</a>
</dt>
<dt id="ientry-idm14292">gst_event_parse_protection, <a class="indexterm" href="GstEvent.html#gst-event-parse-protection">gst_event_parse_protection ()</a>
</dt>
<dt id="ientry-idm13976">gst_event_parse_qos, <a class="indexterm" href="GstEvent.html#gst-event-parse-qos">gst_event_parse_qos ()</a>
</dt>
<dt id="ientry-idm14026">gst_event_parse_seek, <a class="indexterm" href="GstEvent.html#gst-event-parse-seek">gst_event_parse_seek ()</a>
</dt>
<dt id="ientry-idm13867">gst_event_parse_segment, <a class="indexterm" href="GstEvent.html#gst-event-parse-segment">gst_event_parse_segment ()</a>
</dt>
<dt id="ientry-idm14260">gst_event_parse_segment_done, <a class="indexterm" href="GstEvent.html#gst-event-parse-segment-done">gst_event_parse_segment_done ()</a>
</dt>
<dt id="ientry-idm14321">gst_event_parse_select_streams, <a class="indexterm" href="GstEvent.html#gst-event-parse-select-streams">gst_event_parse_select_streams ()</a>
</dt>
<dt id="ientry-idm14150">gst_event_parse_sink_message, <a class="indexterm" href="GstEvent.html#gst-event-parse-sink-message">gst_event_parse_sink_message ()</a>
</dt>
<dt id="ientry-idm14112">gst_event_parse_step, <a class="indexterm" href="GstEvent.html#gst-event-parse-step">gst_event_parse_step ()</a>
</dt>
<dt id="ientry-idm13844">gst_event_parse_stream, <a class="indexterm" href="GstEvent.html#gst-event-parse-stream">gst_event_parse_stream ()</a>
</dt>
<dt id="ientry-idm14344">gst_event_parse_stream_collection, <a class="indexterm" href="GstEvent.html#gst-event-parse-stream-collection">gst_event_parse_stream_collection ()</a>
</dt>
<dt id="ientry-idm13792">gst_event_parse_stream_flags, <a class="indexterm" href="GstEvent.html#gst-event-parse-stream-flags">gst_event_parse_stream_flags ()</a>
</dt>
<dt id="ientry-idm13766">gst_event_parse_stream_start, <a class="indexterm" href="GstEvent.html#gst-event-parse-stream-start">gst_event_parse_stream_start ()</a>
</dt>
<dt id="ientry-idm13903">gst_event_parse_tag, <a class="indexterm" href="GstEvent.html#gst-event-parse-tag">gst_event_parse_tag ()</a>
</dt>
<dt id="ientry-idm14208">gst_event_parse_toc, <a class="indexterm" href="GstEvent.html#gst-event-parse-toc">gst_event_parse_toc ()</a>
</dt>
<dt id="ientry-idm14234">gst_event_parse_toc_select, <a class="indexterm" href="GstEvent.html#gst-event-parse-toc-select">gst_event_parse_toc_select ()</a>
</dt>
<dt id="ientry-idm13518">gst_event_ref, <a class="indexterm" href="GstEvent.html#gst-event-ref">gst_event_ref ()</a>
</dt>
<dt id="ientry-idm13538">gst_event_replace, <a class="indexterm" href="GstEvent.html#gst-event-replace">gst_event_replace ()</a>
</dt>
<dt id="ientry-idm13463">GST_EVENT_SEQNUM, <a class="indexterm" href="GstEvent.html#GST-EVENT-SEQNUM:CAPS">GST_EVENT_SEQNUM()</a>
</dt>
<dt id="ientry-idm13805">gst_event_set_group_id, <a class="indexterm" href="GstEvent.html#gst-event-set-group-id">gst_event_set_group_id ()</a>
</dt>
<dt id="ientry-idm13673">gst_event_set_running_time_offset, <a class="indexterm" href="GstEvent.html#gst-event-set-running-time-offset">gst_event_set_running_time_offset ()</a>
</dt>
<dt id="ientry-idm13650">gst_event_set_seqnum, <a class="indexterm" href="GstEvent.html#gst-event-set-seqnum">gst_event_set_seqnum ()</a>
</dt>
<dt id="ientry-idm13831">gst_event_set_stream, <a class="indexterm" href="GstEvent.html#gst-event-set-stream">gst_event_set_stream ()</a>
</dt>
<dt id="ientry-idm13779">gst_event_set_stream_flags, <a class="indexterm" href="GstEvent.html#gst-event-set-stream-flags">gst_event_set_stream_flags ()</a>
</dt>
<dt id="ientry-idm13561">gst_event_steal, <a class="indexterm" href="GstEvent.html#gst-event-steal">gst_event_steal ()</a>
</dt>
<dt id="ientry-idm13571">gst_event_take, <a class="indexterm" href="GstEvent.html#gst-event-take">gst_event_take ()</a>
</dt>
<dt id="ientry-idm13458">GST_EVENT_TIMESTAMP, <a class="indexterm" href="GstEvent.html#GST-EVENT-TIMESTAMP:CAPS">GST_EVENT_TIMESTAMP()</a>
</dt>
<dt id="ientry-idm13448">GST_EVENT_TYPE, <a class="indexterm" href="GstEvent.html#GST-EVENT-TYPE:CAPS">GST_EVENT_TYPE()</a>
</dt>
<dt id="ientry-idm14401">GST_EVENT_TYPE_BOTH, <a class="indexterm" href="GstEvent.html#GST-EVENT-TYPE-BOTH:CAPS">GST_EVENT_TYPE_BOTH</a>
</dt>
<dt id="ientry-idm13488">gst_event_type_get_flags, <a class="indexterm" href="GstEvent.html#gst-event-type-get-flags">gst_event_type_get_flags ()</a>
</dt>
<dt id="ientry-idm13498">gst_event_type_get_name, <a class="indexterm" href="GstEvent.html#gst-event-type-get-name">gst_event_type_get_name ()</a>
</dt>
<dt id="ientry-idm13453">GST_EVENT_TYPE_NAME, <a class="indexterm" href="GstEvent.html#GST-EVENT-TYPE-NAME:CAPS">GST_EVENT_TYPE_NAME()</a>
</dt>
<dt id="ientry-idm13508">gst_event_type_to_quark, <a class="indexterm" href="GstEvent.html#gst-event-type-to-quark">gst_event_type_to_quark ()</a>
</dt>
<dt id="ientry-idm13528">gst_event_unref, <a class="indexterm" href="GstEvent.html#gst-event-unref">gst_event_unref ()</a>
</dt>
<dt id="ientry-idm13594">gst_event_writable_structure, <a class="indexterm" href="GstEvent.html#gst-event-writable-structure">gst_event_writable_structure ()</a>
</dt>
<dt id="ientry-idm38761">gst_filename_to_uri, <a class="indexterm" href="gstreamer-GstUriHandler.html#gst-filename-to-uri">gst_filename_to_uri ()</a>
</dt>
<dt id="ientry-idm44119">GST_FIXME, <a class="indexterm" href="gstreamer-GstInfo.html#GST-FIXME:CAPS">GST_FIXME()</a>
</dt>
<dt id="ientry-idm44079">GST_FIXME_OBJECT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-FIXME-OBJECT:CAPS">GST_FIXME_OBJECT()</a>
</dt>
<dt id="ientry-idm41725">gst_flagset_register, <a class="indexterm" href="gstreamer-GstValue.html#gst-flagset-register">gst_flagset_register ()</a>
</dt>
<dt id="ientry-idm41757">GST_FLAG_SET_MASK_EXACT, <a class="indexterm" href="gstreamer-GstValue.html#GST-FLAG-SET-MASK-EXACT:CAPS">GST_FLAG_SET_MASK_EXACT</a>
</dt>
<dt id="ientry-idm22254">gst_flow_get_name, <a class="indexterm" href="GstPad.html#gst-flow-get-name">gst_flow_get_name ()</a>
</dt>
<dt id="ientry-idm22264">gst_flow_to_quark, <a class="indexterm" href="GstPad.html#gst-flow-to-quark">gst_flow_to_quark ()</a>
</dt>
<dt id="ientry-idm14858">gst_formats_contains, <a class="indexterm" href="gstreamer-GstFormat.html#gst-formats-contains">gst_formats_contains ()</a>
</dt>
<dt id="ientry-idm14848">gst_format_get_by_nick, <a class="indexterm" href="gstreamer-GstFormat.html#gst-format-get-by-nick">gst_format_get_by_nick ()</a>
</dt>
<dt id="ientry-idm14871">gst_format_get_details, <a class="indexterm" href="gstreamer-GstFormat.html#gst-format-get-details">gst_format_get_details ()</a>
</dt>
<dt id="ientry-idm14815">gst_format_get_name, <a class="indexterm" href="gstreamer-GstFormat.html#gst-format-get-name">gst_format_get_name ()</a>
</dt>
<dt id="ientry-idm14881">gst_format_iterate_definitions, <a class="indexterm" href="gstreamer-GstFormat.html#gst-format-iterate-definitions">gst_format_iterate_definitions ()</a>
</dt>
<dt id="ientry-idm14934">GST_FORMAT_PERCENT_MAX, <a class="indexterm" href="gstreamer-GstFormat.html#GST-FORMAT-PERCENT-MAX:CAPS">GST_FORMAT_PERCENT_MAX</a>
</dt>
<dt id="ientry-idm14939">GST_FORMAT_PERCENT_SCALE, <a class="indexterm" href="gstreamer-GstFormat.html#GST-FORMAT-PERCENT-SCALE:CAPS">GST_FORMAT_PERCENT_SCALE</a>
</dt>
<dt id="ientry-idm14835">gst_format_register, <a class="indexterm" href="gstreamer-GstFormat.html#gst-format-register">gst_format_register ()</a>
</dt>
<dt id="ientry-idm14825">gst_format_to_quark, <a class="indexterm" href="gstreamer-GstFormat.html#gst-format-to-quark">gst_format_to_quark ()</a>
</dt>
<dt id="ientry-idm40783">GST_FOURCC_ARGS, <a class="indexterm" href="gstreamer-GstValue.html#GST-FOURCC-ARGS:CAPS">GST_FOURCC_ARGS()</a>
</dt>
<dt id="ientry-idm41737">GST_FOURCC_FORMAT, <a class="indexterm" href="gstreamer-GstValue.html#GST-FOURCC-FORMAT:CAPS">GST_FOURCC_FORMAT</a>
</dt>
<dt id="ientry-idm44518">GST_FUNCTION, <a class="indexterm" href="gstreamer-GstInfo.html#GST-FUNCTION:CAPS">GST_FUNCTION</a>
</dt>
<dt id="ientry-idm39732">gst_gdouble_to_guint64, <a class="indexterm" href="gstreamer-GstUtils.html#gst-gdouble-to-guint64">gst_gdouble_to_guint64()</a>
</dt>
<dt id="ientry-idm15185">gst_ghost_pad_activate_mode_default, <a class="indexterm" href="GstGhostPad.html#gst-ghost-pad-activate-mode-default">gst_ghost_pad_activate_mode_default ()</a>
</dt>
<dt id="ientry-idm15175">gst_ghost_pad_construct, <a class="indexterm" href="GstGhostPad.html#gst-ghost-pad-construct">gst_ghost_pad_construct ()</a>
</dt>
<dt id="ientry-idm15165">gst_ghost_pad_get_target, <a class="indexterm" href="GstGhostPad.html#gst-ghost-pad-get-target">gst_ghost_pad_get_target ()</a>
</dt>
<dt id="ientry-idm15204">gst_ghost_pad_internal_activate_mode_default, <a class="indexterm" href="GstGhostPad.html#gst-ghost-pad-internal-activate-mode-default">gst_ghost_pad_internal_activate_mode_default ()</a>
</dt>
<dt id="ientry-idm15097">gst_ghost_pad_new, <a class="indexterm" href="GstGhostPad.html#gst-ghost-pad-new">gst_ghost_pad_new ()</a>
</dt>
<dt id="ientry-idm15123">gst_ghost_pad_new_from_template, <a class="indexterm" href="GstGhostPad.html#gst-ghost-pad-new-from-template">gst_ghost_pad_new_from_template ()</a>
</dt>
<dt id="ientry-idm15110">gst_ghost_pad_new_no_target, <a class="indexterm" href="GstGhostPad.html#gst-ghost-pad-new-no-target">gst_ghost_pad_new_no_target ()</a>
</dt>
<dt id="ientry-idm15139">gst_ghost_pad_new_no_target_from_template, <a class="indexterm" href="GstGhostPad.html#gst-ghost-pad-new-no-target-from-template">gst_ghost_pad_new_no_target_from_template ()</a>
</dt>
<dt id="ientry-idm15152">gst_ghost_pad_set_target, <a class="indexterm" href="GstGhostPad.html#gst-ghost-pad-set-target">gst_ghost_pad_set_target ()</a>
</dt>
<dt id="ientry-idm39727">gst_guint64_to_gdouble, <a class="indexterm" href="gstreamer-GstUtils.html#gst-guint64-to-gdouble">gst_guint64_to_gdouble()</a>
</dt>
<dt id="ientry-idm44104">GST_INFO, <a class="indexterm" href="gstreamer-GstInfo.html#GST-INFO:CAPS">GST_INFO()</a>
</dt>
<dt id="ientry-idm44064">GST_INFO_OBJECT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-INFO-OBJECT:CAPS">GST_INFO_OBJECT()</a>
</dt>
<dt id="ientry-idm44252">gst_info_strdup_printf, <a class="indexterm" href="gstreamer-GstInfo.html#gst-info-strdup-printf">gst_info_strdup_printf ()</a>
</dt>
<dt id="ientry-idm44239">gst_info_strdup_vprintf, <a class="indexterm" href="gstreamer-GstInfo.html#gst-info-strdup-vprintf">gst_info_strdup_vprintf ()</a>
</dt>
<dt id="ientry-idm44223">gst_info_vasprintf, <a class="indexterm" href="gstreamer-GstInfo.html#gst-info-vasprintf">gst_info_vasprintf ()</a>
</dt>
<dt id="ientry-idm392">gst_init, <a class="indexterm" href="gstreamer-Gst.html#gst-init">gst_init ()</a>
</dt>
<dt id="ientry-idm405">gst_init_check, <a class="indexterm" href="gstreamer-Gst.html#gst-init-check">gst_init_check ()</a>
</dt>
<dt id="ientry-idm421">gst_init_get_option_group, <a class="indexterm" href="gstreamer-Gst.html#gst-init-get-option-group">gst_init_get_option_group ()</a>
</dt>
<dt id="ientry-idm430">gst_is_initialized, <a class="indexterm" href="gstreamer-Gst.html#gst-is-initialized">gst_is_initialized ()</a>
</dt>
<dt id="ientry-idm15622">GST_ITERATOR, <a class="indexterm" href="gstreamer-GstIterator.html#GST-ITERATOR:CAPS">GST_ITERATOR()</a>
</dt>
<dt id="ientry-idm15632">GST_ITERATOR_COOKIE, <a class="indexterm" href="gstreamer-GstIterator.html#GST-ITERATOR-COOKIE:CAPS">GST_ITERATOR_COOKIE()</a>
</dt>
<dt id="ientry-idm15714">gst_iterator_copy, <a class="indexterm" href="gstreamer-GstIterator.html#gst-iterator-copy">gst_iterator_copy ()</a>
</dt>
<dt id="ientry-idm15770">gst_iterator_filter, <a class="indexterm" href="gstreamer-GstIterator.html#gst-iterator-filter">gst_iterator_filter ()</a>
</dt>
<dt id="ientry-idm15821">gst_iterator_find_custom, <a class="indexterm" href="gstreamer-GstIterator.html#gst-iterator-find-custom">gst_iterator_find_custom ()</a>
</dt>
<dt id="ientry-idm15786">gst_iterator_fold, <a class="indexterm" href="gstreamer-GstIterator.html#gst-iterator-fold">gst_iterator_fold ()</a>
</dt>
<dt id="ientry-idm15805">gst_iterator_foreach, <a class="indexterm" href="gstreamer-GstIterator.html#gst-iterator-foreach">gst_iterator_foreach ()</a>
</dt>
<dt id="ientry-idm15724">gst_iterator_free, <a class="indexterm" href="gstreamer-GstIterator.html#gst-iterator-free">gst_iterator_free ()</a>
</dt>
<dt id="ientry-idm15627">GST_ITERATOR_LOCK, <a class="indexterm" href="gstreamer-GstIterator.html#GST-ITERATOR-LOCK:CAPS">GST_ITERATOR_LOCK()</a>
</dt>
<dt id="ientry-idm15642">gst_iterator_new, <a class="indexterm" href="gstreamer-GstIterator.html#gst-iterator-new">gst_iterator_new ()</a>
</dt>
<dt id="ientry-idm15676">gst_iterator_new_list, <a class="indexterm" href="gstreamer-GstIterator.html#gst-iterator-new-list">gst_iterator_new_list ()</a>
</dt>
<dt id="ientry-idm15701">gst_iterator_new_single, <a class="indexterm" href="gstreamer-GstIterator.html#gst-iterator-new-single">gst_iterator_new_single ()</a>
</dt>
<dt id="ientry-idm15734">gst_iterator_next, <a class="indexterm" href="gstreamer-GstIterator.html#gst-iterator-next">gst_iterator_next ()</a>
</dt>
<dt id="ientry-idm15637">GST_ITERATOR_ORIG_COOKIE, <a class="indexterm" href="gstreamer-GstIterator.html#GST-ITERATOR-ORIG-COOKIE:CAPS">GST_ITERATOR_ORIG_COOKIE()</a>
</dt>
<dt id="ientry-idm15757">gst_iterator_push, <a class="indexterm" href="gstreamer-GstIterator.html#gst-iterator-push">gst_iterator_push ()</a>
</dt>
<dt id="ientry-idm15747">gst_iterator_resync, <a class="indexterm" href="gstreamer-GstIterator.html#gst-iterator-resync">gst_iterator_resync ()</a>
</dt>
<dt id="ientry-idm44327">GST_LEVEL_DEFAULT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-LEVEL-DEFAULT:CAPS">GST_LEVEL_DEFAULT</a>
</dt>
<dt id="ientry-idm44332">GST_LEVEL_MAX, <a class="indexterm" href="gstreamer-GstInfo.html#GST-LEVEL-MAX:CAPS">GST_LEVEL_MAX</a>
</dt>
<dt id="ientry-idm12854">GST_LIBRARY_ERROR, <a class="indexterm" href="gstreamer-GstGError.html#GST-LIBRARY-ERROR:CAPS">GST_LIBRARY_ERROR</a>
</dt>
<dt id="ientry-idm26550">GST_LICENSE_UNKNOWN, <a class="indexterm" href="GstPlugin.html#GST-LICENSE-UNKNOWN:CAPS">GST_LICENSE_UNKNOWN</a>
</dt>
<dt id="ientry-idm20029">GST_LOCK_FLAG_READWRITE, <a class="indexterm" href="gstreamer-GstMiniObject.html#GST-LOCK-FLAG-READWRITE:CAPS">GST_LOCK_FLAG_READWRITE</a>
</dt>
<dt id="ientry-idm44114">GST_LOG, <a class="indexterm" href="gstreamer-GstInfo.html#GST-LOG:CAPS">GST_LOG()</a>
</dt>
<dt id="ientry-idm44074">GST_LOG_OBJECT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-LOG-OBJECT:CAPS">GST_LOG_OBJECT()</a>
</dt>
<dt id="ientry-idm40773">GST_MAKE_FOURCC, <a class="indexterm" href="gstreamer-GstValue.html#GST-MAKE-FOURCC:CAPS">GST_MAKE_FOURCC()</a>
</dt>
<dt id="ientry-idm16638">GST_MAP_INFO_INIT, <a class="indexterm" href="GstMemory.html#GST-MAP-INFO-INIT:CAPS">GST_MAP_INFO_INIT</a>
</dt>
<dt id="ientry-idm16628">GST_MAP_READWRITE, <a class="indexterm" href="GstMemory.html#GST-MAP-READWRITE:CAPS">GST_MAP_READWRITE</a>
</dt>
<dt id="ientry-idm44129">GST_MEMDUMP, <a class="indexterm" href="gstreamer-GstInfo.html#GST-MEMDUMP:CAPS">GST_MEMDUMP()</a>
</dt>
<dt id="ientry-idm44089">GST_MEMDUMP_OBJECT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-MEMDUMP-OBJECT:CAPS">GST_MEMDUMP_OBJECT()</a>
</dt>
<dt id="ientry-idm775">gst_memory_alignment, <a class="indexterm" href="GstAllocator.html#gst-memory-alignment">gst_memory_alignment</a>
</dt>
<dt id="ientry-idm16499">gst_memory_copy, <a class="indexterm" href="GstMemory.html#gst-memory-copy">gst_memory_copy ()</a>
</dt>
<dt id="ientry-idm16176">GST_MEMORY_FLAGS, <a class="indexterm" href="GstMemory.html#GST-MEMORY-FLAGS:CAPS">GST_MEMORY_FLAGS()</a>
</dt>
<dt id="ientry-idm16181">GST_MEMORY_FLAG_IS_SET, <a class="indexterm" href="GstMemory.html#GST-MEMORY-FLAG-IS-SET:CAPS">GST_MEMORY_FLAG_IS_SET()</a>
</dt>
<dt id="ientry-idm16186">GST_MEMORY_FLAG_UNSET, <a class="indexterm" href="GstMemory.html#GST-MEMORY-FLAG-UNSET:CAPS">GST_MEMORY_FLAG_UNSET()</a>
</dt>
<dt id="ientry-idm16402">gst_memory_get_sizes, <a class="indexterm" href="GstMemory.html#gst-memory-get-sizes">gst_memory_get_sizes ()</a>
</dt>
<dt id="ientry-idm16338">gst_memory_init, <a class="indexterm" href="GstMemory.html#gst-memory-init">gst_memory_init ()</a>
</dt>
<dt id="ientry-idm16216">GST_MEMORY_IS_NOT_MAPPABLE, <a class="indexterm" href="GstMemory.html#GST-MEMORY-IS-NOT-MAPPABLE:CAPS">GST_MEMORY_IS_NOT_MAPPABLE()</a>
</dt>
<dt id="ientry-idm16196">GST_MEMORY_IS_NO_SHARE, <a class="indexterm" href="GstMemory.html#GST-MEMORY-IS-NO-SHARE:CAPS">GST_MEMORY_IS_NO_SHARE()</a>
</dt>
<dt id="ientry-idm16211">GST_MEMORY_IS_PHYSICALLY_CONTIGUOUS, <a class="indexterm" href="GstMemory.html#GST-MEMORY-IS-PHYSICALLY-CONTIGUOUS:CAPS">GST_MEMORY_IS_PHYSICALLY_CONTIGUOUS()</a>
</dt>
<dt id="ientry-idm16191">GST_MEMORY_IS_READONLY, <a class="indexterm" href="GstMemory.html#GST-MEMORY-IS-READONLY:CAPS">GST_MEMORY_IS_READONLY()</a>
</dt>
<dt id="ientry-idm16531">gst_memory_is_span, <a class="indexterm" href="GstMemory.html#gst-memory-is-span">gst_memory_is_span ()</a>
</dt>
<dt id="ientry-idm16369">gst_memory_is_type, <a class="indexterm" href="GstMemory.html#gst-memory-is-type">gst_memory_is_type ()</a>
</dt>
<dt id="ientry-idm16444">gst_memory_is_writable, <a class="indexterm" href="GstMemory.html#gst-memory-is-writable">gst_memory_is_writable()</a>
</dt>
<dt id="ientry-idm16201">GST_MEMORY_IS_ZERO_PADDED, <a class="indexterm" href="GstMemory.html#GST-MEMORY-IS-ZERO-PADDED:CAPS">GST_MEMORY_IS_ZERO_PADDED()</a>
</dt>
<dt id="ientry-idm16206">GST_MEMORY_IS_ZERO_PREFIXED, <a class="indexterm" href="GstMemory.html#GST-MEMORY-IS-ZERO-PREFIXED:CAPS">GST_MEMORY_IS_ZERO_PREFIXED()</a>
</dt>
<dt id="ientry-idm16434">gst_memory_lock, <a class="indexterm" href="GstMemory.html#gst-memory-lock">gst_memory_lock()</a>
</dt>
<dt id="ientry-idm16454">gst_memory_make_mapped, <a class="indexterm" href="GstMemory.html#gst-memory-make-mapped">gst_memory_make_mapped ()</a>
</dt>
<dt id="ientry-idm16449">gst_memory_make_writable, <a class="indexterm" href="GstMemory.html#gst-memory-make-writable">gst_memory_make_writable()</a>
</dt>
<dt id="ientry-idm16470">gst_memory_map, <a class="indexterm" href="GstMemory.html#gst-memory-map">gst_memory_map ()</a>
</dt>
<dt id="ientry-idm745">gst_memory_new_wrapped, <a class="indexterm" href="GstAllocator.html#gst-memory-new-wrapped">gst_memory_new_wrapped ()</a>
</dt>
<dt id="ientry-idm16382">gst_memory_ref, <a class="indexterm" href="GstMemory.html#gst-memory-ref">gst_memory_ref ()</a>
</dt>
<dt id="ientry-idm16418">gst_memory_resize, <a class="indexterm" href="GstMemory.html#gst-memory-resize">gst_memory_resize ()</a>
</dt>
<dt id="ientry-idm16515">gst_memory_share, <a class="indexterm" href="GstMemory.html#gst-memory-share">gst_memory_share ()</a>
</dt>
<dt id="ientry-idm16439">gst_memory_unlock, <a class="indexterm" href="GstMemory.html#gst-memory-unlock">gst_memory_unlock()</a>
</dt>
<dt id="ientry-idm16486">gst_memory_unmap, <a class="indexterm" href="GstMemory.html#gst-memory-unmap">gst_memory_unmap ()</a>
</dt>
<dt id="ientry-idm16392">gst_memory_unref, <a class="indexterm" href="GstMemory.html#gst-memory-unref">gst_memory_unref ()</a>
</dt>
<dt id="ientry-idm17433">gst_message_copy, <a class="indexterm" href="GstMessage.html#gst-message-copy">gst_message_copy ()</a>
</dt>
<dt id="ientry-idm17458">gst_message_get_seqnum, <a class="indexterm" href="GstMessage.html#gst-message-get-seqnum">gst_message_get_seqnum ()</a>
</dt>
<dt id="ientry-idm18481">gst_message_get_stream_status_object, <a class="indexterm" href="GstMessage.html#gst-message-get-stream-status-object">gst_message_get_stream_status_object ()</a>
</dt>
<dt id="ientry-idm17443">gst_message_get_structure, <a class="indexterm" href="GstMessage.html#gst-message-get-structure">gst_message_get_structure ()</a>
</dt>
<dt id="ientry-idm17481">gst_message_has_name, <a class="indexterm" href="GstMessage.html#gst-message-has-name">gst_message_has_name ()</a>
</dt>
<dt id="ientry-idm17494">gst_message_is_writable, <a class="indexterm" href="GstMessage.html#gst-message-is-writable">gst_message_is_writable()</a>
</dt>
<dt id="ientry-idm17453">gst_message_make_writable, <a class="indexterm" href="GstMessage.html#gst-message-make-writable">gst_message_make_writable()</a>
</dt>
<dt id="ientry-idm17908">gst_message_new_application, <a class="indexterm" href="GstMessage.html#gst-message-new-application">gst_message_new_application ()</a>
</dt>
<dt id="ientry-idm18044">gst_message_new_async_done, <a class="indexterm" href="GstMessage.html#gst-message-new-async-done">gst_message_new_async_done ()</a>
</dt>
<dt id="ientry-idm18034">gst_message_new_async_start, <a class="indexterm" href="GstMessage.html#gst-message-new-async-start">gst_message_new_async_start ()</a>
</dt>
<dt id="ientry-idm17644">gst_message_new_buffering, <a class="indexterm" href="GstMessage.html#gst-message-new-buffering">gst_message_new_buffering ()</a>
</dt>
<dt id="ientry-idm17856">gst_message_new_clock_lost, <a class="indexterm" href="GstMessage.html#gst-message-new-clock-lost">gst_message_new_clock_lost ()</a>
</dt>
<dt id="ientry-idm17824">gst_message_new_clock_provide, <a class="indexterm" href="GstMessage.html#gst-message-new-clock-provide">gst_message_new_clock_provide ()</a>
</dt>
<dt id="ientry-idm17934">gst_message_new_custom, <a class="indexterm" href="GstMessage.html#gst-message-new-custom">gst_message_new_custom ()</a>
</dt>
<dt id="ientry-idm18581">gst_message_new_device_added, <a class="indexterm" href="GstMessage.html#gst-message-new-device-added">gst_message_new_device_added ()</a>
</dt>
<dt id="ientry-idm18594">gst_message_new_device_removed, <a class="indexterm" href="GstMessage.html#gst-message-new-device-removed">gst_message_new_device_removed ()</a>
</dt>
<dt id="ientry-idm18014">gst_message_new_duration_changed, <a class="indexterm" href="GstMessage.html#gst-message-new-duration-changed">gst_message_new_duration_changed ()</a>
</dt>
<dt id="ientry-idm17921">gst_message_new_element, <a class="indexterm" href="GstMessage.html#gst-message-new-element">gst_message_new_element ()</a>
</dt>
<dt id="ientry-idm17512">gst_message_new_eos, <a class="indexterm" href="GstMessage.html#gst-message-new-eos">gst_message_new_eos ()</a>
</dt>
<dt id="ientry-idm17522">gst_message_new_error, <a class="indexterm" href="GstMessage.html#gst-message-new-error">gst_message_new_error ()</a>
</dt>
<dt id="ientry-idm18555">gst_message_new_have_context, <a class="indexterm" href="GstMessage.html#gst-message-new-have-context">gst_message_new_have_context ()</a>
</dt>
<dt id="ientry-idm17586">gst_message_new_info, <a class="indexterm" href="GstMessage.html#gst-message-new-info">gst_message_new_info ()</a>
</dt>
<dt id="ientry-idm18024">gst_message_new_latency, <a class="indexterm" href="GstMessage.html#gst-message-new-latency">gst_message_new_latency ()</a>
</dt>
<dt id="ientry-idm18529">gst_message_new_need_context, <a class="indexterm" href="GstMessage.html#gst-message-new-need-context">gst_message_new_need_context ()</a>
</dt>
<dt id="ientry-idm17882">gst_message_new_new_clock, <a class="indexterm" href="GstMessage.html#gst-message-new-new-clock">gst_message_new_new_clock ()</a>
</dt>
<dt id="ientry-idm18491">gst_message_new_progress, <a class="indexterm" href="GstMessage.html#gst-message-new-progress">gst_message_new_progress ()</a>
</dt>
<dt id="ientry-idm18633">gst_message_new_property_notify, <a class="indexterm" href="GstMessage.html#gst-message-new-property-notify">gst_message_new_property_notify ()</a>
</dt>
<dt id="ientry-idm18126">gst_message_new_qos, <a class="indexterm" href="GstMessage.html#gst-message-new-qos">gst_message_new_qos ()</a>
</dt>
<dt id="ientry-idm18410">gst_message_new_request_state, <a class="indexterm" href="GstMessage.html#gst-message-new-request-state">gst_message_new_request_state ()</a>
</dt>
<dt id="ientry-idm18284">gst_message_new_reset_time, <a class="indexterm" href="GstMessage.html#gst-message-new-reset-time">gst_message_new_reset_time ()</a>
</dt>
<dt id="ientry-idm17982">gst_message_new_segment_done, <a class="indexterm" href="GstMessage.html#gst-message-new-segment-done">gst_message_new_segment_done ()</a>
</dt>
<dt id="ientry-idm17950">gst_message_new_segment_start, <a class="indexterm" href="GstMessage.html#gst-message-new-segment-start">gst_message_new_segment_start ()</a>
</dt>
<dt id="ientry-idm17714">gst_message_new_state_changed, <a class="indexterm" href="GstMessage.html#gst-message-new-state-changed">gst_message_new_state_changed ()</a>
</dt>
<dt id="ientry-idm17752">gst_message_new_state_dirty, <a class="indexterm" href="GstMessage.html#gst-message-new-state-dirty">gst_message_new_state_dirty ()</a>
</dt>
<dt id="ientry-idm17762">gst_message_new_step_done, <a class="indexterm" href="GstMessage.html#gst-message-new-step-done">gst_message_new_step_done ()</a>
</dt>
<dt id="ientry-idm18070">gst_message_new_step_start, <a class="indexterm" href="GstMessage.html#gst-message-new-step-start">gst_message_new_step_start ()</a>
</dt>
<dt id="ientry-idm18668">gst_message_new_streams_selected, <a class="indexterm" href="GstMessage.html#gst-message-new-streams-selected">gst_message_new_streams_selected ()</a>
</dt>
<dt id="ientry-idm18346">gst_message_new_stream_collection, <a class="indexterm" href="GstMessage.html#gst-message-new-stream-collection">gst_message_new_stream_collection ()</a>
</dt>
<dt id="ientry-idm18310">gst_message_new_stream_start, <a class="indexterm" href="GstMessage.html#gst-message-new-stream-start">gst_message_new_stream_start ()</a>
</dt>
<dt id="ientry-idm18436">gst_message_new_stream_status, <a class="indexterm" href="GstMessage.html#gst-message-new-stream-status">gst_message_new_stream_status ()</a>
</dt>
<dt id="ientry-idm18372">gst_message_new_structure_change, <a class="indexterm" href="GstMessage.html#gst-message-new-structure-change">gst_message_new_structure_change ()</a>
</dt>
<dt id="ientry-idm17618">gst_message_new_tag, <a class="indexterm" href="GstMessage.html#gst-message-new-tag">gst_message_new_tag ()</a>
</dt>
<dt id="ientry-idm18252">gst_message_new_toc, <a class="indexterm" href="GstMessage.html#gst-message-new-toc">gst_message_new_toc ()</a>
</dt>
<dt id="ientry-idm17554">gst_message_new_warning, <a class="indexterm" href="GstMessage.html#gst-message-new-warning">gst_message_new_warning ()</a>
</dt>
<dt id="ientry-idm18057">gst_message_parse_async_done, <a class="indexterm" href="GstMessage.html#gst-message-parse-async-done">gst_message_parse_async_done ()</a>
</dt>
<dt id="ientry-idm17657">gst_message_parse_buffering, <a class="indexterm" href="GstMessage.html#gst-message-parse-buffering">gst_message_parse_buffering ()</a>
</dt>
<dt id="ientry-idm17692">gst_message_parse_buffering_stats, <a class="indexterm" href="GstMessage.html#gst-message-parse-buffering-stats">gst_message_parse_buffering_stats ()</a>
</dt>
<dt id="ientry-idm17869">gst_message_parse_clock_lost, <a class="indexterm" href="GstMessage.html#gst-message-parse-clock-lost">gst_message_parse_clock_lost ()</a>
</dt>
<dt id="ientry-idm17840">gst_message_parse_clock_provide, <a class="indexterm" href="GstMessage.html#gst-message-parse-clock-provide">gst_message_parse_clock_provide ()</a>
</dt>
<dt id="ientry-idm18542">gst_message_parse_context_type, <a class="indexterm" href="GstMessage.html#gst-message-parse-context-type">gst_message_parse_context_type ()</a>
</dt>
<dt id="ientry-idm18607">gst_message_parse_device_added, <a class="indexterm" href="GstMessage.html#gst-message-parse-device-added">gst_message_parse_device_added ()</a>
</dt>
<dt id="ientry-idm18620">gst_message_parse_device_removed, <a class="indexterm" href="GstMessage.html#gst-message-parse-device-removed">gst_message_parse_device_removed ()</a>
</dt>
<dt id="ientry-idm17538">gst_message_parse_error, <a class="indexterm" href="GstMessage.html#gst-message-parse-error">gst_message_parse_error ()</a>
</dt>
<dt id="ientry-idm18333">gst_message_parse_group_id, <a class="indexterm" href="GstMessage.html#gst-message-parse-group-id">gst_message_parse_group_id ()</a>
</dt>
<dt id="ientry-idm18568">gst_message_parse_have_context, <a class="indexterm" href="GstMessage.html#gst-message-parse-have-context">gst_message_parse_have_context ()</a>
</dt>
<dt id="ientry-idm17602">gst_message_parse_info, <a class="indexterm" href="GstMessage.html#gst-message-parse-info">gst_message_parse_info ()</a>
</dt>
<dt id="ientry-idm17895">gst_message_parse_new_clock, <a class="indexterm" href="GstMessage.html#gst-message-parse-new-clock">gst_message_parse_new_clock ()</a>
</dt>
<dt id="ientry-idm18510">gst_message_parse_progress, <a class="indexterm" href="GstMessage.html#gst-message-parse-progress">gst_message_parse_progress ()</a>
</dt>
<dt id="ientry-idm18649">gst_message_parse_property_notify, <a class="indexterm" href="GstMessage.html#gst-message-parse-property-notify">gst_message_parse_property_notify ()</a>
</dt>
<dt id="ientry-idm18189">gst_message_parse_qos, <a class="indexterm" href="GstMessage.html#gst-message-parse-qos">gst_message_parse_qos ()</a>
</dt>
<dt id="ientry-idm18233">gst_message_parse_qos_stats, <a class="indexterm" href="GstMessage.html#gst-message-parse-qos-stats">gst_message_parse_qos_stats ()</a>
</dt>
<dt id="ientry-idm18214">gst_message_parse_qos_values, <a class="indexterm" href="GstMessage.html#gst-message-parse-qos-values">gst_message_parse_qos_values ()</a>
</dt>
<dt id="ientry-idm18423">gst_message_parse_request_state, <a class="indexterm" href="GstMessage.html#gst-message-parse-request-state">gst_message_parse_request_state ()</a>
</dt>
<dt id="ientry-idm18297">gst_message_parse_reset_time, <a class="indexterm" href="GstMessage.html#gst-message-parse-reset-time">gst_message_parse_reset_time ()</a>
</dt>
<dt id="ientry-idm17998">gst_message_parse_segment_done, <a class="indexterm" href="GstMessage.html#gst-message-parse-segment-done">gst_message_parse_segment_done ()</a>
</dt>
<dt id="ientry-idm17966">gst_message_parse_segment_start, <a class="indexterm" href="GstMessage.html#gst-message-parse-segment-start">gst_message_parse_segment_start ()</a>
</dt>
<dt id="ientry-idm17733">gst_message_parse_state_changed, <a class="indexterm" href="GstMessage.html#gst-message-parse-state-changed">gst_message_parse_state_changed ()</a>
</dt>
<dt id="ientry-idm17793">gst_message_parse_step_done, <a class="indexterm" href="GstMessage.html#gst-message-parse-step-done">gst_message_parse_step_done ()</a>
</dt>
<dt id="ientry-idm18098">gst_message_parse_step_start, <a class="indexterm" href="GstMessage.html#gst-message-parse-step-start">gst_message_parse_step_start ()</a>
</dt>
<dt id="ientry-idm18681">gst_message_parse_streams_selected, <a class="indexterm" href="GstMessage.html#gst-message-parse-streams-selected">gst_message_parse_streams_selected ()</a>
</dt>
<dt id="ientry-idm18359">gst_message_parse_stream_collection, <a class="indexterm" href="GstMessage.html#gst-message-parse-stream-collection">gst_message_parse_stream_collection ()</a>
</dt>
<dt id="ientry-idm18452">gst_message_parse_stream_status, <a class="indexterm" href="GstMessage.html#gst-message-parse-stream-status">gst_message_parse_stream_status ()</a>
</dt>
<dt id="ientry-idm18391">gst_message_parse_structure_change, <a class="indexterm" href="GstMessage.html#gst-message-parse-structure-change">gst_message_parse_structure_change ()</a>
</dt>
<dt id="ientry-idm17631">gst_message_parse_tag, <a class="indexterm" href="GstMessage.html#gst-message-parse-tag">gst_message_parse_tag ()</a>
</dt>
<dt id="ientry-idm18268">gst_message_parse_toc, <a class="indexterm" href="GstMessage.html#gst-message-parse-toc">gst_message_parse_toc ()</a>
</dt>
<dt id="ientry-idm17570">gst_message_parse_warning, <a class="indexterm" href="GstMessage.html#gst-message-parse-warning">gst_message_parse_warning ()</a>
</dt>
<dt id="ientry-idm17413">gst_message_ref, <a class="indexterm" href="GstMessage.html#gst-message-ref">gst_message_ref ()</a>
</dt>
<dt id="ientry-idm17499">gst_message_replace, <a class="indexterm" href="GstMessage.html#gst-message-replace">gst_message_replace ()</a>
</dt>
<dt id="ientry-idm17373">GST_MESSAGE_SEQNUM, <a class="indexterm" href="GstMessage.html#GST-MESSAGE-SEQNUM:CAPS">GST_MESSAGE_SEQNUM()</a>
</dt>
<dt id="ientry-idm17670">gst_message_set_buffering_stats, <a class="indexterm" href="GstMessage.html#gst-message-set-buffering-stats">gst_message_set_buffering_stats ()</a>
</dt>
<dt id="ientry-idm18320">gst_message_set_group_id, <a class="indexterm" href="GstMessage.html#gst-message-set-group-id">gst_message_set_group_id ()</a>
</dt>
<dt id="ientry-idm18170">gst_message_set_qos_stats, <a class="indexterm" href="GstMessage.html#gst-message-set-qos-stats">gst_message_set_qos_stats ()</a>
</dt>
<dt id="ientry-idm18151">gst_message_set_qos_values, <a class="indexterm" href="GstMessage.html#gst-message-set-qos-values">gst_message_set_qos_values ()</a>
</dt>
<dt id="ientry-idm17468">gst_message_set_seqnum, <a class="indexterm" href="GstMessage.html#gst-message-set-seqnum">gst_message_set_seqnum ()</a>
</dt>
<dt id="ientry-idm18468">gst_message_set_stream_status_object, <a class="indexterm" href="GstMessage.html#gst-message-set-stream-status-object">gst_message_set_stream_status_object ()</a>
</dt>
<dt id="ientry-idm17358">GST_MESSAGE_SRC, <a class="indexterm" href="GstMessage.html#GST-MESSAGE-SRC:CAPS">GST_MESSAGE_SRC()</a>
</dt>
<dt id="ientry-idm17363">GST_MESSAGE_SRC_NAME, <a class="indexterm" href="GstMessage.html#GST-MESSAGE-SRC-NAME:CAPS">GST_MESSAGE_SRC_NAME()</a>
</dt>
<dt id="ientry-idm18694">gst_message_streams_selected_add, <a class="indexterm" href="GstMessage.html#gst-message-streams-selected-add">gst_message_streams_selected_add ()</a>
</dt>
<dt id="ientry-idm18707">gst_message_streams_selected_get_size, <a class="indexterm" href="GstMessage.html#gst-message-streams-selected-get-size">gst_message_streams_selected_get_size ()</a>
</dt>
<dt id="ientry-idm18717">gst_message_streams_selected_get_stream, <a class="indexterm" href="GstMessage.html#gst-message-streams-selected-get-stream">gst_message_streams_selected_get_stream ()</a>
</dt>
<dt id="ientry-idm17368">GST_MESSAGE_TIMESTAMP, <a class="indexterm" href="GstMessage.html#GST-MESSAGE-TIMESTAMP:CAPS">GST_MESSAGE_TIMESTAMP()</a>
</dt>
<dt id="ientry-idm17378">GST_MESSAGE_TYPE, <a class="indexterm" href="GstMessage.html#GST-MESSAGE-TYPE:CAPS">GST_MESSAGE_TYPE()</a>
</dt>
<dt id="ientry-idm17403">gst_message_type_get_name, <a class="indexterm" href="GstMessage.html#gst-message-type-get-name">gst_message_type_get_name ()</a>
</dt>
<dt id="ientry-idm17383">GST_MESSAGE_TYPE_IS_EXTENDED, <a class="indexterm" href="GstMessage.html#GST-MESSAGE-TYPE-IS-EXTENDED:CAPS">GST_MESSAGE_TYPE_IS_EXTENDED()</a>
</dt>
<dt id="ientry-idm17388">GST_MESSAGE_TYPE_NAME, <a class="indexterm" href="GstMessage.html#GST-MESSAGE-TYPE-NAME:CAPS">GST_MESSAGE_TYPE_NAME()</a>
</dt>
<dt id="ientry-idm17393">gst_message_type_to_quark, <a class="indexterm" href="GstMessage.html#gst-message-type-to-quark">gst_message_type_to_quark ()</a>
</dt>
<dt id="ientry-idm17423">gst_message_unref, <a class="indexterm" href="GstMessage.html#gst-message-unref">gst_message_unref ()</a>
</dt>
<dt id="ientry-idm19298">gst_meta_api_type_get_tags, <a class="indexterm" href="gstreamer-GstMeta.html#gst-meta-api-type-get-tags">gst_meta_api_type_get_tags ()</a>
</dt>
<dt id="ientry-idm19285">gst_meta_api_type_has_tag, <a class="indexterm" href="gstreamer-GstMeta.html#gst-meta-api-type-has-tag">gst_meta_api_type_has_tag ()</a>
</dt>
<dt id="ientry-idm19272">gst_meta_api_type_register, <a class="indexterm" href="gstreamer-GstMeta.html#gst-meta-api-type-register">gst_meta_api_type_register ()</a>
</dt>
<dt id="ientry-idm19190">GST_META_FLAGS, <a class="indexterm" href="gstreamer-GstMeta.html#GST-META-FLAGS:CAPS">GST_META_FLAGS()</a>
</dt>
<dt id="ientry-idm19195">GST_META_FLAG_IS_SET, <a class="indexterm" href="gstreamer-GstMeta.html#GST-META-FLAG-IS-SET:CAPS">GST_META_FLAG_IS_SET()</a>
</dt>
<dt id="ientry-idm19200">GST_META_FLAG_SET, <a class="indexterm" href="gstreamer-GstMeta.html#GST-META-FLAG-SET:CAPS">GST_META_FLAG_SET()</a>
</dt>
<dt id="ientry-idm19205">GST_META_FLAG_UNSET, <a class="indexterm" href="gstreamer-GstMeta.html#GST-META-FLAG-UNSET:CAPS">GST_META_FLAG_UNSET()</a>
</dt>
<dt id="ientry-idm19333">gst_meta_get_info, <a class="indexterm" href="gstreamer-GstMeta.html#gst-meta-get-info">gst_meta_get_info ()</a>
</dt>
<dt id="ientry-idm19308">gst_meta_register, <a class="indexterm" href="gstreamer-GstMeta.html#gst-meta-register">gst_meta_register ()</a>
</dt>
<dt id="ientry-idm19397">GST_META_TAG_MEMORY, <a class="indexterm" href="gstreamer-GstMeta.html#GST-META-TAG-MEMORY:CAPS">GST_META_TAG_MEMORY</a>
</dt>
<dt id="ientry-idm19405">GST_META_TAG_MEMORY_STR, <a class="indexterm" href="gstreamer-GstMeta.html#GST-META-TAG-MEMORY-STR:CAPS">GST_META_TAG_MEMORY_STR</a>
</dt>
<dt id="ientry-idm19267">GST_META_TRANSFORM_IS_COPY, <a class="indexterm" href="gstreamer-GstMeta.html#GST-META-TRANSFORM-IS-COPY:CAPS">GST_META_TRANSFORM_IS_COPY()</a>
</dt>
<dt id="ientry-idm19867">gst_mini_object_copy, <a class="indexterm" href="gstreamer-GstMiniObject.html#gst-mini-object-copy">gst_mini_object_copy ()</a>
</dt>
<dt id="ientry-idm19704">GST_MINI_OBJECT_FLAGS, <a class="indexterm" href="gstreamer-GstMiniObject.html#GST-MINI-OBJECT-FLAGS:CAPS">GST_MINI_OBJECT_FLAGS()</a>
</dt>
<dt id="ientry-idm19709">GST_MINI_OBJECT_FLAG_IS_SET, <a class="indexterm" href="gstreamer-GstMiniObject.html#GST-MINI-OBJECT-FLAG-IS-SET:CAPS">GST_MINI_OBJECT_FLAG_IS_SET()</a>
</dt>
<dt id="ientry-idm19714">GST_MINI_OBJECT_FLAG_SET, <a class="indexterm" href="gstreamer-GstMiniObject.html#GST-MINI-OBJECT-FLAG-SET:CAPS">GST_MINI_OBJECT_FLAG_SET()</a>
</dt>
<dt id="ientry-idm19719">GST_MINI_OBJECT_FLAG_UNSET, <a class="indexterm" href="gstreamer-GstMiniObject.html#GST-MINI-OBJECT-FLAG-UNSET:CAPS">GST_MINI_OBJECT_FLAG_UNSET()</a>
</dt>
<dt id="ientry-idm19896">gst_mini_object_get_qdata, <a class="indexterm" href="gstreamer-GstMiniObject.html#gst-mini-object-get-qdata">gst_mini_object_get_qdata ()</a>
</dt>
<dt id="ientry-idm19744">gst_mini_object_init, <a class="indexterm" href="gstreamer-GstMiniObject.html#gst-mini-object-init">gst_mini_object_init ()</a>
</dt>
<dt id="ientry-idm19724">GST_MINI_OBJECT_IS_LOCKABLE, <a class="indexterm" href="gstreamer-GstMiniObject.html#GST-MINI-OBJECT-IS-LOCKABLE:CAPS">GST_MINI_OBJECT_IS_LOCKABLE()</a>
</dt>
<dt id="ientry-idm19847">gst_mini_object_is_writable, <a class="indexterm" href="gstreamer-GstMiniObject.html#gst-mini-object-is-writable">gst_mini_object_is_writable ()</a>
</dt>
<dt id="ientry-idm19821">gst_mini_object_lock, <a class="indexterm" href="gstreamer-GstMiniObject.html#gst-mini-object-lock">gst_mini_object_lock ()</a>
</dt>
<dt id="ientry-idm19857">gst_mini_object_make_writable, <a class="indexterm" href="gstreamer-GstMiniObject.html#gst-mini-object-make-writable">gst_mini_object_make_writable ()</a>
</dt>
<dt id="ientry-idm19769">gst_mini_object_ref, <a class="indexterm" href="gstreamer-GstMiniObject.html#gst-mini-object-ref">gst_mini_object_ref ()</a>
</dt>
<dt id="ientry-idm19729">GST_MINI_OBJECT_REFCOUNT, <a class="indexterm" href="gstreamer-GstMiniObject.html#GST-MINI-OBJECT-REFCOUNT:CAPS">GST_MINI_OBJECT_REFCOUNT()</a>
</dt>
<dt id="ientry-idm19734">GST_MINI_OBJECT_REFCOUNT_VALUE, <a class="indexterm" href="gstreamer-GstMiniObject.html#GST-MINI-OBJECT-REFCOUNT-VALUE:CAPS">GST_MINI_OBJECT_REFCOUNT_VALUE()</a>
</dt>
<dt id="ientry-idm19922">gst_mini_object_replace, <a class="indexterm" href="gstreamer-GstMiniObject.html#gst-mini-object-replace">gst_mini_object_replace ()</a>
</dt>
<dt id="ientry-idm19877">gst_mini_object_set_qdata, <a class="indexterm" href="gstreamer-GstMiniObject.html#gst-mini-object-set-qdata">gst_mini_object_set_qdata ()</a>
</dt>
<dt id="ientry-idm19948">gst_mini_object_steal, <a class="indexterm" href="gstreamer-GstMiniObject.html#gst-mini-object-steal">gst_mini_object_steal ()</a>
</dt>
<dt id="ientry-idm19909">gst_mini_object_steal_qdata, <a class="indexterm" href="gstreamer-GstMiniObject.html#gst-mini-object-steal-qdata">gst_mini_object_steal_qdata ()</a>
</dt>
<dt id="ientry-idm19935">gst_mini_object_take, <a class="indexterm" href="gstreamer-GstMiniObject.html#gst-mini-object-take">gst_mini_object_take ()</a>
</dt>
<dt id="ientry-idm19699">GST_MINI_OBJECT_TYPE, <a class="indexterm" href="gstreamer-GstMiniObject.html#GST-MINI-OBJECT-TYPE:CAPS">GST_MINI_OBJECT_TYPE()</a>
</dt>
<dt id="ientry-idm19834">gst_mini_object_unlock, <a class="indexterm" href="gstreamer-GstMiniObject.html#gst-mini-object-unlock">gst_mini_object_unlock ()</a>
</dt>
<dt id="ientry-idm19779">gst_mini_object_unref, <a class="indexterm" href="gstreamer-GstMiniObject.html#gst-mini-object-unref">gst_mini_object_unref ()</a>
</dt>
<dt id="ientry-idm19789">gst_mini_object_weak_ref, <a class="indexterm" href="gstreamer-GstMiniObject.html#gst-mini-object-weak-ref">gst_mini_object_weak_ref ()</a>
</dt>
<dt id="ientry-idm19805">gst_mini_object_weak_unref, <a class="indexterm" href="gstreamer-GstMiniObject.html#gst-mini-object-weak-unref">gst_mini_object_weak_unref ()</a>
</dt>
<dt id="ientry-idm8166">GST_MSECOND, <a class="indexterm" href="GstClock.html#GST-MSECOND:CAPS">GST_MSECOND</a>
</dt>
<dt id="ientry-idm8176">GST_NSECOND, <a class="indexterm" href="GstClock.html#GST-NSECOND:CAPS">GST_NSECOND</a>
</dt>
<dt id="ientry-idm20736">gst_object_add_control_binding, <a class="indexterm" href="GstObject.html#gst-object-add-control-binding">gst_object_add_control_binding ()</a>
</dt>
<dt id="ientry-idm20579">gst_object_check_uniqueness, <a class="indexterm" href="GstObject.html#gst-object-check-uniqueness">gst_object_check_uniqueness ()</a>
</dt>
<dt id="ientry-idm20544">gst_object_default_deep_notify, <a class="indexterm" href="GstObject.html#gst-object-default-deep-notify">gst_object_default_deep_notify ()</a>
</dt>
<dt id="ientry-idm20563">gst_object_default_error, <a class="indexterm" href="GstObject.html#gst-object-default-error">gst_object_default_error ()</a>
</dt>
<dt id="ientry-idm20415">GST_OBJECT_FLAGS, <a class="indexterm" href="GstObject.html#GST-OBJECT-FLAGS:CAPS">GST_OBJECT_FLAGS()</a>
</dt>
<dt id="ientry-idm20420">GST_OBJECT_FLAG_IS_SET, <a class="indexterm" href="GstObject.html#GST-OBJECT-FLAG-IS-SET:CAPS">GST_OBJECT_FLAG_IS_SET()</a>
</dt>
<dt id="ientry-idm20425">GST_OBJECT_FLAG_SET, <a class="indexterm" href="GstObject.html#GST-OBJECT-FLAG-SET:CAPS">GST_OBJECT_FLAG_SET()</a>
</dt>
<dt id="ientry-idm20430">GST_OBJECT_FLAG_UNSET, <a class="indexterm" href="GstObject.html#GST-OBJECT-FLAG-UNSET:CAPS">GST_OBJECT_FLAG_UNSET()</a>
</dt>
<dt id="ientry-idm20749">gst_object_get_control_binding, <a class="indexterm" href="GstObject.html#gst-object-get-control-binding">gst_object_get_control_binding ()</a>
</dt>
<dt id="ientry-idm20841">gst_object_get_control_rate, <a class="indexterm" href="GstObject.html#gst-object-get-control-rate">gst_object_get_control_rate ()</a>
</dt>
<dt id="ientry-idm20816">gst_object_get_g_value_array, <a class="indexterm" href="GstObject.html#gst-object-get-g-value-array">gst_object_get_g_value_array ()</a>
</dt>
<dt id="ientry-idm20470">GST_OBJECT_GET_LOCK, <a class="indexterm" href="GstObject.html#GST-OBJECT-GET-LOCK:CAPS">GST_OBJECT_GET_LOCK()</a>
</dt>
<dt id="ientry-idm20488">gst_object_get_name, <a class="indexterm" href="GstObject.html#gst-object-get-name">gst_object_get_name ()</a>
</dt>
<dt id="ientry-idm20511">gst_object_get_parent, <a class="indexterm" href="GstObject.html#gst-object-get-parent">gst_object_get_parent ()</a>
</dt>
<dt id="ientry-idm20664">gst_object_get_path_string, <a class="indexterm" href="GstObject.html#gst-object-get-path-string">gst_object_get_path_string ()</a>
</dt>
<dt id="ientry-idm20775">gst_object_get_value, <a class="indexterm" href="GstObject.html#gst-object-get-value">gst_object_get_value ()</a>
</dt>
<dt id="ientry-idm20791">gst_object_get_value_array, <a class="indexterm" href="GstObject.html#gst-object-get-value-array">gst_object_get_value_array ()</a>
</dt>
<dt id="ientry-idm20697">gst_object_has_active_control_bindings, <a class="indexterm" href="GstObject.html#gst-object-has-active-control-bindings">gst_object_has_active_control_bindings ()</a>
</dt>
<dt id="ientry-idm20605">gst_object_has_ancestor, <a class="indexterm" href="GstObject.html#gst-object-has-ancestor">gst_object_has_ancestor ()</a>
</dt>
<dt id="ientry-idm20592">gst_object_has_as_ancestor, <a class="indexterm" href="GstObject.html#gst-object-has-as-ancestor">gst_object_has_as_ancestor ()</a>
</dt>
<dt id="ientry-idm20521">gst_object_has_as_parent, <a class="indexterm" href="GstObject.html#gst-object-has-as-parent">gst_object_has_as_parent ()</a>
</dt>
<dt id="ientry-idm20455">GST_OBJECT_LOCK, <a class="indexterm" href="GstObject.html#GST-OBJECT-LOCK:CAPS">GST_OBJECT_LOCK()</a>
</dt>
<dt id="ientry-idm20435">GST_OBJECT_NAME, <a class="indexterm" href="GstObject.html#GST-OBJECT-NAME:CAPS">GST_OBJECT_NAME()</a>
</dt>
<dt id="ientry-idm20440">GST_OBJECT_PARENT, <a class="indexterm" href="GstObject.html#GST-OBJECT-PARENT:CAPS">GST_OBJECT_PARENT()</a>
</dt>
<dt id="ientry-idm20621">gst_object_ref, <a class="indexterm" href="GstObject.html#gst-object-ref">gst_object_ref ()</a>
</dt>
<dt id="ientry-idm20445">GST_OBJECT_REFCOUNT, <a class="indexterm" href="GstObject.html#GST-OBJECT-REFCOUNT:CAPS">GST_OBJECT_REFCOUNT()</a>
</dt>
<dt id="ientry-idm20450">GST_OBJECT_REFCOUNT_VALUE, <a class="indexterm" href="GstObject.html#GST-OBJECT-REFCOUNT-VALUE:CAPS">GST_OBJECT_REFCOUNT_VALUE()</a>
</dt>
<dt id="ientry-idm20641">gst_object_ref_sink, <a class="indexterm" href="GstObject.html#gst-object-ref-sink">gst_object_ref_sink ()</a>
</dt>
<dt id="ientry-idm20762">gst_object_remove_control_binding, <a class="indexterm" href="GstObject.html#gst-object-remove-control-binding">gst_object_remove_control_binding ()</a>
</dt>
<dt id="ientry-idm20651">gst_object_replace, <a class="indexterm" href="GstObject.html#gst-object-replace">gst_object_replace ()</a>
</dt>
<dt id="ientry-idm20707">gst_object_set_control_bindings_disabled, <a class="indexterm" href="GstObject.html#gst-object-set-control-bindings-disabled">gst_object_set_control_bindings_disabled ()</a>
</dt>
<dt id="ientry-idm20720">gst_object_set_control_binding_disabled, <a class="indexterm" href="GstObject.html#gst-object-set-control-binding-disabled">gst_object_set_control_binding_disabled ()</a>
</dt>
<dt id="ientry-idm20851">gst_object_set_control_rate, <a class="indexterm" href="GstObject.html#gst-object-set-control-rate">gst_object_set_control_rate ()</a>
</dt>
<dt id="ientry-idm20475">gst_object_set_name, <a class="indexterm" href="GstObject.html#gst-object-set-name">gst_object_set_name ()</a>
</dt>
<dt id="ientry-idm20498">gst_object_set_parent, <a class="indexterm" href="GstObject.html#gst-object-set-parent">gst_object_set_parent ()</a>
</dt>
<dt id="ientry-idm20674">gst_object_suggest_next_sync, <a class="indexterm" href="GstObject.html#gst-object-suggest-next-sync">gst_object_suggest_next_sync ()</a>
</dt>
<dt id="ientry-idm20684">gst_object_sync_values, <a class="indexterm" href="GstObject.html#gst-object-sync-values">gst_object_sync_values ()</a>
</dt>
<dt id="ientry-idm20460">GST_OBJECT_TRYLOCK, <a class="indexterm" href="GstObject.html#GST-OBJECT-TRYLOCK:CAPS">GST_OBJECT_TRYLOCK()</a>
</dt>
<dt id="ientry-idm20465">GST_OBJECT_UNLOCK, <a class="indexterm" href="GstObject.html#GST-OBJECT-UNLOCK:CAPS">GST_OBJECT_UNLOCK()</a>
</dt>
<dt id="ientry-idm20534">gst_object_unparent, <a class="indexterm" href="GstObject.html#gst-object-unparent">gst_object_unparent ()</a>
</dt>
<dt id="ientry-idm20631">gst_object_unref, <a class="indexterm" href="GstObject.html#gst-object-unref">gst_object_unref ()</a>
</dt>
<dt id="ientry-idm23915">GST_PAD_ACTIVATEFUNC, <a class="indexterm" href="GstPad.html#GST-PAD-ACTIVATEFUNC:CAPS">GST_PAD_ACTIVATEFUNC()</a>
</dt>
<dt id="ientry-idm23920">GST_PAD_ACTIVATEMODEFUNC, <a class="indexterm" href="GstPad.html#GST-PAD-ACTIVATEMODEFUNC:CAPS">GST_PAD_ACTIVATEMODEFUNC()</a>
</dt>
<dt id="ientry-idm23300">gst_pad_activate_mode, <a class="indexterm" href="GstPad.html#gst-pad-activate-mode">gst_pad_activate_mode ()</a>
</dt>
<dt id="ientry-idm22669">gst_pad_add_probe, <a class="indexterm" href="GstPad.html#gst-pad-add-probe">gst_pad_add_probe ()</a>
</dt>
<dt id="ientry-idm22418">gst_pad_can_link, <a class="indexterm" href="GstPad.html#gst-pad-can-link">gst_pad_can_link ()</a>
</dt>
<dt id="ientry-idm23777">gst_pad_chain, <a class="indexterm" href="GstPad.html#gst-pad-chain">gst_pad_chain ()</a>
</dt>
<dt id="ientry-idm23925">GST_PAD_CHAINFUNC, <a class="indexterm" href="GstPad.html#GST-PAD-CHAINFUNC:CAPS">GST_PAD_CHAINFUNC()</a>
</dt>
<dt id="ientry-idm23930">GST_PAD_CHAINLISTFUNC, <a class="indexterm" href="GstPad.html#GST-PAD-CHAINLISTFUNC:CAPS">GST_PAD_CHAINLISTFUNC()</a>
</dt>
<dt id="ientry-idm23790">gst_pad_chain_list, <a class="indexterm" href="GstPad.html#gst-pad-chain-list">gst_pad_chain_list ()</a>
</dt>
<dt id="ientry-idm23222">gst_pad_check_reconfigure, <a class="indexterm" href="GstPad.html#gst-pad-check-reconfigure">gst_pad_check_reconfigure ()</a>
</dt>
<dt id="ientry-idm23674">gst_pad_create_stream_id, <a class="indexterm" href="GstPad.html#gst-pad-create-stream-id">gst_pad_create_stream_id ()</a>
</dt>
<dt id="ientry-idm23690">gst_pad_create_stream_id_printf, <a class="indexterm" href="GstPad.html#gst-pad-create-stream-id-printf">gst_pad_create_stream_id_printf ()</a>
</dt>
<dt id="ientry-idm23707">gst_pad_create_stream_id_printf_valist, <a class="indexterm" href="GstPad.html#gst-pad-create-stream-id-printf-valist">gst_pad_create_stream_id_printf_valist ()</a>
</dt>
<dt id="ientry-idm23895">GST_PAD_DIRECTION, <a class="indexterm" href="GstPad.html#GST-PAD-DIRECTION:CAPS">GST_PAD_DIRECTION()</a>
</dt>
<dt id="ientry-idm23885">GST_PAD_ELEMENT_PRIVATE, <a class="indexterm" href="GstPad.html#GST-PAD-ELEMENT-PRIVATE:CAPS">GST_PAD_ELEMENT_PRIVATE()</a>
</dt>
<dt id="ientry-idm23940">GST_PAD_EVENTFULLFUNC, <a class="indexterm" href="GstPad.html#GST-PAD-EVENTFULLFUNC:CAPS">GST_PAD_EVENTFULLFUNC()</a>
</dt>
<dt id="ientry-idm23935">GST_PAD_EVENTFUNC, <a class="indexterm" href="GstPad.html#GST-PAD-EVENTFUNC:CAPS">GST_PAD_EVENTFUNC()</a>
</dt>
<dt id="ientry-idm23329">gst_pad_event_default, <a class="indexterm" href="GstPad.html#gst-pad-event-default">gst_pad_event_default ()</a>
</dt>
<dt id="ientry-idm23761">gst_pad_forward, <a class="indexterm" href="GstPad.html#gst-pad-forward">gst_pad_forward ()</a>
</dt>
<dt id="ientry-idm23945">GST_PAD_GETRANGEFUNC, <a class="indexterm" href="GstPad.html#GST-PAD-GETRANGEFUNC:CAPS">GST_PAD_GETRANGEFUNC()</a>
</dt>
<dt id="ientry-idm22431">gst_pad_get_allowed_caps, <a class="indexterm" href="GstPad.html#gst-pad-get-allowed-caps">gst_pad_get_allowed_caps ()</a>
</dt>
<dt id="ientry-idm22441">gst_pad_get_current_caps, <a class="indexterm" href="GstPad.html#gst-pad-get-current-caps">gst_pad_get_current_caps ()</a>
</dt>
<dt id="ientry-idm22302">gst_pad_get_direction, <a class="indexterm" href="GstPad.html#gst-pad-get-direction">gst_pad_get_direction ()</a>
</dt>
<dt id="ientry-idm23664">gst_pad_get_element_private, <a class="indexterm" href="GstPad.html#gst-pad-get-element-private">gst_pad_get_element_private ()</a>
</dt>
<dt id="ientry-idm22551">gst_pad_get_last_flow_return, <a class="indexterm" href="GstPad.html#gst-pad-get-last-flow-return">gst_pad_get_last_flow_return ()</a>
</dt>
<dt id="ientry-idm22297">gst_pad_get_name, <a class="indexterm" href="GstPad.html#gst-pad-get-name">gst_pad_get_name()</a>
</dt>
<dt id="ientry-idm22724">gst_pad_get_offset, <a class="indexterm" href="GstPad.html#gst-pad-get-offset">gst_pad_get_offset ()</a>
</dt>
<dt id="ientry-idm22327">gst_pad_get_pad_template, <a class="indexterm" href="GstPad.html#gst-pad-get-pad-template">gst_pad_get_pad_template ()</a>
</dt>
<dt id="ientry-idm22451">gst_pad_get_pad_template_caps, <a class="indexterm" href="GstPad.html#gst-pad-get-pad-template-caps">gst_pad_get_pad_template_caps ()</a>
</dt>
<dt id="ientry-idm22312">gst_pad_get_parent, <a class="indexterm" href="GstPad.html#gst-pad-get-parent">gst_pad_get_parent()</a>
</dt>
<dt id="ientry-idm22317">gst_pad_get_parent_element, <a class="indexterm" href="GstPad.html#gst-pad-get-parent-element">gst_pad_get_parent_element ()</a>
</dt>
<dt id="ientry-idm22461">gst_pad_get_peer, <a class="indexterm" href="GstPad.html#gst-pad-get-peer">gst_pad_get_peer ()</a>
</dt>
<dt id="ientry-idm22870">gst_pad_get_range, <a class="indexterm" href="GstPad.html#gst-pad-get-range">gst_pad_get_range ()</a>
</dt>
<dt id="ientry-idm22491">gst_pad_get_sticky_event, <a class="indexterm" href="GstPad.html#gst-pad-get-sticky-event">gst_pad_get_sticky_event ()</a>
</dt>
<dt id="ientry-idm23736">gst_pad_get_stream, <a class="indexterm" href="GstPad.html#gst-pad-get-stream">gst_pad_get_stream ()</a>
</dt>
<dt id="ientry-idm23726">gst_pad_get_stream_id, <a class="indexterm" href="GstPad.html#gst-pad-get-stream-id">gst_pad_get_stream_id ()</a>
</dt>
<dt id="ientry-idm23855">GST_PAD_GET_STREAM_LOCK, <a class="indexterm" href="GstPad.html#GST-PAD-GET-STREAM-LOCK:CAPS">GST_PAD_GET_STREAM_LOCK()</a>
</dt>
<dt id="ientry-idm22481">gst_pad_has_current_caps, <a class="indexterm" href="GstPad.html#gst-pad-has-current-caps">gst_pad_has_current_caps ()</a>
</dt>
<dt id="ientry-idm24030">GST_PAD_HAS_PENDING_EVENTS, <a class="indexterm" href="GstPad.html#GST-PAD-HAS-PENDING-EVENTS:CAPS">GST_PAD_HAS_PENDING_EVENTS()</a>
</dt>
<dt id="ientry-idm24090">GST_PAD_IS_ACCEPT_INTERSECT, <a class="indexterm" href="GstPad.html#GST-PAD-IS-ACCEPT-INTERSECT:CAPS">GST_PAD_IS_ACCEPT_INTERSECT()</a>
</dt>
<dt id="ientry-idm24105">GST_PAD_IS_ACCEPT_TEMPLATE, <a class="indexterm" href="GstPad.html#GST-PAD-IS-ACCEPT-TEMPLATE:CAPS">GST_PAD_IS_ACCEPT_TEMPLATE()</a>
</dt>
<dt id="ientry-idm22541">gst_pad_is_active, <a class="indexterm" href="GstPad.html#gst-pad-is-active">gst_pad_is_active ()</a>
</dt>
<dt id="ientry-idm23990">GST_PAD_IS_ACTIVE, <a class="indexterm" href="GstPad.html#GST-PAD-IS-ACTIVE:CAPS">GST_PAD_IS_ACTIVE()</a>
</dt>
<dt id="ientry-idm22704">gst_pad_is_blocked, <a class="indexterm" href="GstPad.html#gst-pad-is-blocked">gst_pad_is_blocked ()</a>
</dt>
<dt id="ientry-idm23995">GST_PAD_IS_BLOCKED, <a class="indexterm" href="GstPad.html#GST-PAD-IS-BLOCKED:CAPS">GST_PAD_IS_BLOCKED()</a>
</dt>
<dt id="ientry-idm22714">gst_pad_is_blocking, <a class="indexterm" href="GstPad.html#gst-pad-is-blocking">gst_pad_is_blocking ()</a>
</dt>
<dt id="ientry-idm24000">GST_PAD_IS_BLOCKING, <a class="indexterm" href="GstPad.html#GST-PAD-IS-BLOCKING:CAPS">GST_PAD_IS_BLOCKING()</a>
</dt>
<dt id="ientry-idm24020">GST_PAD_IS_EOS, <a class="indexterm" href="GstPad.html#GST-PAD-IS-EOS:CAPS">GST_PAD_IS_EOS()</a>
</dt>
<dt id="ientry-idm24035">GST_PAD_IS_FIXED_CAPS, <a class="indexterm" href="GstPad.html#GST-PAD-IS-FIXED-CAPS">GST_PAD_IS_FIXED_CAPS()</a>
</dt>
<dt id="ientry-idm24005">GST_PAD_IS_FLUSHING, <a class="indexterm" href="GstPad.html#GST-PAD-IS-FLUSHING:CAPS">GST_PAD_IS_FLUSHING()</a>
</dt>
<dt id="ientry-idm22408">gst_pad_is_linked, <a class="indexterm" href="GstPad.html#gst-pad-is-linked">gst_pad_is_linked ()</a>
</dt>
<dt id="ientry-idm23975">GST_PAD_IS_LINKED, <a class="indexterm" href="GstPad.html#GST-PAD-IS-LINKED:CAPS">GST_PAD_IS_LINKED()</a>
</dt>
<dt id="ientry-idm24060">GST_PAD_IS_PROXY_ALLOCATION, <a class="indexterm" href="GstPad.html#GST-PAD-IS-PROXY-ALLOCATION:CAPS">GST_PAD_IS_PROXY_ALLOCATION()</a>
</dt>
<dt id="ientry-idm24045">GST_PAD_IS_PROXY_CAPS, <a class="indexterm" href="GstPad.html#GST-PAD-IS-PROXY-CAPS">GST_PAD_IS_PROXY_CAPS()</a>
</dt>
<dt id="ientry-idm24085">GST_PAD_IS_PROXY_SCHEDULING, <a class="indexterm" href="GstPad.html#GST-PAD-IS-PROXY-SCHEDULING:CAPS">GST_PAD_IS_PROXY_SCHEDULING()</a>
</dt>
<dt id="ientry-idm23985">GST_PAD_IS_SINK, <a class="indexterm" href="GstPad.html#GST-PAD-IS-SINK:CAPS">GST_PAD_IS_SINK()</a>
</dt>
<dt id="ientry-idm23980">GST_PAD_IS_SRC, <a class="indexterm" href="GstPad.html#GST-PAD-IS-SRC:CAPS">GST_PAD_IS_SRC()</a>
</dt>
<dt id="ientry-idm23628">gst_pad_iterate_internal_links, <a class="indexterm" href="GstPad.html#gst-pad-iterate-internal-links">gst_pad_iterate_internal_links ()</a>
</dt>
<dt id="ientry-idm23638">gst_pad_iterate_internal_links_default, <a class="indexterm" href="GstPad.html#gst-pad-iterate-internal-links-default">gst_pad_iterate_internal_links_default ()</a>
</dt>
<dt id="ientry-idm23955">GST_PAD_ITERINTLINKFUNC, <a class="indexterm" href="GstPad.html#GST-PAD-ITERINTLINKFUNC:CAPS">GST_PAD_ITERINTLINKFUNC()</a>
</dt>
<dt id="ientry-idm23900">GST_PAD_LAST_FLOW_RETURN, <a class="indexterm" href="GstPad.html#GST-PAD-LAST-FLOW-RETURN:CAPS">GST_PAD_LAST_FLOW_RETURN()</a>
</dt>
<dt id="ientry-idm22337">gst_pad_link, <a class="indexterm" href="GstPad.html#gst-pad-link">gst_pad_link ()</a>
</dt>
<dt id="ientry-idm23965">GST_PAD_LINKFUNC, <a class="indexterm" href="GstPad.html#GST-PAD-LINKFUNC:CAPS">GST_PAD_LINKFUNC()</a>
</dt>
<dt id="ientry-idm22244">GST_PAD_LINK_FAILED, <a class="indexterm" href="GstPad.html#GST-PAD-LINK-FAILED:CAPS">GST_PAD_LINK_FAILED()</a>
</dt>
<dt id="ientry-idm22350">gst_pad_link_full, <a class="indexterm" href="GstPad.html#gst-pad-link-full">gst_pad_link_full ()</a>
</dt>
<dt id="ientry-idm22234">gst_pad_link_get_name, <a class="indexterm" href="GstPad.html#gst-pad-link-get-name">gst_pad_link_get_name ()</a>
</dt>
<dt id="ientry-idm22366">gst_pad_link_maybe_ghosting, <a class="indexterm" href="GstPad.html#gst-pad-link-maybe-ghosting">gst_pad_link_maybe_ghosting ()</a>
</dt>
<dt id="ientry-idm22379">gst_pad_link_maybe_ghosting_full, <a class="indexterm" href="GstPad.html#gst-pad-link-maybe-ghosting-full">gst_pad_link_maybe_ghosting_full ()</a>
</dt>
<dt id="ientry-idm22249">GST_PAD_LINK_SUCCESSFUL, <a class="indexterm" href="GstPad.html#GST-PAD-LINK-SUCCESSFUL:CAPS">GST_PAD_LINK_SUCCESSFUL()</a>
</dt>
<dt id="ientry-idm23232">gst_pad_mark_reconfigure, <a class="indexterm" href="GstPad.html#gst-pad-mark-reconfigure">gst_pad_mark_reconfigure ()</a>
</dt>
<dt id="ientry-idm23910">GST_PAD_MODE, <a class="indexterm" href="GstPad.html#GST-PAD-MODE:CAPS">GST_PAD_MODE()</a>
</dt>
<dt id="ientry-idm22274">gst_pad_mode_get_name, <a class="indexterm" href="GstPad.html#gst-pad-mode-get-name">gst_pad_mode_get_name ()</a>
</dt>
<dt id="ientry-idm23875">GST_PAD_NAME, <a class="indexterm" href="GstPad.html#GST-PAD-NAME:CAPS">GST_PAD_NAME()</a>
</dt>
<dt id="ientry-idm24040">GST_PAD_NEEDS_PARENT, <a class="indexterm" href="GstPad.html#GST-PAD-NEEDS-PARENT:CAPS">GST_PAD_NEEDS_PARENT()</a>
</dt>
<dt id="ientry-idm23212">gst_pad_needs_reconfigure, <a class="indexterm" href="GstPad.html#gst-pad-needs-reconfigure">gst_pad_needs_reconfigure ()</a>
</dt>
<dt id="ientry-idm24025">GST_PAD_NEEDS_RECONFIGURE, <a class="indexterm" href="GstPad.html#GST-PAD-NEEDS-RECONFIGURE:CAPS">GST_PAD_NEEDS_RECONFIGURE()</a>
</dt>
<dt id="ientry-idm22747">gst_pad_new, <a class="indexterm" href="GstPad.html#gst-pad-new">gst_pad_new ()</a>
</dt>
<dt id="ientry-idm22773">gst_pad_new_from_static_template, <a class="indexterm" href="GstPad.html#gst-pad-new-from-static-template">gst_pad_new_from_static_template ()</a>
</dt>
<dt id="ientry-idm22760">gst_pad_new_from_template, <a class="indexterm" href="GstPad.html#gst-pad-new-from-template">gst_pad_new_from_template ()</a>
</dt>
<dt id="ientry-idm23890">GST_PAD_PAD_TEMPLATE, <a class="indexterm" href="GstPad.html#GST-PAD-PAD-TEMPLATE:CAPS">GST_PAD_PAD_TEMPLATE()</a>
</dt>
<dt id="ientry-idm23880">GST_PAD_PARENT, <a class="indexterm" href="GstPad.html#GST-PAD-PARENT:CAPS">GST_PAD_PARENT()</a>
</dt>
<dt id="ientry-idm23822">gst_pad_pause_task, <a class="indexterm" href="GstPad.html#gst-pad-pause-task">gst_pad_pause_task ()</a>
</dt>
<dt id="ientry-idm23960">GST_PAD_PEER, <a class="indexterm" href="GstPad.html#GST-PAD-PEER:CAPS">GST_PAD_PEER()</a>
</dt>
<dt id="ientry-idm23358">gst_pad_peer_query, <a class="indexterm" href="GstPad.html#gst-pad-peer-query">gst_pad_peer_query ()</a>
</dt>
<dt id="ientry-idm23521">gst_pad_peer_query_accept_caps, <a class="indexterm" href="GstPad.html#gst-pad-peer-query-accept-caps">gst_pad_peer_query_accept_caps ()</a>
</dt>
<dt id="ientry-idm23534">gst_pad_peer_query_caps, <a class="indexterm" href="GstPad.html#gst-pad-peer-query-caps">gst_pad_peer_query_caps ()</a>
</dt>
<dt id="ientry-idm23499">gst_pad_peer_query_convert, <a class="indexterm" href="GstPad.html#gst-pad-peer-query-convert">gst_pad_peer_query_convert ()</a>
</dt>
<dt id="ientry-idm23483">gst_pad_peer_query_duration, <a class="indexterm" href="GstPad.html#gst-pad-peer-query-duration">gst_pad_peer_query_duration ()</a>
</dt>
<dt id="ientry-idm23467">gst_pad_peer_query_position, <a class="indexterm" href="GstPad.html#gst-pad-peer-query-position">gst_pad_peer_query_position ()</a>
</dt>
<dt id="ientry-idm22576">GST_PAD_PROBE_INFO_BUFFER, <a class="indexterm" href="GstPad.html#GST-PAD-PROBE-INFO-BUFFER:CAPS">GST_PAD_PROBE_INFO_BUFFER()</a>
</dt>
<dt id="ientry-idm22581">GST_PAD_PROBE_INFO_BUFFER_LIST, <a class="indexterm" href="GstPad.html#GST-PAD-PROBE-INFO-BUFFER-LIST:CAPS">GST_PAD_PROBE_INFO_BUFFER_LIST()</a>
</dt>
<dt id="ientry-idm22571">GST_PAD_PROBE_INFO_DATA, <a class="indexterm" href="GstPad.html#GST-PAD-PROBE-INFO-DATA:CAPS">GST_PAD_PROBE_INFO_DATA()</a>
</dt>
<dt id="ientry-idm22586">GST_PAD_PROBE_INFO_EVENT, <a class="indexterm" href="GstPad.html#GST-PAD-PROBE-INFO-EVENT:CAPS">GST_PAD_PROBE_INFO_EVENT()</a>
</dt>
<dt id="ientry-idm22646">GST_PAD_PROBE_INFO_FLOW_RETURN, <a class="indexterm" href="GstPad.html#GST-PAD-PROBE-INFO-FLOW-RETURN:CAPS">GST_PAD_PROBE_INFO_FLOW_RETURN()</a>
</dt>
<dt id="ientry-idm22596">gst_pad_probe_info_get_buffer, <a class="indexterm" href="GstPad.html#gst-pad-probe-info-get-buffer">gst_pad_probe_info_get_buffer ()</a>
</dt>
<dt id="ientry-idm22606">gst_pad_probe_info_get_buffer_list, <a class="indexterm" href="GstPad.html#gst-pad-probe-info-get-buffer-list">gst_pad_probe_info_get_buffer_list ()</a>
</dt>
<dt id="ientry-idm22616">gst_pad_probe_info_get_event, <a class="indexterm" href="GstPad.html#gst-pad-probe-info-get-event">gst_pad_probe_info_get_event ()</a>
</dt>
<dt id="ientry-idm22626">gst_pad_probe_info_get_query, <a class="indexterm" href="GstPad.html#gst-pad-probe-info-get-query">gst_pad_probe_info_get_query ()</a>
</dt>
<dt id="ientry-idm22566">GST_PAD_PROBE_INFO_ID, <a class="indexterm" href="GstPad.html#GST-PAD-PROBE-INFO-ID:CAPS">GST_PAD_PROBE_INFO_ID()</a>
</dt>
<dt id="ientry-idm22636">GST_PAD_PROBE_INFO_OFFSET, <a class="indexterm" href="GstPad.html#GST-PAD-PROBE-INFO-OFFSET:CAPS">GST_PAD_PROBE_INFO_OFFSET()</a>
</dt>
<dt id="ientry-idm22591">GST_PAD_PROBE_INFO_QUERY, <a class="indexterm" href="GstPad.html#GST-PAD-PROBE-INFO-QUERY:CAPS">GST_PAD_PROBE_INFO_QUERY()</a>
</dt>
<dt id="ientry-idm22641">GST_PAD_PROBE_INFO_SIZE, <a class="indexterm" href="GstPad.html#GST-PAD-PROBE-INFO-SIZE:CAPS">GST_PAD_PROBE_INFO_SIZE()</a>
</dt>
<dt id="ientry-idm22561">GST_PAD_PROBE_INFO_TYPE, <a class="indexterm" href="GstPad.html#GST-PAD-PROBE-INFO-TYPE:CAPS">GST_PAD_PROBE_INFO_TYPE()</a>
</dt>
<dt id="ientry-idm23115">gst_pad_proxy_query_accept_caps, <a class="indexterm" href="GstPad.html#gst-pad-proxy-query-accept-caps">gst_pad_proxy_query_accept_caps ()</a>
</dt>
<dt id="ientry-idm23102">gst_pad_proxy_query_caps, <a class="indexterm" href="GstPad.html#gst-pad-proxy-query-caps">gst_pad_proxy_query_caps ()</a>
</dt>
<dt id="ientry-idm23281">gst_pad_pull_range, <a class="indexterm" href="GstPad.html#gst-pad-pull-range">gst_pad_pull_range ()</a>
</dt>
<dt id="ientry-idm23242">gst_pad_push, <a class="indexterm" href="GstPad.html#gst-pad-push">gst_pad_push ()</a>
</dt>
<dt id="ientry-idm23255">gst_pad_push_event, <a class="indexterm" href="GstPad.html#gst-pad-push-event">gst_pad_push_event ()</a>
</dt>
<dt id="ientry-idm23268">gst_pad_push_list, <a class="indexterm" href="GstPad.html#gst-pad-push-list">gst_pad_push_list ()</a>
</dt>
<dt id="ientry-idm23345">gst_pad_query, <a class="indexterm" href="GstPad.html#gst-pad-query">gst_pad_query ()</a>
</dt>
<dt id="ientry-idm23950">GST_PAD_QUERYFUNC, <a class="indexterm" href="GstPad.html#GST-PAD-QUERYFUNC:CAPS">GST_PAD_QUERYFUNC()</a>
</dt>
<dt id="ientry-idm23441">gst_pad_query_accept_caps, <a class="indexterm" href="GstPad.html#gst-pad-query-accept-caps">gst_pad_query_accept_caps ()</a>
</dt>
<dt id="ientry-idm23454">gst_pad_query_caps, <a class="indexterm" href="GstPad.html#gst-pad-query-caps">gst_pad_query_caps ()</a>
</dt>
<dt id="ientry-idm23419">gst_pad_query_convert, <a class="indexterm" href="GstPad.html#gst-pad-query-convert">gst_pad_query_convert ()</a>
</dt>
<dt id="ientry-idm23371">gst_pad_query_default, <a class="indexterm" href="GstPad.html#gst-pad-query-default">gst_pad_query_default ()</a>
</dt>
<dt id="ientry-idm23403">gst_pad_query_duration, <a class="indexterm" href="GstPad.html#gst-pad-query-duration">gst_pad_query_duration ()</a>
</dt>
<dt id="ientry-idm23387">gst_pad_query_position, <a class="indexterm" href="GstPad.html#gst-pad-query-position">gst_pad_query_position ()</a>
</dt>
<dt id="ientry-idm22691">gst_pad_remove_probe, <a class="indexterm" href="GstPad.html#gst-pad-remove-probe">gst_pad_remove_probe ()</a>
</dt>
<dt id="ientry-idm23316">gst_pad_send_event, <a class="indexterm" href="GstPad.html#gst-pad-send-event">gst_pad_send_event ()</a>
</dt>
<dt id="ientry-idm24095">GST_PAD_SET_ACCEPT_INTERSECT, <a class="indexterm" href="GstPad.html#GST-PAD-SET-ACCEPT-INTERSECT:CAPS">GST_PAD_SET_ACCEPT_INTERSECT()</a>
</dt>
<dt id="ientry-idm24110">GST_PAD_SET_ACCEPT_TEMPLATE, <a class="indexterm" href="GstPad.html#GST-PAD-SET-ACCEPT-TEMPLATE:CAPS">GST_PAD_SET_ACCEPT_TEMPLATE()</a>
</dt>
<dt id="ientry-idm23167">gst_pad_set_activatemode_function, <a class="indexterm" href="GstPad.html#gst-pad-set-activatemode-function">gst_pad_set_activatemode_function()</a>
</dt>
<dt id="ientry-idm23172">gst_pad_set_activatemode_function_full, <a class="indexterm" href="GstPad.html#gst-pad-set-activatemode-function-full">gst_pad_set_activatemode_function_full ()</a>
</dt>
<dt id="ientry-idm23128">gst_pad_set_activate_function, <a class="indexterm" href="GstPad.html#gst-pad-set-activate-function">gst_pad_set_activate_function()</a>
</dt>
<dt id="ientry-idm23133">gst_pad_set_activate_function_full, <a class="indexterm" href="GstPad.html#gst-pad-set-activate-function-full">gst_pad_set_activate_function_full ()</a>
</dt>
<dt id="ientry-idm23842">gst_pad_set_active, <a class="indexterm" href="GstPad.html#gst-pad-set-active">gst_pad_set_active ()</a>
</dt>
<dt id="ientry-idm22786">gst_pad_set_chain_function, <a class="indexterm" href="GstPad.html#gst-pad-set-chain-function">gst_pad_set_chain_function()</a>
</dt>
<dt id="ientry-idm22791">gst_pad_set_chain_function_full, <a class="indexterm" href="GstPad.html#gst-pad-set-chain-function-full">gst_pad_set_chain_function_full ()</a>
</dt>
<dt id="ientry-idm22828">gst_pad_set_chain_list_function, <a class="indexterm" href="GstPad.html#gst-pad-set-chain-list-function">gst_pad_set_chain_list_function()</a>
</dt>
<dt id="ientry-idm22833">gst_pad_set_chain_list_function_full, <a class="indexterm" href="GstPad.html#gst-pad-set-chain-list-function-full">gst_pad_set_chain_list_function_full ()</a>
</dt>
<dt id="ientry-idm23651">gst_pad_set_element_private, <a class="indexterm" href="GstPad.html#gst-pad-set-element-private">gst_pad_set_element_private ()</a>
</dt>
<dt id="ientry-idm22979">gst_pad_set_event_full_function, <a class="indexterm" href="GstPad.html#gst-pad-set-event-full-function">gst_pad_set_event_full_function()</a>
</dt>
<dt id="ientry-idm22984">gst_pad_set_event_full_function_full, <a class="indexterm" href="GstPad.html#gst-pad-set-event-full-function-full">gst_pad_set_event_full_function_full ()</a>
</dt>
<dt id="ientry-idm22937">gst_pad_set_event_function, <a class="indexterm" href="GstPad.html#gst-pad-set-event-function">gst_pad_set_event_function()</a>
</dt>
<dt id="ientry-idm22942">gst_pad_set_event_function_full, <a class="indexterm" href="GstPad.html#gst-pad-set-event-function-full">gst_pad_set_event_function_full ()</a>
</dt>
<dt id="ientry-idm24010">GST_PAD_SET_FLUSHING, <a class="indexterm" href="GstPad.html#GST-PAD-SET-FLUSHING:CAPS">GST_PAD_SET_FLUSHING()</a>
</dt>
<dt id="ientry-idm22889">gst_pad_set_getrange_function, <a class="indexterm" href="GstPad.html#gst-pad-set-getrange-function">gst_pad_set_getrange_function()</a>
</dt>
<dt id="ientry-idm22894">gst_pad_set_getrange_function_full, <a class="indexterm" href="GstPad.html#gst-pad-set-getrange-function-full">gst_pad_set_getrange_function_full ()</a>
</dt>
<dt id="ientry-idm23589">gst_pad_set_iterate_internal_links_function, <a class="indexterm" href="GstPad.html#gst-pad-set-iterate-internal-links-function">gst_pad_set_iterate_internal_links_function()</a>
</dt>
<dt id="ientry-idm23594">gst_pad_set_iterate_internal_links_function_full, <a class="indexterm" href="GstPad.html#gst-pad-set-iterate-internal-links-function-full">gst_pad_set_iterate_internal_links_function_full ()</a>
</dt>
<dt id="ientry-idm23021">gst_pad_set_link_function, <a class="indexterm" href="GstPad.html#gst-pad-set-link-function">gst_pad_set_link_function()</a>
</dt>
<dt id="ientry-idm23026">gst_pad_set_link_function_full, <a class="indexterm" href="GstPad.html#gst-pad-set-link-function-full">gst_pad_set_link_function_full ()</a>
</dt>
<dt id="ientry-idm22734">gst_pad_set_offset, <a class="indexterm" href="GstPad.html#gst-pad-set-offset">gst_pad_set_offset ()</a>
</dt>
<dt id="ientry-idm24065">GST_PAD_SET_PROXY_ALLOCATION, <a class="indexterm" href="GstPad.html#GST-PAD-SET-PROXY-ALLOCATION:CAPS">GST_PAD_SET_PROXY_ALLOCATION()</a>
</dt>
<dt id="ientry-idm24050">GST_PAD_SET_PROXY_CAPS, <a class="indexterm" href="GstPad.html#GST-PAD-SET-PROXY-CAPS">GST_PAD_SET_PROXY_CAPS()</a>
</dt>
<dt id="ientry-idm24075">GST_PAD_SET_PROXY_SCHEDULING, <a class="indexterm" href="GstPad.html#GST-PAD-SET-PROXY-SCHEDULING:CAPS">GST_PAD_SET_PROXY_SCHEDULING()</a>
</dt>
<dt id="ientry-idm23547">gst_pad_set_query_function, <a class="indexterm" href="GstPad.html#gst-pad-set-query-function">gst_pad_set_query_function()</a>
</dt>
<dt id="ientry-idm23552">gst_pad_set_query_function_full, <a class="indexterm" href="GstPad.html#gst-pad-set-query-function-full">gst_pad_set_query_function_full ()</a>
</dt>
<dt id="ientry-idm23063">gst_pad_set_unlink_function, <a class="indexterm" href="GstPad.html#gst-pad-set-unlink-function">gst_pad_set_unlink_function()</a>
</dt>
<dt id="ientry-idm23068">gst_pad_set_unlink_function_full, <a class="indexterm" href="GstPad.html#gst-pad-set-unlink-function-full">gst_pad_set_unlink_function_full ()</a>
</dt>
<dt id="ientry-idm23803">gst_pad_start_task, <a class="indexterm" href="GstPad.html#gst-pad-start-task">gst_pad_start_task ()</a>
</dt>
<dt id="ientry-idm22525">gst_pad_sticky_events_foreach, <a class="indexterm" href="GstPad.html#gst-pad-sticky-events-foreach">gst_pad_sticky_events_foreach ()</a>
</dt>
<dt id="ientry-idm23832">gst_pad_stop_task, <a class="indexterm" href="GstPad.html#gst-pad-stop-task">gst_pad_stop_task ()</a>
</dt>
<dt id="ientry-idm22284">gst_pad_store_sticky_event, <a class="indexterm" href="GstPad.html#gst-pad-store-sticky-event">gst_pad_store_sticky_event ()</a>
</dt>
<dt id="ientry-idm23860">GST_PAD_STREAM_LOCK, <a class="indexterm" href="GstPad.html#GST-PAD-STREAM-LOCK:CAPS">GST_PAD_STREAM_LOCK()</a>
</dt>
<dt id="ientry-idm23865">GST_PAD_STREAM_TRYLOCK, <a class="indexterm" href="GstPad.html#GST-PAD-STREAM-TRYLOCK:CAPS">GST_PAD_STREAM_TRYLOCK()</a>
</dt>
<dt id="ientry-idm23870">GST_PAD_STREAM_UNLOCK, <a class="indexterm" href="GstPad.html#GST-PAD-STREAM-UNLOCK:CAPS">GST_PAD_STREAM_UNLOCK()</a>
</dt>
<dt id="ientry-idm23905">GST_PAD_TASK, <a class="indexterm" href="GstPad.html#GST-PAD-TASK:CAPS">GST_PAD_TASK()</a>
</dt>
<dt id="ientry-idm24871">GST_PAD_TEMPLATE_CAPS, <a class="indexterm" href="GstPadTemplate.html#GST-PAD-TEMPLATE-CAPS">GST_PAD_TEMPLATE_CAPS()</a>
</dt>
<dt id="ientry-idm24861">GST_PAD_TEMPLATE_DIRECTION, <a class="indexterm" href="GstPadTemplate.html#GST-PAD-TEMPLATE-DIRECTION:CAPS">GST_PAD_TEMPLATE_DIRECTION()</a>
</dt>
<dt id="ientry-idm24900">gst_pad_template_get_caps, <a class="indexterm" href="GstPadTemplate.html#gst-pad-template-get-caps">gst_pad_template_get_caps ()</a>
</dt>
<dt id="ientry-idm24876">GST_PAD_TEMPLATE_IS_FIXED, <a class="indexterm" href="GstPadTemplate.html#GST-PAD-TEMPLATE-IS-FIXED:CAPS">GST_PAD_TEMPLATE_IS_FIXED()</a>
</dt>
<dt id="ientry-idm24856">GST_PAD_TEMPLATE_NAME_TEMPLATE, <a class="indexterm" href="GstPadTemplate.html#GST-PAD-TEMPLATE-NAME-TEMPLATE:CAPS">GST_PAD_TEMPLATE_NAME_TEMPLATE()</a>
</dt>
<dt id="ientry-idm24881">gst_pad_template_new, <a class="indexterm" href="GstPadTemplate.html#gst-pad-template-new">gst_pad_template_new ()</a>
</dt>
<dt id="ientry-idm24866">GST_PAD_TEMPLATE_PRESENCE, <a class="indexterm" href="GstPadTemplate.html#GST-PAD-TEMPLATE-PRESENCE:CAPS">GST_PAD_TEMPLATE_PRESENCE()</a>
</dt>
<dt id="ientry-idm22395">gst_pad_unlink, <a class="indexterm" href="GstPad.html#gst-pad-unlink">gst_pad_unlink ()</a>
</dt>
<dt id="ientry-idm23970">GST_PAD_UNLINKFUNC, <a class="indexterm" href="GstPad.html#GST-PAD-UNLINKFUNC:CAPS">GST_PAD_UNLINKFUNC()</a>
</dt>
<dt id="ientry-idm24100">GST_PAD_UNSET_ACCEPT_INTERSECT, <a class="indexterm" href="GstPad.html#GST-PAD-UNSET-ACCEPT-INTERSECT:CAPS">GST_PAD_UNSET_ACCEPT_INTERSECT()</a>
</dt>
<dt id="ientry-idm24115">GST_PAD_UNSET_ACCEPT_TEMPLATE, <a class="indexterm" href="GstPad.html#GST-PAD-UNSET-ACCEPT-TEMPLATE:CAPS">GST_PAD_UNSET_ACCEPT_TEMPLATE()</a>
</dt>
<dt id="ientry-idm24015">GST_PAD_UNSET_FLUSHING, <a class="indexterm" href="GstPad.html#GST-PAD-UNSET-FLUSHING:CAPS">GST_PAD_UNSET_FLUSHING()</a>
</dt>
<dt id="ientry-idm24070">GST_PAD_UNSET_PROXY_ALLOCATION, <a class="indexterm" href="GstPad.html#GST-PAD-UNSET-PROXY-ALLOCATION:CAPS">GST_PAD_UNSET_PROXY_ALLOCATION()</a>
</dt>
<dt id="ientry-idm24055">GST_PAD_UNSET_PROXY_CAPS, <a class="indexterm" href="GstPad.html#GST-PAD-UNSET-PROXY-CAPS">GST_PAD_UNSET_PROXY_CAPS()</a>
</dt>
<dt id="ientry-idm24080">GST_PAD_UNSET_PROXY_SCHEDULING, <a class="indexterm" href="GstPad.html#GST-PAD-UNSET-PROXY-SCHEDULING:CAPS">GST_PAD_UNSET_PROXY_SCHEDULING()</a>
</dt>
<dt id="ientry-idm22471">gst_pad_use_fixed_caps, <a class="indexterm" href="GstPad.html#gst-pad-use-fixed-caps">gst_pad_use_fixed_caps ()</a>
</dt>
<dt id="ientry-idm25128">GST_PARAM_CONTROLLABLE, <a class="indexterm" href="gstreamer-GstParamSpec.html#GST-PARAM-CONTROLLABLE:CAPS">GST_PARAM_CONTROLLABLE</a>
</dt>
<dt id="ientry-idm25138">GST_PARAM_MUTABLE_PAUSED, <a class="indexterm" href="gstreamer-GstParamSpec.html#GST-PARAM-MUTABLE-PAUSED:CAPS">GST_PARAM_MUTABLE_PAUSED</a>
</dt>
<dt id="ientry-idm25143">GST_PARAM_MUTABLE_PLAYING, <a class="indexterm" href="gstreamer-GstParamSpec.html#GST-PARAM-MUTABLE-PLAYING:CAPS">GST_PARAM_MUTABLE_PLAYING</a>
</dt>
<dt id="ientry-idm25148">GST_PARAM_MUTABLE_READY, <a class="indexterm" href="gstreamer-GstParamSpec.html#GST-PARAM-MUTABLE-READY:CAPS">GST_PARAM_MUTABLE_READY</a>
</dt>
<dt id="ientry-idm25089">gst_param_spec_fraction, <a class="indexterm" href="gstreamer-GstParamSpec.html#gst-param-spec-fraction">gst_param_spec_fraction ()</a>
</dt>
<dt id="ientry-idm25133">GST_PARAM_USER_SHIFT, <a class="indexterm" href="gstreamer-GstParamSpec.html#GST-PARAM-USER-SHIFT:CAPS">GST_PARAM_USER_SHIFT</a>
</dt>
<dt id="ientry-idm25352">gst_parse_bin_from_description, <a class="indexterm" href="gstreamer-GstParse.html#gst-parse-bin-from-description">gst_parse_bin_from_description ()</a>
</dt>
<dt id="ientry-idm25368">gst_parse_bin_from_description_full, <a class="indexterm" href="gstreamer-GstParse.html#gst-parse-bin-from-description-full">gst_parse_bin_from_description_full ()</a>
</dt>
<dt id="ientry-idm25399">gst_parse_context_free, <a class="indexterm" href="gstreamer-GstParse.html#gst-parse-context-free">gst_parse_context_free ()</a>
</dt>
<dt id="ientry-idm25409">gst_parse_context_get_missing_elements, <a class="indexterm" href="gstreamer-GstParse.html#gst-parse-context-get-missing-elements">gst_parse_context_get_missing_elements ()</a>
</dt>
<dt id="ientry-idm25390">gst_parse_context_new, <a class="indexterm" href="gstreamer-GstParse.html#gst-parse-context-new">gst_parse_context_new ()</a>
</dt>
<dt id="ientry-idm25421">GST_PARSE_ERROR, <a class="indexterm" href="gstreamer-GstParse.html#GST-PARSE-ERROR:CAPS">GST_PARSE_ERROR</a>
</dt>
<dt id="ientry-idm25279">gst_parse_error_quark, <a class="indexterm" href="gstreamer-GstParse.html#gst-parse-error-quark">gst_parse_error_quark ()</a>
</dt>
<dt id="ientry-idm25288">gst_parse_launch, <a class="indexterm" href="gstreamer-GstParse.html#gst-parse-launch">gst_parse_launch ()</a>
</dt>
<dt id="ientry-idm25320">gst_parse_launchv, <a class="indexterm" href="gstreamer-GstParse.html#gst-parse-launchv">gst_parse_launchv ()</a>
</dt>
<dt id="ientry-idm25333">gst_parse_launchv_full, <a class="indexterm" href="gstreamer-GstParse.html#gst-parse-launchv-full">gst_parse_launchv_full ()</a>
</dt>
<dt id="ientry-idm25301">gst_parse_launch_full, <a class="indexterm" href="gstreamer-GstParse.html#gst-parse-launch-full">gst_parse_launch_full ()</a>
</dt>
<dt id="ientry-idm25755">gst_pipeline_auto_clock, <a class="indexterm" href="GstPipeline.html#gst-pipeline-auto-clock">gst_pipeline_auto_clock ()</a>
</dt>
<dt id="ientry-idm25778">gst_pipeline_get_auto_flush_bus, <a class="indexterm" href="GstPipeline.html#gst-pipeline-get-auto-flush-bus">gst_pipeline_get_auto_flush_bus ()</a>
</dt>
<dt id="ientry-idm25699">gst_pipeline_get_bus, <a class="indexterm" href="GstPipeline.html#gst-pipeline-get-bus">gst_pipeline_get_bus ()</a>
</dt>
<dt id="ientry-idm25732">gst_pipeline_get_clock, <a class="indexterm" href="GstPipeline.html#gst-pipeline-get-clock">gst_pipeline_get_clock ()</a>
</dt>
<dt id="ientry-idm25801">gst_pipeline_get_delay, <a class="indexterm" href="GstPipeline.html#gst-pipeline-get-delay">gst_pipeline_get_delay ()</a>
</dt>
<dt id="ientry-idm25824">gst_pipeline_get_latency, <a class="indexterm" href="GstPipeline.html#gst-pipeline-get-latency">gst_pipeline_get_latency ()</a>
</dt>
<dt id="ientry-idm25722">gst_pipeline_get_pipeline_clock, <a class="indexterm" href="GstPipeline.html#gst-pipeline-get-pipeline-clock">gst_pipeline_get_pipeline_clock ()</a>
</dt>
<dt id="ientry-idm25689">gst_pipeline_new, <a class="indexterm" href="GstPipeline.html#gst-pipeline-new">gst_pipeline_new ()</a>
</dt>
<dt id="ientry-idm25765">gst_pipeline_set_auto_flush_bus, <a class="indexterm" href="GstPipeline.html#gst-pipeline-set-auto-flush-bus">gst_pipeline_set_auto_flush_bus ()</a>
</dt>
<dt id="ientry-idm25709">gst_pipeline_set_clock, <a class="indexterm" href="GstPipeline.html#gst-pipeline-set-clock">gst_pipeline_set_clock ()</a>
</dt>
<dt id="ientry-idm25788">gst_pipeline_set_delay, <a class="indexterm" href="GstPipeline.html#gst-pipeline-set-delay">gst_pipeline_set_delay ()</a>
</dt>
<dt id="ientry-idm25811">gst_pipeline_set_latency, <a class="indexterm" href="GstPipeline.html#gst-pipeline-set-latency">gst_pipeline_set_latency ()</a>
</dt>
<dt id="ientry-idm25742">gst_pipeline_use_clock, <a class="indexterm" href="GstPipeline.html#gst-pipeline-use-clock">gst_pipeline_use_clock ()</a>
</dt>
<dt id="ientry-idm26462">gst_plugin_add_dependency, <a class="indexterm" href="GstPlugin.html#gst-plugin-add-dependency">gst_plugin_add_dependency ()</a>
</dt>
<dt id="ientry-idm26484">gst_plugin_add_dependency_simple, <a class="indexterm" href="GstPlugin.html#gst-plugin-add-dependency-simple">gst_plugin_add_dependency_simple ()</a>
</dt>
<dt id="ientry-idm26189">GST_PLUGIN_DEFINE, <a class="indexterm" href="GstPlugin.html#GST-PLUGIN-DEFINE:CAPS">GST_PLUGIN_DEFINE()</a>
</dt>
<dt id="ientry-idm26508">GST_PLUGIN_ERROR, <a class="indexterm" href="GstPlugin.html#GST-PLUGIN-ERROR:CAPS">GST_PLUGIN_ERROR</a>
</dt>
<dt id="ientry-idm26153">gst_plugin_error_quark, <a class="indexterm" href="GstPlugin.html#gst-plugin-error-quark">gst_plugin_error_quark ()</a>
</dt>
<dt id="ientry-idm26858">gst_plugin_feature_check_version, <a class="indexterm" href="GstPluginFeature.html#gst-plugin-feature-check-version">gst_plugin_feature_check_version ()</a>
</dt>
<dt id="ientry-idm26798">gst_plugin_feature_get_name, <a class="indexterm" href="GstPluginFeature.html#gst-plugin-feature-get-name">gst_plugin_feature_get_name()</a>
</dt>
<dt id="ientry-idm26803">gst_plugin_feature_get_plugin, <a class="indexterm" href="GstPluginFeature.html#gst-plugin-feature-get-plugin">gst_plugin_feature_get_plugin ()</a>
</dt>
<dt id="ientry-idm26813">gst_plugin_feature_get_plugin_name, <a class="indexterm" href="GstPluginFeature.html#gst-plugin-feature-get-plugin-name">gst_plugin_feature_get_plugin_name ()</a>
</dt>
<dt id="ientry-idm26788">gst_plugin_feature_get_rank, <a class="indexterm" href="GstPluginFeature.html#gst-plugin-feature-get-rank">gst_plugin_feature_get_rank ()</a>
</dt>
<dt id="ientry-idm26833">gst_plugin_feature_list_copy, <a class="indexterm" href="GstPluginFeature.html#gst-plugin-feature-list-copy">gst_plugin_feature_list_copy ()</a>
</dt>
<dt id="ientry-idm26853">GST_PLUGIN_FEATURE_LIST_DEBUG, <a class="indexterm" href="GstPluginFeature.html#GST-PLUGIN-FEATURE-LIST-DEBUG:CAPS">GST_PLUGIN_FEATURE_LIST_DEBUG()</a>
</dt>
<dt id="ientry-idm26843">gst_plugin_feature_list_free, <a class="indexterm" href="GstPluginFeature.html#gst-plugin-feature-list-free">gst_plugin_feature_list_free ()</a>
</dt>
<dt id="ientry-idm26823">gst_plugin_feature_load, <a class="indexterm" href="GstPluginFeature.html#gst-plugin-feature-load">gst_plugin_feature_load ()</a>
</dt>
<dt id="ientry-idm26877">gst_plugin_feature_rank_compare_func, <a class="indexterm" href="GstPluginFeature.html#gst-plugin-feature-rank-compare-func">gst_plugin_feature_rank_compare_func ()</a>
</dt>
<dt id="ientry-idm26783">gst_plugin_feature_set_name, <a class="indexterm" href="GstPluginFeature.html#gst-plugin-feature-set-name">gst_plugin_feature_set_name()</a>
</dt>
<dt id="ientry-idm26770">gst_plugin_feature_set_rank, <a class="indexterm" href="GstPluginFeature.html#gst-plugin-feature-set-rank">gst_plugin_feature_set_rank ()</a>
</dt>
<dt id="ientry-idm26319">gst_plugin_get_cache_data, <a class="indexterm" href="GstPlugin.html#gst-plugin-get-cache-data">gst_plugin_get_cache_data ()</a>
</dt>
<dt id="ientry-idm26229">gst_plugin_get_description, <a class="indexterm" href="GstPlugin.html#gst-plugin-get-description">gst_plugin_get_description ()</a>
</dt>
<dt id="ientry-idm26239">gst_plugin_get_filename, <a class="indexterm" href="GstPlugin.html#gst-plugin-get-filename">gst_plugin_get_filename ()</a>
</dt>
<dt id="ientry-idm26249">gst_plugin_get_license, <a class="indexterm" href="GstPlugin.html#gst-plugin-get-license">gst_plugin_get_license ()</a>
</dt>
<dt id="ientry-idm26219">gst_plugin_get_name, <a class="indexterm" href="GstPlugin.html#gst-plugin-get-name">gst_plugin_get_name ()</a>
</dt>
<dt id="ientry-idm26269">gst_plugin_get_origin, <a class="indexterm" href="GstPlugin.html#gst-plugin-get-origin">gst_plugin_get_origin ()</a>
</dt>
<dt id="ientry-idm26259">gst_plugin_get_package, <a class="indexterm" href="GstPlugin.html#gst-plugin-get-package">gst_plugin_get_package ()</a>
</dt>
<dt id="ientry-idm26299">gst_plugin_get_release_date_string, <a class="indexterm" href="GstPlugin.html#gst-plugin-get-release-date-string">gst_plugin_get_release_date_string ()</a>
</dt>
<dt id="ientry-idm26279">gst_plugin_get_source, <a class="indexterm" href="GstPlugin.html#gst-plugin-get-source">gst_plugin_get_source ()</a>
</dt>
<dt id="ientry-idm26289">gst_plugin_get_version, <a class="indexterm" href="GstPlugin.html#gst-plugin-get-version">gst_plugin_get_version ()</a>
</dt>
<dt id="ientry-idm26309">gst_plugin_is_loaded, <a class="indexterm" href="GstPlugin.html#gst-plugin-is-loaded">gst_plugin_is_loaded ()</a>
</dt>
<dt id="ientry-idm26375">gst_plugin_list_free, <a class="indexterm" href="GstPlugin.html#gst-plugin-list-free">gst_plugin_list_free ()</a>
</dt>
<dt id="ientry-idm26355">gst_plugin_load, <a class="indexterm" href="GstPlugin.html#gst-plugin-load">gst_plugin_load ()</a>
</dt>
<dt id="ientry-idm26365">gst_plugin_load_by_name, <a class="indexterm" href="GstPlugin.html#gst-plugin-load-by-name">gst_plugin_load_by_name ()</a>
</dt>
<dt id="ientry-idm26342">gst_plugin_load_file, <a class="indexterm" href="GstPlugin.html#gst-plugin-load-file">gst_plugin_load_file ()</a>
</dt>
<dt id="ientry-idm26385">gst_plugin_register_static, <a class="indexterm" href="GstPlugin.html#gst-plugin-register-static">gst_plugin_register_static ()</a>
</dt>
<dt id="ientry-idm26422">gst_plugin_register_static_full, <a class="indexterm" href="GstPlugin.html#gst-plugin-register-static-full">gst_plugin_register_static_full ()</a>
</dt>
<dt id="ientry-idm26329">gst_plugin_set_cache_data, <a class="indexterm" href="GstPlugin.html#gst-plugin-set-cache-data">gst_plugin_set_cache_data ()</a>
</dt>
<dt id="ientry-idm26194">GST_PLUGIN_STATIC_DECLARE, <a class="indexterm" href="GstPlugin.html#GST-PLUGIN-STATIC-DECLARE:CAPS">GST_PLUGIN_STATIC_DECLARE()</a>
</dt>
<dt id="ientry-idm26199">GST_PLUGIN_STATIC_REGISTER, <a class="indexterm" href="GstPlugin.html#GST-PLUGIN-STATIC-REGISTER:CAPS">GST_PLUGIN_STATIC_REGISTER()</a>
</dt>
<dt id="ientry-idm27110">gst_poll_add_fd, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-add-fd">gst_poll_add_fd ()</a>
</dt>
<dt id="ientry-idm27123">gst_poll_fd_can_read, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-fd-can-read">gst_poll_fd_can_read ()</a>
</dt>
<dt id="ientry-idm27136">gst_poll_fd_can_write, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-fd-can-write">gst_poll_fd_can_write ()</a>
</dt>
<dt id="ientry-idm27149">gst_poll_fd_ctl_read, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-fd-ctl-read">gst_poll_fd_ctl_read ()</a>
</dt>
<dt id="ientry-idm27165">gst_poll_fd_ctl_write, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-fd-ctl-write">gst_poll_fd_ctl_write ()</a>
</dt>
<dt id="ientry-idm27181">gst_poll_fd_has_closed, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-fd-has-closed">gst_poll_fd_has_closed ()</a>
</dt>
<dt id="ientry-idm27194">gst_poll_fd_has_error, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-fd-has-error">gst_poll_fd_has_error ()</a>
</dt>
<dt id="ientry-idm27207">gst_poll_fd_ignored, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-fd-ignored">gst_poll_fd_ignored ()</a>
</dt>
<dt id="ientry-idm27220">gst_poll_fd_init, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-fd-init">gst_poll_fd_init ()</a>
</dt>
<dt id="ientry-idm27366">GST_POLL_FD_INIT, <a class="indexterm" href="gstreamer-GstPoll.html#GST-POLL-FD-INIT:CAPS">GST_POLL_FD_INIT</a>
</dt>
<dt id="ientry-idm27230">gst_poll_free, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-free">gst_poll_free ()</a>
</dt>
<dt id="ientry-idm27259">gst_poll_get_read_gpollfd, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-get-read-gpollfd">gst_poll_get_read_gpollfd ()</a>
</dt>
<dt id="ientry-idm27240">gst_poll_new, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-new">gst_poll_new ()</a>
</dt>
<dt id="ientry-idm27250">gst_poll_new_timer, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-new-timer">gst_poll_new_timer ()</a>
</dt>
<dt id="ientry-idm27334">gst_poll_read_control, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-read-control">gst_poll_read_control ()</a>
</dt>
<dt id="ientry-idm27272">gst_poll_remove_fd, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-remove-fd">gst_poll_remove_fd ()</a>
</dt>
<dt id="ientry-idm27285">gst_poll_restart, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-restart">gst_poll_restart ()</a>
</dt>
<dt id="ientry-idm27295">gst_poll_set_controllable, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-set-controllable">gst_poll_set_controllable ()</a>
</dt>
<dt id="ientry-idm27308">gst_poll_set_flushing, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-set-flushing">gst_poll_set_flushing ()</a>
</dt>
<dt id="ientry-idm27321">gst_poll_wait, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-wait">gst_poll_wait ()</a>
</dt>
<dt id="ientry-idm27344">gst_poll_write_control, <a class="indexterm" href="gstreamer-GstPoll.html#gst-poll-write-control">gst_poll_write_control ()</a>
</dt>
<dt id="ientry-idm27552">gst_preset_delete_preset, <a class="indexterm" href="GstPreset.html#gst-preset-delete-preset">gst_preset_delete_preset ()</a>
</dt>
<dt id="ientry-idm27613">gst_preset_get_app_dir, <a class="indexterm" href="GstPreset.html#gst-preset-get-app-dir">gst_preset_get_app_dir ()</a>
</dt>
<dt id="ientry-idm27584">gst_preset_get_meta, <a class="indexterm" href="GstPreset.html#gst-preset-get-meta">gst_preset_get_meta ()</a>
</dt>
<dt id="ientry-idm27490">gst_preset_get_preset_names, <a class="indexterm" href="GstPreset.html#gst-preset-get-preset-names">gst_preset_get_preset_names ()</a>
</dt>
<dt id="ientry-idm27500">gst_preset_get_property_names, <a class="indexterm" href="GstPreset.html#gst-preset-get-property-names">gst_preset_get_property_names ()</a>
</dt>
<dt id="ientry-idm27622">gst_preset_is_editable, <a class="indexterm" href="GstPreset.html#gst-preset-is-editable">gst_preset_is_editable ()</a>
</dt>
<dt id="ientry-idm27510">gst_preset_load_preset, <a class="indexterm" href="GstPreset.html#gst-preset-load-preset">gst_preset_load_preset ()</a>
</dt>
<dt id="ientry-idm27536">gst_preset_rename_preset, <a class="indexterm" href="GstPreset.html#gst-preset-rename-preset">gst_preset_rename_preset ()</a>
</dt>
<dt id="ientry-idm27523">gst_preset_save_preset, <a class="indexterm" href="GstPreset.html#gst-preset-save-preset">gst_preset_save_preset ()</a>
</dt>
<dt id="ientry-idm27603">gst_preset_set_app_dir, <a class="indexterm" href="GstPreset.html#gst-preset-set-app-dir">gst_preset_set_app_dir ()</a>
</dt>
<dt id="ientry-idm27565">gst_preset_set_meta, <a class="indexterm" href="GstPreset.html#gst-preset-set-meta">gst_preset_set_meta ()</a>
</dt>
<dt id="ientry-idm27718">gst_protection_select_system, <a class="indexterm" href="gstreamer-GstProtectionMeta.html#gst-protection-select-system">gst_protection_select_system ()</a>
</dt>
<dt id="ientry-idm27735">GST_PROTECTION_SYSTEM_ID_CAPS_FIELD, <a class="indexterm" href="gstreamer-GstProtectionMeta.html#GST-PROTECTION-SYSTEM-ID-CAPS-FIELD:CAPS">GST_PROTECTION_SYSTEM_ID_CAPS_FIELD</a>
</dt>
<dt id="ientry-idm15246">gst_proxy_pad_chain_default, <a class="indexterm" href="GstGhostPad.html#gst-proxy-pad-chain-default">gst_proxy_pad_chain_default ()</a>
</dt>
<dt id="ientry-idm15262">gst_proxy_pad_chain_list_default, <a class="indexterm" href="GstGhostPad.html#gst-proxy-pad-chain-list-default">gst_proxy_pad_chain_list_default ()</a>
</dt>
<dt id="ientry-idm15278">gst_proxy_pad_getrange_default, <a class="indexterm" href="GstGhostPad.html#gst-proxy-pad-getrange-default">gst_proxy_pad_getrange_default ()</a>
</dt>
<dt id="ientry-idm15223">gst_proxy_pad_get_internal, <a class="indexterm" href="GstGhostPad.html#gst-proxy-pad-get-internal">gst_proxy_pad_get_internal ()</a>
</dt>
<dt id="ientry-idm15233">gst_proxy_pad_iterate_internal_links_default, <a class="indexterm" href="GstGhostPad.html#gst-proxy-pad-iterate-internal-links-default">gst_proxy_pad_iterate_internal_links_default ()</a>
</dt>
<dt id="ientry-idm44538">GST_PTR_FORMAT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-PTR-FORMAT:CAPS">GST_PTR_FORMAT</a>
</dt>
<dt id="ientry-idm29528">gst_query_add_allocation_meta, <a class="indexterm" href="GstQuery.html#gst-query-add-allocation-meta">gst_query_add_allocation_meta ()</a>
</dt>
<dt id="ientry-idm29451">gst_query_add_allocation_param, <a class="indexterm" href="GstQuery.html#gst-query-add-allocation-param">gst_query_add_allocation_param ()</a>
</dt>
<dt id="ientry-idm29356">gst_query_add_allocation_pool, <a class="indexterm" href="GstQuery.html#gst-query-add-allocation-pool">gst_query_add_allocation_pool ()</a>
</dt>
<dt id="ientry-idm29195">gst_query_add_buffering_range, <a class="indexterm" href="GstQuery.html#gst-query-add-buffering-range">gst_query_add_buffering_range ()</a>
</dt>
<dt id="ientry-idm29652">gst_query_add_scheduling_mode, <a class="indexterm" href="GstQuery.html#gst-query-add-scheduling-mode">gst_query_add_scheduling_mode ()</a>
</dt>
<dt id="ientry-idm28534">gst_query_copy, <a class="indexterm" href="GstQuery.html#gst-query-copy">gst_query_copy ()</a>
</dt>
<dt id="ientry-idm29583">gst_query_find_allocation_meta, <a class="indexterm" href="GstQuery.html#gst-query-find-allocation-meta">gst_query_find_allocation_meta ()</a>
</dt>
<dt id="ientry-idm29544">gst_query_get_n_allocation_metas, <a class="indexterm" href="GstQuery.html#gst-query-get-n-allocation-metas">gst_query_get_n_allocation_metas ()</a>
</dt>
<dt id="ientry-idm29467">gst_query_get_n_allocation_params, <a class="indexterm" href="GstQuery.html#gst-query-get-n-allocation-params">gst_query_get_n_allocation_params ()</a>
</dt>
<dt id="ientry-idm29378">gst_query_get_n_allocation_pools, <a class="indexterm" href="GstQuery.html#gst-query-get-n-allocation-pools">gst_query_get_n_allocation_pools ()</a>
</dt>
<dt id="ientry-idm29211">gst_query_get_n_buffering_ranges, <a class="indexterm" href="GstQuery.html#gst-query-get-n-buffering-ranges">gst_query_get_n_buffering_ranges ()</a>
</dt>
<dt id="ientry-idm29665">gst_query_get_n_scheduling_modes, <a class="indexterm" href="GstQuery.html#gst-query-get-n-scheduling-modes">gst_query_get_n_scheduling_modes ()</a>
</dt>
<dt id="ientry-idm28590">gst_query_get_structure, <a class="indexterm" href="GstQuery.html#gst-query-get-structure">gst_query_get_structure ()</a>
</dt>
<dt id="ientry-idm29688">gst_query_has_scheduling_mode, <a class="indexterm" href="GstQuery.html#gst-query-has-scheduling-mode">gst_query_has_scheduling_mode ()</a>
</dt>
<dt id="ientry-idm29701">gst_query_has_scheduling_mode_with_flags, <a class="indexterm" href="GstQuery.html#gst-query-has-scheduling-mode-with-flags">gst_query_has_scheduling_mode_with_flags ()</a>
</dt>
<dt id="ientry-idm28474">GST_QUERY_IS_DOWNSTREAM, <a class="indexterm" href="GstQuery.html#GST-QUERY-IS-DOWNSTREAM:CAPS">GST_QUERY_IS_DOWNSTREAM()</a>
</dt>
<dt id="ientry-idm28479">GST_QUERY_IS_SERIALIZED, <a class="indexterm" href="GstQuery.html#GST-QUERY-IS-SERIALIZED:CAPS">GST_QUERY_IS_SERIALIZED()</a>
</dt>
<dt id="ientry-idm28469">GST_QUERY_IS_UPSTREAM, <a class="indexterm" href="GstQuery.html#GST-QUERY-IS-UPSTREAM:CAPS">GST_QUERY_IS_UPSTREAM()</a>
</dt>
<dt id="ientry-idm28549">gst_query_is_writable, <a class="indexterm" href="GstQuery.html#gst-query-is-writable">gst_query_is_writable()</a>
</dt>
<dt id="ientry-idm28454">GST_QUERY_MAKE_TYPE, <a class="indexterm" href="GstQuery.html#GST-QUERY-MAKE-TYPE:CAPS">GST_QUERY_MAKE_TYPE()</a>
</dt>
<dt id="ientry-idm28544">gst_query_make_writable, <a class="indexterm" href="GstQuery.html#gst-query-make-writable">gst_query_make_writable()</a>
</dt>
<dt id="ientry-idm29016">gst_query_new_accept_caps, <a class="indexterm" href="GstQuery.html#gst-query-new-accept-caps">gst_query_new_accept_caps ()</a>
</dt>
<dt id="ientry-idm29327">gst_query_new_allocation, <a class="indexterm" href="GstQuery.html#gst-query-new-allocation">gst_query_new_allocation ()</a>
</dt>
<dt id="ientry-idm29065">gst_query_new_buffering, <a class="indexterm" href="GstQuery.html#gst-query-new-buffering">gst_query_new_buffering ()</a>
</dt>
<dt id="ientry-idm28967">gst_query_new_caps, <a class="indexterm" href="GstQuery.html#gst-query-new-caps">gst_query_new_caps ()</a>
</dt>
<dt id="ientry-idm29726">gst_query_new_context, <a class="indexterm" href="GstQuery.html#gst-query-new-context">gst_query_new_context ()</a>
</dt>
<dt id="ientry-idm28600">gst_query_new_convert, <a class="indexterm" href="GstQuery.html#gst-query-new-convert">gst_query_new_convert ()</a>
</dt>
<dt id="ientry-idm28577">gst_query_new_custom, <a class="indexterm" href="GstQuery.html#gst-query-new-custom">gst_query_new_custom ()</a>
</dt>
<dt id="ientry-idm29717">gst_query_new_drain, <a class="indexterm" href="GstQuery.html#gst-query-new-drain">gst_query_new_drain ()</a>
</dt>
<dt id="ientry-idm28702">gst_query_new_duration, <a class="indexterm" href="GstQuery.html#gst-query-new-duration">gst_query_new_duration ()</a>
</dt>
<dt id="ientry-idm28845">gst_query_new_formats, <a class="indexterm" href="GstQuery.html#gst-query-new-formats">gst_query_new_formats ()</a>
</dt>
<dt id="ientry-idm28744">gst_query_new_latency, <a class="indexterm" href="GstQuery.html#gst-query-new-latency">gst_query_new_latency ()</a>
</dt>
<dt id="ientry-idm28660">gst_query_new_position, <a class="indexterm" href="GstQuery.html#gst-query-new-position">gst_query_new_position ()</a>
</dt>
<dt id="ientry-idm29599">gst_query_new_scheduling, <a class="indexterm" href="GstQuery.html#gst-query-new-scheduling">gst_query_new_scheduling ()</a>
</dt>
<dt id="ientry-idm28791">gst_query_new_seeking, <a class="indexterm" href="GstQuery.html#gst-query-new-seeking">gst_query_new_seeking ()</a>
</dt>
<dt id="ientry-idm28913">gst_query_new_segment, <a class="indexterm" href="GstQuery.html#gst-query-new-segment">gst_query_new_segment ()</a>
</dt>
<dt id="ientry-idm29240">gst_query_new_uri, <a class="indexterm" href="GstQuery.html#gst-query-new-uri">gst_query_new_uri ()</a>
</dt>
<dt id="ientry-idm29026">gst_query_parse_accept_caps, <a class="indexterm" href="GstQuery.html#gst-query-parse-accept-caps">gst_query_parse_accept_caps ()</a>
</dt>
<dt id="ientry-idm29052">gst_query_parse_accept_caps_result, <a class="indexterm" href="GstQuery.html#gst-query-parse-accept-caps-result">gst_query_parse_accept_caps_result ()</a>
</dt>
<dt id="ientry-idm29340">gst_query_parse_allocation, <a class="indexterm" href="GstQuery.html#gst-query-parse-allocation">gst_query_parse_allocation ()</a>
</dt>
<dt id="ientry-idm29091">gst_query_parse_buffering_percent, <a class="indexterm" href="GstQuery.html#gst-query-parse-buffering-percent">gst_query_parse_buffering_percent ()</a>
</dt>
<dt id="ientry-idm29173">gst_query_parse_buffering_range, <a class="indexterm" href="GstQuery.html#gst-query-parse-buffering-range">gst_query_parse_buffering_range ()</a>
</dt>
<dt id="ientry-idm29129">gst_query_parse_buffering_stats, <a class="indexterm" href="GstQuery.html#gst-query-parse-buffering-stats">gst_query_parse_buffering_stats ()</a>
</dt>
<dt id="ientry-idm28977">gst_query_parse_caps, <a class="indexterm" href="GstQuery.html#gst-query-parse-caps">gst_query_parse_caps ()</a>
</dt>
<dt id="ientry-idm29003">gst_query_parse_caps_result, <a class="indexterm" href="GstQuery.html#gst-query-parse-caps-result">gst_query_parse_caps_result ()</a>
</dt>
<dt id="ientry-idm29749">gst_query_parse_context, <a class="indexterm" href="GstQuery.html#gst-query-parse-context">gst_query_parse_context ()</a>
</dt>
<dt id="ientry-idm29762">gst_query_parse_context_type, <a class="indexterm" href="GstQuery.html#gst-query-parse-context-type">gst_query_parse_context_type ()</a>
</dt>
<dt id="ientry-idm28638">gst_query_parse_convert, <a class="indexterm" href="GstQuery.html#gst-query-parse-convert">gst_query_parse_convert ()</a>
</dt>
<dt id="ientry-idm28728">gst_query_parse_duration, <a class="indexterm" href="GstQuery.html#gst-query-parse-duration">gst_query_parse_duration ()</a>
</dt>
<dt id="ientry-idm28753">gst_query_parse_latency, <a class="indexterm" href="GstQuery.html#gst-query-parse-latency">gst_query_parse_latency ()</a>
</dt>
<dt id="ientry-idm29554">gst_query_parse_nth_allocation_meta, <a class="indexterm" href="GstQuery.html#gst-query-parse-nth-allocation-meta">gst_query_parse_nth_allocation_meta ()</a>
</dt>
<dt id="ientry-idm29477">gst_query_parse_nth_allocation_param, <a class="indexterm" href="GstQuery.html#gst-query-parse-nth-allocation-param">gst_query_parse_nth_allocation_param ()</a>
</dt>
<dt id="ientry-idm29388">gst_query_parse_nth_allocation_pool, <a class="indexterm" href="GstQuery.html#gst-query-parse-nth-allocation-pool">gst_query_parse_nth_allocation_pool ()</a>
</dt>
<dt id="ientry-idm29221">gst_query_parse_nth_buffering_range, <a class="indexterm" href="GstQuery.html#gst-query-parse-nth-buffering-range">gst_query_parse_nth_buffering_range ()</a>
</dt>
<dt id="ientry-idm28897">gst_query_parse_nth_format, <a class="indexterm" href="GstQuery.html#gst-query-parse-nth-format">gst_query_parse_nth_format ()</a>
</dt>
<dt id="ientry-idm29675">gst_query_parse_nth_scheduling_mode, <a class="indexterm" href="GstQuery.html#gst-query-parse-nth-scheduling-mode">gst_query_parse_nth_scheduling_mode ()</a>
</dt>
<dt id="ientry-idm28884">gst_query_parse_n_formats, <a class="indexterm" href="GstQuery.html#gst-query-parse-n-formats">gst_query_parse_n_formats ()</a>
</dt>
<dt id="ientry-idm28686">gst_query_parse_position, <a class="indexterm" href="GstQuery.html#gst-query-parse-position">gst_query_parse_position ()</a>
</dt>
<dt id="ientry-idm29608">gst_query_parse_scheduling, <a class="indexterm" href="GstQuery.html#gst-query-parse-scheduling">gst_query_parse_scheduling ()</a>
</dt>
<dt id="ientry-idm28823">gst_query_parse_seeking, <a class="indexterm" href="GstQuery.html#gst-query-parse-seeking">gst_query_parse_seeking ()</a>
</dt>
<dt id="ientry-idm28945">gst_query_parse_segment, <a class="indexterm" href="GstQuery.html#gst-query-parse-segment">gst_query_parse_segment ()</a>
</dt>
<dt id="ientry-idm29249">gst_query_parse_uri, <a class="indexterm" href="GstQuery.html#gst-query-parse-uri">gst_query_parse_uri ()</a>
</dt>
<dt id="ientry-idm29275">gst_query_parse_uri_redirection, <a class="indexterm" href="GstQuery.html#gst-query-parse-uri-redirection">gst_query_parse_uri_redirection ()</a>
</dt>
<dt id="ientry-idm29301">gst_query_parse_uri_redirection_permanent, <a class="indexterm" href="GstQuery.html#gst-query-parse-uri-redirection-permanent">gst_query_parse_uri_redirection_permanent ()</a>
</dt>
<dt id="ientry-idm28514">gst_query_ref, <a class="indexterm" href="GstQuery.html#gst-query-ref">gst_query_ref ()</a>
</dt>
<dt id="ientry-idm29570">gst_query_remove_nth_allocation_meta, <a class="indexterm" href="GstQuery.html#gst-query-remove-nth-allocation-meta">gst_query_remove_nth_allocation_meta ()</a>
</dt>
<dt id="ientry-idm29515">gst_query_remove_nth_allocation_param, <a class="indexterm" href="GstQuery.html#gst-query-remove-nth-allocation-param">gst_query_remove_nth_allocation_param ()</a>
</dt>
<dt id="ientry-idm29438">gst_query_remove_nth_allocation_pool, <a class="indexterm" href="GstQuery.html#gst-query-remove-nth-allocation-pool">gst_query_remove_nth_allocation_pool ()</a>
</dt>
<dt id="ientry-idm28554">gst_query_replace, <a class="indexterm" href="GstQuery.html#gst-query-replace">gst_query_replace ()</a>
</dt>
<dt id="ientry-idm29039">gst_query_set_accept_caps_result, <a class="indexterm" href="GstQuery.html#gst-query-set-accept-caps-result">gst_query_set_accept_caps_result ()</a>
</dt>
<dt id="ientry-idm29075">gst_query_set_buffering_percent, <a class="indexterm" href="GstQuery.html#gst-query-set-buffering-percent">gst_query_set_buffering_percent ()</a>
</dt>
<dt id="ientry-idm29151">gst_query_set_buffering_range, <a class="indexterm" href="GstQuery.html#gst-query-set-buffering-range">gst_query_set_buffering_range ()</a>
</dt>
<dt id="ientry-idm29107">gst_query_set_buffering_stats, <a class="indexterm" href="GstQuery.html#gst-query-set-buffering-stats">gst_query_set_buffering_stats ()</a>
</dt>
<dt id="ientry-idm28990">gst_query_set_caps_result, <a class="indexterm" href="GstQuery.html#gst-query-set-caps-result">gst_query_set_caps_result ()</a>
</dt>
<dt id="ientry-idm29736">gst_query_set_context, <a class="indexterm" href="GstQuery.html#gst-query-set-context">gst_query_set_context ()</a>
</dt>
<dt id="ientry-idm28616">gst_query_set_convert, <a class="indexterm" href="GstQuery.html#gst-query-set-convert">gst_query_set_convert ()</a>
</dt>
<dt id="ientry-idm28712">gst_query_set_duration, <a class="indexterm" href="GstQuery.html#gst-query-set-duration">gst_query_set_duration ()</a>
</dt>
<dt id="ientry-idm28854">gst_query_set_formats, <a class="indexterm" href="GstQuery.html#gst-query-set-formats">gst_query_set_formats ()</a>
</dt>
<dt id="ientry-idm28868">gst_query_set_formatsv, <a class="indexterm" href="GstQuery.html#gst-query-set-formatsv">gst_query_set_formatsv ()</a>
</dt>
<dt id="ientry-idm28772">gst_query_set_latency, <a class="indexterm" href="GstQuery.html#gst-query-set-latency">gst_query_set_latency ()</a>
</dt>
<dt id="ientry-idm29496">gst_query_set_nth_allocation_param, <a class="indexterm" href="GstQuery.html#gst-query-set-nth-allocation-param">gst_query_set_nth_allocation_param ()</a>
</dt>
<dt id="ientry-idm29413">gst_query_set_nth_allocation_pool, <a class="indexterm" href="GstQuery.html#gst-query-set-nth-allocation-pool">gst_query_set_nth_allocation_pool ()</a>
</dt>
<dt id="ientry-idm28670">gst_query_set_position, <a class="indexterm" href="GstQuery.html#gst-query-set-position">gst_query_set_position ()</a>
</dt>
<dt id="ientry-idm29630">gst_query_set_scheduling, <a class="indexterm" href="GstQuery.html#gst-query-set-scheduling">gst_query_set_scheduling ()</a>
</dt>
<dt id="ientry-idm28801">gst_query_set_seeking, <a class="indexterm" href="GstQuery.html#gst-query-set-seeking">gst_query_set_seeking ()</a>
</dt>
<dt id="ientry-idm28923">gst_query_set_segment, <a class="indexterm" href="GstQuery.html#gst-query-set-segment">gst_query_set_segment ()</a>
</dt>
<dt id="ientry-idm29262">gst_query_set_uri, <a class="indexterm" href="GstQuery.html#gst-query-set-uri">gst_query_set_uri ()</a>
</dt>
<dt id="ientry-idm29288">gst_query_set_uri_redirection, <a class="indexterm" href="GstQuery.html#gst-query-set-uri-redirection">gst_query_set_uri_redirection ()</a>
</dt>
<dt id="ientry-idm29314">gst_query_set_uri_redirection_permanent, <a class="indexterm" href="GstQuery.html#gst-query-set-uri-redirection-permanent">gst_query_set_uri_redirection_permanent ()</a>
</dt>
<dt id="ientry-idm28459">GST_QUERY_TYPE, <a class="indexterm" href="GstQuery.html#GST-QUERY-TYPE:CAPS">GST_QUERY_TYPE()</a>
</dt>
<dt id="ientry-idm29809">GST_QUERY_TYPE_BOTH, <a class="indexterm" href="GstQuery.html#GST-QUERY-TYPE-BOTH:CAPS">GST_QUERY_TYPE_BOTH</a>
</dt>
<dt id="ientry-idm28484">gst_query_type_get_flags, <a class="indexterm" href="GstQuery.html#gst-query-type-get-flags">gst_query_type_get_flags ()</a>
</dt>
<dt id="ientry-idm28494">gst_query_type_get_name, <a class="indexterm" href="GstQuery.html#gst-query-type-get-name">gst_query_type_get_name ()</a>
</dt>
<dt id="ientry-idm28464">GST_QUERY_TYPE_NAME, <a class="indexterm" href="GstQuery.html#GST-QUERY-TYPE-NAME:CAPS">GST_QUERY_TYPE_NAME()</a>
</dt>
<dt id="ientry-idm28504">gst_query_type_to_quark, <a class="indexterm" href="GstQuery.html#gst-query-type-to-quark">gst_query_type_to_quark ()</a>
</dt>
<dt id="ientry-idm28524">gst_query_unref, <a class="indexterm" href="GstQuery.html#gst-query-unref">gst_query_unref ()</a>
</dt>
<dt id="ientry-idm28567">gst_query_writable_structure, <a class="indexterm" href="GstQuery.html#gst-query-writable-structure">gst_query_writable_structure ()</a>
</dt>
<dt id="ientry-idm39480">GST_READ_DOUBLE_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-READ-DOUBLE-BE:CAPS">GST_READ_DOUBLE_BE ()</a>
</dt>
<dt id="ientry-idm39470">GST_READ_DOUBLE_LE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-READ-DOUBLE-LE:CAPS">GST_READ_DOUBLE_LE ()</a>
</dt>
<dt id="ientry-idm39460">GST_READ_FLOAT_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-READ-FLOAT-BE:CAPS">GST_READ_FLOAT_BE ()</a>
</dt>
<dt id="ientry-idm39450">GST_READ_FLOAT_LE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-READ-FLOAT-LE:CAPS">GST_READ_FLOAT_LE ()</a>
</dt>
<dt id="ientry-idm39415">GST_READ_UINT16_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-READ-UINT16-BE:CAPS">GST_READ_UINT16_BE()</a>
</dt>
<dt id="ientry-idm39410">GST_READ_UINT16_LE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-READ-UINT16-LE:CAPS">GST_READ_UINT16_LE()</a>
</dt>
<dt id="ientry-idm39425">GST_READ_UINT24_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-READ-UINT24-BE:CAPS">GST_READ_UINT24_BE()</a>
</dt>
<dt id="ientry-idm39420">GST_READ_UINT24_LE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-READ-UINT24-LE:CAPS">GST_READ_UINT24_LE()</a>
</dt>
<dt id="ientry-idm39435">GST_READ_UINT32_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-READ-UINT32-BE:CAPS">GST_READ_UINT32_BE()</a>
</dt>
<dt id="ientry-idm39430">GST_READ_UINT32_LE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-READ-UINT32-LE:CAPS">GST_READ_UINT32_LE()</a>
</dt>
<dt id="ientry-idm39445">GST_READ_UINT64_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-READ-UINT64-BE:CAPS">GST_READ_UINT64_BE()</a>
</dt>
<dt id="ientry-idm39440">GST_READ_UINT64_LE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-READ-UINT64-LE:CAPS">GST_READ_UINT64_LE()</a>
</dt>
<dt id="ientry-idm39405">GST_READ_UINT8, <a class="indexterm" href="gstreamer-GstUtils.html#GST-READ-UINT8:CAPS">GST_READ_UINT8()</a>
</dt>
<dt id="ientry-idm30402">gst_registry_add_feature, <a class="indexterm" href="GstRegistry.html#gst-registry-add-feature">gst_registry_add_feature ()</a>
</dt>
<dt id="ientry-idm30340">gst_registry_add_path, <a class="indexterm" href="GstRegistry.html#gst-registry-add-path">gst_registry_add_path ()</a>
</dt>
<dt id="ientry-idm30234">gst_registry_add_plugin, <a class="indexterm" href="GstRegistry.html#gst-registry-add-plugin">gst_registry_add_plugin ()</a>
</dt>
<dt id="ientry-idm30415">gst_registry_check_feature_version, <a class="indexterm" href="GstRegistry.html#gst-registry-check-feature-version">gst_registry_check_feature_version ()</a>
</dt>
<dt id="ientry-idm30279">gst_registry_feature_filter, <a class="indexterm" href="GstRegistry.html#gst-registry-feature-filter">gst_registry_feature_filter ()</a>
</dt>
<dt id="ientry-idm30311">gst_registry_find_feature, <a class="indexterm" href="GstRegistry.html#gst-registry-find-feature">gst_registry_find_feature ()</a>
</dt>
<dt id="ientry-idm30298">gst_registry_find_plugin, <a class="indexterm" href="GstRegistry.html#gst-registry-find-plugin">gst_registry_find_plugin ()</a>
</dt>
<dt id="ientry-idm495">gst_registry_fork_is_enabled, <a class="indexterm" href="gstreamer-Gst.html#gst-registry-fork-is-enabled">gst_registry_fork_is_enabled ()</a>
</dt>
<dt id="ientry-idm504">gst_registry_fork_set_enabled, <a class="indexterm" href="gstreamer-Gst.html#gst-registry-fork-set-enabled">gst_registry_fork_set_enabled ()</a>
</dt>
<dt id="ientry-idm30179">gst_registry_get, <a class="indexterm" href="GstRegistry.html#gst-registry-get">gst_registry_get ()</a>
</dt>
<dt id="ientry-idm30188">gst_registry_get_feature_list, <a class="indexterm" href="GstRegistry.html#gst-registry-get-feature-list">gst_registry_get_feature_list ()</a>
</dt>
<dt id="ientry-idm30211">gst_registry_get_feature_list_by_plugin, <a class="indexterm" href="GstRegistry.html#gst-registry-get-feature-list-by-plugin">gst_registry_get_feature_list_by_plugin ()</a>
</dt>
<dt id="ientry-idm30201">gst_registry_get_feature_list_cookie, <a class="indexterm" href="GstRegistry.html#gst-registry-get-feature-list-cookie">gst_registry_get_feature_list_cookie ()</a>
</dt>
<dt id="ientry-idm30353">gst_registry_get_path_list, <a class="indexterm" href="GstRegistry.html#gst-registry-get-path-list">gst_registry_get_path_list ()</a>
</dt>
<dt id="ientry-idm30224">gst_registry_get_plugin_list, <a class="indexterm" href="GstRegistry.html#gst-registry-get-plugin-list">gst_registry_get_plugin_list ()</a>
</dt>
<dt id="ientry-idm30376">gst_registry_lookup, <a class="indexterm" href="GstRegistry.html#gst-registry-lookup">gst_registry_lookup ()</a>
</dt>
<dt id="ientry-idm30327">gst_registry_lookup_feature, <a class="indexterm" href="GstRegistry.html#gst-registry-lookup-feature">gst_registry_lookup_feature ()</a>
</dt>
<dt id="ientry-idm30260">gst_registry_plugin_filter, <a class="indexterm" href="GstRegistry.html#gst-registry-plugin-filter">gst_registry_plugin_filter ()</a>
</dt>
<dt id="ientry-idm30389">gst_registry_remove_feature, <a class="indexterm" href="GstRegistry.html#gst-registry-remove-feature">gst_registry_remove_feature ()</a>
</dt>
<dt id="ientry-idm30247">gst_registry_remove_plugin, <a class="indexterm" href="GstRegistry.html#gst-registry-remove-plugin">gst_registry_remove_plugin ()</a>
</dt>
<dt id="ientry-idm30363">gst_registry_scan_path, <a class="indexterm" href="GstRegistry.html#gst-registry-scan-path">gst_registry_scan_path ()</a>
</dt>
<dt id="ientry-idm12859">GST_RESOURCE_ERROR, <a class="indexterm" href="gstreamer-GstGError.html#GST-RESOURCE-ERROR:CAPS">GST_RESOURCE_ERROR</a>
</dt>
<dt id="ientry-idm39657">GST_ROUND_DOWN_128, <a class="indexterm" href="gstreamer-GstUtils.html#GST-ROUND-DOWN-128:CAPS">GST_ROUND_DOWN_128()</a>
</dt>
<dt id="ientry-idm39642">GST_ROUND_DOWN_16, <a class="indexterm" href="gstreamer-GstUtils.html#GST-ROUND-DOWN-16:CAPS">GST_ROUND_DOWN_16()</a>
</dt>
<dt id="ientry-idm39627">GST_ROUND_DOWN_2, <a class="indexterm" href="gstreamer-GstUtils.html#GST-ROUND-DOWN-2:CAPS">GST_ROUND_DOWN_2()</a>
</dt>
<dt id="ientry-idm39647">GST_ROUND_DOWN_32, <a class="indexterm" href="gstreamer-GstUtils.html#GST-ROUND-DOWN-32:CAPS">GST_ROUND_DOWN_32()</a>
</dt>
<dt id="ientry-idm39632">GST_ROUND_DOWN_4, <a class="indexterm" href="gstreamer-GstUtils.html#GST-ROUND-DOWN-4:CAPS">GST_ROUND_DOWN_4()</a>
</dt>
<dt id="ientry-idm39652">GST_ROUND_DOWN_64, <a class="indexterm" href="gstreamer-GstUtils.html#GST-ROUND-DOWN-64:CAPS">GST_ROUND_DOWN_64()</a>
</dt>
<dt id="ientry-idm39637">GST_ROUND_DOWN_8, <a class="indexterm" href="gstreamer-GstUtils.html#GST-ROUND-DOWN-8:CAPS">GST_ROUND_DOWN_8()</a>
</dt>
<dt id="ientry-idm39662">GST_ROUND_DOWN_N, <a class="indexterm" href="gstreamer-GstUtils.html#GST-ROUND-DOWN-N:CAPS">GST_ROUND_DOWN_N()</a>
</dt>
<dt id="ientry-idm39617">GST_ROUND_UP_128, <a class="indexterm" href="gstreamer-GstUtils.html#GST-ROUND-UP-128:CAPS">GST_ROUND_UP_128()</a>
</dt>
<dt id="ientry-idm39602">GST_ROUND_UP_16, <a class="indexterm" href="gstreamer-GstUtils.html#GST-ROUND-UP-16:CAPS">GST_ROUND_UP_16()</a>
</dt>
<dt id="ientry-idm39587">GST_ROUND_UP_2, <a class="indexterm" href="gstreamer-GstUtils.html#GST-ROUND-UP-2:CAPS">GST_ROUND_UP_2()</a>
</dt>
<dt id="ientry-idm39607">GST_ROUND_UP_32, <a class="indexterm" href="gstreamer-GstUtils.html#GST-ROUND-UP-32:CAPS">GST_ROUND_UP_32()</a>
</dt>
<dt id="ientry-idm39592">GST_ROUND_UP_4, <a class="indexterm" href="gstreamer-GstUtils.html#GST-ROUND-UP-4:CAPS">GST_ROUND_UP_4()</a>
</dt>
<dt id="ientry-idm39612">GST_ROUND_UP_64, <a class="indexterm" href="gstreamer-GstUtils.html#GST-ROUND-UP-64:CAPS">GST_ROUND_UP_64()</a>
</dt>
<dt id="ientry-idm39597">GST_ROUND_UP_8, <a class="indexterm" href="gstreamer-GstUtils.html#GST-ROUND-UP-8:CAPS">GST_ROUND_UP_8()</a>
</dt>
<dt id="ientry-idm39622">GST_ROUND_UP_N, <a class="indexterm" href="gstreamer-GstUtils.html#GST-ROUND-UP-N:CAPS">GST_ROUND_UP_N()</a>
</dt>
<dt id="ientry-idm6710">gst_sample_copy, <a class="indexterm" href="GstSample.html#gst-sample-copy">gst_sample_copy ()</a>
</dt>
<dt id="ientry-idm6608">gst_sample_get_buffer, <a class="indexterm" href="GstSample.html#gst-sample-get-buffer">gst_sample_get_buffer ()</a>
</dt>
<dt id="ientry-idm6618">gst_sample_get_buffer_list, <a class="indexterm" href="GstSample.html#gst-sample-get-buffer-list">gst_sample_get_buffer_list ()</a>
</dt>
<dt id="ientry-idm6628">gst_sample_get_caps, <a class="indexterm" href="GstSample.html#gst-sample-get-caps">gst_sample_get_caps ()</a>
</dt>
<dt id="ientry-idm6638">gst_sample_get_info, <a class="indexterm" href="GstSample.html#gst-sample-get-info">gst_sample_get_info ()</a>
</dt>
<dt id="ientry-idm6648">gst_sample_get_segment, <a class="indexterm" href="GstSample.html#gst-sample-get-segment">gst_sample_get_segment ()</a>
</dt>
<dt id="ientry-idm6671">gst_sample_new, <a class="indexterm" href="GstSample.html#gst-sample-new">gst_sample_new ()</a>
</dt>
<dt id="ientry-idm6690">gst_sample_ref, <a class="indexterm" href="GstSample.html#gst-sample-ref">gst_sample_ref ()</a>
</dt>
<dt id="ientry-idm6658">gst_sample_set_buffer_list, <a class="indexterm" href="GstSample.html#gst-sample-set-buffer-list">gst_sample_set_buffer_list ()</a>
</dt>
<dt id="ientry-idm6700">gst_sample_unref, <a class="indexterm" href="GstSample.html#gst-sample-unref">gst_sample_unref ()</a>
</dt>
<dt id="ientry-idm8161">GST_SECOND, <a class="indexterm" href="GstClock.html#GST-SECOND:CAPS">GST_SECOND</a>
</dt>
<dt id="ientry-idm30653">gst_segment_clip, <a class="indexterm" href="GstSegment.html#gst-segment-clip">gst_segment_clip ()</a>
</dt>
<dt id="ientry-idm30700">gst_segment_copy, <a class="indexterm" href="GstSegment.html#gst-segment-copy">gst_segment_copy ()</a>
</dt>
<dt id="ientry-idm30929">gst_segment_copy_into, <a class="indexterm" href="GstSegment.html#gst-segment-copy-into">gst_segment_copy_into ()</a>
</dt>
<dt id="ientry-idm30720">gst_segment_do_seek, <a class="indexterm" href="GstSegment.html#gst-segment-do-seek">gst_segment_do_seek ()</a>
</dt>
<dt id="ientry-idm44543">GST_SEGMENT_FORMAT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-SEGMENT-FORMAT:CAPS">GST_SEGMENT_FORMAT</a>
</dt>
<dt id="ientry-idm30710">gst_segment_free, <a class="indexterm" href="GstSegment.html#gst-segment-free">gst_segment_free ()</a>
</dt>
<dt id="ientry-idm30678">gst_segment_init, <a class="indexterm" href="GstSegment.html#gst-segment-init">gst_segment_init ()</a>
</dt>
<dt id="ientry-idm30958">gst_segment_is_equal, <a class="indexterm" href="GstSegment.html#gst-segment-is-equal">gst_segment_is_equal ()</a>
</dt>
<dt id="ientry-idm30691">gst_segment_new, <a class="indexterm" href="GstSegment.html#gst-segment-new">gst_segment_new ()</a>
</dt>
<dt id="ientry-idm30942">gst_segment_offset_running_time, <a class="indexterm" href="GstSegment.html#gst-segment-offset-running-time">gst_segment_offset_running_time ()</a>
</dt>
<dt id="ientry-idm30859">gst_segment_position_from_running_time, <a class="indexterm" href="GstSegment.html#gst-segment-position-from-running-time">gst_segment_position_from_running_time ()</a>
</dt>
<dt id="ientry-idm30875">gst_segment_position_from_running_time_full, <a class="indexterm" href="GstSegment.html#gst-segment-position-from-running-time-full">gst_segment_position_from_running_time_full ()</a>
</dt>
<dt id="ientry-idm30754">gst_segment_position_from_stream_time, <a class="indexterm" href="GstSegment.html#gst-segment-position-from-stream-time">gst_segment_position_from_stream_time ()</a>
</dt>
<dt id="ientry-idm30770">gst_segment_position_from_stream_time_full, <a class="indexterm" href="GstSegment.html#gst-segment-position-from-stream-time-full">gst_segment_position_from_stream_time_full ()</a>
</dt>
<dt id="ientry-idm30913">gst_segment_set_running_time, <a class="indexterm" href="GstSegment.html#gst-segment-set-running-time">gst_segment_set_running_time ()</a>
</dt>
<dt id="ientry-idm30894">gst_segment_to_position, <a class="indexterm" href="GstSegment.html#gst-segment-to-position">gst_segment_to_position ()</a>
</dt>
<dt id="ientry-idm30789">gst_segment_to_running_time, <a class="indexterm" href="GstSegment.html#gst-segment-to-running-time">gst_segment_to_running_time ()</a>
</dt>
<dt id="ientry-idm30805">gst_segment_to_running_time_full, <a class="indexterm" href="GstSegment.html#gst-segment-to-running-time-full">gst_segment_to_running_time_full ()</a>
</dt>
<dt id="ientry-idm30824">gst_segment_to_stream_time, <a class="indexterm" href="GstSegment.html#gst-segment-to-stream-time">gst_segment_to_stream_time ()</a>
</dt>
<dt id="ientry-idm30840">gst_segment_to_stream_time_full, <a class="indexterm" href="GstSegment.html#gst-segment-to-stream-time-full">gst_segment_to_stream_time_full ()</a>
</dt>
<dt id="ientry-idm476">gst_segtrap_is_enabled, <a class="indexterm" href="gstreamer-Gst.html#gst-segtrap-is-enabled">gst_segtrap_is_enabled ()</a>
</dt>
<dt id="ientry-idm485">gst_segtrap_set_enabled, <a class="indexterm" href="gstreamer-Gst.html#gst-segtrap-set-enabled">gst_segtrap_set_enabled ()</a>
</dt>
<dt id="ientry-idm10433">GST_STATE, <a class="indexterm" href="GstElement.html#GST-STATE:CAPS">GST_STATE()</a>
</dt>
<dt id="ientry-idm10483">GST_STATE_GET_COND, <a class="indexterm" href="GstElement.html#GST-STATE-GET-COND:CAPS">GST_STATE_GET_COND()</a>
</dt>
<dt id="ientry-idm10478">GST_STATE_GET_LOCK, <a class="indexterm" href="GstElement.html#GST-STATE-GET-LOCK:CAPS">GST_STATE_GET_LOCK()</a>
</dt>
<dt id="ientry-idm10438">GST_STATE_GET_NEXT, <a class="indexterm" href="GstElement.html#GST-STATE-GET-NEXT:CAPS">GST_STATE_GET_NEXT()</a>
</dt>
<dt id="ientry-idm10443">GST_STATE_NEXT, <a class="indexterm" href="GstElement.html#GST-STATE-NEXT:CAPS">GST_STATE_NEXT()</a>
</dt>
<dt id="ientry-idm10448">GST_STATE_PENDING, <a class="indexterm" href="GstElement.html#GST-STATE-PENDING:CAPS">GST_STATE_PENDING()</a>
</dt>
<dt id="ientry-idm10453">GST_STATE_RETURN, <a class="indexterm" href="GstElement.html#GST-STATE-RETURN:CAPS">GST_STATE_RETURN()</a>
</dt>
<dt id="ientry-idm10458">GST_STATE_TARGET, <a class="indexterm" href="GstElement.html#GST-STATE-TARGET:CAPS">GST_STATE_TARGET()</a>
</dt>
<dt id="ientry-idm10463">GST_STATE_TRANSITION, <a class="indexterm" href="GstElement.html#GST-STATE-TRANSITION:CAPS">GST_STATE_TRANSITION()</a>
</dt>
<dt id="ientry-idm10468">GST_STATE_TRANSITION_CURRENT, <a class="indexterm" href="GstElement.html#GST-STATE-TRANSITION-CURRENT:CAPS">GST_STATE_TRANSITION_CURRENT()</a>
</dt>
<dt id="ientry-idm10473">GST_STATE_TRANSITION_NEXT, <a class="indexterm" href="GstElement.html#GST-STATE-TRANSITION-NEXT:CAPS">GST_STATE_TRANSITION_NEXT()</a>
</dt>
<dt id="ientry-idm5208">GST_STATIC_CAPS, <a class="indexterm" href="GstCaps.html#GST-STATIC-CAPS">GST_STATIC_CAPS()</a>
</dt>
<dt id="ientry-idm6008">GST_STATIC_CAPS_ANY, <a class="indexterm" href="GstCaps.html#GST-STATIC-CAPS-ANY:CAPS">GST_STATIC_CAPS_ANY</a>
</dt>
<dt id="ientry-idm5391">gst_static_caps_cleanup, <a class="indexterm" href="GstCaps.html#gst-static-caps-cleanup">gst_static_caps_cleanup ()</a>
</dt>
<dt id="ientry-idm5381">gst_static_caps_get, <a class="indexterm" href="GstCaps.html#gst-static-caps-get">gst_static_caps_get ()</a>
</dt>
<dt id="ientry-idm6013">GST_STATIC_CAPS_NONE, <a class="indexterm" href="GstCaps.html#GST-STATIC-CAPS-NONE:CAPS">GST_STATIC_CAPS_NONE</a>
</dt>
<dt id="ientry-idm24831">GST_STATIC_PAD_TEMPLATE, <a class="indexterm" href="GstPadTemplate.html#GST-STATIC-PAD-TEMPLATE:CAPS">GST_STATIC_PAD_TEMPLATE()</a>
</dt>
<dt id="ientry-idm24836">gst_static_pad_template_get, <a class="indexterm" href="GstPadTemplate.html#gst-static-pad-template-get">gst_static_pad_template_get ()</a>
</dt>
<dt id="ientry-idm24846">gst_static_pad_template_get_caps, <a class="indexterm" href="GstPadTemplate.html#gst-static-pad-template-get-caps">gst_static_pad_template_get_caps ()</a>
</dt>
<dt id="ientry-idm44173">GST_STIME_ARGS, <a class="indexterm" href="gstreamer-GstInfo.html#GST-STIME-ARGS:CAPS">GST_STIME_ARGS()</a>
</dt>
<dt id="ientry-idm44533">GST_STIME_FORMAT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-STIME-FORMAT:CAPS">GST_STIME_FORMAT</a>
</dt>
<dt id="ientry-idm31405">gst_stream_collection_add_stream, <a class="indexterm" href="gstreamer-GstStreamCollection.html#gst-stream-collection-add-stream">gst_stream_collection_add_stream ()</a>
</dt>
<dt id="ientry-idm31428">gst_stream_collection_get_size, <a class="indexterm" href="gstreamer-GstStreamCollection.html#gst-stream-collection-get-size">gst_stream_collection_get_size ()</a>
</dt>
<dt id="ientry-idm31438">gst_stream_collection_get_stream, <a class="indexterm" href="gstreamer-GstStreamCollection.html#gst-stream-collection-get-stream">gst_stream_collection_get_stream ()</a>
</dt>
<dt id="ientry-idm31418">gst_stream_collection_get_upstream_id, <a class="indexterm" href="gstreamer-GstStreamCollection.html#gst-stream-collection-get-upstream-id">gst_stream_collection_get_upstream_id ()</a>
</dt>
<dt id="ientry-idm31395">gst_stream_collection_new, <a class="indexterm" href="gstreamer-GstStreamCollection.html#gst-stream-collection-new">gst_stream_collection_new ()</a>
</dt>
<dt id="ientry-idm12864">GST_STREAM_ERROR, <a class="indexterm" href="gstreamer-GstGError.html#GST-STREAM-ERROR:CAPS">GST_STREAM_ERROR</a>
</dt>
<dt id="ientry-idm31162">gst_stream_get_caps, <a class="indexterm" href="gstreamer-GstStream.html#gst-stream-get-caps">gst_stream_get_caps ()</a>
</dt>
<dt id="ientry-idm31172">gst_stream_get_stream_flags, <a class="indexterm" href="gstreamer-GstStream.html#gst-stream-get-stream-flags">gst_stream_get_stream_flags ()</a>
</dt>
<dt id="ientry-idm31182">gst_stream_get_stream_id, <a class="indexterm" href="gstreamer-GstStream.html#gst-stream-get-stream-id">gst_stream_get_stream_id ()</a>
</dt>
<dt id="ientry-idm31192">gst_stream_get_stream_type, <a class="indexterm" href="gstreamer-GstStream.html#gst-stream-get-stream-type">gst_stream_get_stream_type ()</a>
</dt>
<dt id="ientry-idm31202">gst_stream_get_tags, <a class="indexterm" href="gstreamer-GstStream.html#gst-stream-get-tags">gst_stream_get_tags ()</a>
</dt>
<dt id="ientry-idm31143">gst_stream_new, <a class="indexterm" href="gstreamer-GstStream.html#gst-stream-new">gst_stream_new ()</a>
</dt>
<dt id="ientry-idm31212">gst_stream_set_caps, <a class="indexterm" href="gstreamer-GstStream.html#gst-stream-set-caps">gst_stream_set_caps ()</a>
</dt>
<dt id="ientry-idm31225">gst_stream_set_stream_flags, <a class="indexterm" href="gstreamer-GstStream.html#gst-stream-set-stream-flags">gst_stream_set_stream_flags ()</a>
</dt>
<dt id="ientry-idm31238">gst_stream_set_stream_type, <a class="indexterm" href="gstreamer-GstStream.html#gst-stream-set-stream-type">gst_stream_set_stream_type ()</a>
</dt>
<dt id="ientry-idm31251">gst_stream_set_tags, <a class="indexterm" href="gstreamer-GstStream.html#gst-stream-set-tags">gst_stream_set_tags ()</a>
</dt>
<dt id="ientry-idm31264">gst_stream_type_get_name, <a class="indexterm" href="gstreamer-GstStream.html#gst-stream-type-get-name">gst_stream_type_get_name ()</a>
</dt>
<dt id="ientry-idm32525">gst_structure_can_intersect, <a class="indexterm" href="GstStructure.html#gst-structure-can-intersect">gst_structure_can_intersect ()</a>
</dt>
<dt id="ientry-idm32118">gst_structure_copy, <a class="indexterm" href="GstStructure.html#gst-structure-copy">gst_structure_copy ()</a>
</dt>
<dt id="ientry-idm32807">gst_structure_filter_and_map_in_place, <a class="indexterm" href="GstStructure.html#gst-structure-filter-and-map-in-place">gst_structure_filter_and_map_in_place ()</a>
</dt>
<dt id="ientry-idm32872">gst_structure_fixate, <a class="indexterm" href="GstStructure.html#gst-structure-fixate">gst_structure_fixate ()</a>
</dt>
<dt id="ientry-idm32882">gst_structure_fixate_field, <a class="indexterm" href="GstStructure.html#gst-structure-fixate-field">gst_structure_fixate_field ()</a>
</dt>
<dt id="ientry-idm32946">gst_structure_fixate_field_boolean, <a class="indexterm" href="GstStructure.html#gst-structure-fixate-field-boolean">gst_structure_fixate_field_boolean ()</a>
</dt>
<dt id="ientry-idm32911">gst_structure_fixate_field_nearest_double, <a class="indexterm" href="GstStructure.html#gst-structure-fixate-field-nearest-double">gst_structure_fixate_field_nearest_double ()</a>
</dt>
<dt id="ientry-idm32927">gst_structure_fixate_field_nearest_fraction, <a class="indexterm" href="GstStructure.html#gst-structure-fixate-field-nearest-fraction">gst_structure_fixate_field_nearest_fraction ()</a>
</dt>
<dt id="ientry-idm32895">gst_structure_fixate_field_nearest_int, <a class="indexterm" href="GstStructure.html#gst-structure-fixate-field-nearest-int">gst_structure_fixate_field_nearest_int ()</a>
</dt>
<dt id="ientry-idm32962">gst_structure_fixate_field_string, <a class="indexterm" href="GstStructure.html#gst-structure-fixate-field-string">gst_structure_fixate_field_string ()</a>
</dt>
<dt id="ientry-idm32775">gst_structure_foreach, <a class="indexterm" href="GstStructure.html#gst-structure-foreach">gst_structure_foreach ()</a>
</dt>
<dt id="ientry-idm32128">gst_structure_free, <a class="indexterm" href="GstStructure.html#gst-structure-free">gst_structure_free ()</a>
</dt>
<dt id="ientry-idm32859">gst_structure_from_string, <a class="indexterm" href="GstStructure.html#gst-structure-from-string">gst_structure_from_string ()</a>
</dt>
<dt id="ientry-idm32259">gst_structure_get, <a class="indexterm" href="GstStructure.html#gst-structure-get">gst_structure_get ()</a>
</dt>
<dt id="ientry-idm32580">gst_structure_get_boolean, <a class="indexterm" href="GstStructure.html#gst-structure-get-boolean">gst_structure_get_boolean ()</a>
</dt>
<dt id="ientry-idm32721">gst_structure_get_clock_time, <a class="indexterm" href="GstStructure.html#gst-structure-get-clock-time">gst_structure_get_clock_time ()</a>
</dt>
<dt id="ientry-idm32689">gst_structure_get_date, <a class="indexterm" href="GstStructure.html#gst-structure-get-date">gst_structure_get_date ()</a>
</dt>
<dt id="ientry-idm32705">gst_structure_get_date_time, <a class="indexterm" href="GstStructure.html#gst-structure-get-date-time">gst_structure_get_date_time ()</a>
</dt>
<dt id="ientry-idm32660">gst_structure_get_double, <a class="indexterm" href="GstStructure.html#gst-structure-get-double">gst_structure_get_double ()</a>
</dt>
<dt id="ientry-idm32737">gst_structure_get_enum, <a class="indexterm" href="GstStructure.html#gst-structure-get-enum">gst_structure_get_enum ()</a>
</dt>
<dt id="ientry-idm32447">gst_structure_get_field_type, <a class="indexterm" href="GstStructure.html#gst-structure-get-field-type">gst_structure_get_field_type ()</a>
</dt>
<dt id="ientry-idm40891">gst_structure_get_flagset, <a class="indexterm" href="gstreamer-GstValue.html#gst-structure-get-flagset">gst_structure_get_flagset ()</a>
</dt>
<dt id="ientry-idm32756">gst_structure_get_fraction, <a class="indexterm" href="GstStructure.html#gst-structure-get-fraction">gst_structure_get_fraction ()</a>
</dt>
<dt id="ientry-idm32596">gst_structure_get_int, <a class="indexterm" href="GstStructure.html#gst-structure-get-int">gst_structure_get_int ()</a>
</dt>
<dt id="ientry-idm32628">gst_structure_get_int64, <a class="indexterm" href="GstStructure.html#gst-structure-get-int64">gst_structure_get_int64 ()</a>
</dt>
<dt id="ientry-idm32138">gst_structure_get_name, <a class="indexterm" href="GstStructure.html#gst-structure-get-name">gst_structure_get_name ()</a>
</dt>
<dt id="ientry-idm32174">gst_structure_get_name_id, <a class="indexterm" href="GstStructure.html#gst-structure-get-name-id">gst_structure_get_name_id ()</a>
</dt>
<dt id="ientry-idm32676">gst_structure_get_string, <a class="indexterm" href="GstStructure.html#gst-structure-get-string">gst_structure_get_string ()</a>
</dt>
<dt id="ientry-idm32612">gst_structure_get_uint, <a class="indexterm" href="GstStructure.html#gst-structure-get-uint">gst_structure_get_uint ()</a>
</dt>
<dt id="ientry-idm32644">gst_structure_get_uint64, <a class="indexterm" href="GstStructure.html#gst-structure-get-uint64">gst_structure_get_uint64 ()</a>
</dt>
<dt id="ientry-idm32273">gst_structure_get_valist, <a class="indexterm" href="GstStructure.html#gst-structure-get-valist">gst_structure_get_valist ()</a>
</dt>
<dt id="ientry-idm32289">gst_structure_get_value, <a class="indexterm" href="GstStructure.html#gst-structure-get-value">gst_structure_get_value ()</a>
</dt>
<dt id="ientry-idm32470">gst_structure_has_field, <a class="indexterm" href="GstStructure.html#gst-structure-has-field">gst_structure_has_field ()</a>
</dt>
<dt id="ientry-idm32483">gst_structure_has_field_typed, <a class="indexterm" href="GstStructure.html#gst-structure-has-field-typed">gst_structure_has_field_typed ()</a>
</dt>
<dt id="ientry-idm32148">gst_structure_has_name, <a class="indexterm" href="GstStructure.html#gst-structure-has-name">gst_structure_has_name ()</a>
</dt>
<dt id="ientry-idm32184">gst_structure_id_get, <a class="indexterm" href="GstStructure.html#gst-structure-id-get">gst_structure_id_get ()</a>
</dt>
<dt id="ientry-idm32198">gst_structure_id_get_valist, <a class="indexterm" href="GstStructure.html#gst-structure-id-get-valist">gst_structure_id_get_valist ()</a>
</dt>
<dt id="ientry-idm32214">gst_structure_id_get_value, <a class="indexterm" href="GstStructure.html#gst-structure-id-get-value">gst_structure_id_get_value ()</a>
</dt>
<dt id="ientry-idm32551">gst_structure_id_has_field, <a class="indexterm" href="GstStructure.html#gst-structure-id-has-field">gst_structure_id_has_field ()</a>
</dt>
<dt id="ientry-idm32564">gst_structure_id_has_field_typed, <a class="indexterm" href="GstStructure.html#gst-structure-id-has-field-typed">gst_structure_id_has_field_typed ()</a>
</dt>
<dt id="ientry-idm32364">gst_structure_id_set, <a class="indexterm" href="GstStructure.html#gst-structure-id-set">gst_structure_id_set ()</a>
</dt>
<dt id="ientry-idm32378">gst_structure_id_set_valist, <a class="indexterm" href="GstStructure.html#gst-structure-id-set-valist">gst_structure_id_set_valist ()</a>
</dt>
<dt id="ientry-idm32227">gst_structure_id_set_value, <a class="indexterm" href="GstStructure.html#gst-structure-id-set-value">gst_structure_id_set_value ()</a>
</dt>
<dt id="ientry-idm32243">gst_structure_id_take_value, <a class="indexterm" href="GstStructure.html#gst-structure-id-take-value">gst_structure_id_take_value ()</a>
</dt>
<dt id="ientry-idm32538">gst_structure_intersect, <a class="indexterm" href="GstStructure.html#gst-structure-intersect">gst_structure_intersect ()</a>
</dt>
<dt id="ientry-idm32499">gst_structure_is_equal, <a class="indexterm" href="GstStructure.html#gst-structure-is-equal">gst_structure_is_equal ()</a>
</dt>
<dt id="ientry-idm32512">gst_structure_is_subset, <a class="indexterm" href="GstStructure.html#gst-structure-is-subset">gst_structure_is_subset ()</a>
</dt>
<dt id="ientry-idm32791">gst_structure_map_in_place, <a class="indexterm" href="GstStructure.html#gst-structure-map-in-place">gst_structure_map_in_place ()</a>
</dt>
<dt id="ientry-idm32064">gst_structure_new, <a class="indexterm" href="GstStructure.html#gst-structure-new">gst_structure_new ()</a>
</dt>
<dt id="ientry-idm32044">gst_structure_new_empty, <a class="indexterm" href="GstStructure.html#gst-structure-new-empty">gst_structure_new_empty ()</a>
</dt>
<dt id="ientry-idm32108">gst_structure_new_from_string, <a class="indexterm" href="GstStructure.html#gst-structure-new-from-string">gst_structure_new_from_string ()</a>
</dt>
<dt id="ientry-idm32094">gst_structure_new_id, <a class="indexterm" href="GstStructure.html#gst-structure-new-id">gst_structure_new_id ()</a>
</dt>
<dt id="ientry-idm32054">gst_structure_new_id_empty, <a class="indexterm" href="GstStructure.html#gst-structure-new-id-empty">gst_structure_new_id_empty ()</a>
</dt>
<dt id="ientry-idm32078">gst_structure_new_valist, <a class="indexterm" href="GstStructure.html#gst-structure-new-valist">gst_structure_new_valist ()</a>
</dt>
<dt id="ientry-idm32823">gst_structure_nth_field_name, <a class="indexterm" href="GstStructure.html#gst-structure-nth-field-name">gst_structure_nth_field_name ()</a>
</dt>
<dt id="ientry-idm32460">gst_structure_n_fields, <a class="indexterm" href="GstStructure.html#gst-structure-n-fields">gst_structure_n_fields ()</a>
</dt>
<dt id="ientry-idm32437">gst_structure_remove_all_fields, <a class="indexterm" href="GstStructure.html#gst-structure-remove-all-fields">gst_structure_remove_all_fields ()</a>
</dt>
<dt id="ientry-idm32394">gst_structure_remove_field, <a class="indexterm" href="GstStructure.html#gst-structure-remove-field">gst_structure_remove_field ()</a>
</dt>
<dt id="ientry-idm32407">gst_structure_remove_fields, <a class="indexterm" href="GstStructure.html#gst-structure-remove-fields">gst_structure_remove_fields ()</a>
</dt>
<dt id="ientry-idm32421">gst_structure_remove_fields_valist, <a class="indexterm" href="GstStructure.html#gst-structure-remove-fields-valist">gst_structure_remove_fields_valist ()</a>
</dt>
<dt id="ientry-idm32334">gst_structure_set, <a class="indexterm" href="GstStructure.html#gst-structure-set">gst_structure_set ()</a>
</dt>
<dt id="ientry-idm32161">gst_structure_set_name, <a class="indexterm" href="GstStructure.html#gst-structure-set-name">gst_structure_set_name ()</a>
</dt>
<dt id="ientry-idm32836">gst_structure_set_parent_refcount, <a class="indexterm" href="GstStructure.html#gst-structure-set-parent-refcount">gst_structure_set_parent_refcount ()</a>
</dt>
<dt id="ientry-idm32348">gst_structure_set_valist, <a class="indexterm" href="GstStructure.html#gst-structure-set-valist">gst_structure_set_valist ()</a>
</dt>
<dt id="ientry-idm32302">gst_structure_set_value, <a class="indexterm" href="GstStructure.html#gst-structure-set-value">gst_structure_set_value ()</a>
</dt>
<dt id="ientry-idm32318">gst_structure_take_value, <a class="indexterm" href="GstStructure.html#gst-structure-take-value">gst_structure_take_value ()</a>
</dt>
<dt id="ientry-idm32849">gst_structure_to_string, <a class="indexterm" href="GstStructure.html#gst-structure-to-string">gst_structure_to_string ()</a>
</dt>
<dt id="ientry-idm40778">GST_STR_FOURCC, <a class="indexterm" href="gstreamer-GstValue.html#GST-STR-FOURCC:CAPS">GST_STR_FOURCC()</a>
</dt>
<dt id="ientry-idm43530">GST_STR_NULL, <a class="indexterm" href="gstreamer-GstInfo.html#GST-STR-NULL:CAPS">GST_STR_NULL()</a>
</dt>
<dt id="ientry-idm33062">gst_system_clock_obtain, <a class="indexterm" href="GstSystemClock.html#gst-system-clock-obtain">gst_system_clock_obtain ()</a>
</dt>
<dt id="ientry-idm33071">gst_system_clock_set_default, <a class="indexterm" href="GstSystemClock.html#gst-system-clock-set-default">gst_system_clock_set_default ()</a>
</dt>
<dt id="ientry-idm35084">GST_TAG_ALBUM, <a class="indexterm" href="GstTagList.html#GST-TAG-ALBUM:CAPS">GST_TAG_ALBUM</a>
</dt>
<dt id="ientry-idm35094">GST_TAG_ALBUM_ARTIST, <a class="indexterm" href="GstTagList.html#GST-TAG-ALBUM-ARTIST:CAPS">GST_TAG_ALBUM_ARTIST</a>
</dt>
<dt id="ientry-idm35099">GST_TAG_ALBUM_ARTIST_SORTNAME, <a class="indexterm" href="GstTagList.html#GST-TAG-ALBUM-ARTIST-SORTNAME:CAPS">GST_TAG_ALBUM_ARTIST_SORTNAME</a>
</dt>
<dt id="ientry-idm35294">GST_TAG_ALBUM_GAIN, <a class="indexterm" href="GstTagList.html#GST-TAG-ALBUM-GAIN:CAPS">GST_TAG_ALBUM_GAIN</a>
</dt>
<dt id="ientry-idm35299">GST_TAG_ALBUM_PEAK, <a class="indexterm" href="GstTagList.html#GST-TAG-ALBUM-PEAK:CAPS">GST_TAG_ALBUM_PEAK</a>
</dt>
<dt id="ientry-idm35089">GST_TAG_ALBUM_SORTNAME, <a class="indexterm" href="GstTagList.html#GST-TAG-ALBUM-SORTNAME:CAPS">GST_TAG_ALBUM_SORTNAME</a>
</dt>
<dt id="ientry-idm35144">GST_TAG_ALBUM_VOLUME_COUNT, <a class="indexterm" href="GstTagList.html#GST-TAG-ALBUM-VOLUME-COUNT:CAPS">GST_TAG_ALBUM_VOLUME_COUNT</a>
</dt>
<dt id="ientry-idm35139">GST_TAG_ALBUM_VOLUME_NUMBER, <a class="indexterm" href="GstTagList.html#GST-TAG-ALBUM-VOLUME-NUMBER:CAPS">GST_TAG_ALBUM_VOLUME_NUMBER</a>
</dt>
<dt id="ientry-idm35454">GST_TAG_APPLICATION_DATA, <a class="indexterm" href="GstTagList.html#GST-TAG-APPLICATION-DATA:CAPS">GST_TAG_APPLICATION_DATA</a>
</dt>
<dt id="ientry-idm35449">GST_TAG_APPLICATION_NAME, <a class="indexterm" href="GstTagList.html#GST-TAG-APPLICATION-NAME:CAPS">GST_TAG_APPLICATION_NAME</a>
</dt>
<dt id="ientry-idm35074">GST_TAG_ARTIST, <a class="indexterm" href="GstTagList.html#GST-TAG-ARTIST:CAPS">GST_TAG_ARTIST</a>
</dt>
<dt id="ientry-idm35079">GST_TAG_ARTIST_SORTNAME, <a class="indexterm" href="GstTagList.html#GST-TAG-ARTIST-SORTNAME:CAPS">GST_TAG_ARTIST_SORTNAME</a>
</dt>
<dt id="ientry-idm35329">GST_TAG_ATTACHMENT, <a class="indexterm" href="GstTagList.html#GST-TAG-ATTACHMENT:CAPS">GST_TAG_ATTACHMENT</a>
</dt>
<dt id="ientry-idm35234">GST_TAG_AUDIO_CODEC, <a class="indexterm" href="GstTagList.html#GST-TAG-AUDIO-CODEC:CAPS">GST_TAG_AUDIO_CODEC</a>
</dt>
<dt id="ientry-idm35334">GST_TAG_BEATS_PER_MINUTE, <a class="indexterm" href="GstTagList.html#GST-TAG-BEATS-PER-MINUTE:CAPS">GST_TAG_BEATS_PER_MINUTE</a>
</dt>
<dt id="ientry-idm35249">GST_TAG_BITRATE, <a class="indexterm" href="GstTagList.html#GST-TAG-BITRATE:CAPS">GST_TAG_BITRATE</a>
</dt>
<dt id="ientry-idm35224">GST_TAG_CODEC, <a class="indexterm" href="GstTagList.html#GST-TAG-CODEC:CAPS">GST_TAG_CODEC</a>
</dt>
<dt id="ientry-idm35119">GST_TAG_COMMENT, <a class="indexterm" href="GstTagList.html#GST-TAG-COMMENT:CAPS">GST_TAG_COMMENT</a>
</dt>
<dt id="ientry-idm35194">GST_TAG_COMPOSER, <a class="indexterm" href="GstTagList.html#GST-TAG-COMPOSER:CAPS">GST_TAG_COMPOSER</a>
</dt>
<dt id="ientry-idm35424">GST_TAG_COMPOSER_SORTNAME, <a class="indexterm" href="GstTagList.html#GST-TAG-COMPOSER-SORTNAME:CAPS">GST_TAG_COMPOSER_SORTNAME</a>
</dt>
<dt id="ientry-idm35199">GST_TAG_CONTACT, <a class="indexterm" href="GstTagList.html#GST-TAG-CONTACT:CAPS">GST_TAG_CONTACT</a>
</dt>
<dt id="ientry-idm35244">GST_TAG_CONTAINER_FORMAT, <a class="indexterm" href="GstTagList.html#GST-TAG-CONTAINER-FORMAT:CAPS">GST_TAG_CONTAINER_FORMAT</a>
</dt>
<dt id="ientry-idm35179">GST_TAG_COPYRIGHT, <a class="indexterm" href="GstTagList.html#GST-TAG-COPYRIGHT:CAPS">GST_TAG_COPYRIGHT</a>
</dt>
<dt id="ientry-idm35184">GST_TAG_COPYRIGHT_URI, <a class="indexterm" href="GstTagList.html#GST-TAG-COPYRIGHT-URI:CAPS">GST_TAG_COPYRIGHT_URI</a>
</dt>
<dt id="ientry-idm35104">GST_TAG_DATE, <a class="indexterm" href="GstTagList.html#GST-TAG-DATE:CAPS">GST_TAG_DATE</a>
</dt>
<dt id="ientry-idm35109">GST_TAG_DATE_TIME, <a class="indexterm" href="GstTagList.html#GST-TAG-DATE-TIME:CAPS">GST_TAG_DATE_TIME</a>
</dt>
<dt id="ientry-idm35159">GST_TAG_DESCRIPTION, <a class="indexterm" href="GstTagList.html#GST-TAG-DESCRIPTION:CAPS">GST_TAG_DESCRIPTION</a>
</dt>
<dt id="ientry-idm35439">GST_TAG_DEVICE_MANUFACTURER, <a class="indexterm" href="GstTagList.html#GST-TAG-DEVICE-MANUFACTURER:CAPS">GST_TAG_DEVICE_MANUFACTURER</a>
</dt>
<dt id="ientry-idm35444">GST_TAG_DEVICE_MODEL, <a class="indexterm" href="GstTagList.html#GST-TAG-DEVICE-MODEL:CAPS">GST_TAG_DEVICE_MODEL</a>
</dt>
<dt id="ientry-idm35219">GST_TAG_DURATION, <a class="indexterm" href="GstTagList.html#GST-TAG-DURATION:CAPS">GST_TAG_DURATION</a>
</dt>
<dt id="ientry-idm35189">GST_TAG_ENCODED_BY, <a class="indexterm" href="GstTagList.html#GST-TAG-ENCODED-BY:CAPS">GST_TAG_ENCODED_BY</a>
</dt>
<dt id="ientry-idm35274">GST_TAG_ENCODER, <a class="indexterm" href="GstTagList.html#GST-TAG-ENCODER:CAPS">GST_TAG_ENCODER</a>
</dt>
<dt id="ientry-idm35279">GST_TAG_ENCODER_VERSION, <a class="indexterm" href="GstTagList.html#GST-TAG-ENCODER-VERSION:CAPS">GST_TAG_ENCODER_VERSION</a>
</dt>
<dt id="ientry-idm34083">gst_tag_exists, <a class="indexterm" href="GstTagList.html#gst-tag-exists">gst_tag_exists ()</a>
</dt>
<dt id="ientry-idm35124">GST_TAG_EXTENDED_COMMENT, <a class="indexterm" href="GstTagList.html#GST-TAG-EXTENDED-COMMENT:CAPS">GST_TAG_EXTENDED_COMMENT</a>
</dt>
<dt id="ientry-idm35114">GST_TAG_GENRE, <a class="indexterm" href="GstTagList.html#GST-TAG-GENRE:CAPS">GST_TAG_GENRE</a>
</dt>
<dt id="ientry-idm35394">GST_TAG_GEO_LOCATION_CAPTURE_DIRECTION, <a class="indexterm" href="GstTagList.html#GST-TAG-GEO-LOCATION-CAPTURE-DIRECTION:CAPS">GST_TAG_GEO_LOCATION_CAPTURE_DIRECTION</a>
</dt>
<dt id="ientry-idm35364">GST_TAG_GEO_LOCATION_CITY, <a class="indexterm" href="GstTagList.html#GST-TAG-GEO-LOCATION-CITY:CAPS">GST_TAG_GEO_LOCATION_CITY</a>
</dt>
<dt id="ientry-idm35369">GST_TAG_GEO_LOCATION_COUNTRY, <a class="indexterm" href="GstTagList.html#GST-TAG-GEO-LOCATION-COUNTRY:CAPS">GST_TAG_GEO_LOCATION_COUNTRY</a>
</dt>
<dt id="ientry-idm35359">GST_TAG_GEO_LOCATION_ELEVATION, <a class="indexterm" href="GstTagList.html#GST-TAG-GEO-LOCATION-ELEVATION:CAPS">GST_TAG_GEO_LOCATION_ELEVATION</a>
</dt>
<dt id="ientry-idm35379">GST_TAG_GEO_LOCATION_HORIZONTAL_ERROR, <a class="indexterm" href="GstTagList.html#GST-TAG-GEO-LOCATION-HORIZONTAL-ERROR:CAPS">GST_TAG_GEO_LOCATION_HORIZONTAL_ERROR</a>
</dt>
<dt id="ientry-idm35349">GST_TAG_GEO_LOCATION_LATITUDE, <a class="indexterm" href="GstTagList.html#GST-TAG-GEO-LOCATION-LATITUDE:CAPS">GST_TAG_GEO_LOCATION_LATITUDE</a>
</dt>
<dt id="ientry-idm35354">GST_TAG_GEO_LOCATION_LONGITUDE, <a class="indexterm" href="GstTagList.html#GST-TAG-GEO-LOCATION-LONGITUDE:CAPS">GST_TAG_GEO_LOCATION_LONGITUDE</a>
</dt>
<dt id="ientry-idm35384">GST_TAG_GEO_LOCATION_MOVEMENT_DIRECTION, <a class="indexterm" href="GstTagList.html#GST-TAG-GEO-LOCATION-MOVEMENT-DIRECTION:CAPS">GST_TAG_GEO_LOCATION_MOVEMENT_DIRECTION</a>
</dt>
<dt id="ientry-idm35389">GST_TAG_GEO_LOCATION_MOVEMENT_SPEED, <a class="indexterm" href="GstTagList.html#GST-TAG-GEO-LOCATION-MOVEMENT-SPEED:CAPS">GST_TAG_GEO_LOCATION_MOVEMENT_SPEED</a>
</dt>
<dt id="ientry-idm35344">GST_TAG_GEO_LOCATION_NAME, <a class="indexterm" href="GstTagList.html#GST-TAG-GEO-LOCATION-NAME:CAPS">GST_TAG_GEO_LOCATION_NAME</a>
</dt>
<dt id="ientry-idm35374">GST_TAG_GEO_LOCATION_SUBLOCATION, <a class="indexterm" href="GstTagList.html#GST-TAG-GEO-LOCATION-SUBLOCATION:CAPS">GST_TAG_GEO_LOCATION_SUBLOCATION</a>
</dt>
<dt id="ientry-idm34113">gst_tag_get_description, <a class="indexterm" href="GstTagList.html#gst-tag-get-description">gst_tag_get_description ()</a>
</dt>
<dt id="ientry-idm34123">gst_tag_get_flag, <a class="indexterm" href="GstTagList.html#gst-tag-get-flag">gst_tag_get_flag ()</a>
</dt>
<dt id="ientry-idm34103">gst_tag_get_nick, <a class="indexterm" href="GstTagList.html#gst-tag-get-nick">gst_tag_get_nick ()</a>
</dt>
<dt id="ientry-idm34093">gst_tag_get_type, <a class="indexterm" href="GstTagList.html#gst-tag-get-type">gst_tag_get_type ()</a>
</dt>
<dt id="ientry-idm35429">GST_TAG_GROUPING, <a class="indexterm" href="GstTagList.html#GST-TAG-GROUPING:CAPS">GST_TAG_GROUPING</a>
</dt>
<dt id="ientry-idm35154">GST_TAG_HOMEPAGE, <a class="indexterm" href="GstTagList.html#GST-TAG-HOMEPAGE:CAPS">GST_TAG_HOMEPAGE</a>
</dt>
<dt id="ientry-idm35319">GST_TAG_IMAGE, <a class="indexterm" href="GstTagList.html#GST-TAG-IMAGE:CAPS">GST_TAG_IMAGE</a>
</dt>
<dt id="ientry-idm35459">GST_TAG_IMAGE_ORIENTATION, <a class="indexterm" href="GstTagList.html#GST-TAG-IMAGE-ORIENTATION:CAPS">GST_TAG_IMAGE_ORIENTATION</a>
</dt>
<dt id="ientry-idm35469">GST_TAG_INTERPRETED_BY, <a class="indexterm" href="GstTagList.html#GST-TAG-INTERPRETED-BY:CAPS">GST_TAG_INTERPRETED_BY</a>
</dt>
<dt id="ientry-idm35169">GST_TAG_ISRC, <a class="indexterm" href="GstTagList.html#GST-TAG-ISRC:CAPS">GST_TAG_ISRC</a>
</dt>
<dt id="ientry-idm34133">gst_tag_is_fixed, <a class="indexterm" href="GstTagList.html#gst-tag-is-fixed">gst_tag_is_fixed ()</a>
</dt>
<dt id="ientry-idm35339">GST_TAG_KEYWORDS, <a class="indexterm" href="GstTagList.html#GST-TAG-KEYWORDS:CAPS">GST_TAG_KEYWORDS</a>
</dt>
<dt id="ientry-idm35309">GST_TAG_LANGUAGE_CODE, <a class="indexterm" href="GstTagList.html#GST-TAG-LANGUAGE-CODE:CAPS">GST_TAG_LANGUAGE_CODE</a>
</dt>
<dt id="ientry-idm35314">GST_TAG_LANGUAGE_NAME, <a class="indexterm" href="GstTagList.html#GST-TAG-LANGUAGE-NAME:CAPS">GST_TAG_LANGUAGE_NAME</a>
</dt>
<dt id="ientry-idm35204">GST_TAG_LICENSE, <a class="indexterm" href="GstTagList.html#GST-TAG-LICENSE:CAPS">GST_TAG_LICENSE</a>
</dt>
<dt id="ientry-idm35209">GST_TAG_LICENSE_URI, <a class="indexterm" href="GstTagList.html#GST-TAG-LICENSE-URI:CAPS">GST_TAG_LICENSE_URI</a>
</dt>
<dt id="ientry-idm34355">gst_tag_list_add, <a class="indexterm" href="GstTagList.html#gst-tag-list-add">gst_tag_list_add ()</a>
</dt>
<dt id="ientry-idm34408">gst_tag_list_add_valist, <a class="indexterm" href="GstTagList.html#gst-tag-list-add-valist">gst_tag_list_add_valist ()</a>
</dt>
<dt id="ientry-idm34427">gst_tag_list_add_valist_values, <a class="indexterm" href="GstTagList.html#gst-tag-list-add-valist-values">gst_tag_list_add_valist_values ()</a>
</dt>
<dt id="ientry-idm34372">gst_tag_list_add_value, <a class="indexterm" href="GstTagList.html#gst-tag-list-add-value">gst_tag_list_add_value ()</a>
</dt>
<dt id="ientry-idm34391">gst_tag_list_add_values, <a class="indexterm" href="GstTagList.html#gst-tag-list-add-values">gst_tag_list_add_values ()</a>
</dt>
<dt id="ientry-idm34247">gst_tag_list_copy, <a class="indexterm" href="GstTagList.html#gst-tag-list-copy">gst_tag_list_copy ()</a>
</dt>
<dt id="ientry-idm34491">gst_tag_list_copy_value, <a class="indexterm" href="GstTagList.html#gst-tag-list-copy-value">gst_tag_list_copy_value ()</a>
</dt>
<dt id="ientry-idm34459">gst_tag_list_foreach, <a class="indexterm" href="GstTagList.html#gst-tag-list-foreach">gst_tag_list_foreach ()</a>
</dt>
<dt id="ientry-idm34183">gst_tag_list_free, <a class="indexterm" href="GstTagList.html#gst-tag-list-free">gst_tag_list_free()</a>
</dt>
<dt id="ientry-idm34507">gst_tag_list_get_boolean, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-boolean">gst_tag_list_get_boolean ()</a>
</dt>
<dt id="ientry-idm34523">gst_tag_list_get_boolean_index, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-boolean-index">gst_tag_list_get_boolean_index ()</a>
</dt>
<dt id="ientry-idm34841">gst_tag_list_get_date, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-date">gst_tag_list_get_date ()</a>
</dt>
<dt id="ientry-idm34857">gst_tag_list_get_date_index, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-date-index">gst_tag_list_get_date_index ()</a>
</dt>
<dt id="ientry-idm34876">gst_tag_list_get_date_time, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-date-time">gst_tag_list_get_date_time ()</a>
</dt>
<dt id="ientry-idm34892">gst_tag_list_get_date_time_index, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-date-time-index">gst_tag_list_get_date_time_index ()</a>
</dt>
<dt id="ientry-idm34717">gst_tag_list_get_double, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-double">gst_tag_list_get_double ()</a>
</dt>
<dt id="ientry-idm34733">gst_tag_list_get_double_index, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-double-index">gst_tag_list_get_double_index ()</a>
</dt>
<dt id="ientry-idm34682">gst_tag_list_get_float, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-float">gst_tag_list_get_float ()</a>
</dt>
<dt id="ientry-idm34698">gst_tag_list_get_float_index, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-float-index">gst_tag_list_get_float_index ()</a>
</dt>
<dt id="ientry-idm34542">gst_tag_list_get_int, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-int">gst_tag_list_get_int ()</a>
</dt>
<dt id="ientry-idm34612">gst_tag_list_get_int64, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-int64">gst_tag_list_get_int64 ()</a>
</dt>
<dt id="ientry-idm34628">gst_tag_list_get_int64_index, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-int64-index">gst_tag_list_get_int64_index ()</a>
</dt>
<dt id="ientry-idm34558">gst_tag_list_get_int_index, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-int-index">gst_tag_list_get_int_index ()</a>
</dt>
<dt id="ientry-idm34806">gst_tag_list_get_pointer, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-pointer">gst_tag_list_get_pointer ()</a>
</dt>
<dt id="ientry-idm34822">gst_tag_list_get_pointer_index, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-pointer-index">gst_tag_list_get_pointer_index ()</a>
</dt>
<dt id="ientry-idm34911">gst_tag_list_get_sample, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-sample">gst_tag_list_get_sample ()</a>
</dt>
<dt id="ientry-idm34927">gst_tag_list_get_sample_index, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-sample-index">gst_tag_list_get_sample_index ()</a>
</dt>
<dt id="ientry-idm34191">gst_tag_list_get_scope, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-scope">gst_tag_list_get_scope ()</a>
</dt>
<dt id="ientry-idm34752">gst_tag_list_get_string, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-string">gst_tag_list_get_string ()</a>
</dt>
<dt id="ientry-idm34768">gst_tag_list_get_string_index, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-string-index">gst_tag_list_get_string_index ()</a>
</dt>
<dt id="ientry-idm34319">gst_tag_list_get_tag_size, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-tag-size">gst_tag_list_get_tag_size ()</a>
</dt>
<dt id="ientry-idm34577">gst_tag_list_get_uint, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-uint">gst_tag_list_get_uint ()</a>
</dt>
<dt id="ientry-idm34647">gst_tag_list_get_uint64, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-uint64">gst_tag_list_get_uint64 ()</a>
</dt>
<dt id="ientry-idm34663">gst_tag_list_get_uint64_index, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-uint64-index">gst_tag_list_get_uint64_index ()</a>
</dt>
<dt id="ientry-idm34593">gst_tag_list_get_uint_index, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-uint-index">gst_tag_list_get_uint_index ()</a>
</dt>
<dt id="ientry-idm34475">gst_tag_list_get_value_index, <a class="indexterm" href="GstTagList.html#gst-tag-list-get-value-index">gst_tag_list_get_value_index ()</a>
</dt>
<dt id="ientry-idm34287">gst_tag_list_insert, <a class="indexterm" href="GstTagList.html#gst-tag-list-insert">gst_tag_list_insert ()</a>
</dt>
<dt id="ientry-idm34224">gst_tag_list_is_empty, <a class="indexterm" href="GstTagList.html#gst-tag-list-is-empty">gst_tag_list_is_empty ()</a>
</dt>
<dt id="ientry-idm34234">gst_tag_list_is_equal, <a class="indexterm" href="GstTagList.html#gst-tag-list-is-equal">gst_tag_list_is_equal ()</a>
</dt>
<dt id="ientry-idm34277">gst_tag_list_is_writable, <a class="indexterm" href="GstTagList.html#gst-tag-list-is-writable">gst_tag_list_is_writable()</a>
</dt>
<dt id="ientry-idm34282">gst_tag_list_make_writable, <a class="indexterm" href="GstTagList.html#gst-tag-list-make-writable">gst_tag_list_make_writable()</a>
</dt>
<dt id="ientry-idm34303">gst_tag_list_merge, <a class="indexterm" href="GstTagList.html#gst-tag-list-merge">gst_tag_list_merge ()</a>
</dt>
<dt id="ientry-idm34143">gst_tag_list_new, <a class="indexterm" href="GstTagList.html#gst-tag-list-new">gst_tag_list_new ()</a>
</dt>
<dt id="ientry-idm34154">gst_tag_list_new_empty, <a class="indexterm" href="GstTagList.html#gst-tag-list-new-empty">gst_tag_list_new_empty ()</a>
</dt>
<dt id="ientry-idm34173">gst_tag_list_new_from_string, <a class="indexterm" href="GstTagList.html#gst-tag-list-new-from-string">gst_tag_list_new_from_string ()</a>
</dt>
<dt id="ientry-idm34163">gst_tag_list_new_valist, <a class="indexterm" href="GstTagList.html#gst-tag-list-new-valist">gst_tag_list_new_valist ()</a>
</dt>
<dt id="ientry-idm34342">gst_tag_list_nth_tag_name, <a class="indexterm" href="GstTagList.html#gst-tag-list-nth-tag-name">gst_tag_list_nth_tag_name ()</a>
</dt>
<dt id="ientry-idm34332">gst_tag_list_n_tags, <a class="indexterm" href="GstTagList.html#gst-tag-list-n-tags">gst_tag_list_n_tags ()</a>
</dt>
<dt id="ientry-idm34787">gst_tag_list_peek_string_index, <a class="indexterm" href="GstTagList.html#gst-tag-list-peek-string-index">gst_tag_list_peek_string_index ()</a>
</dt>
<dt id="ientry-idm34257">gst_tag_list_ref, <a class="indexterm" href="GstTagList.html#gst-tag-list-ref">gst_tag_list_ref ()</a>
</dt>
<dt id="ientry-idm34446">gst_tag_list_remove_tag, <a class="indexterm" href="GstTagList.html#gst-tag-list-remove-tag">gst_tag_list_remove_tag ()</a>
</dt>
<dt id="ientry-idm34201">gst_tag_list_set_scope, <a class="indexterm" href="GstTagList.html#gst-tag-list-set-scope">gst_tag_list_set_scope ()</a>
</dt>
<dt id="ientry-idm34214">gst_tag_list_to_string, <a class="indexterm" href="GstTagList.html#gst-tag-list-to-string">gst_tag_list_to_string ()</a>
</dt>
<dt id="ientry-idm34267">gst_tag_list_unref, <a class="indexterm" href="GstTagList.html#gst-tag-list-unref">gst_tag_list_unref ()</a>
</dt>
<dt id="ientry-idm35149">GST_TAG_LOCATION, <a class="indexterm" href="GstTagList.html#GST-TAG-LOCATION:CAPS">GST_TAG_LOCATION</a>
</dt>
<dt id="ientry-idm35419">GST_TAG_LYRICS, <a class="indexterm" href="GstTagList.html#GST-TAG-LYRICS:CAPS">GST_TAG_LYRICS</a>
</dt>
<dt id="ientry-idm35264">GST_TAG_MAXIMUM_BITRATE, <a class="indexterm" href="GstTagList.html#GST-TAG-MAXIMUM-BITRATE:CAPS">GST_TAG_MAXIMUM_BITRATE</a>
</dt>
<dt id="ientry-idm34070">gst_tag_merge_strings_with_comma, <a class="indexterm" href="GstTagList.html#gst-tag-merge-strings-with-comma">gst_tag_merge_strings_with_comma ()</a>
</dt>
<dt id="ientry-idm34057">gst_tag_merge_use_first, <a class="indexterm" href="GstTagList.html#gst-tag-merge-use-first">gst_tag_merge_use_first ()</a>
</dt>
<dt id="ientry-idm35474">GST_TAG_MIDI_BASE_NOTE, <a class="indexterm" href="GstTagList.html#GST-TAG-MIDI-BASE-NOTE:CAPS">GST_TAG_MIDI_BASE_NOTE</a>
</dt>
<dt id="ientry-idm35259">GST_TAG_MINIMUM_BITRATE, <a class="indexterm" href="GstTagList.html#GST-TAG-MINIMUM-BITRATE:CAPS">GST_TAG_MINIMUM_BITRATE</a>
</dt>
<dt id="ientry-idm35254">GST_TAG_NOMINAL_BITRATE, <a class="indexterm" href="GstTagList.html#GST-TAG-NOMINAL-BITRATE:CAPS">GST_TAG_NOMINAL_BITRATE</a>
</dt>
<dt id="ientry-idm35174">GST_TAG_ORGANIZATION, <a class="indexterm" href="GstTagList.html#GST-TAG-ORGANIZATION:CAPS">GST_TAG_ORGANIZATION</a>
</dt>
<dt id="ientry-idm35214">GST_TAG_PERFORMER, <a class="indexterm" href="GstTagList.html#GST-TAG-PERFORMER:CAPS">GST_TAG_PERFORMER</a>
</dt>
<dt id="ientry-idm35324">GST_TAG_PREVIEW_IMAGE, <a class="indexterm" href="GstTagList.html#GST-TAG-PREVIEW-IMAGE:CAPS">GST_TAG_PREVIEW_IMAGE</a>
</dt>
<dt id="ientry-idm35479">GST_TAG_PRIVATE_DATA, <a class="indexterm" href="GstTagList.html#GST-TAG-PRIVATE-DATA:CAPS">GST_TAG_PRIVATE_DATA</a>
</dt>
<dt id="ientry-idm35464">GST_TAG_PUBLISHER, <a class="indexterm" href="GstTagList.html#GST-TAG-PUBLISHER:CAPS">GST_TAG_PUBLISHER</a>
</dt>
<dt id="ientry-idm35304">GST_TAG_REFERENCE_LEVEL, <a class="indexterm" href="GstTagList.html#GST-TAG-REFERENCE-LEVEL:CAPS">GST_TAG_REFERENCE_LEVEL</a>
</dt>
<dt id="ientry-idm34007">gst_tag_register, <a class="indexterm" href="GstTagList.html#gst-tag-register">gst_tag_register ()</a>
</dt>
<dt id="ientry-idm34032">gst_tag_register_static, <a class="indexterm" href="GstTagList.html#gst-tag-register-static">gst_tag_register_static ()</a>
</dt>
<dt id="ientry-idm35269">GST_TAG_SERIAL, <a class="indexterm" href="GstTagList.html#GST-TAG-SERIAL:CAPS">GST_TAG_SERIAL</a>
</dt>
<dt id="ientry-idm35626">gst_tag_setter_add_tags, <a class="indexterm" href="GstTagSetter.html#gst-tag-setter-add-tags">gst_tag_setter_add_tags ()</a>
</dt>
<dt id="ientry-idm35679">gst_tag_setter_add_tag_valist, <a class="indexterm" href="GstTagSetter.html#gst-tag-setter-add-tag-valist">gst_tag_setter_add_tag_valist ()</a>
</dt>
<dt id="ientry-idm35698">gst_tag_setter_add_tag_valist_values, <a class="indexterm" href="GstTagSetter.html#gst-tag-setter-add-tag-valist-values">gst_tag_setter_add_tag_valist_values ()</a>
</dt>
<dt id="ientry-idm35643">gst_tag_setter_add_tag_value, <a class="indexterm" href="GstTagSetter.html#gst-tag-setter-add-tag-value">gst_tag_setter_add_tag_value ()</a>
</dt>
<dt id="ientry-idm35662">gst_tag_setter_add_tag_values, <a class="indexterm" href="GstTagSetter.html#gst-tag-setter-add-tag-values">gst_tag_setter_add_tag_values ()</a>
</dt>
<dt id="ientry-idm35717">gst_tag_setter_get_tag_list, <a class="indexterm" href="GstTagSetter.html#gst-tag-setter-get-tag-list">gst_tag_setter_get_tag_list ()</a>
</dt>
<dt id="ientry-idm35740">gst_tag_setter_get_tag_merge_mode, <a class="indexterm" href="GstTagSetter.html#gst-tag-setter-get-tag-merge-mode">gst_tag_setter_get_tag_merge_mode ()</a>
</dt>
<dt id="ientry-idm35610">gst_tag_setter_merge_tags, <a class="indexterm" href="GstTagSetter.html#gst-tag-setter-merge-tags">gst_tag_setter_merge_tags ()</a>
</dt>
<dt id="ientry-idm35600">gst_tag_setter_reset_tags, <a class="indexterm" href="GstTagSetter.html#gst-tag-setter-reset-tags">gst_tag_setter_reset_tags ()</a>
</dt>
<dt id="ientry-idm35727">gst_tag_setter_set_tag_merge_mode, <a class="indexterm" href="GstTagSetter.html#gst-tag-setter-set-tag-merge-mode">gst_tag_setter_set_tag_merge_mode ()</a>
</dt>
<dt id="ientry-idm35409">GST_TAG_SHOW_EPISODE_NUMBER, <a class="indexterm" href="GstTagList.html#GST-TAG-SHOW-EPISODE-NUMBER:CAPS">GST_TAG_SHOW_EPISODE_NUMBER</a>
</dt>
<dt id="ientry-idm35399">GST_TAG_SHOW_NAME, <a class="indexterm" href="GstTagList.html#GST-TAG-SHOW-NAME:CAPS">GST_TAG_SHOW_NAME</a>
</dt>
<dt id="ientry-idm35414">GST_TAG_SHOW_SEASON_NUMBER, <a class="indexterm" href="GstTagList.html#GST-TAG-SHOW-SEASON-NUMBER:CAPS">GST_TAG_SHOW_SEASON_NUMBER</a>
</dt>
<dt id="ientry-idm35404">GST_TAG_SHOW_SORTNAME, <a class="indexterm" href="GstTagList.html#GST-TAG-SHOW-SORTNAME:CAPS">GST_TAG_SHOW_SORTNAME</a>
</dt>
<dt id="ientry-idm35239">GST_TAG_SUBTITLE_CODEC, <a class="indexterm" href="GstTagList.html#GST-TAG-SUBTITLE-CODEC:CAPS">GST_TAG_SUBTITLE_CODEC</a>
</dt>
<dt id="ientry-idm35064">GST_TAG_TITLE, <a class="indexterm" href="GstTagList.html#GST-TAG-TITLE:CAPS">GST_TAG_TITLE</a>
</dt>
<dt id="ientry-idm35069">GST_TAG_TITLE_SORTNAME, <a class="indexterm" href="GstTagList.html#GST-TAG-TITLE-SORTNAME:CAPS">GST_TAG_TITLE_SORTNAME</a>
</dt>
<dt id="ientry-idm35134">GST_TAG_TRACK_COUNT, <a class="indexterm" href="GstTagList.html#GST-TAG-TRACK-COUNT:CAPS">GST_TAG_TRACK_COUNT</a>
</dt>
<dt id="ientry-idm35284">GST_TAG_TRACK_GAIN, <a class="indexterm" href="GstTagList.html#GST-TAG-TRACK-GAIN:CAPS">GST_TAG_TRACK_GAIN</a>
</dt>
<dt id="ientry-idm35129">GST_TAG_TRACK_NUMBER, <a class="indexterm" href="GstTagList.html#GST-TAG-TRACK-NUMBER:CAPS">GST_TAG_TRACK_NUMBER</a>
</dt>
<dt id="ientry-idm35289">GST_TAG_TRACK_PEAK, <a class="indexterm" href="GstTagList.html#GST-TAG-TRACK-PEAK:CAPS">GST_TAG_TRACK_PEAK</a>
</dt>
<dt id="ientry-idm35434">GST_TAG_USER_RATING, <a class="indexterm" href="GstTagList.html#GST-TAG-USER-RATING:CAPS">GST_TAG_USER_RATING</a>
</dt>
<dt id="ientry-idm35164">GST_TAG_VERSION, <a class="indexterm" href="GstTagList.html#GST-TAG-VERSION:CAPS">GST_TAG_VERSION</a>
</dt>
<dt id="ientry-idm35229">GST_TAG_VIDEO_CODEC, <a class="indexterm" href="GstTagList.html#GST-TAG-VIDEO-CODEC:CAPS">GST_TAG_VIDEO_CODEC</a>
</dt>
<dt id="ientry-idm35959">GST_TASK_BROADCAST, <a class="indexterm" href="GstTask.html#GST-TASK-BROADCAST:CAPS">GST_TASK_BROADCAST()</a>
</dt>
<dt id="ientry-idm36160">gst_task_cleanup_all, <a class="indexterm" href="GstTask.html#gst-task-cleanup-all">gst_task_cleanup_all ()</a>
</dt>
<dt id="ientry-idm35964">GST_TASK_GET_COND, <a class="indexterm" href="GstTask.html#GST-TASK-GET-COND:CAPS">GST_TASK_GET_COND()</a>
</dt>
<dt id="ientry-idm35969">GST_TASK_GET_LOCK, <a class="indexterm" href="GstTask.html#GST-TASK-GET-LOCK:CAPS">GST_TASK_GET_LOCK()</a>
</dt>
<dt id="ientry-idm36031">gst_task_get_pool, <a class="indexterm" href="GstTask.html#gst-task-get-pool">gst_task_get_pool ()</a>
</dt>
<dt id="ientry-idm36097">gst_task_get_state, <a class="indexterm" href="GstTask.html#gst-task-get-state">gst_task_get_state ()</a>
</dt>
<dt id="ientry-idm36150">gst_task_join, <a class="indexterm" href="GstTask.html#gst-task-join">gst_task_join ()</a>
</dt>
<dt id="ientry-idm35989">gst_task_new, <a class="indexterm" href="GstTask.html#gst-task-new">gst_task_new ()</a>
</dt>
<dt id="ientry-idm36120">gst_task_pause, <a class="indexterm" href="GstTask.html#gst-task-pause">gst_task_pause ()</a>
</dt>
<dt id="ientry-idm36359">gst_task_pool_cleanup, <a class="indexterm" href="GstTaskPool.html#gst-task-pool-cleanup">gst_task_pool_cleanup ()</a>
</dt>
<dt id="ientry-idm36346">gst_task_pool_join, <a class="indexterm" href="GstTaskPool.html#gst-task-pool-join">gst_task_pool_join ()</a>
</dt>
<dt id="ientry-idm36305">gst_task_pool_new, <a class="indexterm" href="GstTaskPool.html#gst-task-pool-new">gst_task_pool_new ()</a>
</dt>
<dt id="ientry-idm36314">gst_task_pool_prepare, <a class="indexterm" href="GstTaskPool.html#gst-task-pool-prepare">gst_task_pool_prepare ()</a>
</dt>
<dt id="ientry-idm36327">gst_task_pool_push, <a class="indexterm" href="GstTaskPool.html#gst-task-pool-push">gst_task_pool_push ()</a>
</dt>
<dt id="ientry-idm36059">gst_task_set_enter_callback, <a class="indexterm" href="GstTask.html#gst-task-set-enter-callback">gst_task_set_enter_callback ()</a>
</dt>
<dt id="ientry-idm36078">gst_task_set_leave_callback, <a class="indexterm" href="GstTask.html#gst-task-set-leave-callback">gst_task_set_leave_callback ()</a>
</dt>
<dt id="ientry-idm36005">gst_task_set_lock, <a class="indexterm" href="GstTask.html#gst-task-set-lock">gst_task_set_lock ()</a>
</dt>
<dt id="ientry-idm36018">gst_task_set_pool, <a class="indexterm" href="GstTask.html#gst-task-set-pool">gst_task_set_pool ()</a>
</dt>
<dt id="ientry-idm36107">gst_task_set_state, <a class="indexterm" href="GstTask.html#gst-task-set-state">gst_task_set_state ()</a>
</dt>
<dt id="ientry-idm35974">GST_TASK_SIGNAL, <a class="indexterm" href="GstTask.html#GST-TASK-SIGNAL:CAPS">GST_TASK_SIGNAL()</a>
</dt>
<dt id="ientry-idm36130">gst_task_start, <a class="indexterm" href="GstTask.html#gst-task-start">gst_task_start ()</a>
</dt>
<dt id="ientry-idm35979">GST_TASK_STATE, <a class="indexterm" href="GstTask.html#GST-TASK-STATE:CAPS">GST_TASK_STATE()</a>
</dt>
<dt id="ientry-idm36140">gst_task_stop, <a class="indexterm" href="GstTask.html#gst-task-stop">gst_task_stop ()</a>
</dt>
<dt id="ientry-idm35984">GST_TASK_WAIT, <a class="indexterm" href="GstTask.html#GST-TASK-WAIT:CAPS">GST_TASK_WAIT()</a>
</dt>
<dt id="ientry-idm7614">GST_TIMESPEC_TO_TIME, <a class="indexterm" href="GstClock.html#GST-TIMESPEC-TO-TIME:CAPS">GST_TIMESPEC_TO_TIME()</a>
</dt>
<dt id="ientry-idm7604">GST_TIMEVAL_TO_TIME, <a class="indexterm" href="GstClock.html#GST-TIMEVAL-TO-TIME:CAPS">GST_TIMEVAL_TO_TIME()</a>
</dt>
<dt id="ientry-idm44168">GST_TIME_ARGS, <a class="indexterm" href="gstreamer-GstInfo.html#GST-TIME-ARGS:CAPS">GST_TIME_ARGS()</a>
</dt>
<dt id="ientry-idm7584">GST_TIME_AS_MSECONDS, <a class="indexterm" href="GstClock.html#GST-TIME-AS-MSECONDS:CAPS">GST_TIME_AS_MSECONDS()</a>
</dt>
<dt id="ientry-idm7594">GST_TIME_AS_NSECONDS, <a class="indexterm" href="GstClock.html#GST-TIME-AS-NSECONDS:CAPS">GST_TIME_AS_NSECONDS()</a>
</dt>
<dt id="ientry-idm7579">GST_TIME_AS_SECONDS, <a class="indexterm" href="GstClock.html#GST-TIME-AS-SECONDS:CAPS">GST_TIME_AS_SECONDS()</a>
</dt>
<dt id="ientry-idm7589">GST_TIME_AS_USECONDS, <a class="indexterm" href="GstClock.html#GST-TIME-AS-USECONDS:CAPS">GST_TIME_AS_USECONDS()</a>
</dt>
<dt id="ientry-idm44528">GST_TIME_FORMAT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-TIME-FORMAT:CAPS">GST_TIME_FORMAT</a>
</dt>
<dt id="ientry-idm7619">GST_TIME_TO_TIMESPEC, <a class="indexterm" href="GstClock.html#GST-TIME-TO-TIMESPEC:CAPS">GST_TIME_TO_TIMESPEC()</a>
</dt>
<dt id="ientry-idm7609">GST_TIME_TO_TIMEVAL, <a class="indexterm" href="GstClock.html#GST-TIME-TO-TIMEVAL:CAPS">GST_TIME_TO_TIMEVAL()</a>
</dt>
<dt id="ientry-idm36723">gst_toc_append_entry, <a class="indexterm" href="GstToc.html#gst-toc-append-entry">gst_toc_append_entry ()</a>
</dt>
<dt id="ientry-idm36693">gst_toc_copy, <a class="indexterm" href="GstToc.html#gst-toc-copy">gst_toc_copy()</a>
</dt>
<dt id="ientry-idm36775">gst_toc_dump, <a class="indexterm" href="GstToc.html#gst-toc-dump">gst_toc_dump ()</a>
</dt>
<dt id="ientry-idm36871">gst_toc_entry_append_sub_entry, <a class="indexterm" href="GstToc.html#gst-toc-entry-append-sub-entry">gst_toc_entry_append_sub_entry ()</a>
</dt>
<dt id="ientry-idm36808">gst_toc_entry_copy, <a class="indexterm" href="GstToc.html#gst-toc-entry-copy">gst_toc_entry_copy()</a>
</dt>
<dt id="ientry-idm36997">gst_toc_entry_get_entry_type, <a class="indexterm" href="GstToc.html#gst-toc-entry-get-entry-type">gst_toc_entry_get_entry_type ()</a>
</dt>
<dt id="ientry-idm36884">gst_toc_entry_get_loop, <a class="indexterm" href="GstToc.html#gst-toc-entry-get-loop">gst_toc_entry_get_loop ()</a>
</dt>
<dt id="ientry-idm36851">gst_toc_entry_get_parent, <a class="indexterm" href="GstToc.html#gst-toc-entry-get-parent">gst_toc_entry_get_parent ()</a>
</dt>
<dt id="ientry-idm36916">gst_toc_entry_get_start_stop_times, <a class="indexterm" href="GstToc.html#gst-toc-entry-get-start-stop-times">gst_toc_entry_get_start_stop_times ()</a>
</dt>
<dt id="ientry-idm36861">gst_toc_entry_get_sub_entries, <a class="indexterm" href="GstToc.html#gst-toc-entry-get-sub-entries">gst_toc_entry_get_sub_entries ()</a>
</dt>
<dt id="ientry-idm36948">gst_toc_entry_get_tags, <a class="indexterm" href="GstToc.html#gst-toc-entry-get-tags">gst_toc_entry_get_tags ()</a>
</dt>
<dt id="ientry-idm36831">gst_toc_entry_get_toc, <a class="indexterm" href="GstToc.html#gst-toc-entry-get-toc">gst_toc_entry_get_toc ()</a>
</dt>
<dt id="ientry-idm36841">gst_toc_entry_get_uid, <a class="indexterm" href="GstToc.html#gst-toc-entry-get-uid">gst_toc_entry_get_uid ()</a>
</dt>
<dt id="ientry-idm37007">gst_toc_entry_is_alternative, <a class="indexterm" href="GstToc.html#gst-toc-entry-is-alternative">gst_toc_entry_is_alternative ()</a>
</dt>
<dt id="ientry-idm37017">gst_toc_entry_is_sequence, <a class="indexterm" href="GstToc.html#gst-toc-entry-is-sequence">gst_toc_entry_is_sequence ()</a>
</dt>
<dt id="ientry-idm36813">gst_toc_entry_make_writable, <a class="indexterm" href="GstToc.html#gst-toc-entry-make-writable">gst_toc_entry_make_writable()</a>
</dt>
<dt id="ientry-idm36958">gst_toc_entry_merge_tags, <a class="indexterm" href="GstToc.html#gst-toc-entry-merge-tags">gst_toc_entry_merge_tags ()</a>
</dt>
<dt id="ientry-idm36785">gst_toc_entry_new, <a class="indexterm" href="GstToc.html#gst-toc-entry-new">gst_toc_entry_new ()</a>
</dt>
<dt id="ientry-idm36798">gst_toc_entry_ref, <a class="indexterm" href="GstToc.html#gst-toc-entry-ref">gst_toc_entry_ref()</a>
</dt>
<dt id="ientry-idm36900">gst_toc_entry_set_loop, <a class="indexterm" href="GstToc.html#gst-toc-entry-set-loop">gst_toc_entry_set_loop ()</a>
</dt>
<dt id="ientry-idm36932">gst_toc_entry_set_start_stop_times, <a class="indexterm" href="GstToc.html#gst-toc-entry-set-start-stop-times">gst_toc_entry_set_start_stop_times ()</a>
</dt>
<dt id="ientry-idm36974">gst_toc_entry_set_tags, <a class="indexterm" href="GstToc.html#gst-toc-entry-set-tags">gst_toc_entry_set_tags ()</a>
</dt>
<dt id="ientry-idm36987">gst_toc_entry_type_get_nick, <a class="indexterm" href="GstToc.html#gst-toc-entry-type-get-nick">gst_toc_entry_type_get_nick ()</a>
</dt>
<dt id="ientry-idm37027">GST_TOC_ENTRY_TYPE_IS_ALTERNATIVE, <a class="indexterm" href="GstToc.html#GST-TOC-ENTRY-TYPE-IS-ALTERNATIVE:CAPS">GST_TOC_ENTRY_TYPE_IS_ALTERNATIVE()</a>
</dt>
<dt id="ientry-idm37032">GST_TOC_ENTRY_TYPE_IS_SEQUENCE, <a class="indexterm" href="GstToc.html#GST-TOC-ENTRY-TYPE-IS-SEQUENCE:CAPS">GST_TOC_ENTRY_TYPE_IS_SEQUENCE()</a>
</dt>
<dt id="ientry-idm36803">gst_toc_entry_unref, <a class="indexterm" href="GstToc.html#gst-toc-entry-unref">gst_toc_entry_unref()</a>
</dt>
<dt id="ientry-idm36818">gst_toc_find_entry, <a class="indexterm" href="GstToc.html#gst-toc-find-entry">gst_toc_find_entry ()</a>
</dt>
<dt id="ientry-idm36713">gst_toc_get_entries, <a class="indexterm" href="GstToc.html#gst-toc-get-entries">gst_toc_get_entries ()</a>
</dt>
<dt id="ientry-idm36703">gst_toc_get_scope, <a class="indexterm" href="GstToc.html#gst-toc-get-scope">gst_toc_get_scope ()</a>
</dt>
<dt id="ientry-idm36736">gst_toc_get_tags, <a class="indexterm" href="GstToc.html#gst-toc-get-tags">gst_toc_get_tags ()</a>
</dt>
<dt id="ientry-idm36698">gst_toc_make_writable, <a class="indexterm" href="GstToc.html#gst-toc-make-writable">gst_toc_make_writable()</a>
</dt>
<dt id="ientry-idm36746">gst_toc_merge_tags, <a class="indexterm" href="GstToc.html#gst-toc-merge-tags">gst_toc_merge_tags ()</a>
</dt>
<dt id="ientry-idm36673">gst_toc_new, <a class="indexterm" href="GstToc.html#gst-toc-new">gst_toc_new ()</a>
</dt>
<dt id="ientry-idm36683">gst_toc_ref, <a class="indexterm" href="GstToc.html#gst-toc-ref">gst_toc_ref()</a>
</dt>
<dt id="ientry-idm37150">GST_TOC_REPEAT_COUNT_INFINITE, <a class="indexterm" href="GstToc.html#GST-TOC-REPEAT-COUNT-INFINITE:CAPS">GST_TOC_REPEAT_COUNT_INFINITE</a>
</dt>
<dt id="ientry-idm37226">gst_toc_setter_get_toc, <a class="indexterm" href="gstreamer-GstTocSetter.html#gst-toc-setter-get-toc">gst_toc_setter_get_toc ()</a>
</dt>
<dt id="ientry-idm37236">gst_toc_setter_reset, <a class="indexterm" href="gstreamer-GstTocSetter.html#gst-toc-setter-reset">gst_toc_setter_reset ()</a>
</dt>
<dt id="ientry-idm37213">gst_toc_setter_set_toc, <a class="indexterm" href="gstreamer-GstTocSetter.html#gst-toc-setter-set-toc">gst_toc_setter_set_toc ()</a>
</dt>
<dt id="ientry-idm36762">gst_toc_set_tags, <a class="indexterm" href="GstToc.html#gst-toc-set-tags">gst_toc_set_tags ()</a>
</dt>
<dt id="ientry-idm36688">gst_toc_unref, <a class="indexterm" href="GstToc.html#gst-toc-unref">gst_toc_unref()</a>
</dt>
<dt id="ientry-idm44124">GST_TRACE, <a class="indexterm" href="gstreamer-GstInfo.html#GST-TRACE:CAPS">GST_TRACE()</a>
</dt>
<dt id="ientry-idm45553">gst_tracer_factory_get_list, <a class="indexterm" href="GstTracerFactory.html#gst-tracer-factory-get-list">gst_tracer_factory_get_list ()</a>
</dt>
<dt id="ientry-idm45647">gst_tracer_record_log, <a class="indexterm" href="GstTracerRecord.html#gst-tracer-record-log">gst_tracer_record_log ()</a>
</dt>
<dt id="ientry-idm45633">gst_tracer_record_new, <a class="indexterm" href="GstTracerRecord.html#gst-tracer-record-new">gst_tracer_record_new ()</a>
</dt>
<dt id="ientry-idm44862">gst_tracer_register, <a class="indexterm" href="GstTracer.html#gst-tracer-register">gst_tracer_register ()</a>
</dt>
<dt id="ientry-idm44084">GST_TRACE_OBJECT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-TRACE-OBJECT:CAPS">GST_TRACE_OBJECT()</a>
</dt>
<dt id="ientry-idm44878">gst_tracing_register_hook, <a class="indexterm" href="GstTracer.html#gst-tracing-register-hook">gst_tracing_register_hook ()</a>
</dt>
<dt id="ientry-idm41777">GST_TYPE_ARRAY, <a class="indexterm" href="gstreamer-GstValue.html#GST-TYPE-ARRAY:CAPS">GST_TYPE_ARRAY</a>
</dt>
<dt id="ientry-idm41747">GST_TYPE_BITMASK, <a class="indexterm" href="gstreamer-GstValue.html#GST-TYPE-BITMASK:CAPS">GST_TYPE_BITMASK</a>
</dt>
<dt id="ientry-idm9687">GST_TYPE_DATE_TIME, <a class="indexterm" href="GstDateTime.html#GST-TYPE-DATE-TIME:CAPS">GST_TYPE_DATE_TIME</a>
</dt>
<dt id="ientry-idm41767">GST_TYPE_DOUBLE_RANGE, <a class="indexterm" href="gstreamer-GstValue.html#GST-TYPE-DOUBLE-RANGE:CAPS">GST_TYPE_DOUBLE_RANGE</a>
</dt>
<dt id="ientry-idm37614">gst_type_find_factory_call_function, <a class="indexterm" href="GstTypeFindFactory.html#gst-type-find-factory-call-function">gst_type_find_factory_call_function ()</a>
</dt>
<dt id="ientry-idm37594">gst_type_find_factory_get_caps, <a class="indexterm" href="GstTypeFindFactory.html#gst-type-find-factory-get-caps">gst_type_find_factory_get_caps ()</a>
</dt>
<dt id="ientry-idm37584">gst_type_find_factory_get_extensions, <a class="indexterm" href="GstTypeFindFactory.html#gst-type-find-factory-get-extensions">gst_type_find_factory_get_extensions ()</a>
</dt>
<dt id="ientry-idm37575">gst_type_find_factory_get_list, <a class="indexterm" href="GstTypeFindFactory.html#gst-type-find-factory-get-list">gst_type_find_factory_get_list ()</a>
</dt>
<dt id="ientry-idm37604">gst_type_find_factory_has_function, <a class="indexterm" href="GstTypeFindFactory.html#gst-type-find-factory-has-function">gst_type_find_factory_has_function ()</a>
</dt>
<dt id="ientry-idm37406">gst_type_find_get_length, <a class="indexterm" href="gstreamer-GstTypeFind.html#gst-type-find-get-length">gst_type_find_get_length ()</a>
</dt>
<dt id="ientry-idm37354">gst_type_find_peek, <a class="indexterm" href="gstreamer-GstTypeFind.html#gst-type-find-peek">gst_type_find_peek ()</a>
</dt>
<dt id="ientry-idm37416">gst_type_find_register, <a class="indexterm" href="gstreamer-GstTypeFind.html#gst-type-find-register">gst_type_find_register ()</a>
</dt>
<dt id="ientry-idm37370">gst_type_find_suggest, <a class="indexterm" href="gstreamer-GstTypeFind.html#gst-type-find-suggest">gst_type_find_suggest ()</a>
</dt>
<dt id="ientry-idm37386">gst_type_find_suggest_simple, <a class="indexterm" href="gstreamer-GstTypeFind.html#gst-type-find-suggest-simple">gst_type_find_suggest_simple ()</a>
</dt>
<dt id="ientry-idm41752">GST_TYPE_FLAG_SET, <a class="indexterm" href="gstreamer-GstValue.html#GST-TYPE-FLAG-SET:CAPS">GST_TYPE_FLAG_SET</a>
</dt>
<dt id="ientry-idm41782">GST_TYPE_FRACTION, <a class="indexterm" href="gstreamer-GstValue.html#GST-TYPE-FRACTION:CAPS">GST_TYPE_FRACTION</a>
</dt>
<dt id="ientry-idm41787">GST_TYPE_FRACTION_RANGE, <a class="indexterm" href="gstreamer-GstValue.html#GST-TYPE-FRACTION-RANGE:CAPS">GST_TYPE_FRACTION_RANGE</a>
</dt>
<dt id="ientry-idm41762">GST_TYPE_INT64_RANGE, <a class="indexterm" href="gstreamer-GstValue.html#GST-TYPE-INT64-RANGE:CAPS">GST_TYPE_INT64_RANGE</a>
</dt>
<dt id="ientry-idm41742">GST_TYPE_INT_RANGE, <a class="indexterm" href="gstreamer-GstValue.html#GST-TYPE-INT-RANGE:CAPS">GST_TYPE_INT_RANGE</a>
</dt>
<dt id="ientry-idm41772">GST_TYPE_LIST, <a class="indexterm" href="gstreamer-GstValue.html#GST-TYPE-LIST:CAPS">GST_TYPE_LIST</a>
</dt>
<dt id="ientry-idm514">gst_update_registry, <a class="indexterm" href="gstreamer-Gst.html#gst-update-registry">gst_update_registry ()</a>
</dt>
<dt id="ientry-idm38343">gst_uri_append_path, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-append-path">gst_uri_append_path ()</a>
</dt>
<dt id="ientry-idm38356">gst_uri_append_path_segment, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-append-path-segment">gst_uri_append_path_segment ()</a>
</dt>
<dt id="ientry-idm37971">GST_URI_CAST, <a class="indexterm" href="gstreamer-GstUri.html#GST-URI-CAST:CAPS">GST_URI_CAST()</a>
</dt>
<dt id="ientry-idm38748">gst_uri_construct, <a class="indexterm" href="gstreamer-GstUriHandler.html#gst-uri-construct">gst_uri_construct ()</a>
</dt>
<dt id="ientry-idm37976">GST_URI_CONST_CAST, <a class="indexterm" href="gstreamer-GstUri.html#GST-URI-CONST-CAST:CAPS">GST_URI_CONST_CAST()</a>
</dt>
<dt id="ientry-idm38063">gst_uri_copy, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-copy">gst_uri_copy ()</a>
</dt>
<dt id="ientry-idm38073">gst_uri_equal, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-equal">gst_uri_equal ()</a>
</dt>
<dt id="ientry-idm38668">gst_uri_error_quark, <a class="indexterm" href="gstreamer-GstUriHandler.html#gst-uri-error-quark">gst_uri_error_quark ()</a>
</dt>
<dt id="ientry-idm38040">gst_uri_from_string, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-from-string">gst_uri_from_string ()</a>
</dt>
<dt id="ientry-idm38050">gst_uri_from_string_with_base, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-from-string-with-base">gst_uri_from_string_with_base ()</a>
</dt>
<dt id="ientry-idm38480">gst_uri_get_fragment, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-get-fragment">gst_uri_get_fragment ()</a>
</dt>
<dt id="ientry-idm38228">gst_uri_get_host, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-get-host">gst_uri_get_host ()</a>
</dt>
<dt id="ientry-idm38738">gst_uri_get_location, <a class="indexterm" href="gstreamer-GstUriHandler.html#gst-uri-get-location">gst_uri_get_location ()</a>
</dt>
<dt id="ientry-idm38274">gst_uri_get_path, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-get-path">gst_uri_get_path ()</a>
</dt>
<dt id="ientry-idm38320">gst_uri_get_path_segments, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-get-path-segments">gst_uri_get_path_segments ()</a>
</dt>
<dt id="ientry-idm38297">gst_uri_get_path_string, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-get-path-string">gst_uri_get_path_string ()</a>
</dt>
<dt id="ientry-idm38251">gst_uri_get_port, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-get-port">gst_uri_get_port ()</a>
</dt>
<dt id="ientry-idm38728">gst_uri_get_protocol, <a class="indexterm" href="gstreamer-GstUriHandler.html#gst-uri-get-protocol">gst_uri_get_protocol ()</a>
</dt>
<dt id="ientry-idm38470">gst_uri_get_query_keys, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-get-query-keys">gst_uri_get_query_keys ()</a>
</dt>
<dt id="ientry-idm38369">gst_uri_get_query_string, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-get-query-string">gst_uri_get_query_string ()</a>
</dt>
<dt id="ientry-idm38392">gst_uri_get_query_table, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-get-query-table">gst_uri_get_query_table ()</a>
</dt>
<dt id="ientry-idm38415">gst_uri_get_query_value, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-get-query-value">gst_uri_get_query_value ()</a>
</dt>
<dt id="ientry-idm38182">gst_uri_get_scheme, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-get-scheme">gst_uri_get_scheme ()</a>
</dt>
<dt id="ientry-idm38205">gst_uri_get_userinfo, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-get-userinfo">gst_uri_get_userinfo ()</a>
</dt>
<dt id="ientry-idm38803">gst_uri_handler_get_protocols, <a class="indexterm" href="gstreamer-GstUriHandler.html#gst-uri-handler-get-protocols">gst_uri_handler_get_protocols ()</a>
</dt>
<dt id="ientry-idm38813">gst_uri_handler_get_uri, <a class="indexterm" href="gstreamer-GstUriHandler.html#gst-uri-handler-get-uri">gst_uri_handler_get_uri ()</a>
</dt>
<dt id="ientry-idm38793">gst_uri_handler_get_uri_type, <a class="indexterm" href="gstreamer-GstUriHandler.html#gst-uri-handler-get-uri-type">gst_uri_handler_get_uri_type ()</a>
</dt>
<dt id="ientry-idm38823">gst_uri_handler_set_uri, <a class="indexterm" href="gstreamer-GstUriHandler.html#gst-uri-handler-set-uri">gst_uri_handler_set_uri ()</a>
</dt>
<dt id="ientry-idm38715">gst_uri_has_protocol, <a class="indexterm" href="gstreamer-GstUriHandler.html#gst-uri-has-protocol">gst_uri_has_protocol ()</a>
</dt>
<dt id="ientry-idm38162">gst_uri_is_normalized, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-is-normalized">gst_uri_is_normalized ()</a>
</dt>
<dt id="ientry-idm38705">gst_uri_is_valid, <a class="indexterm" href="gstreamer-GstUriHandler.html#gst-uri-is-valid">gst_uri_is_valid ()</a>
</dt>
<dt id="ientry-idm38112">gst_uri_is_writable, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-is-writable">gst_uri_is_writable ()</a>
</dt>
<dt id="ientry-idm38086">gst_uri_join, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-join">gst_uri_join ()</a>
</dt>
<dt id="ientry-idm38099">gst_uri_join_strings, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-join-strings">gst_uri_join_strings ()</a>
</dt>
<dt id="ientry-idm38122">gst_uri_make_writable, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-make-writable">gst_uri_make_writable ()</a>
</dt>
<dt id="ientry-idm37981">gst_uri_new, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-new">gst_uri_new ()</a>
</dt>
<dt id="ientry-idm38009">gst_uri_new_with_base, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-new-with-base">gst_uri_new_with_base ()</a>
</dt>
<dt id="ientry-idm38172">gst_uri_normalize, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-normalize">gst_uri_normalize ()</a>
</dt>
<dt id="ientry-idm38910">GST_URI_NO_PORT, <a class="indexterm" href="gstreamer-GstUriHandler.html#GST-URI-NO-PORT:CAPS">GST_URI_NO_PORT</a>
</dt>
<dt id="ientry-idm38692">gst_uri_protocol_is_supported, <a class="indexterm" href="gstreamer-GstUriHandler.html#gst-uri-protocol-is-supported">gst_uri_protocol_is_supported ()</a>
</dt>
<dt id="ientry-idm38682">gst_uri_protocol_is_valid, <a class="indexterm" href="gstreamer-GstUriHandler.html#gst-uri-protocol-is-valid">gst_uri_protocol_is_valid ()</a>
</dt>
<dt id="ientry-idm38457">gst_uri_query_has_key, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-query-has-key">gst_uri_query_has_key ()</a>
</dt>
<dt id="ientry-idm38142">gst_uri_ref, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-ref">gst_uri_ref ()</a>
</dt>
<dt id="ientry-idm38444">gst_uri_remove_query_key, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-remove-query-key">gst_uri_remove_query_key ()</a>
</dt>
<dt id="ientry-idm38490">gst_uri_set_fragment, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-set-fragment">gst_uri_set_fragment ()</a>
</dt>
<dt id="ientry-idm38238">gst_uri_set_host, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-set-host">gst_uri_set_host ()</a>
</dt>
<dt id="ientry-idm38284">gst_uri_set_path, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-set-path">gst_uri_set_path ()</a>
</dt>
<dt id="ientry-idm38330">gst_uri_set_path_segments, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-set-path-segments">gst_uri_set_path_segments ()</a>
</dt>
<dt id="ientry-idm38307">gst_uri_set_path_string, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-set-path-string">gst_uri_set_path_string ()</a>
</dt>
<dt id="ientry-idm38261">gst_uri_set_port, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-set-port">gst_uri_set_port ()</a>
</dt>
<dt id="ientry-idm38379">gst_uri_set_query_string, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-set-query-string">gst_uri_set_query_string ()</a>
</dt>
<dt id="ientry-idm38402">gst_uri_set_query_table, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-set-query-table">gst_uri_set_query_table ()</a>
</dt>
<dt id="ientry-idm38428">gst_uri_set_query_value, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-set-query-value">gst_uri_set_query_value ()</a>
</dt>
<dt id="ientry-idm38192">gst_uri_set_scheme, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-set-scheme">gst_uri_set_scheme ()</a>
</dt>
<dt id="ientry-idm38215">gst_uri_set_userinfo, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-set-userinfo">gst_uri_set_userinfo ()</a>
</dt>
<dt id="ientry-idm38132">gst_uri_to_string, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-to-string">gst_uri_to_string ()</a>
</dt>
<dt id="ientry-idm38677">GST_URI_TYPE_IS_VALID, <a class="indexterm" href="gstreamer-GstUriHandler.html#GST-URI-TYPE-IS-VALID:CAPS">GST_URI_TYPE_IS_VALID()</a>
</dt>
<dt id="ientry-idm38152">gst_uri_unref, <a class="indexterm" href="gstreamer-GstUri.html#gst-uri-unref">gst_uri_unref ()</a>
</dt>
<dt id="ientry-idm8171">GST_USECOND, <a class="indexterm" href="GstClock.html#GST-USECOND:CAPS">GST_USECOND</a>
</dt>
<dt id="ientry-idm40042">gst_util_array_binary_search, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-array-binary-search">gst_util_array_binary_search ()</a>
</dt>
<dt id="ientry-idm39888">gst_util_double_to_fraction, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-double-to-fraction">gst_util_double_to_fraction ()</a>
</dt>
<dt id="ientry-idm39737">gst_util_dump_mem, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-dump-mem">gst_util_dump_mem ()</a>
</dt>
<dt id="ientry-idm39929">gst_util_fraction_add, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-fraction-add">gst_util_fraction_add ()</a>
</dt>
<dt id="ientry-idm39954">gst_util_fraction_compare, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-fraction-compare">gst_util_fraction_compare ()</a>
</dt>
<dt id="ientry-idm39904">gst_util_fraction_multiply, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-fraction-multiply">gst_util_fraction_multiply ()</a>
</dt>
<dt id="ientry-idm39872">gst_util_fraction_to_double, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-fraction-to-double">gst_util_fraction_to_double ()</a>
</dt>
<dt id="ientry-idm40033">gst_util_get_timestamp, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-get-timestamp">gst_util_get_timestamp ()</a>
</dt>
<dt id="ientry-idm39846">gst_util_greatest_common_divisor, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-greatest-common-divisor">gst_util_greatest_common_divisor ()</a>
</dt>
<dt id="ientry-idm39859">gst_util_greatest_common_divisor_int64, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-greatest-common-divisor-int64">gst_util_greatest_common_divisor_int64 ()</a>
</dt>
<dt id="ientry-idm39995">gst_util_group_id_next, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-group-id-next">gst_util_group_id_next ()</a>
</dt>
<dt id="ientry-idm39982">gst_util_seqnum_compare, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-seqnum-compare">gst_util_seqnum_compare ()</a>
</dt>
<dt id="ientry-idm39973">gst_util_seqnum_next, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-seqnum-next">gst_util_seqnum_next ()</a>
</dt>
<dt id="ientry-idm40004">gst_util_set_object_arg, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-set-object-arg">gst_util_set_object_arg ()</a>
</dt>
<dt id="ientry-idm40020">gst_util_set_value_from_string, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-set-value-from-string">gst_util_set_value_from_string ()</a>
</dt>
<dt id="ientry-idm39750">gst_util_uint64_scale, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-uint64-scale">gst_util_uint64_scale ()</a>
</dt>
<dt id="ientry-idm39782">gst_util_uint64_scale_ceil, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-uint64-scale-ceil">gst_util_uint64_scale_ceil ()</a>
</dt>
<dt id="ientry-idm39798">gst_util_uint64_scale_int, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-uint64-scale-int">gst_util_uint64_scale_int ()</a>
</dt>
<dt id="ientry-idm39830">gst_util_uint64_scale_int_ceil, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-uint64-scale-int-ceil">gst_util_uint64_scale_int_ceil ()</a>
</dt>
<dt id="ientry-idm39814">gst_util_uint64_scale_int_round, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-uint64-scale-int-round">gst_util_uint64_scale_int_round ()</a>
</dt>
<dt id="ientry-idm39766">gst_util_uint64_scale_round, <a class="indexterm" href="gstreamer-GstUtils.html#gst-util-uint64-scale-round">gst_util_uint64_scale_round ()</a>
</dt>
<dt id="ientry-idm41663">gst_value_array_append_and_take_value, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-array-append-and-take-value">gst_value_array_append_and_take_value ()</a>
</dt>
<dt id="ientry-idm41650">gst_value_array_append_value, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-array-append-value">gst_value_array_append_value ()</a>
</dt>
<dt id="ientry-idm41676">gst_value_array_get_size, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-array-get-size">gst_value_array_get_size ()</a>
</dt>
<dt id="ientry-idm41686">gst_value_array_get_value, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-array-get-value">gst_value_array_get_value ()</a>
</dt>
<dt id="ientry-idm41699">gst_value_array_prepend_value, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-array-prepend-value">gst_value_array_prepend_value ()</a>
</dt>
<dt id="ientry-idm41537">gst_value_can_compare, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-can-compare">gst_value_can_compare ()</a>
</dt>
<dt id="ientry-idm41624">gst_value_can_intersect, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-can-intersect">gst_value_can_intersect ()</a>
</dt>
<dt id="ientry-idm41595">gst_value_can_subtract, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-can-subtract">gst_value_can_subtract ()</a>
</dt>
<dt id="ientry-idm41566">gst_value_can_union, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-can-union">gst_value_can_union ()</a>
</dt>
<dt id="ientry-idm41524">gst_value_compare, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-compare">gst_value_compare ()</a>
</dt>
<dt id="ientry-idm41511">gst_value_deserialize, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-deserialize">gst_value_deserialize ()</a>
</dt>
<dt id="ientry-idm41797">GST_VALUE_EQUAL, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-EQUAL:CAPS">GST_VALUE_EQUAL</a>
</dt>
<dt id="ientry-idm41712">gst_value_fixate, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-fixate">gst_value_fixate ()</a>
</dt>
<dt id="ientry-idm41202">gst_value_fraction_multiply, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-fraction-multiply">gst_value_fraction_multiply ()</a>
</dt>
<dt id="ientry-idm41218">gst_value_fraction_subtract, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-fraction-subtract">gst_value_fraction_subtract ()</a>
</dt>
<dt id="ientry-idm40876">gst_value_get_bitmask, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-bitmask">gst_value_get_bitmask ()</a>
</dt>
<dt id="ientry-idm41391">gst_value_get_buffer, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-buffer">gst_value_get_buffer()</a>
</dt>
<dt id="ientry-idm41320">gst_value_get_caps, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-caps">gst_value_get_caps ()</a>
</dt>
<dt id="ientry-idm41348">gst_value_get_caps_features, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-caps-features">gst_value_get_caps_features ()</a>
</dt>
<dt id="ientry-idm41047">gst_value_get_double_range_max, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-double-range-max">gst_value_get_double_range_max ()</a>
</dt>
<dt id="ientry-idm41037">gst_value_get_double_range_min, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-double-range-min">gst_value_get_double_range_min ()</a>
</dt>
<dt id="ientry-idm40910">gst_value_get_flagset_flags, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-flagset-flags">gst_value_get_flagset_flags ()</a>
</dt>
<dt id="ientry-idm40920">gst_value_get_flagset_mask, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-flagset-mask">gst_value_get_flagset_mask ()</a>
</dt>
<dt id="ientry-idm41192">gst_value_get_fraction_denominator, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-fraction-denominator">gst_value_get_fraction_denominator ()</a>
</dt>
<dt id="ientry-idm41182">gst_value_get_fraction_numerator, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-fraction-numerator">gst_value_get_fraction_numerator ()</a>
</dt>
<dt id="ientry-idm41265">gst_value_get_fraction_range_max, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-fraction-range-max">gst_value_get_fraction_range_max ()</a>
</dt>
<dt id="ientry-idm41255">gst_value_get_fraction_range_min, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-fraction-range-min">gst_value_get_fraction_range_min ()</a>
</dt>
<dt id="ientry-idm40977">gst_value_get_int64_range_max, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-int64-range-max">gst_value_get_int64_range_max ()</a>
</dt>
<dt id="ientry-idm40967">gst_value_get_int64_range_min, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-int64-range-min">gst_value_get_int64_range_min ()</a>
</dt>
<dt id="ientry-idm41006">gst_value_get_int64_range_step, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-int64-range-step">gst_value_get_int64_range_step ()</a>
</dt>
<dt id="ientry-idm40819">gst_value_get_int_range_max, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-int-range-max">gst_value_get_int_range_max ()</a>
</dt>
<dt id="ientry-idm40809">gst_value_get_int_range_min, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-int-range-min">gst_value_get_int_range_min ()</a>
</dt>
<dt id="ientry-idm40848">gst_value_get_int_range_step, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-int-range-step">gst_value_get_int_range_step ()</a>
</dt>
<dt id="ientry-idm41411">gst_value_get_sample, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-sample">gst_value_get_sample()</a>
</dt>
<dt id="ientry-idm41376">gst_value_get_structure, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-get-structure">gst_value_get_structure ()</a>
</dt>
<dt id="ientry-idm41802">GST_VALUE_GREATER_THAN, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-GREATER-THAN:CAPS">GST_VALUE_GREATER_THAN</a>
</dt>
<dt id="ientry-idm41062">GST_VALUE_HOLDS_ARRAY, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-HOLDS-ARRAY:CAPS">GST_VALUE_HOLDS_ARRAY()</a>
</dt>
<dt id="ientry-idm40858">GST_VALUE_HOLDS_BITMASK, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-HOLDS-BITMASK:CAPS">GST_VALUE_HOLDS_BITMASK()</a>
</dt>
<dt id="ientry-idm41386">GST_VALUE_HOLDS_BUFFER, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-HOLDS-BUFFER:CAPS">GST_VALUE_HOLDS_BUFFER()</a>
</dt>
<dt id="ientry-idm41302">GST_VALUE_HOLDS_CAPS, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-HOLDS-CAPS">GST_VALUE_HOLDS_CAPS()</a>
</dt>
<dt id="ientry-idm41330">GST_VALUE_HOLDS_CAPS_FEATURES, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-HOLDS-CAPS-FEATURES:CAPS">GST_VALUE_HOLDS_CAPS_FEATURES()</a>
</dt>
<dt id="ientry-idm41297">GST_VALUE_HOLDS_DATE_TIME, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-HOLDS-DATE-TIME:CAPS">GST_VALUE_HOLDS_DATE_TIME()</a>
</dt>
<dt id="ientry-idm41016">GST_VALUE_HOLDS_DOUBLE_RANGE, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-HOLDS-DOUBLE-RANGE:CAPS">GST_VALUE_HOLDS_DOUBLE_RANGE()</a>
</dt>
<dt id="ientry-idm40886">GST_VALUE_HOLDS_FLAG_SET, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-HOLDS-FLAG-SET:CAPS">GST_VALUE_HOLDS_FLAG_SET()</a>
</dt>
<dt id="ientry-idm41161">GST_VALUE_HOLDS_FRACTION, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-HOLDS-FRACTION:CAPS">GST_VALUE_HOLDS_FRACTION()</a>
</dt>
<dt id="ientry-idm41234">GST_VALUE_HOLDS_FRACTION_RANGE, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-HOLDS-FRACTION-RANGE:CAPS">GST_VALUE_HOLDS_FRACTION_RANGE()</a>
</dt>
<dt id="ientry-idm40946">GST_VALUE_HOLDS_INT64_RANGE, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-HOLDS-INT64-RANGE:CAPS">GST_VALUE_HOLDS_INT64_RANGE()</a>
</dt>
<dt id="ientry-idm40788">GST_VALUE_HOLDS_INT_RANGE, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-HOLDS-INT-RANGE:CAPS">GST_VALUE_HOLDS_INT_RANGE()</a>
</dt>
<dt id="ientry-idm41057">GST_VALUE_HOLDS_LIST, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-HOLDS-LIST:CAPS">GST_VALUE_HOLDS_LIST()</a>
</dt>
<dt id="ientry-idm41406">GST_VALUE_HOLDS_SAMPLE, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-HOLDS-SAMPLE:CAPS">GST_VALUE_HOLDS_SAMPLE()</a>
</dt>
<dt id="ientry-idm41358">GST_VALUE_HOLDS_STRUCTURE, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-HOLDS-STRUCTURE:CAPS">GST_VALUE_HOLDS_STRUCTURE()</a>
</dt>
<dt id="ientry-idm41488">gst_value_init_and_copy, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-init-and-copy">gst_value_init_and_copy ()</a>
</dt>
<dt id="ientry-idm41608">gst_value_intersect, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-intersect">gst_value_intersect ()</a>
</dt>
<dt id="ientry-idm41468">gst_value_is_fixed, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-is-fixed">gst_value_is_fixed ()</a>
</dt>
<dt id="ientry-idm41637">gst_value_is_subset, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-is-subset">gst_value_is_subset ()</a>
</dt>
<dt id="ientry-idm41792">GST_VALUE_LESS_THAN, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-LESS-THAN:CAPS">GST_VALUE_LESS_THAN</a>
</dt>
<dt id="ientry-idm41080">gst_value_list_append_and_take_value, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-list-append-and-take-value">gst_value_list_append_and_take_value ()</a>
</dt>
<dt id="ientry-idm41067">gst_value_list_append_value, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-list-append-value">gst_value_list_append_value ()</a>
</dt>
<dt id="ientry-idm41106">gst_value_list_concat, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-list-concat">gst_value_list_concat ()</a>
</dt>
<dt id="ientry-idm41138">gst_value_list_get_size, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-list-get-size">gst_value_list_get_size ()</a>
</dt>
<dt id="ientry-idm41148">gst_value_list_get_value, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-list-get-value">gst_value_list_get_value ()</a>
</dt>
<dt id="ientry-idm41122">gst_value_list_merge, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-list-merge">gst_value_list_merge ()</a>
</dt>
<dt id="ientry-idm41093">gst_value_list_prepend_value, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-list-prepend-value">gst_value_list_prepend_value ()</a>
</dt>
<dt id="ientry-idm41478">gst_value_register, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-register">gst_value_register ()</a>
</dt>
<dt id="ientry-idm41501">gst_value_serialize, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-serialize">gst_value_serialize ()</a>
</dt>
<dt id="ientry-idm40863">gst_value_set_bitmask, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-set-bitmask">gst_value_set_bitmask ()</a>
</dt>
<dt id="ientry-idm41396">gst_value_set_buffer, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-set-buffer">gst_value_set_buffer()</a>
</dt>
<dt id="ientry-idm41307">gst_value_set_caps, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-set-caps">gst_value_set_caps ()</a>
</dt>
<dt id="ientry-idm41335">gst_value_set_caps_features, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-set-caps-features">gst_value_set_caps_features ()</a>
</dt>
<dt id="ientry-idm41021">gst_value_set_double_range, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-set-double-range">gst_value_set_double_range ()</a>
</dt>
<dt id="ientry-idm40930">gst_value_set_flagset, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-set-flagset">gst_value_set_flagset ()</a>
</dt>
<dt id="ientry-idm41166">gst_value_set_fraction, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-set-fraction">gst_value_set_fraction ()</a>
</dt>
<dt id="ientry-idm41239">gst_value_set_fraction_range, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-set-fraction-range">gst_value_set_fraction_range ()</a>
</dt>
<dt id="ientry-idm41275">gst_value_set_fraction_range_full, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-set-fraction-range-full">gst_value_set_fraction_range_full ()</a>
</dt>
<dt id="ientry-idm40951">gst_value_set_int64_range, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-set-int64-range">gst_value_set_int64_range ()</a>
</dt>
<dt id="ientry-idm40987">gst_value_set_int64_range_step, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-set-int64-range-step">gst_value_set_int64_range_step ()</a>
</dt>
<dt id="ientry-idm40793">gst_value_set_int_range, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-set-int-range">gst_value_set_int_range ()</a>
</dt>
<dt id="ientry-idm40829">gst_value_set_int_range_step, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-set-int-range-step">gst_value_set_int_range_step ()</a>
</dt>
<dt id="ientry-idm41416">gst_value_set_sample, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-set-sample">gst_value_set_sample()</a>
</dt>
<dt id="ientry-idm41363">gst_value_set_structure, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-set-structure">gst_value_set_structure ()</a>
</dt>
<dt id="ientry-idm41579">gst_value_subtract, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-subtract">gst_value_subtract ()</a>
</dt>
<dt id="ientry-idm41401">gst_value_take_buffer, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-take-buffer">gst_value_take_buffer()</a>
</dt>
<dt id="ientry-idm41421">gst_value_take_sample, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-take-sample">gst_value_take_sample()</a>
</dt>
<dt id="ientry-idm41550">gst_value_union, <a class="indexterm" href="gstreamer-GstValue.html#gst-value-union">gst_value_union ()</a>
</dt>
<dt id="ientry-idm41807">GST_VALUE_UNORDERED, <a class="indexterm" href="gstreamer-GstValue.html#GST-VALUE-UNORDERED:CAPS">GST_VALUE_UNORDERED</a>
</dt>
<dt id="ientry-idm448">gst_version, <a class="indexterm" href="gstreamer-Gst.html#gst-version">gst_version ()</a>
</dt>
<dt id="ientry-idm41874">GST_VERSION_MAJOR, <a class="indexterm" href="gstreamer-GstVersion.html#GST-VERSION-MAJOR:CAPS">GST_VERSION_MAJOR</a>
</dt>
<dt id="ientry-idm41884">GST_VERSION_MICRO, <a class="indexterm" href="gstreamer-GstVersion.html#GST-VERSION-MICRO:CAPS">GST_VERSION_MICRO</a>
</dt>
<dt id="ientry-idm41879">GST_VERSION_MINOR, <a class="indexterm" href="gstreamer-GstVersion.html#GST-VERSION-MINOR:CAPS">GST_VERSION_MINOR</a>
</dt>
<dt id="ientry-idm41889">GST_VERSION_NANO, <a class="indexterm" href="gstreamer-GstVersion.html#GST-VERSION-NANO:CAPS">GST_VERSION_NANO</a>
</dt>
<dt id="ientry-idm467">gst_version_string, <a class="indexterm" href="gstreamer-Gst.html#gst-version-string">gst_version_string ()</a>
</dt>
<dt id="ientry-idm44099">GST_WARNING, <a class="indexterm" href="gstreamer-GstInfo.html#GST-WARNING:CAPS">GST_WARNING()</a>
</dt>
<dt id="ientry-idm44059">GST_WARNING_OBJECT, <a class="indexterm" href="gstreamer-GstInfo.html#GST-WARNING-OBJECT:CAPS">GST_WARNING_OBJECT()</a>
</dt>
<dt id="ientry-idm39574">GST_WRITE_DOUBLE_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-WRITE-DOUBLE-BE:CAPS">GST_WRITE_DOUBLE_BE ()</a>
</dt>
<dt id="ientry-idm39561">GST_WRITE_DOUBLE_LE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-WRITE-DOUBLE-LE:CAPS">GST_WRITE_DOUBLE_LE ()</a>
</dt>
<dt id="ientry-idm39548">GST_WRITE_FLOAT_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-WRITE-FLOAT-BE:CAPS">GST_WRITE_FLOAT_BE ()</a>
</dt>
<dt id="ientry-idm39535">GST_WRITE_FLOAT_LE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-WRITE-FLOAT-LE:CAPS">GST_WRITE_FLOAT_LE ()</a>
</dt>
<dt id="ientry-idm39500">GST_WRITE_UINT16_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-WRITE-UINT16-BE:CAPS">GST_WRITE_UINT16_BE()</a>
</dt>
<dt id="ientry-idm39495">GST_WRITE_UINT16_LE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-WRITE-UINT16-LE:CAPS">GST_WRITE_UINT16_LE()</a>
</dt>
<dt id="ientry-idm39510">GST_WRITE_UINT24_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-WRITE-UINT24-BE:CAPS">GST_WRITE_UINT24_BE()</a>
</dt>
<dt id="ientry-idm39505">GST_WRITE_UINT24_LE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-WRITE-UINT24-LE:CAPS">GST_WRITE_UINT24_LE()</a>
</dt>
<dt id="ientry-idm39520">GST_WRITE_UINT32_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-WRITE-UINT32-BE:CAPS">GST_WRITE_UINT32_BE()</a>
</dt>
<dt id="ientry-idm39515">GST_WRITE_UINT32_LE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-WRITE-UINT32-LE:CAPS">GST_WRITE_UINT32_LE()</a>
</dt>
<dt id="ientry-idm39530">GST_WRITE_UINT64_BE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-WRITE-UINT64-BE:CAPS">GST_WRITE_UINT64_BE()</a>
</dt>
<dt id="ientry-idm39525">GST_WRITE_UINT64_LE, <a class="indexterm" href="gstreamer-GstUtils.html#GST-WRITE-UINT64-LE:CAPS">GST_WRITE_UINT64_LE()</a>
</dt>
<dt id="ientry-idm39490">GST_WRITE_UINT8, <a class="indexterm" href="gstreamer-GstUtils.html#GST-WRITE-UINT8:CAPS">GST_WRITE_UINT8()</a>
</dt>
</dl>
</div></div>
</div>
<div class="footer">
<hr>Generated by GTK-Doc V1.25</div>
</body>
</html>