gaspard7/wiki_gpac huggingface dataset:
Pixel formats

Name | File extensions | QT 4CC | Description    
 --- | --- |  --- | ---    
yuv420 | yuv | j420 | Planar YUV 420 8 bit    
yvu420 | yvu |  | Planar YVU 420 8 bit    
yuv420_10 | yuvl |  | Planar YUV 420 10 bit    
yuv422 | yuv2 |  | Planar YUV 422 8 bit    
yuv422_10 | yp2l |  | Planar YUV 422 10 bit    
yuv444 | yuv4 |  | Planar YUV 444 8 bit    
yuv444_10 | yp4l |  | Planar YUV 444 10 bit    
uyvy | uyvy | 2vuy | Packed UYVY 422 8 bit    
vyuy | vyuy |  | Packed VYUV 422 8 bit    
yuyv | yuyv | yuv2 | Packed YUYV 422 8 bit    
yvyu | yvyu | YVYU | Packed YVYU 422 8 bit    
uyvl | uyvl | v216 | Packed UYVY 422 10->16 bit    
vyul | vyul |  | Packed VYUV 422 10->16 bit    
yuyl | yuyl |  | Packed YUYV 422 10->16 bit    
yvyl | yvyl |  | Packed YVYU 422 10->16 bit    
nv12 | nv12 |  | Semi-planar YUV 420 8 bit, Y plane and UV packed plane    
nv21 | nv21 |  | Semi-planar YVU 420 8 bit, Y plane and VU packed plane    
nv1l | nv1l |  | Semi-planar YUV 420 10 bit, Y plane and UV plane    
nv2l | nv2l |  | Semi-planar YVU 420 8 bit, Y plane and VU plane    
yuva | yuva |  | Planar YUV+alpha 420 8 bit    
yuvd | yuvd |  | Planar YUV+depth  420 8 bit    
yuv444a | yp4a |  | Planar YUV+alpha 444 8 bit    
yuv444p | yv4p |  | Packed YUV 444 8 bit    
v308 | v308 | v308 | Packed VYU 444 8 bit    
yuv444ap | y4ap |  | Packed YUV+alpha 444 8 bit    
v408 | v408 | v408 | Packed UYV+alpha 444 8 bit    
v410 | v410 | v410 | Packed UYV 444 10 bit LE    
v210 | v210 | v210 | Packed UYVY 422 10 bit LE    
grey | grey |  | Greyscale 8 bit    
algr | algr |  | Alpha+Grey 8 bit    
gral | gral |  | Grey+Alpha 8 bit    
rgb4 | rgb4 |  | RGB 444, 12 bits (16 stored) / pixel    
rgb5 | rgb5 |  | RGB 555, 15 bits (16 stored) / pixel    
rgb6 | rgb6 |  | RGB 555, 16 bits / pixel    
rgba | rgba | RGBA | RGBA 32 bits (8 bits / component)    
argb | argb |  | ARGB 32 bits (8 bits / component)    
bgra | bgra |  | BGRA 32 bits (8 bits / component)    
abgr | abgr | ABGR | ABGR 32 bits (8 bits / component)    
rgb | rgb | raw  | RGB 24 bits (8 bits / component)    
bgr | bgr |  | BGR 24 bits (8 bits / component)    
xrgb | xrgb |  | xRGB 32 bits (8 bits / component)    
rgbx | rgbx |  | RGBx 32 bits (8 bits / component)    
xbgr | xbgr |  | xBGR 32 bits (8 bits / component)    
bgrx | bgrx |  | BGRx 32 bits (8 bits / component)    
rgbd | rgbd |  | RGB+depth 32 bits (8 bits / component)    
rgbds | rgbds |  | RGB+depth+bit shape (8 bits / RGB component, 7 bit depth (low bits) + 1 bit shape)    
extgl | extgl |  | External OpenGL texture of unknown format, to be used with samplerExternalOES  <br/>    
uncv | uncv |  | Generic uncompressed format ISO/IEC 23001-17
Audio formats

Name | File extensions | Description    
 --- | --- | ---    
u8 | pc8 | 8 bit PCM    
s16 | pcm | 16 bit PCM Little Endian    
s16b | pcmb | 16 bit PCM Big Endian    
s24 | s24 | 24 bit PCM    
s24b | s24b | 24 bit Big-Endian PCM    
s32 | s32 | 32 bit PCM Little Endian    
s32b | s32b | 32 bit PCM Big Endian    
flt | flt | 32-bit floating point PCM    
fltb | fltb | 32-bit floating point PCM Big Endian    
dbl | dbl | 64-bit floating point PCM    
dblb | dblb | 64-bit floating point PCM Big Endian    
u8p | pc8p | 8 bit PCM planar    
s16p | pcmp | 16 bit PCM Little Endian planar    
s24p | s24p | 24 bit PCM planar    
s32p | s32p | 32 bit PCM Little Endian planar    
fltp | fltp | 32-bit floating point PCM planar    
dblp | dblp | 64-bit floating point PCM planar
Stream types

Name | Description    
 --- | ---    
Visual | Video or Image stream    
Audio | Audio stream    
SceneDescription | Scene stream    
Text | Text or subtitle stream    
Metadata | Metadata stream    
File | Raw file stream    
Encrypted | Encrypted media stream    
ObjectDescriptor | MPEG-4 ObjectDescriptor stream    
ClockReference | MPEG-4 Clock Reference stream    
MPEG7 | MPEG-7 description stream    
IPMP | MPEG-4 IPMP/DRM stream    
OCI | MPEG-4 ObjectContentInformation stream    
MPEGJ | MPEG-4 JAVA stream    
Interaction | MPEG-4 Interaction Sensor stream    
Font | MPEG-4 Font stream
Audio channel layout code points (ISO/IEC 23091-3)

Name | Integer value | ChannelMask    
 --- | ---  | ---    
mono | 1 | 0x0000000000000004    
stereo | 2 | 0x0000000000000003    
3/0.0 | 3 | 0x0000000000000007    
3/1.0 | 4 | 0x0000000000000407    
3/2.0 | 5 | 0x0000000000000037    
3/2.1 | 6 | 0x000000000000003f    
5/2.1 | 7 | 0x000000000000003f    
1+1 | 8 | 0x0000000000000003    
2/1.0 | 9 | 0x0000000000000403    
2/2.0 | 10 | 0x0000000000000033    
3/3.1 | 11 | 0x000000000000043f    
3/4.1 | 12 | 0x000000000000033f    
11/11.2 | 13 | 0x000000003ffe67cf    
5/2.1 | 14 | 0x000000000006003f    
5/5.2 | 15 | 0x000000000606603f    
5/4.1 | 16 | 0x000000000036003f    
6/5.1 | 17 | 0x00000000023e003f    
6/7.1 | 18 | 0x00000600023e003f    
5/6.1 | 19 | 0x000000000036630f    
7/6.1 | 20 | 0x000000600036630f
Color Primaries code points (ISO/IEC 23091-2)

Name | Integer value   
 --- | ---    
 reserved0 | 0   
 BT709 | 1   
 undef | 2   
 reserved3 | 3   
 BT470M | 4   
 BT470G | 5   
 SMPTE170 | 6   
 SMPTE240 | 7   
 FILM | 8   
 BT2020 | 9   
 SMPTE428 | 10   
 SMPTE431 | 11   
 SMPTE432 | 12   
 EBU3213 | 22
Transfer Characteristics code points (ISO/IEC 23091-2)

Name | Integer value   
 --- | ---    
 reserved0 | 0   
 BT709 | 1   
 undef | 2   
 reserved3 | 3   
 BT470M | 4   
 BT470BG | 5   
 SMPTE170 | 6   
 SMPTE249 | 7   
 Linear | 8   
 Log100 | 9   
 Log316 | 10   
 IEC61966 | 11   
 BT1361 | 12   
 sRGB | 13   
 BT2020_10 | 14   
 BT2020_12 | 15   
 SMPTE2084 | 16   
 SMPTE428 | 17   
 STDB67 | 18
Matrix Coefficients code points (ISO/IEC 23091-2)

Name | Integer value   
 --- | ---    
 GBR | 0   
 BT709 | 1   
 undef | 2   
 unknown | 3   
 FCC | 4   
 BT601 | 5   
 SMPTE170 | 6   
 SMPTE240 | 7   
 YCgCo | 8   
 BT2020 | 9   
 BT2020cl | 10   
 YDzDx | 11
Protocol Schemes

_NOTE: This table does not include meta filters (ffmpeg, ...), use `gpac -hx protocols` to list them._  
  
 Scheme | Input Filter(s) | Output Filter(s)  
 --- | --- | ---    
file | fin | fout  
isobmf | fin |  n/a  
gmem | fin httpin |  n/a  
gfio | fin | fout  
http | httpin | httpout  
https | httpin | httpout  
dict | httpin |  n/a  
ftp | httpin |  n/a  
ftps | httpin |  n/a  
gopher | httpin |  n/a  
gophers | httpin |  n/a  
imap | httpin |  n/a  
imaps | httpin |  n/a  
ldap | httpin |  n/a  
ldaps | httpin |  n/a  
mqtt | httpin |  n/a  
pop3 | httpin |  n/a  
pop3s | httpin |  n/a  
rtmp | httpin |  n/a  
rtsp | httpin rtpin | rtspout  
scp | httpin |  n/a  
sftp | httpin |  n/a  
smb | httpin |  n/a  
smbs | httpin |  n/a  
smtp | httpin |  n/a  
smtps | httpin |  n/a  
telnet | httpin |  n/a  
tftp | httpin |  n/a  
tcp | sockin | sockout  
udp | sockin | sockout  
tcpu | sockin | sockout  
udpu | sockin | sockout  
rtp | rtpin | rtpout  
rtspu | rtpin |  n/a  
rtsph | rtpin | rtspout  
satip | rtpin |  n/a  
rtsps | rtpin | rtspout  
pipe | pin | pout  
atsc | routein | routeout  
route | routein | routeout  
mabr | routein | routeout  
video | ffavin |  n/a  
audio | ffavin |  n/a  
av | ffavin |  n/a
ATSC 3.0 mode

In this mode, the filter allows multiple service multiplexing, identified through the `ServiceID` property.  
By default, a single multicast IP is used for route sessions, each service will be assigned a different port.  
The filter will look for `MCASTIP` and `MCASTPort` properties on the incoming PID. If not found, the default [ip](#ip) and [port](#port) will be used.  
  
ATSC 3.0 attributes set by using the following PID properties:  

- ATSC3ShortServiceName: set the short service name, maxiumu of 7 characters.  If not found, `ServiceName` is checked, otherwise default to `GPAC`.  
- ATSC3MajorChannel: set major channel number of service. Default to 2.  This really should be set and should not use the default.  
- ATSC3MinorChannel: set minor channel number of service. Default of 1.  
- ATSC3ServiceCat: set service category, default to 1 if not found. 1=Linear a/v service. 2=Linear audio only service. 3=App-based service. 4=ESg service. 5=EA service. 6=DRM service.  
- ATSC3hidden: set if service is hidden.  Boolean true or false. Default of false.  
- ATSC3hideInGuide: set if service is hidden in ESG.  Boolean true or false. Default of false.  
- ATSC3configuration: set service configuration.  Choices are Broadcast or Broadband.  Default of Broadcast
DVB-MABR mode

In this mode, the filter allows multiple service multiplexing, identified through the `ServiceID` and `ServiceName` properties.  
_Note: [ip](#ip) and [first_port](#first_port) are used to send the multicast gateway configuration, init segments and manifests. [first_port](#first_port) is used only if no port is specified in [dst](#dst)._  
  
The session will carry DVB-MABR gateway configuration, maifests and init segments on `TSI=1`  
  
The FLUTE session always uses a symbol length of [mtu](#mtu) minus 44 bytes.
Low latency mode

When using low-latency mode (-llmode)(), the input media segments are not re-assembled in a single packet but are instead sent as they are received.  
In order for the real-time scheduling of data chunks to work, each fragment of the segment should have a CTS and timestamp describing its timing.  
If this is not the case (typically when used with an existing DASH session in file mode), the scheduler will estimate CTS and duration based on the stream bitrate and segment duration. The indicated bitrate is increased by [brinc](#brinc) percent for safety.  
If this fails, the filter will trigger warnings and send as fast as possible.  
_Note: The LCT objects are sent with no length (TOL header) assigned until the final segment size is known, potentially leading to a final 0-size LCT fragment signaling only the final size._  
  
In this mode, init segments and manifests are sent at the frequency given by property `MCASTCarousel` of the source PID if set or by (-carousel)[] option.  
Indicating `MCASTCarousel=0` will disable mid-segment repeating of manifests and init segments.
Examples

Since the ROUTE filter only consumes files, it is required to insert:  

- the dash demultiplexer in file forwarding mode when loading a DASH session  
- the dash multiplexer when creating a DASH session  

  
Multiplexing an existing DASH session in route:  
Example
```
gpac -i source.mpd dashin:forward=file -o route://225.1.1.0:6000/
```
  
Multiplexing an existing DASH session in atsc:  
Example
```
gpac -i source.mpd dashin:forward=file -o atsc://
```
  
Dashing and multiplexing in route:  
Example
```
gpac -i source.mp4 dasher:profile=live -o route://225.1.1.0:6000/manifest.mpd
```
  
Dashing and multiplexing in route Low Latency:  
Example
```
gpac -i source.mp4 dasher -o route://225.1.1.0:6000/manifest.mpd:profile=live:cdur=0.2:llmode
```
  
  
Sending a single file in ROUTE using half a second upload time, 2 seconds carousel:  
Example
```
gpac -i URL:#MCASTUpload=0.5:#MCASTCarousel=2 -o route://225.1.1.0:6000/
```
  
  
Common mistakes:  
Example
```
gpac -i source.mpd -o route://225.1.1.0:6000/
```
  
This will only send the manifest file as a regular object and will not load the dash session.  
Example
```
gpac -i source.mpd dashin:forward=file -o route://225.1.1.0:6000/manifest.mpd
```
  
This will force the ROUTE multiplexer to only accept .mpd files, and will drop all segment files (same if [ext](#ext) is used).  
Example
```
gpac -i source.mpd dasher -o route://225.1.1.0:6000/  
gpac -i source.mpd dasher -o route://225.1.1.0:6000/manifest.mpd
```
  
These will demultiplex the input, re-dash it and send the output of the dasher to ROUTE
Error simulation

It is possible to simulate errors with (-errsim)(). In this mode the LCT network sender implements a 2-state Markov chain:  
Example
```
gpac -i source.mpd dasher -o route://225.1.1.0:6000/:errsim=1.0x98.0
```
  
for a 1.0 percent chance to transition to error (not sending data over the network) and 98.0 to transition from error back to OK.
CENC encryptor

Register name used to load filter: __cecrypt__  
This filter is not checked during graph resolution and needs explicit loading.  
  
The CENC encryptor supports CENC, ISMA and Adobe encryption. It uses a DRM config file for declaring keys.  
The syntax is available at https://wiki.gpac.io/xmlformats/Common-Encryption  
The DRM config file can be set per PID using the property `CryptInfo`, or set at the filter level using [cfile](#cfile).  
When the DRM config file is set per PID, the first `CrypTrack` in the DRM config file with the same ID is used, otherwise the first `CrypTrack` is used (regardless of the `CrypTrack` ID).  
When the DRM config 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.  
If no DRM config file is defined for a given PID, this PID will not be encrypted, or an error will be thrown if [allc](#allc) is specified.
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="allc" data-level="basic">__allc__</a> (bool): throw error if no DRM config file is found for a PID  
</div>  
<div markdown class="option">  
<a id="bk_stats" data-level="basic">__bk_stats__</a> (bool): print number of encrypted blocks to stdout upon exit  
</div>
pipe input

Register name used to load filter: __pin__  
This filter may be automatically loaded during graph resolution.  
  
This filter handles generic input pipes (mono-directional) in blocking or non blocking mode.  

__Warning: Input pipes cannot seek.__  
  
Data format of the pipe may be specified using extension (either in file name or through [ext](#ext)) or MIME type through [mime](#mime).  
_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._
Named pipes

The filter can handle reading from named pipes. The associated protocol scheme is `pipe://` when loaded as a generic input (e.g. `-i pipe://URL` where URL is a relative or absolute pipe name).  
On Windows hosts, the default pipe prefix is `\\.\pipe\gpac\` if no prefix is set.  
`dst=mypipe` resolves in `\\.\pipe\gpac\mypipe`  
`dst=\\.\pipe\myapp\mypipe` resolves in `\\.\pipe\myapp\mypipe`  
Any destination name starting with `\\` is used as is, with `\` translated in `/`.  
  
Input pipes are created by default in non-blocking mode.  
  
The filter can create the pipe if not found using [mkp](#mkp). On windows hosts, this will create a pipe server.  
On non windows hosts, the created pipe will delete the pipe file upon filter destruction.  
    
Input pipes can be setup to run forever using [ka](#ka). In this case:  

- any potential pipe close on the writing side will be ignored  
- pipeline flushing will be triggered upon pipe close if [sigflush](#sigflush) is set  
- final end of stream will be triggered upon session close.  

    
This can be useful to pipe raw streams from different process into gpac:  

- Receiver side: `gpac -i pipe://mypipe:ext=.264:mkp:ka`  
- Sender side: `cat raw1.264 > mypipe && gpac -i raw2.264 -o pipe://mypipe:ext=.264`    

The pipeline flush is signaled as EOS while keeping the stream active.  
This is typically needed for mux filters waiting for EOS to flush their data.  
    
If [marker](#marker) is set, the following strings (all 8-bytes with ``
Options  {.no-collapse}

<div markdown class="option">  
<a id="src" data-level="basic">__src__</a> (cstr): name of source pipe  
</div>  
<div markdown class="option">  
<a id="block_size">__block_size__</a> (uint, default: _5000_): buffer size used to read pipe  
</div>  
<div markdown class="option">  
<a id="ext" data-level="basic">__ext__</a> (str): indicate file extension of pipe data  
</div>  
<div markdown class="option">  
<a id="mime" data-level="basic">__mime__</a> (str): indicate mime type of pipe data  
</div>  
<div markdown class="option">  
<a id="blk">__blk__</a> (bool, default: _false_): open pipe in block mode  
</div>  
<div markdown class="option">  
<a id="ka">__ka__</a> (bool, default: _false_): keep-alive pipe when end of input is detected  
</div>  
<div markdown class="option">  
<a id="mkp" data-level="basic">__mkp__</a> (bool, default: _false_): create pipe if not found  
</div>  
<div markdown class="option">  
<a id="sigflush">__sigflush__</a> (bool, default: _false_): signal end of stream upon pipe close - cf filter help  
</div>  
<div markdown class="option">  
<a id="marker">__marker__</a> (bool, default: _false_): inspect payload for flush and reconfigure signals - cf filter help  
</div>  
<div markdown class="option">  
<a id="bpcnt">__bpcnt__</a> (uint, default: _0_): number of broken pipe allowed before exiting, 0 means forever  
</div>  
<div markdown class="option">  
<a id="timeout">__timeout__</a> (uint, default: _0_): timeout in ms before considering input is in end of stream (0: no timeout)  
</div>
Tracks and Items

By default all input PIDs with ItemID property set are multiplexed as items, otherwise they are multiplexed as tracks.  
To prevent source items to be multiplexed as items, use [-itemid](mp4dmx/#itemid) option from ISOBMFF demultiplexer.  
Example
```
gpac -i source.mp4:itemid=false -o file.mp4
```
  
    
To force non-item streams to be multiplexed as items, use _#ItemID_ option on that PID:  
Example
```
gpac -i source.jpg:#ItemID=1 -o file.mp4
```
Storage

The [store](#store) option allows controlling if the file is fragmented or not, and when not fragmented, how interleaving is done. For cases where disk requirements are tight and fragmentation cannot be used, it is recommended to use either `flat` or `fstart` modes.  
    
The [vodcache](#vodcache) option allows controlling how DASH onDemand segments are generated:  

- If set to `on`, file data is stored to a temporary file on disk and flushed upon completion, no padding is present.  
- If set to `insert`, SIDX/SSIX will be injected upon completion of the file by shifting bytes in file. In this case, no padding is required but this might not be compatible with all output sinks and will take longer to write the file.  
- If set to `replace`, SIDX/SSIX size will be estimated based on duration and DASH segment length, and padding will be used in the file _before_ the final SIDX. If input PIDs have the properties `DSegs` set, this will used be as the number of segments.  

The `on` and `insert` modes will produce exactly the same file, while the mode `replace` may inject a `free` box before the sidx.
Custom boxes

Custom boxes can be specified as box patches:  
For movie-level patch, the [boxpatch](#boxpatch) option of the filter should be used.  
Per PID box patch can be specified through the PID property `boxpatch`.  
Example
```
gpac -i source:#boxpatch=myfile.xml -o mux.mp4
```
  
Per Item box patch can be specified through the PID property `boxpatch`.  
Example
```
gpac -i source:1ItemID=1:#boxpatch=myfile.xml -o mux.mp4
```
  
    
The box patch is applied before writing the initial `moov box in fragmented mode, or when writing the complete file otherwise.`  
The box patch can either be a filename or the full XML string.
Tagging

When tagging is enabled, the filter will watch the property `CoverArt` and all custom properties on incoming PID.  
The built-in tag names are indicated by `MP4Box -h tags`.  
QT tags can be specified using `qtt_NAME` property names, and will be added using formatting specified in `MP4Box -h tags`.  
Other tag class may be specified using `tag_NAME` property names, and will be added if [tags](#tags) is set to `all` using:  

- `NAME` as a box 4CC if `NAME` is four characters long  
- `NAME` as a box 4CC if `NAME` is 3 characters long, and will be prefixed by 0xA9  
- the CRC32 of the `NAME` as a box 4CC if `NAME` is not four characters long
User data

The filter will look for the following PID properties to create user data entries:  

- `udtab`: set the track user-data box to the property value which _must_ be a serialized box array blob  
- `mudtab`: set the movie user-data box to the property value which _must_ be a serialized box array blob  
- `udta_U4CC`: set track user-data box entry of type `U4CC` to property value  
- `mudta_U4CC`: set movie user-data box entry of type `U4CC` to property value  
- `tkgp_T4CC`: set/remove membership to track group with type `T4CC` and ID given by property value. A negative value N removes from track group with ID -N  

    
Example
```
gpac -i src.mp4:#udta_tagc='My Awesome Tag' -o tag.mp4  
gpac -i src.mp4:#mudtab=data@box.bin -o tag.mp4
```
Custom sample group descriptions and sample auxiliary info

The filter watches the following custom data properties on incoming packets:  

- `grp_A4CC`: maps packet to sample group description of type `A4CC` and entry set to property payload  
- `grp_A4CC_param`: same as above and sets sample to group `grouping_type_parameter` to `param`  
- `sai_A4CC`: adds property payload as sample auxiliary information of type `A4CC`  
- `sai_A4CC_param`: same as above and sets `aux_info_type_parameter`to `param`  

    
The property `grp_EMSG` consists in one or more `EventMessageBox` as defined in MPEG-DASH.  

- in fragmented mode, presence of this property in a packet will start a new fragment, with the boxes written before the `moof`  
- in regular mode, an internal sample group of type `EMSG` is currently used for `emsg` box storage
Notes

The filter watches the property `FileNumber` on incoming packets to create new files (regular mode) or new segments (DASH mode).  
    
The filter watches the property `DSIWrap` (4CC as int or string) on incoming PID to wrap decoder configuration in a box of given type (unknown wrapping)  
Example
```
-i unkn.mkv:#ISOMSubtype=VIUK:#DSIWrap=cfgv -o t.mp4
```
  
This will wrap the unknown stream using `VIUK` code point in `stsd` and wrap any decoder configuration data in a `cfgv` box.  
  
If [pad_sparse](#pad_sparse) is set, the filter watches the property `Sparse` on incoming PID to decide whether empty packets should be injected to keep packet duration info.  
Such packets are only injected when a whole in the timeline is detected.  

- if `Sparse` is absent, empty packet is inserted for unknown text and metadata streams  
- if `Sparse` is true, empty packet is inserted for all stream types  
- if `Sparse` is false, empty packet is never injected  

    
The default media type used for a PID can be overriden using property `StreamSubtype`.   
Example
```
-i src.srt:#StreamSubtype=sbtl [-i ...]  -o test.mp4 
```
  
This will force the text stream to use `sbtl` handler type instead of default `text` one.  
Subtitle streams may be used as chapters by setting the property `IsChap` on the desired PID.  
Example
```
-i src.srt:#IsChap  [-i ...] -o test.mp4 
```
  
This will force the text stream to be used as a QT chapter track.
Subtitle loader

Register name used to load filter: __txtin__  
This filter may be automatically loaded during graph resolution.  
  
This filter reads subtitle data from input PID to produce subtitle frames on a single PID.  
The filter supports the following formats:  

- SRT: https://en.wikipedia.org/wiki/SubRip  
- WebVTT: https://www.w3.org/TR/webvtt1/  
- TTXT: https://wiki.gpac.io/xmlformats/TTXT-Format-Documentation  
- QT 3GPP Text XML (TexML): Apple QT6, likely deprecated  
- TTML: https://www.w3.org/TR/ttml2/  
- SUB: one subtitle per line formatted as `{start_frame}{end_frame}text`  
- SSA (Substation Alpha): basic parsing support for common files  

  
Input files must be in UTF-8 or UTF-16 format, with or without BOM. The internal frame format is:   

- WebVTT (and srt if desired): ISO/IEC 14496-30 VTT cues  
- TTML: ISO/IEC 14496-30 XML subtitles  
- stxt and sbtt: ISO/IEC 14496-30 text stream and text subtitles  
- Others: 3GPP/QT Timed Text