Documentation des utilitaires FFmpeg

1 Description

Ce document décrit quelques fonctionnalités et utilitaires génériques fournis par la bibliothèque libavutil.

2 Syntaxe

Cette section documente la syntaxe et les formats employés par les bibliothèques et outils FFmpeg.

2.1 Guillemets et échappement

Sauf indication contraire explicite, FFmpeg adopte le mécanisme de mise entre guillemets et d'échappement suivant. Les règles suivantes s'appliquent :

‘'’ et ‘\’ sont des caractères spéciaux (utilisés respectivement pour la mise entre guillemets et l'échappement). Outre ces deux caractères, il peut exister d'autres caractères spéciaux selon la syntaxe précise où l'échappement et la mise entre guillemets sont employés.
Un caractère spécial est échappé en le faisant précéder d'un ‘\’.
Tous les caractères placés entre ‘''’ sont inclus littéralement dans la chaîne analysée. Le caractère de guillemet ‘'’ ne peut pas lui-même être mis entre guillemets ; il peut donc être nécessaire de fermer les guillemets puis de l'échapper.
Les espaces en début et en fin de chaîne, sauf s'ils sont échappés ou mis entre guillemets, sont retirés de la chaîne analysée.

Notez qu'il peut être nécessaire d'ajouter un second niveau d'échappement lors de l'utilisation de la ligne de commande ou d'un script, ce qui dépend de la syntaxe du langage shell adopté.

La fonction av_get_token, définie dans libavutil/avstring.h, permet d'analyser un jeton mis entre guillemets ou échappé selon les règles définies ci-dessus.

L'outil tools/ffescape, présent dans l'arborescence des sources de FFmpeg, permet de mettre automatiquement entre guillemets ou d'échapper une chaîne dans un script.

2.1.1 Exemples

Échappez la chaîne Crime d'Amour contenant le caractère spécial ' :
```
Crime d\'Amour
```
La chaîne ci-dessus contient un guillemet simple, il faut donc échapper le ' lors de sa mise entre guillemets :
```
'Crime d'\''Amour'
```
Incluez des espaces de début ou de fin grâce à la mise entre guillemets :
```
'  this string starts and ends with whitespaces  '
```
L'échappement et la mise entre guillemets peuvent se combiner :
```
' The string '\'string\'' is a string '
```
Pour inclure un ‘\’ littéral, vous pouvez utiliser aussi bien l'échappement que la mise entre guillemets :
```
'c:\foo' can be written as c:\\foo
```

2.2 Date

La syntaxe acceptée est la suivante :

[(YYYY-MM-DD|YYYYMMDD)[T|t| ]]((HH:MM:SS[.m...]]])|(HHMMSS[.m...]]]))[Z]
now

Si la valeur est "now", l'heure actuelle est utilisée.

L'heure est locale sauf si Z est ajouté, auquel cas elle est interprétée comme UTC. Si la partie année-mois-jour n'est pas indiquée, l'année-mois-jour actuelle est utilisée.

2.3 Durée

Il existe deux syntaxes acceptées pour exprimer une durée.

[-][HH:]MM:SS[.m...]

HH exprime le nombre d'heures, MM le nombre de minutes sur 2 chiffres maximum, et SS le nombre de secondes sur 2 chiffres maximum. Le m final exprime la valeur décimale de SS.

[-]S+[.m...][s|ms|us]

S exprime le nombre de secondes, avec la partie décimale optionnelle m. Les suffixes littéraux facultatifs ‘s’, ‘ms’ ou ‘us’ indiquent que la valeur doit être interprétée respectivement en secondes, millisecondes ou microsecondes.

Dans les deux expressions, le ‘-’ facultatif indique une durée négative.

2.3.1 Exemples

Les exemples suivants sont tous des durées valides :

‘55’

55 secondes

‘0.2’

0.2 seconde

‘200ms’

200 millisecondes, soit 0.2s

‘200000us’

200000 microsecondes, soit 0.2s

‘12:03:45’

12 heures, 03 minutes et 45 secondes

‘23.189’

23.189 secondes

2.4 Taille vidéo

Indique la taille de la vidéo source ; il peut s'agir d'une chaîne de la forme widthxheight, ou du nom d'une abréviation de taille.

Les abréviations suivantes sont reconnues :

‘ntsc’

720x480

‘pal’

720x576

‘qntsc’

352x240

‘qpal’

352x288

‘sntsc’

640x480

‘spal’

768x576

‘film’

352x240

‘ntsc-film’

352x240

‘sqcif’

128x96

‘qcif’

176x144

‘cif’

352x288

‘4cif’

704x576

‘16cif’

1408x1152

‘qqvga’

160x120

‘qvga’

320x240

‘vga’

640x480

‘svga’

800x600

‘xga’

1024x768

‘uxga’

1600x1200

‘qxga’

2048x1536

‘sxga’

1280x1024

‘qsxga’

2560x2048

‘hsxga’

5120x4096

‘wvga’

852x480

‘wxga’

1366x768

‘wsxga’

1600x1024

‘wuxga’

1920x1200

‘woxga’

2560x1600

‘wqsxga’

3200x2048

‘wquxga’

3840x2400

‘whsxga’

6400x4096

‘whuxga’

7680x4800

‘cga’

320x200

‘ega’

640x350

‘hd480’

852x480

‘hd720’

1280x720

‘hd1080’

1920x1080

‘2k’

2048x1080

‘2kflat’

1998x1080

‘2kscope’

2048x858

‘4k’

4096x2160

‘4kflat’

3996x2160

‘4kscope’

4096x1716

‘nhd’

640x360

‘hqvga’

240x160

‘wqvga’

400x240

‘fwqvga’

432x240

‘hvga’

480x320

‘qhd’

960x540

‘2kdci’

2048x1080

‘4kdci’

4096x2160

‘uhd2160’

3840x2160

‘uhd4320’

7680x4320

2.5 Fréquence vidéo

Indique la fréquence d'images d'une vidéo, exprimée comme le nombre d'images générées par seconde. Il doit s'agir d'une chaîne au format frame_rate_num/frame_rate_den, d'un nombre entier, d'un nombre à virgule flottante ou d'une abréviation valide de fréquence d'images vidéo.

Les abréviations suivantes sont reconnues :

‘ntsc’

30000/1001

‘pal’

25/1

‘qntsc’

30000/1001

‘qpal’

25/1

‘sntsc’

30000/1001

‘spal’

25/1

‘film’

24/1

‘ntsc-film’

24000/1001

2.6 Rapport

Un rapport peut être exprimé sous la forme d'une expression, ou sous la forme numerator:denominator.

Notez qu'un rapport de valeur infinie (1/0) ou négative est considéré comme valide ; vérifiez donc la valeur renvoyée si vous souhaitez exclure ces valeurs.

La valeur indéfinie peut être exprimée à l'aide de la chaîne "0:0".

2.7 Couleur

Il peut s'agir du nom d'une couleur telle que définie ci-dessous (correspondance insensible à la casse) ou d'une séquence [0x|#]RRGGBB[AA], éventuellement suivie de @ et d'une chaîne représentant la composante alpha.

La composante alpha peut être une chaîne composée de "0x" suivi d'un nombre hexadécimal, ou d'un nombre décimal compris entre 0.0 et 1.0, qui représente la valeur d'opacité (‘0x00’ ou ‘0.0’ signifie totalement transparent, ‘0xff’ ou ‘1.0’ totalement opaque). Si la composante alpha n'est pas indiquée, ‘0xff’ est alors supposée.

La chaîne ‘random’ donne une couleur aléatoire.

Les noms de couleurs suivants sont reconnus :

‘AliceBlue’

0xF0F8FF

‘AntiqueWhite’

0xFAEBD7

‘Aqua’

0x00FFFF

‘Aquamarine’

0x7FFFD4

‘Azure’

0xF0FFFF

‘Beige’

0xF5F5DC

‘Bisque’

0xFFE4C4

‘Black’

0x000000

‘BlanchedAlmond’

0xFFEBCD

‘Blue’

0x0000FF

‘BlueViolet’

0x8A2BE2

‘Brown’

0xA52A2A

‘BurlyWood’

0xDEB887

‘CadetBlue’

0x5F9EA0

‘Chartreuse’

0x7FFF00

‘Chocolate’

0xD2691E

‘Coral’

0xFF7F50

‘CornflowerBlue’

0x6495ED

‘Cornsilk’

0xFFF8DC

‘Crimson’

0xDC143C

‘Cyan’

0x00FFFF

‘DarkBlue’

0x00008B

‘DarkCyan’

0x008B8B

‘DarkGoldenRod’

0xB8860B

‘DarkGray’

0xA9A9A9

‘DarkGreen’

0x006400

‘DarkKhaki’

0xBDB76B

‘DarkMagenta’

0x8B008B

‘DarkOliveGreen’

0x556B2F

‘Darkorange’

0xFF8C00

‘DarkOrchid’

0x9932CC

‘DarkRed’

0x8B0000

‘DarkSalmon’

0xE9967A

‘DarkSeaGreen’

0x8FBC8F

‘DarkSlateBlue’

0x483D8B

‘DarkSlateGray’

0x2F4F4F

‘DarkTurquoise’

0x00CED1

‘DarkViolet’

0x9400D3

‘DeepPink’

0xFF1493

‘DeepSkyBlue’

0x00BFFF

‘DimGray’

0x696969

‘DodgerBlue’

0x1E90FF

‘FireBrick’

0xB22222

‘FloralWhite’

0xFFFAF0

‘ForestGreen’

0x228B22

‘Fuchsia’

0xFF00FF

‘Gainsboro’

0xDCDCDC

‘GhostWhite’

0xF8F8FF

‘Gold’

0xFFD700

‘GoldenRod’

0xDAA520

‘Gray’

0x808080

‘Green’

0x008000

‘GreenYellow’

0xADFF2F

‘HoneyDew’

0xF0FFF0

‘HotPink’

0xFF69B4

‘IndianRed’

0xCD5C5C

‘Indigo’

0x4B0082

‘Ivory’

0xFFFFF0

‘Khaki’

0xF0E68C

‘Lavender’

0xE6E6FA

‘LavenderBlush’

0xFFF0F5

‘LawnGreen’

0x7CFC00

‘LemonChiffon’

0xFFFACD

‘LightBlue’

0xADD8E6

‘LightCoral’

0xF08080

‘LightCyan’

0xE0FFFF

‘LightGoldenRodYellow’

0xFAFAD2

‘LightGreen’

0x90EE90

‘LightGrey’

0xD3D3D3

‘LightPink’

0xFFB6C1

‘LightSalmon’

0xFFA07A

‘LightSeaGreen’

0x20B2AA

‘LightSkyBlue’

0x87CEFA

‘LightSlateGray’

0x778899

‘LightSteelBlue’

0xB0C4DE

‘LightYellow’

0xFFFFE0

‘Lime’

0x00FF00

‘LimeGreen’

0x32CD32

‘Linen’

0xFAF0E6

‘Magenta’

0xFF00FF

‘Maroon’

0x800000

‘MediumAquaMarine’

0x66CDAA

‘MediumBlue’

0x0000CD

‘MediumOrchid’

0xBA55D3

‘MediumPurple’

0x9370D8

‘MediumSeaGreen’

0x3CB371

‘MediumSlateBlue’

0x7B68EE

‘MediumSpringGreen’

0x00FA9A

‘MediumTurquoise’

0x48D1CC

‘MediumVioletRed’

0xC71585

‘MidnightBlue’

0x191970

‘MintCream’

0xF5FFFA

‘MistyRose’

0xFFE4E1

‘Moccasin’

0xFFE4B5

‘NavajoWhite’

0xFFDEAD

‘Navy’

0x000080

‘OldLace’

0xFDF5E6

‘Olive’

0x808000

‘OliveDrab’

0x6B8E23

‘Orange’

0xFFA500

‘OrangeRed’

0xFF4500

‘Orchid’

0xDA70D6

‘PaleGoldenRod’

0xEEE8AA

‘PaleGreen’

0x98FB98

‘PaleTurquoise’

0xAFEEEE

‘PaleVioletRed’

0xD87093

‘PapayaWhip’

0xFFEFD5

‘PeachPuff’

0xFFDAB9

‘Peru’

0xCD853F

‘Pink’

0xFFC0CB

‘Plum’

0xDDA0DD

‘PowderBlue’

0xB0E0E6

‘Purple’

0x800080

‘Red’

0xFF0000

‘RosyBrown’

0xBC8F8F

‘RoyalBlue’

0x4169E1

‘SaddleBrown’

0x8B4513

‘Salmon’

0xFA8072

‘SandyBrown’

0xF4A460

‘SeaGreen’

0x2E8B57

‘SeaShell’

0xFFF5EE

‘Sienna’

0xA0522D

‘Silver’

0xC0C0C0

‘SkyBlue’

0x87CEEB

‘SlateBlue’

0x6A5ACD

‘SlateGray’

0x708090

‘Snow’

0xFFFAFA

‘SpringGreen’

0x00FF7F

‘SteelBlue’

0x4682B4

‘Tan’

0xD2B48C

‘Teal’

0x008080

‘Thistle’

0xD8BFD8

‘Tomato’

0xFF6347

‘Turquoise’

0x40E0D0

‘Violet’

0xEE82EE

‘Wheat’

0xF5DEB3

‘White’

0xFFFFFF

‘WhiteSmoke’

0xF5F5F5

‘Yellow’

0xFFFF00

‘YellowGreen’

0x9ACD32

2.8 Disposition des canaux

Une disposition des canaux spécifie la disposition spatiale des canaux dans un flux audio multicanal. Pour spécifier une disposition des canaux, FFmpeg utilise une syntaxe spéciale.

Chaque canal individuel est identifié par un identifiant, comme indiqué dans le tableau ci-dessous :

‘FL’

avant gauche

‘FR’

avant droit

‘FC’

avant centre

‘LFE’

basse fréquence

‘BL’

arrière gauche

‘BR’

arrière droit

‘FLC’

avant centre-gauche

‘FRC’

avant centre-droit

‘BC’

arrière centre

‘SL’

latéral gauche

‘SR’

latéral droit

‘TC’

centre supérieur

‘TFL’

avant gauche supérieur

‘TFC’

avant centre supérieur

‘TFR’

avant droit supérieur

‘TBL’

arrière gauche supérieur

‘TBC’

arrière centre supérieur

‘TBR’

arrière droit supérieur

‘DL’

downmix gauche

‘DR’

downmix droit

‘WL’

large gauche

‘WR’

large droite

‘SDL’

surround direct gauche

‘SDR’

surround direct droite

‘LFE2’

basse fréquence 2

Les compositions de dispositions de canaux standard peuvent être spécifiées à l'aide des identifiants suivants :

‘mono’

‘stereo’

FL+FR

‘2.1’

FL+FR+LFE

‘3.0’

FL+FR+FC

‘3.0(back)’

FL+FR+BC

‘4.0’

FL+FR+FC+BC

‘quad’

FL+FR+BL+BR

‘quad(side)’

FL+FR+SL+SR

‘3.1’

FL+FR+FC+LFE

‘5.0’

FL+FR+FC+BL+BR

‘5.0(side)’

FL+FR+FC+SL+SR

‘4.1’

FL+FR+FC+LFE+BC

‘5.1’

FL+FR+FC+LFE+BL+BR

‘5.1(side)’

FL+FR+FC+LFE+SL+SR

‘6.0’

FL+FR+FC+BC+SL+SR

‘6.0(front)’

FL+FR+FLC+FRC+SL+SR

‘3.1.2’

FL+FR+FC+LFE+TFL+TFR

‘hexagonal’

FL+FR+FC+BL+BR+BC

‘6.1’

FL+FR+FC+LFE+BC+SL+SR

‘6.1’

FL+FR+FC+LFE+BL+BR+BC

‘6.1(front)’

FL+FR+LFE+FLC+FRC+SL+SR

‘7.0’

FL+FR+FC+BL+BR+SL+SR

‘7.0(front)’

FL+FR+FC+FLC+FRC+SL+SR

‘7.1’

FL+FR+FC+LFE+BL+BR+SL+SR

‘7.1(wide)’

FL+FR+FC+LFE+BL+BR+FLC+FRC

‘7.1(wide-side)’

FL+FR+FC+LFE+FLC+FRC+SL+SR

‘5.1.2’

FL+FR+FC+LFE+BL+BR+TFL+TFR

‘octagonal’

FL+FR+FC+BL+BR+BC+SL+SR

‘cube’

FL+FR+BL+BR+TFL+TFR+TBL+TBR

‘5.1.4’

FL+FR+FC+LFE+BL+BR+TFL+TFR+TBL+TBR

‘7.1.2’

FL+FR+FC+LFE+BL+BR+SL+SR+TFL+TFR

‘7.1.4’

FL+FR+FC+LFE+BL+BR+SL+SR+TFL+TFR+TBL+TBR

‘7.2.3’

FL+FR+FC+LFE+BL+BR+SL+SR+TFL+TFR+TBC+LFE2

‘9.1.4’

FL+FR+FC+LFE+BL+BR+FLC+FRC+SL+SR+TFL+TFR+TBL+TBR

‘9.1.6’

FL+FR+FC+LFE+BL+BR+FLC+FRC+SL+SR+TFL+TFR+TBL+TBR+TSL+TSR

‘hexadecagonal’

FL+FR+FC+BL+BR+BC+SL+SR+WL+WR+TBL+TBR+TBC+TFC+TFL+TFR

‘binaural’

BIL+BIR

‘downmix’

DL+DR

‘22.2’

FL+FR+FC+LFE+BL+BR+FLC+FRC+BC+SL+SR+TC+TFL+TFC+TFR+TBL+TBC+TBR+LFE2+TSL+TSR+BFC+BFL+BFR

Une disposition de canaux personnalisée peut être spécifiée comme une suite de termes séparés par ’+’. Chaque terme peut être :

le nom d'un canal unique (par exemple ‘FL’, ‘FR’, ‘FC’, ‘LFE’, etc.), chacun pouvant éventuellement comporter un nom personnalisé après un ’@’, (par exemple ‘FL@Left’, ‘FR@Right’, ‘FC@Center’, ‘LFE@Low_Frequency’, etc.)

Une disposition de canaux standard peut être spécifiée de l'une des façons suivantes :

le nom d'un canal unique (par exemple ‘FL’, ‘FR’, ‘FC’, ‘LFE’, etc.)
le nom d'une disposition de canaux standard (par exemple ‘mono’, ‘stereo’, ‘4.0’, ‘quad’, ‘5.0’, etc.)
un nombre de canaux, en décimal, suivi de ’c’, donnant la disposition de canaux par défaut pour ce nombre de canaux (voir la fonction av_channel_layout_default). Notez que tous les nombres de canaux n'ont pas de disposition par défaut.
un nombre de canaux, en décimal, suivi de ’C’, donnant une disposition de canaux inconnue avec le nombre de canaux spécifié. Notez que toutes les chaînes de spécification de disposition de canaux ne prennent pas en charge les dispositions inconnues.
un masque de disposition de canaux, en hexadécimal commençant par "0x" (voir les macros AV_CH_* dans libavutil/channel_layout.h.

Avant la version 53 de libavutil, le caractère final "c" pour spécifier un nombre de canaux était facultatif, mais il est désormais obligatoire ; un masque de disposition de canaux peut également être spécifié sous forme de nombre décimal (si et seulement si non suivi de "c" ou "C").

Voir aussi la fonction av_channel_layout_from_string définie dans libavutil/channel_layout.h.

3 Évaluation d'expressions

Lors de l'évaluation d'une expression arithmétique, FFmpeg utilise un évaluateur de formules interne, mis en œuvre via l'interface libavutil/eval.h.

Une expression peut contenir des opérateurs unaires, des opérateurs binaires, des constantes et des fonctions.

Deux expressions expr1 et expr2 peuvent être combinées pour former une autre expression "expr1;expr2". expr1 et expr2 sont évaluées l'une après l'autre, et la nouvelle expression prend la valeur de expr2.

Les opérateurs binaires disponibles sont : +, -, *, /, ^.

Les opérateurs unaires disponibles sont : +, -.

Quelques variables internes permettent de stocker et de charger des résultats intermédiaires. On y accède avec les fonctions ld et st, en précisant un index compris entre 0 et 9 pour indiquer la variable interne concernée.

Les fonctions disponibles sont les suivantes :

abs(x)

Calcule la valeur absolue de x.

acos(x)

Calcule l'arc cosinus de x.

asin(x)

Calcule l'arc sinus de x.

atan(x)

Calcule l'arc tangente de x.

atan2(y, x)

Calcule la valeur principale de l'arc tangente de y/x.

between(x, min, max)

Renvoie 1 si x est supérieur ou égal à min et inférieur ou égal à max, 0 sinon.

bitand(x, y) bitor(x, y)

Calcule l'opération bit à bit ET/OU sur x et y.

Les résultats de l'évaluation de x et de y sont convertis en entiers avant d'exécuter l'opération bit à bit.

Notez que la conversion en entier, comme la conversion inverse en virgule flottante, peut entraîner une perte de précision. Méfiez-vous des résultats inattendus pour les grands nombres (généralement à partir de 2^53).

ceil(expr)

Arrondit la valeur de l'expression expr à l'entier supérieur le plus proche. Par exemple, "ceil(1.5)" vaut "2.0".

clip(x, min, max)

Renvoie la valeur de x limitée entre min et max.

cos(x)

Calcule le cosinus de x.

cosh(x)

Calcule le cosinus hyperbolique de x.

eq(x, y)

Renvoie 1 si x et y sont égaux, 0 sinon.

exp(x)

Calcule l'exponentielle de x (en base e, le nombre d'Euler).

floor(expr)

Arrondit la valeur de l'expression expr à l'entier inférieur le plus proche. Par exemple, "floor(-1.5)" vaut "-2.0".

gauss(x)

Calcule la fonction de Gauss de x, correspondant à exp(-x*x/2) / sqrt(2*PI).

gcd(x, y)

Renvoie le plus grand commun diviseur de x et y. Si x et y valent tous deux 0, ou si l'un d'eux au moins est négatif, le comportement est indéfini.

gt(x, y)

Renvoie 1 si x est supérieur à y, 0 sinon.

gte(x, y)

Renvoie 1 si x est supérieur ou égal à y, 0 sinon.

hypot(x, y)

Cette fonction est semblable à la fonction C du même nom ; elle renvoie "sqrt(xx + yy)", la longueur de l'hypoténuse d'un triangle rectangle dont les côtés ont pour longueur x et y, ou encore la distance du point (x, y) à l'origine.

if(x, y)

Évalue x et, si le résultat est non nul, renvoie le résultat de l'évaluation de y ; sinon, renvoie 0.

if(x, y, z)

Évalue x et, si le résultat est non nul, renvoie le résultat de l'évaluation de y, sinon celui de z.

ifnot(x, y)

Évalue x et, si le résultat est nul, renvoie le résultat de l'évaluation de y ; sinon, renvoie 0.

ifnot(x, y, z)

Évalue x et, si le résultat est nul, renvoie le résultat de l'évaluation de y, sinon celui de z.

isinf(x)

Renvoie 1.0 si x vaut +/-INFINITY, 0.0 sinon.

isnan(x)

Renvoie 1.0 si x vaut NAN, 0.0 sinon.

ld(idx)

Charge la valeur de la variable interne d'index idx, préalablement enregistrée avec st(idx, expr). La fonction renvoie la valeur chargée.

lerp(x, y, z)

Renvoie l'interpolation linéaire entre x et y selon la proportion z.

log(x)

Calcule le logarithme naturel de x.

lt(x, y)

Renvoie 1 si x est inférieur à y, 0 sinon.

lte(x, y)

Renvoie 1 si x est inférieur ou égal à y, 0 sinon.

max(x, y)

Renvoie le maximum entre x et y.

min(x, y)

Renvoie le minimum entre x et y.

mod(x, y)

Calcule le reste de la division de x par y.

not(expr)

Renvoie 1.0 si expr est nul, 0.0 sinon.

pow(x, y)

Calcule x élevé à la puissance y ; équivaut à "(x)^(y)".

print(t) print(t, l)

Affiche la valeur de l'expression t avec le niveau de journalisation l. Si l n'est pas spécifié, un niveau de journalisation par défaut est utilisé. Renvoie la valeur de l'expression affichée.

random(idx)

Renvoie une valeur pseudo-aléatoire entre 0.0 et 1.0. idx est l'index de la variable interne utilisée pour enregistrer la graine ou l'état, qui peut avoir été préalablement stockée avec st(idx).

Pour initialiser la graine, vous devez stocker sa valeur sous forme d'entier non signé 64 bits dans la variable interne d'index idx.

Par exemple, pour stocker la graine de valeur 42 dans la variable interne d'index 0 et afficher quelques valeurs aléatoires :

st(0,42); print(random(0)); print(random(0)); print(random(0))

randomi(idx, min, max)

Renvoie une valeur pseudo-aléatoire dans l'intervalle entre min et max. idx est l'index de la variable interne utilisée pour enregistrer la graine ou l'état, qui peut avoir été préalablement stockée avec st(idx).

Pour initialiser la graine, vous devez stocker sa valeur sous forme d'entier non signé 64 bits dans la variable interne d'index idx.

root(expr, max)

Trouve une valeur d'entrée pour laquelle la fonction représentée par expr avec l'argument ld(0) vaut 0 dans l'intervalle 0..max.

L'expression expr doit représenter une fonction continue, sinon le résultat est indéfini.

ld(0) sert à représenter la valeur d'entrée de la fonction, ce qui signifie que l'expression donnée sera évaluée plusieurs fois avec différentes valeurs d'entrée, accessibles depuis l'expression via ld(0). Lorsque l'expression s'évalue à 0, la valeur d'entrée correspondante est renvoyée.

round(expr)

Arrondit la valeur de l'expression expr à l'entier le plus proche. Par exemple, "round(1.5)" vaut "2.0".

sgn(x)

Calcule le signe de x.

sin(x)

Calcule le sinus de x.

sinh(x)

Calcule le sinus hyperbolique de x.

sqrt(expr)

Calcule la racine carrée de expr. Équivaut à "(expr)^.5".

squish(x)

Calcule l'expression 1/(1 + exp(4*x)).

st(idx, expr)

Stocke la valeur de l'expression expr dans une variable interne. idx spécifie l'index de la variable où stocker la valeur ; c'est une valeur comprise entre 0 et 9. La fonction renvoie la valeur stockée dans la variable interne.

La valeur stockée peut être récupérée avec ld(var).

Remarque : les variables ne sont pas partagées entre les expressions pour l'instant.

tan(x)

Calcule la tangente de x.

tanh(x)

Calcule la tangente hyperbolique de x.

taylor(expr, x) taylor(expr, x, idx)

Évalue une série de Taylor en x, à partir d'une expression représentant la dérivée d'ordre ld(idx) d'une fonction en 0.

Si la série ne converge pas, le résultat est indéfini.

ld(idx) sert à représenter l'ordre de la dérivée dans expr, ce qui signifie que l'expression donnée sera évaluée plusieurs fois avec différentes valeurs d'entrée, accessibles depuis l'expression via ld(idx). Si idx n'est pas spécifié, 0 est utilisé par défaut.

À noter : si les dérivées sont données en y au lieu de 0, taylor(expr, x-y) peut être utilisé.

time(0)

Renvoie l'heure actuelle (horloge murale) en secondes.

trunc(expr)

Arrondit la valeur de l'expression expr vers zéro à l'entier le plus proche. Par exemple, "trunc(-1.5)" vaut "-1.0".

while(cond, expr)

Évalue l'expression expr tant que l'expression cond est non nulle, et renvoie la valeur de la dernière évaluation de expr, ou NAN si cond était toujours fausse.

Les constantes suivantes sont disponibles :

aire du disque unité, environ 3.14

exp(1) (nombre d'Euler), environ 2.718

PHI

nombre d'or (1+sqrt(5))/2, environ 1.618

En considérant qu'une expression est vraie ("true") si sa valeur est non nulle, notez que :

* fonctionne comme un ET

+ fonctionne comme un OU

Par exemple, la construction :

if (A AND B) then C

équivaut à :

if(A*B, C)

Dans votre code C, vous pouvez étendre la liste des fonctions unaires et binaires, et définir des constantes reconnues, afin de les rendre disponibles pour vos expressions.

L'évaluateur reconnaît également les préfixes d'unités du Système international. Si ’i’ est ajouté après le préfixe, des préfixes binaires sont utilisés, fondés sur des puissances de 1024 au lieu de puissances de 1000. Le suffixe ’B’ multiplie la valeur par 8 et peut être ajouté après un préfixe d'unité ou utilisé seul. Cela permet par exemple d'utiliser ’KB’, ’MiB’, ’G’ et ’B’ comme suffixe numérique.

La liste des préfixes du Système international disponibles suit, avec l'indication des puissances de 10 et de 2 correspondantes.

10^-24 / 2^-80

10^-21 / 2^-70

10^-18 / 2^-60

10^-15 / 2^-50

10^-12 / 2^-40

10^-9 / 2^-30

10^-6 / 2^-20

10^-3 / 2^-10

10^-2

10^-1

10^2

10^3 / 2^10

10^6 / 2^20

10^9 / 2^30

10^12 / 2^40

10^15 / 2^50

10^18 / 2^60

10^21 / 2^70

10^24 / 2^80

4 Voir aussi

ffmpeg, ffplay, ffprobe, libavutil

5 Auteurs

Les développeurs de FFmpeg.

Pour plus de détails sur les auteurs, consultez l'historique Git du projet (https://git.ffmpeg.org/ffmpeg), par exemple en tapant la commande git log dans le répertoire source de FFmpeg, ou en parcourant le dépôt en ligne à l'adresse https://git.ffmpeg.org/ffmpeg.

Les mainteneurs des différents composants sont répertoriés dans le fichier MAINTAINERS de l'arborescence des sources.

Hébergement fourni par telepoint.bg