Documentación de utilidades de FFmpeg

1 Descripción

Este documento describe algunas funciones y utilidades genéricas que ofrece la biblioteca libavutil.

2 Sintaxis

Esta sección documenta la sintaxis y los formatos que emplean las bibliotecas y herramientas de FFmpeg.

2.1 Comillado y escape

FFmpeg adopta el siguiente mecanismo de comillado y escape, salvo que se indique explícitamente lo contrario. Se aplican las siguientes reglas:

‘'’ y ‘\’ son caracteres especiales (se usan respectivamente para el comillado y el escape). Además de estos, puede haber otros caracteres especiales según la sintaxis concreta en la que se empleen el escape y el comillado.
Un carácter especial se escapa anteponiéndole una ‘\’.
Todos los caracteres incluidos entre ‘''’ se incorporan literalmente a la cadena analizada. El propio carácter de comilla ‘'’ no puede entrecomillarse, por lo que puede ser necesario cerrar las comillas y escaparlo.
Los espacios en blanco iniciales y finales, salvo que estén escapados o entrecomillados, se eliminan de la cadena analizada.

Tenga en cuenta que puede ser necesario añadir un segundo nivel de escape al usar la línea de comandos o un script, lo cual depende de la sintaxis del lenguaje de shell adoptado.

La función av_get_token, definida en libavutil/avstring.h, permite analizar un token entrecomillado o escapado conforme a las reglas definidas anteriormente.

La herramienta tools/ffescape, incluida en el árbol de fuentes de FFmpeg, permite entrecomillar o escapar automáticamente una cadena dentro de un script.

2.1.1 Ejemplos

Escapar la cadena Crime d'Amour, que contiene el carácter especial ':
```
Crime d\'Amour
```
La cadena anterior contiene una comilla, así que hay que escapar ' al entrecomillarla:
```
'Crime d'\''Amour'
```
Incluir espacios en blanco iniciales o finales mediante comillas:
```
'  this string starts and ends with whitespaces  '
```
El escape y el comillado pueden combinarse:
```
' The string '\'string\'' is a string '
```
Para incluir una ‘\’ literal, puede usarse tanto el escape como las comillas:
```
'c:\foo' can be written as c:\\foo
```

2.2 Fecha

La sintaxis aceptada es:

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

Si el valor es "now", se toma la hora actual.

La hora se interpreta como hora local, salvo que se añada Z, en cuyo caso se interpreta como UTC. Si no se especifica la parte de año-mes-día, se toma la fecha actual.

2.3 Duración temporal

Existen dos sintaxis aceptadas para expresar una duración temporal.

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

HH expresa el número de horas, MM el número de minutos con un máximo de 2 dígitos, y SS el número de segundos con un máximo de 2 dígitos. La m final expresa el valor decimal de SS.

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

S expresa el número de segundos, con la parte decimal opcional m. Los sufijos literales opcionales ‘s’, ‘ms’ o ‘us’ indican que el valor debe interpretarse como segundos, milisegundos o microsegundos, respectivamente.

En ambas expresiones, el ‘-’ opcional indica una duración negativa.

2.3.1 Ejemplos

Los siguientes son ejemplos válidos de duración temporal:

‘55’

55 segundos

‘0.2’

0.2 segundos

‘200ms’

200 milisegundos, es decir 0.2s

‘200000us’

200000 microsegundos, es decir 0.2s

‘12:03:45’

12 horas, 03 minutos y 45 segundos

‘23.189’

23.189 segundos

2.4 Tamaño de vídeo

Especifica el tamaño del vídeo de origen; puede ser una cadena con el formato widthxheight o el nombre de una abreviatura de tamaño.

Se reconocen las siguientes abreviaturas:

‘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 Velocidad de fotogramas

Especifica la velocidad de fotogramas de un vídeo, expresada como el número de fotogramas generados por segundo. Debe ser una cadena con el formato frame_rate_num/frame_rate_den, un número entero, un número de coma flotante o una abreviatura válida de velocidad de fotogramas.

Se reconocen las siguientes abreviaturas:

‘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 Relación

Una relación puede expresarse como una expresión o con el formato numerator:denominator.

Tenga en cuenta que una relación con valor infinito (1/0) o negativo se considera válida, por lo que conviene comprobar el valor devuelto si se desea excluir esos casos.

El valor indefinido puede expresarse con la cadena "0:0".

2.7 Color

Puede ser el nombre de un color de los definidos a continuación (sin distinguir mayúsculas y minúsculas) o una secuencia [0x|#]RRGGBB[AA], seguida opcionalmente de @ y una cadena que representa el componente alfa.

El componente alfa puede ser una cadena formada por "0x" seguido de un número hexadecimal, o un número decimal entre 0.0 y 1.0, que representa el valor de opacidad (‘0x00’ o ‘0.0’ significa totalmente transparente; ‘0xff’ o ‘1.0’, totalmente opaco). Si no se especifica el componente alfa, se asume ‘0xff’.

La cadena ‘random’ da como resultado un color aleatorio.

Se reconocen los siguientes nombres de colores:

‘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 Disposición de canales

Una disposición de canales especifica la ubicación espacial de los canales en un flujo de audio multicanal. Para especificarla, FFmpeg emplea una sintaxis especial.

Cada canal individual se identifica mediante un id, como se indica en la siguiente tabla:

‘FL’

frontal izquierdo

‘FR’

frontal derecho

‘FC’

frontal central

‘LFE’

baja frecuencia

‘BL’

trasero izquierdo

‘BR’

trasero derecho

‘FLC’

frontal centro-izquierdo

‘FRC’

frontal centro-derecho

‘BC’

trasero central

‘SL’

lateral izquierdo

‘SR’

lateral derecho

‘TC’

superior central

‘TFL’

superior frontal izquierdo

‘TFC’

superior frontal central

‘TFR’

superior frontal derecho

‘TBL’

superior trasero izquierdo

‘TBC’

superior trasero central

‘TBR’

superior trasero derecho

‘DL’

downmix izquierdo

‘DR’

downmix derecho

‘WL’

amplio izquierdo

‘WR’

amplio derecho

‘SDL’

surround directo izquierdo

‘SDR’

surround directo derecho

‘LFE2’

baja frecuencia 2

Las composiciones de disposición de canales estándar pueden especificarse mediante los siguientes identificadores:

‘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

Una disposición de canales personalizada puede especificarse como una secuencia de términos separados por ’+’. Cada término puede ser:

el nombre de un único canal (p. ej. ‘FL’, ‘FR’, ‘FC’, ‘LFE’, etc.), que opcionalmente puede incluir un nombre personalizado tras una ’@’ (p. ej. ‘FL@Left’, ‘FR@Right’, ‘FC@Center’, ‘LFE@Low_Frequency’, etc.)

Una disposición de canales estándar puede especificarse mediante lo siguiente:

el nombre de un único canal (p. ej. ‘FL’, ‘FR’, ‘FC’, ‘LFE’, etc.)
el nombre de una disposición de canales estándar (p. ej. ‘mono’, ‘stereo’, ‘4.0’, ‘quad’, ‘5.0’, etc.)
un número de canales, en decimal, seguido de ’c’, que produce la disposición de canales predeterminada para ese número de canales (véase la función av_channel_layout_default). Tenga en cuenta que no todos los números de canales tienen una disposición predeterminada.
un número de canales, en decimal, seguido de ’C’, que produce una disposición de canales desconocida con el número de canales especificado. Tenga en cuenta que no todas las cadenas de especificación de disposición de canales admiten disposiciones desconocidas.
una máscara de disposición de canales, en hexadecimal comenzando con "0x" (véanse las macros AV_CH_* en libavutil/channel_layout.h.

Antes de la versión 53 de libavutil, el carácter final "c" para especificar un número de canales era opcional, pero ahora es obligatorio; una máscara de disposición de canales también puede especificarse como un número decimal (si y solo si no va seguido de "c" o "C").

Véase también la función av_channel_layout_from_string, definida en libavutil/channel_layout.h.

3 Evaluación de expresiones

Al evaluar una expresión aritmética, FFmpeg utiliza un evaluador de fórmulas interno, implementado mediante la interfaz libavutil/eval.h.

Una expresión puede contener operadores unarios, operadores binarios, constantes y funciones.

Dos expresiones expr1 y expr2 pueden combinarse para formar otra expresión "expr1;expr2". expr1 y expr2 se evalúan por turno, y la nueva expresión toma el valor de expr2.

Están disponibles los siguientes operadores binarios: +, -, *, /, ^.

Están disponibles los siguientes operadores unarios: +, -.

Se pueden usar algunas variables internas para almacenar y cargar resultados intermedios. Se accede a ellas mediante las funciones ld y st con un argumento de índice, entre 0 y 9, que especifica a qué variable interna se accede.

Están disponibles las siguientes funciones:

abs(x)

Calcula el valor absoluto de x.

acos(x)

Calcula el arcocoseno de x.

asin(x)

Calcula el arcoseno de x.

atan(x)

Calcula la arcotangente de x.

atan2(y, x)

Calcula el valor principal de la arcotangente de y/x.

between(x, min, max)

Devuelve 1 si x es mayor o igual que min y menor o igual que max, y 0 en caso contrario.

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

Calcula la operación bit a bit AND/OR entre x e y.

Los resultados de evaluar x e y se convierten a enteros antes de ejecutar la operación bit a bit.

Tenga en cuenta que tanto la conversión a entero como la conversión de vuelta a coma flotante pueden perder precisión. Tenga cuidado con resultados inesperados en números grandes (normalmente a partir de 2^53).

ceil(expr)

Redondea el valor de la expresión expr hacia arriba al entero más cercano. Por ejemplo, "ceil(1.5)" es "2.0".

clip(x, min, max)

Devuelve el valor de x limitado entre min y max.

cos(x)

Calcula el coseno de x.

cosh(x)

Calcula el coseno hiperbólico de x.

eq(x, y)

Devuelve 1 si x e y son equivalentes, y 0 en caso contrario.

exp(x)

Calcula la exponencial de x (con base e, el número de Euler).

floor(expr)

Redondea el valor de la expresión expr hacia abajo al entero más cercano. Por ejemplo, "floor(-1.5)" es "-2.0".

gauss(x)

Calcula la función gaussiana de x, correspondiente a exp(-x*x/2) / sqrt(2*PI).

gcd(x, y)

Devuelve el máximo común divisor de x e y. Si x e y son ambos 0, o si uno o los dos son negativos, el comportamiento no está definido.

gt(x, y)

Devuelve 1 si x es mayor que y, y 0 en caso contrario.

gte(x, y)

Devuelve 1 si x es mayor o igual que y, y 0 en caso contrario.

hypot(x, y)

Esta función es similar a la función C del mismo nombre; devuelve "sqrt(xx + yy)", la longitud de la hipotenusa de un triángulo rectángulo con catetos de longitud x e y, o la distancia del punto (x, y) al origen.

if(x, y)

Evalúa x, y si el resultado es distinto de cero, devuelve el resultado de evaluar y; en caso contrario, devuelve 0.

if(x, y, z)

Evalúa x, y si el resultado es distinto de cero, devuelve el resultado de evaluar y; en caso contrario, el de evaluar z.

ifnot(x, y)

Evalúa x, y si el resultado es cero, devuelve el resultado de evaluar y; en caso contrario, devuelve 0.

ifnot(x, y, z)

Evalúa x, y si el resultado es cero, devuelve el resultado de evaluar y; en caso contrario, el de evaluar z.

isinf(x)

Devuelve 1.0 si x es +/-INFINITY, y 0.0 en caso contrario.

isnan(x)

Devuelve 1.0 si x es NAN, y 0.0 en caso contrario.

ld(idx)

Carga el valor de la variable interna con índice idx, previamente almacenado con st(idx, expr). La función devuelve el valor cargado.

lerp(x, y, z)

Devuelve la interpolación lineal entre x e y según la proporción z.

log(x)

Calcula el logaritmo natural de x.

lt(x, y)

Devuelve 1 si x es menor que y, y 0 en caso contrario.

lte(x, y)

Devuelve 1 si x es menor o igual que y, y 0 en caso contrario.

max(x, y)

Devuelve el máximo entre x e y.

min(x, y)

Devuelve el mínimo entre x e y.

mod(x, y)

Calcula el resto de la división de x entre y.

not(expr)

Devuelve 1.0 si expr es cero, y 0.0 en caso contrario.

pow(x, y)

Calcula x elevado a la potencia y; equivale a "(x)^(y)".

print(t) print(t, l)

Imprime el valor de la expresión t con el nivel de registro l. Si no se especifica l, se usa un nivel de registro predeterminado. Devuelve el valor de la expresión impresa.

random(idx)

Devuelve un valor pseudoaleatorio entre 0.0 y 1.0. idx es el índice de la variable interna usada para guardar la semilla/estado, que puede haberse almacenado previamente con st(idx).

Para inicializar la semilla, hay que almacenar su valor como un entero sin signo de 64 bits en la variable interna con índice idx.

Por ejemplo, para almacenar la semilla con valor 42 en la variable interna con índice 0 e imprimir algunos valores aleatorios:

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

randomi(idx, min, max)

Devuelve un valor pseudoaleatorio en el intervalo entre min y max. idx es el índice de la variable interna que se usará para guardar la semilla/estado, que puede haberse almacenado previamente con st(idx).

Para inicializar la semilla, hay que almacenar su valor como un entero sin signo de 64 bits en la variable interna con índice idx.

root(expr, max)

Busca un valor de entrada para el cual la función representada por expr, con argumento ld(0), sea 0 en el intervalo 0..max.

La expresión expr debe representar una función continua; de lo contrario, el resultado no está definido.

ld(0) se usa para representar el valor de entrada de la función, lo que significa que la expresión dada se evaluará varias veces con distintos valores de entrada, accesibles mediante ld(0). Cuando la expresión se evalúa a 0, se devuelve el valor de entrada correspondiente.

round(expr)

Redondea el valor de la expresión expr al entero más cercano. Por ejemplo, "round(1.5)" es "2.0".

sgn(x)

Calcula el signo de x.

sin(x)

Calcula el seno de x.

sinh(x)

Calcula el seno hiperbólico de x.

sqrt(expr)

Calcula la raíz cuadrada de expr. Equivale a "(expr)^.5".

squish(x)

Calcula la expresión 1/(1 + exp(4*x)).

st(idx, expr)

Almacena el valor de la expresión expr en una variable interna. idx especifica el índice de la variable donde se guarda el valor, con un rango de 0 a 9. La función devuelve el valor almacenado en la variable interna.

El valor almacenado puede recuperarse con ld(var).

Nota: actualmente las variables no se comparten entre expresiones.

tan(x)

Calcula la tangente de x.

tanh(x)

Calcula la tangente hiperbólica de x.

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

Evalúa una serie de Taylor en x, dada una expresión que representa la derivada ld(idx)-ésima de una función en 0.

Cuando la serie no converge, el resultado no está definido.

ld(idx) se usa para representar el orden de la derivada en expr, lo que significa que la expresión dada se evaluará varias veces con distintos valores de entrada, accesibles mediante ld(idx). Si no se especifica idx, se asume 0.

Tenga en cuenta que, cuando las derivadas están en y en lugar de 0, puede usarse taylor(expr, x-y).

time(0)

Devuelve la hora actual (de reloj) en segundos.

trunc(expr)

Redondea el valor de la expresión expr hacia cero al entero más cercano. Por ejemplo, "trunc(-1.5)" es "-1.0".

while(cond, expr)

Evalúa la expresión expr mientras la expresión cond sea distinta de cero, y devuelve el valor de la última evaluación de expr, o NAN si cond fue siempre falsa.

Están disponibles las siguientes constantes:

área del disco unitario, aproximadamente 3.14

exp(1) (el número de Euler), aproximadamente 2.718

PHI

razón áurea (1+sqrt(5))/2, aproximadamente 1.618

Suponiendo que una expresión se considera "verdadera" si tiene un valor distinto de cero, tenga en cuenta que:

* funciona como AND

+ funciona como OR

Por ejemplo, la construcción:

if (A AND B) then C

es equivalente a:

if(A*B, C)

En su código C, puede ampliar la lista de funciones unarias y binarias, y definir constantes reconocidas, para que estén disponibles en sus expresiones.

El evaluador también reconoce los prefijos de unidades del Sistema Internacional. Si se añade ’i’ tras el prefijo, se usan prefijos binarios, basados en potencias de 1024 en lugar de potencias de 1000. El sufijo ’B’ multiplica el valor por 8, y puede añadirse tras un prefijo de unidad o usarse solo. Esto permite usar, por ejemplo, ’KB’, ’MiB’, ’G’ y ’B’ como sufijo numérico.

A continuación se muestra la lista de prefijos del Sistema Internacional disponibles, con indicación de las potencias correspondientes de 10 y de 2.

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 Véase también

ffmpeg, ffplay, ffprobe, libavutil

5 Autores

Los desarrolladores de FFmpeg.

Para más detalles sobre la autoría, consulte el historial Git del proyecto (https://git.ffmpeg.org/ffmpeg), por ejemplo ejecutando el comando git log en el directorio fuente de FFmpeg, o visitando el repositorio en línea en https://git.ffmpeg.org/ffmpeg.

Los mantenedores de los componentes específicos figuran en el archivo MAINTAINERS del árbol de código fuente.

Alojamiento proporcionado por telepoint.bg