Documentação de utilitários do FFmpeg

1 Descrição

Este documento descreve alguns recursos e utilitários genéricos oferecidos pela biblioteca libavutil.

2 Sintaxe

Esta seção documenta a sintaxe e os formatos empregados pelas bibliotecas e ferramentas do FFmpeg.

2.1 Aspas e escape

O FFmpeg adota o seguinte mecanismo de aspas e escape, salvo indicação explícita em contrário. Aplicam-se as seguintes regras:

‘'’ e ‘\’ são caracteres especiais (usados, respectivamente, para aspas e escape). Além deles, pode haver outros caracteres especiais, dependendo da sintaxe específica em que o escape e as aspas são empregados.
Um caractere especial é escapado prefixando-o com um ‘\’.
Todos os caracteres entre ‘''’ são incluídos literalmente na string analisada. O próprio caractere de aspas ‘'’ não pode ser colocado entre aspas, portanto pode ser necessário fechar as aspas e escapá-lo.
Os espaços em branco no início e no fim, salvo se escapados ou entre aspas, são removidos da string analisada.

Observe que pode ser necessário adicionar um segundo nível de escape ao usar a linha de comando ou um script, o que depende da sintaxe da linguagem de shell adotada.

A função av_get_token, definida em libavutil/avstring.h, pode ser usada para analisar um token entre aspas ou escapado de acordo com as regras definidas acima.

A ferramenta tools/ffescape, presente na árvore de código-fonte do FFmpeg, pode ser usada para colocar entre aspas ou escapar automaticamente uma string em um script.

2.1.1 Exemplos

Escape a string Crime d'Amour, que contém o caractere especial ':
```
Crime d\'Amour
```
A string acima contém uma aspa, portanto o ' precisa ser escapado ao colocá-la entre aspas:
```
'Crime d'\''Amour'
```
Inclua espaços em branco no início ou no fim usando aspas:
```
'  this string starts and ends with whitespaces  '
```

O escape e as aspas podem ser combinados:

' The string '\'string\'' is a string '

Para incluir um ‘\’ literal, você pode usar tanto o escape quanto as aspas:
```
'c:\foo' can be written as c:\\foo
```

2.2 Data

A sintaxe aceita é:

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

Se o valor for "now", é usado o horário atual.

O horário é interpretado como horário local, a menos que Z seja acrescentado, caso em que é interpretado como UTC. Se a parte ano-mês-dia não for especificada, é usada a data atual.

2.3 Duração de tempo

Há duas sintaxes aceitas para expressar duração de tempo.

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

HH expressa o número de horas, MM o número de minutos, com no máximo 2 dígitos, e SS o número de segundos, com no máximo 2 dígitos. O m no final expressa o valor decimal de SS.

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

S expressa o número de segundos, com a parte decimal opcional m. Os sufixos literais opcionais ‘s’, ‘ms’ ou ‘us’ indicam que o valor deve ser interpretado como segundos, milissegundos ou microssegundos, respectivamente.

Em ambas as expressões, o ‘-’ opcional indica duração negativa.

2.3.1 Exemplos

Os exemplos a seguir são todos durações de tempo válidas:

‘55’

55 segundos

‘0.2’

0.2 segundos

‘200ms’

200 milissegundos, ou seja, 0.2s

‘200000us’

200000 microssegundos, ou seja, 0.2s

‘12:03:45’

12 horas, 03 minutos e 45 segundos

‘23.189’

23.189 segundos

2.4 Tamanho de vídeo

Especifica o tamanho do vídeo de origem; pode ser uma string no formato widthxheight ou o nome de uma abreviação de tamanho.

São reconhecidas as seguintes abreviações:

‘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 Taxa de quadros

Especifica a taxa de quadros de um vídeo, expressa como o número de quadros gerados por segundo. Deve ser uma string no formato frame_rate_num/frame_rate_den, um número inteiro, um número de ponto flutuante ou uma abreviação válida de taxa de quadros de vídeo.

São reconhecidas as seguintes abreviações:

‘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 Razão

Uma razão pode ser expressa como uma expressão ou no formato numerator:denominator.

Observe que uma razão com valor infinito (1/0) ou negativo é considerada válida; portanto, é preciso verificar o valor retornado caso se deseje excluir esses valores.

O valor indefinido pode ser expresso usando a string "0:0".

2.7 Cor

Pode ser o nome de uma cor conforme definido abaixo (correspondência sem diferenciar maiúsculas de minúsculas) ou uma sequência [0x|#]RRGGBB[AA], possivelmente seguida de @ e uma string que representa o componente alfa.

O componente alfa pode ser uma string composta por "0x" seguido de um número hexadecimal, ou um número decimal entre 0.0 e 1.0, que representa o valor de opacidade (‘0x00’ ou ‘0.0’ significa totalmente transparente; ‘0xff’ ou ‘1.0’, totalmente opaco). Se o componente alfa não for especificado, assume-se ‘0xff’.

A string ‘random’ resulta em uma cor aleatória.

São reconhecidos os seguintes nomes de cores:

‘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 Layout de canais

Um layout de canais especifica a disposição espacial dos canais em um fluxo de áudio multicanal. Para especificar um layout de canais, o FFmpeg usa uma sintaxe especial.

Cada canal individual é identificado por um id, conforme indicado na tabela abaixo:

‘FL’

frontal esquerdo

‘FR’

frontal direito

‘FC’

frontal central

‘LFE’

baixa frequência

‘BL’

traseiro esquerdo

‘BR’

traseiro direito

‘FLC’

frontal centro-esquerdo

‘FRC’

frontal centro-direito

‘BC’

traseiro central

‘SL’

lateral esquerdo

‘SR’

lateral direito

‘TC’

superior central

‘TFL’

superior frontal esquerdo

‘TFC’

superior frontal central

‘TFR’

superior frontal direito

‘TBL’

superior traseiro esquerdo

‘TBC’

superior traseiro central

‘TBR’

superior traseiro direito

‘DL’

downmix esquerdo

‘DR’

downmix direito

‘WL’

largo esquerdo

‘WR’

largo direito

‘SDL’

surround direto esquerdo

‘SDR’

surround direto direito

‘LFE2’

baixa frequência 2

As composições de layout de canais padrão podem ser especificadas usando os seguintes 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

Um layout de canais personalizado pode ser especificado como uma sequência de termos, separados por ’+’. Cada termo pode ser:

o nome de um único canal (por exemplo, ‘FL’, ‘FR’, ‘FC’, ‘LFE’ etc.), cada um podendo opcionalmente conter um nome personalizado após um ’@’, (por exemplo, ‘FL@Left’, ‘FR@Right’, ‘FC@Center’, ‘LFE@Low_Frequency’ etc.)

Um layout de canais padrão pode ser especificado pelo seguinte:

o nome de um único canal (por exemplo, ‘FL’, ‘FR’, ‘FC’, ‘LFE’ etc.)
o nome de um layout de canais padrão (por exemplo, ‘mono’, ‘stereo’, ‘4.0’, ‘quad’, ‘5.0’ etc.)
um número de canais, em decimal, seguido de ’c’, produzindo o layout de canais padrão para esse número de canais (consulte a função av_channel_layout_default). Observe que nem todas as contagens de canais têm um layout padrão.
um número de canais, em decimal, seguido de ’C’, produzindo um layout de canais desconhecido com o número de canais especificado. Observe que nem todas as strings de especificação de layout de canais admitem layouts desconhecidos.
uma máscara de layout de canais, em hexadecimal começando com "0x" (consulte as macros AV_CH_* em libavutil/channel_layout.h.

Antes da versão 53 da libavutil, o caractere final "c" para especificar um número de canais era opcional, mas agora é obrigatório, enquanto uma máscara de layout de canais também pode ser especificada como um número decimal (se e somente se não for seguida de "c" ou "C").

Consulte também a função av_channel_layout_from_string, definida em libavutil/channel_layout.h.

3 Avaliação de expressões

Ao avaliar uma expressão aritmética, o FFmpeg usa um avaliador de fórmulas interno, implementado por meio da interface libavutil/eval.h.

Uma expressão pode conter operadores unários, operadores binários, constantes e funções.

Duas expressões expr1 e expr2 podem ser combinadas para formar outra expressão "expr1;expr2". expr1 e expr2 são avaliadas em sequência, e a nova expressão assume o valor de expr2.

Os seguintes operadores binários estão disponíveis: +, -, *, /, ^.

Os seguintes operadores unários estão disponíveis: +, -.

Algumas variáveis internas podem ser usadas para armazenar e carregar resultados intermediários. É possível acessá-las por meio das funções ld e st, com um argumento de índice variando de 0 a 9 para especificar qual variável interna acessar.

As seguintes funções estão disponíveis:

abs(x)

Calcula o valor absoluto de x.

acos(x)

Calcula o arco-cosseno de x.

asin(x)

Calcula o arco-seno de x.

atan(x)

Calcula o arco-tangente de x.

atan2(y, x)

Calcula o valor principal do arco-tangente de y/x.

between(x, min, max)

Retorna 1 se x for maior ou igual a min e menor ou igual a max, 0 caso contrário.

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

Calcula a operação bit a bit AND/OR entre x e y.

Os resultados da avaliação de x e y são convertidos em números inteiros antes de executar a operação bit a bit.

Observe que tanto a conversão para inteiro quanto a conversão de volta para ponto flutuante podem perder precisão. Tenha cuidado com resultados inesperados em números grandes (geralmente a partir de 2^53).

ceil(expr)

Arredonda o valor da expressão expr para cima, para o inteiro mais próximo. Por exemplo, "ceil(1.5)" é "2.0".

clip(x, min, max)

Retorna o valor de x limitado entre min e max.

cos(x)

Calcula o cosseno de x.

cosh(x)

Calcula o cosseno hiperbólico de x.

eq(x, y)

Retorna 1 se x e y forem equivalentes, 0 caso contrário.

exp(x)

Calcula a exponencial de x (com base e, o número de Euler).

floor(expr)

Arredonda o valor da expressão expr para baixo, para o inteiro mais próximo. Por exemplo, "floor(-1.5)" é "-2.0".

gauss(x)

Calcula a função gaussiana de x, correspondente a exp(-x*x/2) / sqrt(2*PI).

gcd(x, y)

Retorna o máximo divisor comum de x e y. Se x e y forem ambos 0, ou se um ou ambos forem menores que zero, o comportamento é indefinido.

gt(x, y)

Retorna 1 se x for maior que y, 0 caso contrário.

gte(x, y)

Retorna 1 se x for maior ou igual a y, 0 caso contrário.

hypot(x, y)

Esta função é semelhante à função C de mesmo nome; retorna "sqrt(xx + yy)", o comprimento da hipotenusa de um triângulo retângulo com catetos de comprimento x e y, ou a distância do ponto (x, y) até a origem.

if(x, y)

Avalia x e, se o resultado for diferente de zero, retorna o resultado da avaliação de y; caso contrário, retorna 0.

if(x, y, z)

Avalia x e, se o resultado for diferente de zero, retorna o resultado da avaliação de y; caso contrário, o resultado da avaliação de z.

ifnot(x, y)

Avalia x e, se o resultado for zero, retorna o resultado da avaliação de y; caso contrário, retorna 0.

ifnot(x, y, z)

Avalia x e, se o resultado for zero, retorna o resultado da avaliação de y; caso contrário, o resultado da avaliação de z.

isinf(x)

Retorna 1.0 se x for +/-INFINITY, 0.0 caso contrário.

isnan(x)

Retorna 1.0 se x for NAN, 0.0 caso contrário.

ld(idx)

Carrega o valor da variável interna com índice idx, previamente armazenado com st(idx, expr). A função retorna o valor carregado.

lerp(x, y, z)

Retorna a interpolação linear entre x e y pelo fator z.

log(x)

Calcula o logaritmo natural de x.

lt(x, y)

Retorna 1 se x for menor que y, 0 caso contrário.

lte(x, y)

Retorna 1 se x for menor ou igual a y, 0 caso contrário.

max(x, y)

Retorna o máximo entre x e y.

min(x, y)

Retorna o mínimo entre x e y.

mod(x, y)

Calcula o resto da divisão de x por y.

not(expr)

Retorna 1.0 se expr for zero, 0.0 caso contrário.

pow(x, y)

Calcula a potência de x elevado a y; equivale a "(x)^(y)".

print(t) print(t, l)

Imprime o valor da expressão t com o nível de log l. Se l não for especificado, é usado um nível de log padrão. Retorna o valor da expressão impressa.

random(idx)

Retorna um valor pseudoaleatório entre 0.0 e 1.0. idx é o índice da variável interna usada para salvar a semente/estado, que pode ser armazenada previamente com st(idx).

Para inicializar a semente, é necessário armazenar seu valor como um inteiro sem sinal de 64 bits na variável interna com índice idx.

Por exemplo, para armazenar a semente com valor 42 na variável interna com índice 0 e imprimir alguns valores aleatórios:

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

randomi(idx, min, max)

Retorna um valor pseudoaleatório no intervalo entre min e max. idx é o índice da variável interna que será usada para salvar a semente/estado, que pode ser armazenada previamente com st(idx).

Para inicializar a semente, é necessário armazenar seu valor como um inteiro sem sinal de 64 bits na variável interna com índice idx.

root(expr, max)

Encontra um valor de entrada para o qual a função representada por expr, com argumento ld(0), seja 0 no intervalo 0..max.

A expressão em expr deve representar uma função contínua; caso contrário, o resultado é indefinido.

ld(0) é usado para representar o valor de entrada da função, o que significa que a expressão fornecida será avaliada várias vezes com diferentes valores de entrada, acessíveis por meio de ld(0). Quando a expressão for avaliada como 0, o valor de entrada correspondente será retornado.

round(expr)

Arredonda o valor da expressão expr para o inteiro mais próximo. Por exemplo, "round(1.5)" é "2.0".

sgn(x)

Calcula o sinal de x.

sin(x)

Calcula o seno de x.

sinh(x)

Calcula o seno hiperbólico de x.

sqrt(expr)

Calcula a raiz quadrada de expr. Equivale a "(expr)^.5".

squish(x)

Calcula a expressão 1/(1 + exp(4*x)).

st(idx, expr)

Armazena o valor da expressão expr em uma variável interna. idx especifica o índice da variável em que o valor será armazenado, com um valor entre 0 e 9. A função retorna o valor armazenado na variável interna.

O valor armazenado pode ser recuperado com ld(var).

Observação: atualmente as variáveis não são compartilhadas entre expressões.

tan(x)

Calcula a tangente de x.

tanh(x)

Calcula a tangente hiperbólica de x.

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

Avalia uma série de Taylor em x, dada uma expressão que representa a ld(idx)-ésima derivada de uma função em 0.

Quando a série não converge, o resultado é indefinido.

ld(idx) é usado para representar a ordem da derivada em expr, o que significa que a expressão fornecida será avaliada várias vezes com diferentes valores de entrada, acessíveis por meio de ld(idx). Se idx não for especificado, assume-se 0.

Observação: quando as derivadas estiverem em y em vez de 0, pode-se usar taylor(expr, x-y).

time(0)

Retorna a hora atual (do relógio de parede) em segundos.

trunc(expr)

Arredonda o valor da expressão expr em direção a zero, para o inteiro mais próximo. Por exemplo, "trunc(-1.5)" é "-1.0".

while(cond, expr)

Avalia a expressão expr enquanto a expressão cond for diferente de zero, e retorna o valor da última avaliação de expr, ou NAN se cond sempre foi falsa.

As seguintes constantes estão disponíveis:

área do disco unitário, aproximadamente 3.14

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

PHI

razão áurea (1+sqrt(5))/2, aproximadamente 1.618

Considerando que uma expressão é tratada como "verdadeira" se tiver um valor diferente de zero, observe que:

* funciona como AND

+ funciona como OR

Por exemplo, a construção:

if (A AND B) then C

é equivalente a:

if(A*B, C)

No seu código C, é possível estender a lista de funções unárias e binárias, e definir constantes reconhecidas, para que fiquem disponíveis em suas expressões.

O avaliador também reconhece os prefixos de unidades do Sistema Internacional. Se ’i’ for anexado após o prefixo, são usados prefixos binários, baseados em potências de 1024 em vez de potências de 1000. O sufixo ’B’ multiplica o valor por 8, e pode ser anexado após um prefixo de unidade ou usado sozinho. Isso permite usar, por exemplo, ’KB’, ’MiB’, ’G’ e ’B’ como sufixo numérico.

A seguir está a lista dos prefixos do Sistema Internacional disponíveis, com indicação das potências correspondentes de 10 e 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 Veja também

ffmpeg, ffplay, ffprobe, libavutil

5 Autores

Os desenvolvedores do FFmpeg.

Para mais detalhes sobre a autoria, consulte o histórico Git do projeto (https://git.ffmpeg.org/ffmpeg), por exemplo executando o comando git log no diretório fonte do FFmpeg, ou navegando pelo repositório on-line em https://git.ffmpeg.org/ffmpeg.

Os mantenedores dos componentes específicos estão listados no arquivo MAINTAINERS na árvore de código-fonte.

Hospedagem fornecida por telepoint.bg