gaspard7/wiki_gpac huggingface dataset:
Options  {.no-collapse}

<div markdown class="option">  
<a id="floop" data-level="basic">__floop__</a> (sint, default: _0_): loop playlist/list of files, `0` for one time, `n` for n+1 times, `-1` for indefinitely  
</div>  
<div markdown class="option">  
<a id="srcs" data-level="basic">__srcs__</a> (strl): list of files to play  
</div>  
<div markdown class="option">  
<a id="fdur" data-level="basic">__fdur__</a> (frac, default: _1/25_): frame duration for source files with a single frame (0/NaN fraction means reuse source timing which is usually not set!)  
</div>  
<div markdown class="option">  
<a id="revert">__revert__</a> (bool, default: _false_): revert list of files ([srcs](#srcs), not playlist)  
</div>  
<div markdown class="option">  
<a id="timescale">__timescale__</a> (uint, default: _0_): force output timescale on all PIDs (0 uses the timescale of the first PID found)  
</div>  
<div markdown class="option">  
<a id="ka">__ka__</a> (uint, default: _0_): keep playlist alive (disable loop), waiting for a new input to be added or `#end` directive to end playlist. The value specifies the refresh rate in ms  
</div>  
<div markdown class="option">  
<a id="timeout">__timeout__</a> (luint, default: _-1_): timeout in ms after which the playlist is considered dead (`-1` means indefinitely)  
</div>  
<div markdown class="option">  
<a id="fsort" data-level="basic">__fsort__</a> (enum, default: _no_): sort list of files  

- no: no sorting, use default directory enumeration of OS  
- name: sort by alphabetical name  
- size: sort by increasing size  
- date: sort by increasing modification time  
- datex: sort by increasing modification time  
</div>  
  
<div markdown class="option">  
<a id="sigcues">__sigcues__</a> (bool, default: _false_): inject `CueStart` property at each source begin (new or repeated) for DASHing  
</div>  
<div markdown class="option">  
<a id="fdel">__fdel__</a> (bool, default: _false_): delete source files after processing in playlist mode (does not delete the playlist)  
</div>  
<div markdown class="option">  
<a id="keepts">__keepts__</a> (bool, default: _false_): keep initial timestamps unmodified (no reset to 0)  
</div>  
<div markdown class="option">  
<a id="raw" data-level="basic">__raw__</a> (enum, default: _no_): force input AV streams to be in raw format  

- no: do not force decoding of inputs  
- av: force decoding of audio and video inputs  
- a: force decoding of audio inputs  
- v: force decoding of video inputs  
</div>  
  
<div markdown class="option">  
<a id="flush" data-level="basic">__flush__</a> (bool, default: _false_): send a flush signal once playlist is done before entering keepalive  
</div>
TTXT/TX3G decoder

Register name used to load filter: __ttxtdec__  
This filter may be automatically loaded during graph resolution.  
  
This filter decodes TTXT/TX3G streams into a BIFS scene graph of the compositor filter.  
The TTXT documentation is available at https://wiki.gpac.io/xmlformats/TTXT-Format-Documentation  
  
In stand-alone rendering (no associated video), the filter will use:  

- `Width` and `Height` properties of input pid if any  
- otherwise, `osize` option of compositor if set  
- otherwise, [txtw](#txtw) and [txth](#txth)
Options  {.no-collapse}

<div markdown class="option">  
<a id="texture">__texture__</a> (bool, default: _false_): use texturing for output text  
</div>  
<div markdown class="option">  
<a id="outline">__outline__</a> (bool, default: _false_): draw text outline  
</div>  
<div markdown class="option">  
<a id="txtw">__txtw__</a> (uint, default: _400_): default width in standalone rendering  
</div>  
<div markdown class="option">  
<a id="txth">__txth__</a> (uint, default: _200_): default height in standalone rendering  
</div>
AVI multiplexer

Register name used to load filter: __avimx__  
This filter may be automatically loaded during graph resolution.  
  
This filter multiplexes raw or compressed audio and video to produce an AVI output.  
  
Unlike other multiplexing filters in GPAC, this filter is a sink filter and does not produce any PID to be redirected in the graph.  
The filter can however use template names for its output, using the first input PID to resolve the final name.  
The filter watches the property `FileNumber` on incoming packets to create new files.  
  
The filter will look for property `AVIType` set on the input stream.  
The value can either be a 4CC or a string, indicating the mux format for the PID.  
If the string is prefixed with `+` and the decoder configuration is present and formatted as an ISOBMFF box, the box header will be removed.
Options  {.no-collapse}

<div markdown class="option">  
<a id="dst" data-level="basic">__dst__</a> (cstr): location of destination file  
</div>  
<div markdown class="option">  
<a id="fps" data-level="basic">__fps__</a> (frac, default: _25/1_): default framerate if none indicated in stream  
</div>  
<div markdown class="option">  
<a id="noraw">__noraw__</a> (bool, default: _false_): disable raw output in AVI, only compressed ones allowed  
</div>  
<div markdown class="option">  
<a id="opendml_size">__opendml_size__</a> (luint, default: _0_): force opendml format when chunks are larger than this amount (0 means 1.9Gb max size in each riff chunk)  
</div>
Options

<a id="reorder">__reorder__</a> (uint, default: _6_): number of frames to wait for temporal re-ordering  
<a id="no_copy">__no_copy__</a> (bool, default: _true_): dispatch decoded frames as OpenGL textures (true) or as copied packets (false)   
<a id="ofmt">__ofmt__</a> (pfmt, default: _nv12_): set default pixel format for decoded video. If not found, fall back to `nv12`  
<a id="disable_hw">__disable_hw__</a> (bool, default: _false_): disable hardware decoding  
<a id="wait_sync">__wait_sync__</a> (bool, default: _false_, updatable): wait for sync frame before decoding
CryptFile input

Register name used to load filter: __cryptin__  
This filter is not checked during graph resolution and needs explicit loading.  
  
This filter dispatch raw blocks from encrypted files with AES 128 CBC in PKCS7 to clear input files  
  
The filter is automatically loaded by the DASH/HLS demultiplexer and should not be explicitly loaded by your application.  
  
The filter accepts URL with scheme `gcryp://URL`, where `URL` is the URL to decrypt.  
  
The filter can process http(s) and local file key URLs (setup through HLS manifest), and expects a full key (16 bytes) as result of resource fetching.
HTTP input

Register name used to load filter: __httpin__  
This filter may be automatically loaded during graph resolution.  
  
This filter dispatch raw blocks from a remote HTTP resource into a filter chain.  
Block size can be adjusted using [block_size](#block_size), and disk caching policies can be adjusted.  
Content format can be forced through [mime](#mime) and file extension can be changed through [ext](#ext).  
  
The filter supports both http and https schemes, and will attempt reconnecting as TLS if TCP connection fails.  
  
_Note: Unless disabled at session level (see [-no-probe](core_options/#no-probe) ), file extensions are usually ignored and format probing is done on the first data block._
Options  {.no-collapse}

<div markdown class="option">  
<a id="src" data-level="basic">__src__</a> (cstr): URL of source content  
</div>  
<div markdown class="option">  
<a id="block_size">__block_size__</a> (uint, default: _100000_): block size used to read file  
</div>  
<div markdown class="option">  
<a id="cache">__cache__</a> (enum, default: _none_): set cache mode  

- auto: cache to disk if content length is known, no cache otherwise  
- disk: cache to disk,  discard once session is no longer used  
- keep: cache to disk and keep  
- mem: stores to memory, discard once session is no longer used  
- mem_keep: stores to memory, keep after session is reassigned but move to `mem` after first download  
- none: no cache  
- none_keep: stores to memory, keep after session is reassigned but move to `none` after first download  
</div>  
  
<div markdown class="option">  
<a id="range" data-level="basic">__range__</a> (lfrac, default: _0-0_): set byte range, as fraction  
</div>  
<div markdown class="option">  
<a id="ext" data-level="basic">__ext__</a> (cstr): override file extension  
</div>  
<div markdown class="option">  
<a id="mime" data-level="basic">__mime__</a> (cstr): set file mime type  
</div>  
<div markdown class="option">  
<a id="blockio">__blockio__</a> (bool, default: _false_): use blocking IO  
</div>
CENC decryptor

Register name used to load filter: __cdcrypt__  
This filter may be automatically loaded during graph resolution.  
  
The CENC decryptor supports decrypting CENC, ISMA, HLS Sample-AES (MPEG2 ts) and Adobe streams.  
  
For HLS, key is retrieved according to the key URI in the manifest.  
Otherwise, the filter uses a configuration file.  
The syntax is available at https://wiki.gpac.io/xmlformats/Common-Encryption  
The DRM config file can be set per PID using the property `DecryptInfo` (highest priority), `CryptInfo` (lower priority) or set at the filter level using [cfile](#cfile) (lowest priority).  
When the file is set per PID, the first `CryptInfo` with the same ID is used, otherwise the first `CryptInfo` is used.When the file is set globally (not per PID), the first `CrypTrack` in the DRM config file with the same ID is used, otherwise the first `CrypTrack` with ID 0 or not set is used.
Options  {.no-collapse}

<div markdown class="option">  
<a id="cfile" data-level="basic">__cfile__</a> (str): crypt file location  
</div>  
<div markdown class="option">  
<a id="decrypt">__decrypt__</a> (enum, default: _full_): decrypt mode (CENC only)  

- full: decrypt everything, throwing error if keys are not found  
- nokey: decrypt everything for which a key is found, skip decryption otherwise  
- skip: decrypt nothing  
- pad0: decrypt nothing and replace all crypted bits with 0  
- pad1: decrypt nothing and replace all crypted bits with 1  
- padsc: decrypt nothing and replace all crypted bytes with start codes  
</div>  
  
<div markdown class="option">  
<a id="drop_keys">__drop_keys__</a> (uintl): consider keys with given 1-based indexes as not available (multi-key debug)  
</div>  
<div markdown class="option">  
<a id="kids">__kids__</a> (strl): define KIDs. If `keys` is empty, consider keys with given KID (as hex string) as not available (debug)  
</div>  
<div markdown class="option">  
<a id="keys">__keys__</a> (strl): define key values for each of the specified KID  
</div>  
<div markdown class="option">  
<a id="hls_cenc_patch_iv">__hls_cenc_patch_iv__</a> (bool, default: _false_): ignore IV updates in some broken HLS+CENC streams  
</div>
RTP/RTSP/SDP input

Register name used to load filter: __rtpin__  
This filter may be automatically loaded during graph resolution.  
  
This filter handles SDP/RTSP/RTP input reading. It supports:  

- SDP file reading  
- RTP direct url through `rtp://` protocol scheme  
- RTSP session processing through `rtsp://` and `satip://` protocol schemes  

   
The filter produces either PIDs with media frames, or file PIDs with multiplexed data (e.g. MPEG-2 TS).   
The filter will use:  

- RTSP over HTTP tunnel if server port is 80 or 8080 or if protocol scheme is `rtsph://`.  
- RTSP over TLS if server port is 322 or if protocol scheme is `rtsps://`.  
- RTSP over HTTPS tunnel if server port is 443 and if protocol scheme is `rtsph://`.  

   
The filter will attempt reconnecting in TLS mode after two consecutive initial connection failures.
Direct RTP mode

When the destination URL uses the protocol scheme `rtp://IP:PORT`, the filter does not output any SDP and streams a single input over RTP, using PORT indicated in the destination URL, or the first [port](#port) configured.  
In this mode, it is usually needed to specify the desired format using [ext](#ext) or [mime](#mime).  
Example
```
gpac -i src -o rtp://localhost:1234/:ext=ts
```
  
This will indicate that the RTP streamer expects a MPEG-2 TS mux as an input.
RTP Packets

The RTP packets produced have a maximum payload set by the [mtu](#mtu) option (IP packet will be MTU + 40 bytes of IP+UDP+RTP headers).  
The real-time scheduling algorithm works as follows:  

- first initialize the clock by:  

    - computing the smallest timestamp for all input PIDs  
    - mapping this media time to the system clock  

- determine the earliest packet to send next on each input PID, adding [delay](#delay) if any  
- finally compare the packet mapped timestamp _TS_ to the system clock _SC_. When _TS_ - _SC_ is less than [tt](#tt), the RTP packets for the source packet are sent  

  
The filter does not check for RTCP timeout and will run until all input PIDs reach end of stream.
Options  {.no-collapse}

<div markdown class="option">  
<a id="ip" data-level="basic">__ip__</a> (str): destination IP address (NULL is 127.0.0.1)  
</div>  
<div markdown class="option">  
<a id="port" data-level="basic">__port__</a> (uint, default: _7000_): port for first stream in session  
</div>  
<div markdown class="option">  
<a id="loop" data-level="basic">__loop__</a> (bool, default: _true_): loop all streams in session (not always possible depending on source type)  
</div>  
<div markdown class="option">  
<a id="mpeg4">__mpeg4__</a> (bool, default: _false_): send all streams using MPEG-4 generic payload format if possible  
</div>  
<div markdown class="option">  
<a id="mtu" data-level="basic">__mtu__</a> (uint, default: _1460_): size of RTP MTU in bytes  
</div>  
<div markdown class="option">  
<a id="ttl">__ttl__</a> (uint, default: _2_): time-to-live for multicast packets  
</div>  
<div markdown class="option">  
<a id="ifce">__ifce__</a> (str): default network interface to use  
</div>  
<div markdown class="option">  
<a id="payt">__payt__</a> (uint, default: _96_, minmax: 96-127): payload type to use for dynamic decoder configurations  
</div>  
<div markdown class="option">  
<a id="delay" data-level="basic">__delay__</a> (sint, default: _0_): send delay for packet (negative means send earlier)  
</div>  
<div markdown class="option">  
<a id="tt">__tt__</a> (uint, default: _1000_): time tolerance in microseconds. Whenever schedule time minus realtime is below this value, the packet is sent right away  
</div>  
<div markdown class="option">  
<a id="runfor" data-level="basic">__runfor__</a> (sint, default: _-1_): run for the given time in ms. Negative value means run for ever (if loop) or source duration, 0 only outputs the sdp  
</div>  
<div markdown class="option">  
<a id="tso">__tso__</a> (sint, default: _-1_): set timestamp offset in microseconds. Negative value means random initial timestamp  
</div>  
<div markdown class="option">  
<a id="xps">__xps__</a> (bool, default: _false_): force parameter set injection at each SAP. If not set, only inject if different from SDP ones  
</div>  
<div markdown class="option">  
<a id="latm">__latm__</a> (bool, default: _false_): use latm for AAC payload format  
</div>  
<div markdown class="option">  
<a id="dst" data-level="basic">__dst__</a> (cstr): URL for direct RTP mode  
</div>  
<div markdown class="option">  
<a id="ext">__ext__</a> (str): file extension for direct RTP mode  
</div>  
<div markdown class="option">  
<a id="mime">__mime__</a> (cstr): set mime type for direct RTP mode  
</div>
Probe source

Register name used to load filter: __probe__  
This filter is not checked during graph resolution and needs explicit loading.  
  
The Probe filter is used by applications (typically `MP4Box`) to query demultiplexed PIDs (audio, video, ...) available in a source chain.  
  
The filter outputs the number of input PIDs in the file specified by [log](#log).  
It is up to the app developer to query input PIDs of the prober and take appropriated decisions.
Options  {.no-collapse}

<div markdown class="option">  
<a id="log" data-level="basic">__log__</a> (str, default: _stdout_, Enum: _any|stderr|stdout|GLOG|null): set probe log filename to print number of streams  

- _any: target file path and name  
- stderr: dump to stderr  
- stdout: dump to stdout  
- GLOG: use GPAC logs `app@info`  
- null: silent mode  
</div>
Options  {.no-collapse}

<div markdown class="option">  
<a id="frame_size">__frame_size__</a> (uint, default: _1024_): size of AAC frame in audio samples  
</div>  
<div markdown class="option">  
<a id="index" data-level="basic">__index__</a> (dbl, default: _1.0_): indexing window length  
</div>  
<div markdown class="option">  
<a id="ovsbr">__ovsbr__</a> (bool, default: _false_): force oversampling SBR (does not multiply timescales by 2)  
</div>  
<div markdown class="option">  
<a id="sbr">__sbr__</a> (enum, default: _no_): set SBR signaling  

- no: no SBR signaling at all  
- imp: backward-compatible SBR signaling (audio signaled as AAC-LC)  
- exp: explicit SBR signaling (audio signaled as AAC-SBR)  
</div>  
  
<div markdown class="option">  
<a id="ps">__ps__</a> (enum, default: _no_): set PS signaling  

- no: no PS signaling at all  
- imp: backward-compatible PS signaling (audio signaled as AAC-LC)  
- exp: explicit PS signaling (audio signaled as AAC-PS)  
</div>  
  
<div markdown class="option">  
<a id="expart" data-level="basic">__expart__</a> (bool, default: _false_): expose pictures as a dedicated video PID  
</div>  
<div markdown class="option">  
<a id="aacchcfg">__aacchcfg__</a> (sint, default: _0_): set AAC channel configuration to this value if missing from ADTS header, use negative value to always override  
</div>
Options  {.no-collapse}

<div markdown class="option">  
<a id="mpeg2">__mpeg2__</a> (enum, default: _auto_): signal as MPEG2 AAC  

- auto: selects based on AAC profile  
- no: always signals as MPEG-4 AAC  
- yes: always signals as MPEG-2 AAC  
</div>
Track Selection

The filter can use fragment identifiers of source to select a single track for playback. The allowed fragments are:  

    - #audio: only use the first audio track  
    - #video: only use the first video track  
    - #auxv: only use the first auxiliary video track  
    - #pict: only use the first picture track  
    - #text: only use the first text track  
    - #trackID=VAL: only use the track with given ID  
    - #itemID=VAL: only use the item with given ID  
    - #ID=VAL: only use the track/item with given ID  
    - #VAL: only use the track/item with given ID
Scalable Tracks

When scalable tracks are present in a file, the reader can operate in 3 modes using [smode](#smode) option:  

- smode=single: resolves all extractors to extract a single bitstream from a scalable set. The highest level is used  

In this mode, there is no enhancement decoder config, only a base one resulting from the merge of the layers configurations  

- smode=split: all extractors are removed and every track of the scalable set is declared. In this mode, each enhancement track has no base decoder config  

and an enhancement decoder config.  

- smode=splitx: extractors are kept in the bitstream, and every track of the scalable set is declared. In this mode, each enhancement track has a base decoder config  

 (copied from base) and an enhancement decoder config. This is mostly used for DASHing content.  

__Warning: smode=splitx will result in extractor NAL units still present in the output bitstream, which shall only be true if the output is ISOBMFF based__
Options  {.no-collapse}

<div markdown class="option">  
<a id="exporter">__exporter__</a> (bool, default: _false_): compatibility with old exporter, displays export results  
</div>  
<div markdown class="option">  
<a id="large" data-level="basic">__large__</a> (bool, default: _false_): use large file mode  
</div>
Options  {.no-collapse}

<div markdown class="option">  
<a id="mode" data-level="basic">__mode__</a> (enum, default: _23001-18_): mode to operate in  

- 23001-18: extract SCTE-35 markers as emib/emeb boxes for Event Tracks  
- passthrough: pass-through mode adding cue start property on splice points  
</div>  
  
<div markdown class="option">  
<a id="segdur" data-level="basic">__segdur__</a> (frac, default: _1/1_): segmentation duration in seconds. 0/0 flushes immediately for each input packet (beware of the bitrate overhead)  
</div>
Compressed layered bitstream splitter

Register name used to load filter: __bssplit__  
This filter is not checked during graph resolution and needs explicit loading.  
Filters of this class can connect to each-other.  
  
This filter splits input stream by layers and sublayers  
  
The filter supports AVC|H264, HEVC and VVC stream splitting and is pass-through for other codec types.  
  
Splitting is based on temporalID value (start from 1) and layerID value (start from 0).  
For AVC|H264, layerID is the dependency value, or quality value if `svcqid` is set.  
  
Each input stream is filtered according to the `ltid` option as follows:  

- no value set: input stream is split by layerID, i.e. each layer creates an output  
- `all`: input stream is split by layerID and temporalID, i.e. each {layerID,temporalID} creates an output  
- `lID`: input stream is split according to layer `lID` value, and temporalID is ignored  
- `.tID`: input stream is split according to temporal sub-layer `tID` value and layerID is ignored  
- `lID.tID`: input stream is split according to layer `lID` and sub-layer `tID` values  

  
_Note: A tID value of 0 in `ltid` is equivalent to value 1._  
  
Multiple values can be given in `ltid`, in which case each value gives the maximum {layerID,temporalID} values for the current layer.  
A few examples on an input with 2 layers each with 2 temporal sublayers:  

- `ltid=0.2`: this will split the stream in:  

    - one stream with {lID=0,tID=1} and {lID=0,tID=2} NAL units  
    - one stream with all other layers/substreams  

- `ltid=0.1,1.1`: this will split the stream in:  

    - one stream with {lID=0,tID=1} NAL units  
    - one stream with {lID=0,tID=2}, {lID=1,tID=1} NAL units  
    - one stream with the rest {lID=0,tID=2}, {lID=1,tID=2} NAL units  

- `ltid=0.1,0.2`: this will split the stream in:  

    - one stream with {lID=0,tID=1} NAL units  
    - one stream with {lID=0,tID=2} NAL units  
    - one stream with the rest {lID=1,tID=1}, {lID=1,tID=2} NAL units  

  
The filter can also be used on AVC and HEVC DolbyVision streams to split base stream and DV RPU/EL.  
  
The filter does not create aggregator or extractor NAL units.
Options  {.no-collapse}

<div markdown class="option">  
<a id="ltid" data-level="basic">__ltid__</a> (strl): temporal and layer ID of output streams  
</div>  
<div markdown class="option">  
<a id="svcqid" data-level="basic">__svcqid__</a> (bool, default: _false_): use qualityID instead of dependencyID for SVC splitting  
</div>  
<div markdown class="option">  
<a id="sig_ltid" data-level="basic">__sig_ltid__</a> (bool, default: _false_): signal maximum temporal (`max_temporal_id`) and layer ID (`max_layer_id`) of output streams (mostly used for debug)  
</div>
Closed-Caption decoder  {:data-level="all"}

Register name used to load filter: __ccdec__  
This filter is not checked during graph resolution and needs explicit loading.  
  
This filter decodes Closed Captions to unframed SRT.  
Supported video media types are MPEG2, AVC, HEVC, VVC and AV1 streams.  
  
Only a subset of CEA 608/708 is supported.  
  
No options