Basicamente, AviSynth trabalha assim: Primeiro, você cria um documento de texto simples com comandos especiais, chamados scripts (escritos). Estes comandos fazem referências a um ou mais vídeos e os filtros que você deseja rodar neles. Então, você roda uma aplicação de vídeo, como o VirtualDub e abre o arquivo do escrito. Aqui é quando AviSynth entra em ação. Abre os vídeos que você referenciou no escrito, roda os filtros especificados e alimenta a produção para a aplicação de vídeo. Porém, a aplicação não está ciente que AviSynth está trabalhando no fundo. Ao invés, a aplicação pensa que está abrindo diretamente um arquivo de AVI filtrado que reside em seu disco rígido.
Há muita coisa nova e funcionalidade redescoberta em AviSynth2. Para fazer esses itens claramente visíveis (especialmente quando a característica não foi bem documentada no passado) eles são marcados com v2
A versão 2.5 é uma versão interna principal aperfeiçoada. Leia AviSynth 2.5 cuidadosamente antes de usar. Mudanças pertinentes são marcadas com v2.5
A coisa mais simples que você pode fazer com AviSynth é o tipo de edição que pode ser feito no VirtualDub. Os escritos para isto são fáceis de escrever porque não há com que se preocupar sobre variáveis e expressões complicadas, se não quiser.
Para testar crie um arquivo de nome test.avs e ponha uma linha com o seguinte texto:
Version
Agora abra este arquivo com o Windows Mídia Player, por exemplo e você deverá ver um clipe de vídeo de dez segundos mostrando o número da versão do AviSynth e uma notificação de protegido por direitos autorais.
Version
é
um filtro de fonte, significando que gera um clipe em vez de modificá-lo. O
primeiro comando em um escrito de AviSynth será sempre um filtro de fonte.
Agora
acrescente uma segunda linha ao arquivo do escrito, de forma a ler assim:
Version ReduceBy2
Você
deverá ver o aviso de protegido por direitos autorais novamente, mas agora com
a metade do tamanho de antes.
ReduceBy2
é
um “filtro de transformação” significando que pega o clipe e o modifica de
algum modo. Você pode encadear muitos filtros de transformação, como no
VirtualDub.
Vamos pôr um outro para fazer o vídeo desvanecer ao preto no fim. Acrescente
outra linha ao arquivo do escrito desta forma:
Version ReduceBy2 FadeOut(10)
Agora
reabra o arquivo. O clipe deverá ser o mesmo durante os primeiros 9 segundos e
no último segundo que deverá desvanecer suavemente ao preto.
O filtro FadeOut recebe
um argumento numérico que indica o número de quadros para desvanecer.
Leva
um tempo antes que o desvanecer comece, assim, aparemos o começo do clipe
para reduzir a espera e diminuir depois disso.
Descartemos os primeiros 120 deles e mantenhamos os quadros 120-150:
Version
ReduceBy2
Trim(120,150) # corte fora os primeiros 119 quadros e mantenha os quadros 120-150 (AviSynth começa numerando os quadros de 0)FadeOut(10)
Neste
exemplo usamos um comentário pela primeira vez.
Os comentários
começam com o caractere # e continuam até o fim da linha e são completamente ignorados por AviSynth.
O filtro Trim recebe dois argumentos, separados por uma vírgula: o primeiro e o último quadro para manter o do clipe. Se você pôs 0 para o último quadro, é igual ao fim do clipe, assim se quer remover só os primeiros 119 quadros, deve usar Trim(120,0).
Ficar atento ao número de quadros é uma obrigação. É muito mais fácil abrir um escrito parcialmente completo em uma aplicação como o VirtualDub, que exibirá o número de quadro. Você também pode usar o filtro ShowFrameNumber, que imprime o número de cada quadro em si mesmo
Na
prática, um filtro de fonte muito mais útil que Version
é o AVISource
que lê num arquivo AVI (ou um de vários outros tipos de arquivos) do disco. Se
você tiver um AVI à mão, pode tentar aplicando estes mesmos filtros a seu
arquivo:
AVISource("d:\capture.avi") # ou qualquer outro nome de caminho atual
ReduceBy2
FadeOut(15)
Trim(120,0)
Até
mesmo um escrito de uma linha que contém só o comando AVISource pode ser útil
para dar suporte a arquivos AVI >2GB em aplicações que só suportam <
2GB.
Vamos à parte divertida. Faça um arquivo AVS com este escrito:
StackVertical(Version, Version)
Agora
abra-o. Resultado: Um vídeo com duas linhas idênticas de informação da versão,
um em cima do outro.
Em
vez de ter números ou strings como
argumentos, StackVertical
pega clipes de vídeo como argumentos. Neste escrito, o filtro Version
está sendo chamado duas vezes. A cada vez, retorna uma cópia da versão
do clipe. Estes dois clipes são passados então a StackVertical
que os une (sem saber de onde vieram).
Um dos filtros mais úteis deste tipo é UnalignedSplice que une os clipes de vídeo. Aqui um escrito que carrega três arquivos AVI (como poderia ser produzido por AVI_IO) e os concatena juntos.
UnalignedSplice(AVISource("d:\capture.00.avi"), AVISource("d:\capture.01.avi"), AVISource("d:\capture.02.avi"))
StackVertical
e UnalignedSplice tanto
podem ter dois argumentos como sessenta.
Você pode usar o operador + como uma taquigrafia para UnalignedSplice.
Por exemplo, este escrito faz a mesma coisa que o exemplo anterior:
AVISource("d:\capture.00.avi") + AVISource("d:\capture.01.avi") + AVISource("d:\capture.02.avi")
Agora
vamos supor que você está capturando com uma aplicação que também salva o vídeo
em múltiplos segmentos AVI, mas põe o áudio em um arquivo WAV separado.
Podemos combinar tudo? Você apostou:
AudioDub(AVISource("d:\capture.00.avi")+AVISource("d:\capture.01.avi")+AVISource("d:\capture.02.avi"), WAVSource("d:\audio.wav"))
Um script AviSynth consiste de muitas linhas de declarações como esta:
variable_name = expression
Neste exemplo expression é avaliada e o resultado é atribuído à variable_name.
Muito importante é a forma de atalho comum :
expression
Neste caso, expression é avaliada e o resultado
é atribuído à variável especial last do clipe.
E é o mesmo que:
last = expression
O fim do escrito sempre se parece com:
return expression
Aqui expression é avaliada e usada como return value, valor de retôrno do escrito - quer dizer, o clipe de vídeo será visto pela aplicação que abre o arquivo AVS.
A forma básica de uma expressão que invoca uma função éFunction(args)
As funções Clip sempre produzem um novo clipe de vídeo e nunca modificam o existente, Args é uma lista de argumentos de função separada por vírgulas. A lista pode estar vazia (significa que tudo ou alguns argumentos podem ser opcionais)
Se a função do filtro espera um clipe de vídeo como seu primeiro argumento e ele não é fornecido, então o clipe na variável especial last
O
filtro
do AviSynth pode ter argumentos nomeados. Eles podem ser especificados em qualquer
ordem e escolherá valores padrões para os que você não o fez
(argumentos nomeados são sempre opcionais).
Isto faz certos filtros muito mais fácil de usar.
Você pode escrever: Subtitle("Alô, Mundo!", text_color=$00FF00, x=100, y=200) em vez de Subtitle("Alô, Mundo!", 100, 200, 0, 999999, "Arial", 24, $00FF00)
Uma sintaxe alternada (chamada "OOP notation") para funções de clip é
expression.Function(args) exemplo: Version.ReduceBy2.FadeOut(15)
E é equivalente a
Function(expression, args) exemplo: FadeOut(15, ReduceBy2(Version))
e pode ser lembrado que Function
é aplicado a expression
.
Uma
desvantagem da notação OOP é que só pode ser usada com filtros que tenham um
só argumento de clipe de vídeo, não com filtros que tenham vários.
Todas
as funções AviSynth produzem número de quadros e taxas definidos, até
mesmo se a declaração parecer muito complexa.
AviSynth
sabe depois de ter lido o escrito qual será o tamanho do arquivo, quais taxas
de quadro tem e a sucessão de cortes de todas as entradas usadas.
Isto tudo
é calculado ao abrir o escrito. Só o filtro atual é executado em tempo
real na solicitação.
Comentários: AviSynth ignora tudo após um caractere # até o fim dessa linha.
Ignorar Caso: aViSouRCe é tão bom quanto AVISource.
Continue à próxima ou da linha anterior: \
Subtitle ("Test-Text") Subtitle ( \ "Test-Text") Subtitle ( \ "Test-Text")
Um nome variável pode ter até 50 caracteres e conter letras, dígitos, e sublinhes (_), mas nenhum outro caractere. O nome não pode começar com um dígito.
Podem ser usados os seguintes tipos de variáveis:
clip:
um clipe de vídeo que contém vídeo e / ou áudio.
Pelo
menos uma variável deve ser usada para um clipe e deve ser retornada pelo
escrito.
string: cercado
por aspas ou por 3 aspas como """este exemplo""".
Uma string de texto pode conter qualquer caractere menos as aspas ou apóstrofe
duplo. Se você precisar pôr aspas na frase, use a notação tripla:
Subtitle ("""Isto exibe "alô mundo" com aspas""")
int: entrado como uma string de dígitos, opcionalmente com um +
ou - no início.
float: entrado como uma string de dígitos com um ponto (.) em
algum lugar e opcionalmente com um + ou -. Por exemplo, +1. é tratado como um
número de ponto flutuante.
val: como
tipo de um argumento de função onde não importa se é int
ou flutuante
bool: pode ser TRUE ou FALSE
hexadecimal numbers: entrado precedendo um $. Esta variável é
tratada como inteiro. Vários filtros usam esta notação para especificar cores.
Por exemplo, $FF8800 é uma sombra laranja.
global: define uma variável global, que pode ser usada por todas as funções definidas pelo usuário e no script principal em comum.
Aqui outra versão do exemplo acima, mais controlável e fácil de entender:
a = AVISource("d:\capture.00.avi") b = AVISource("d:\capture.01.avi") c = AVISource("d:\capture.02.avi") sound_track = WAVSource("d:\audio.wav") AudioDub(a+b+c, sound_track)
Para todos os tipos de operandos (clip, int, float, string, bool) você pode
usar:
==
is equal
!=
not equal
||
or
&&
and
Para tipos numéricos (int, flut):
+
somar
-
subtrair
*
multiplicar
/
dividir
%
mod
>=
maior ou igual a
<=
menor ou igual a
<
menor que
>
maior que
AviSynth em versões anteriores analisou expressões da direita para a esquerda que deu resultados inesperados: a = 10 - 5 - 5 resultou 10 - (5 - 5) = 10 em vez de (10 - 5) - 5 = 0 ! Este bug foi corrigido! Também a partir de v2.53 a multiplicação e a divisão são analisadas da esquerda para a direita (em vez de direita para a esquerda).
Para o tipo string:
+
somar
>=
maior ou igual a (insensitivo ao caso)
<=
menor ou igual a (insensitivo ao caso)
<
menor que (insensitivo ao caso)
>
maior que (insensitivo ao caso)
Para o tipo clip:
+
o mesmo que a função UnalignedSplice
++
o mesmo que a função
AlignedSplice
Para o tipo bool:
?:
executa código condicionalmente
b = (a==true) ? 1 : 2 Isto significa em pseudo-basic: if (a=true) then b=1 else b=2
A entrada e saída destas funções não são clipes, mas algumas outras variáveis usadas no escrito.
Floor(float) : converte de flutuante
a inteiro |
Floor (1.2) = 1Floor (1.6) = 1Floor (-1.2) = -2Floor (-1.6) = -2 |
Ceil (float): converte de flutuante
a inteiro |
Ceil (1.2) = 2.0Ceil (1.6) = 2.0Ceil (-1.2) = -1br>
Ceil (-1.6) = -1 |
Round (float): converte de flutuante
a inteiro |
Round (1.2) = 1Round (1.6) = 2Round (-1.2) = -1Round (-1.6) = -2 |
Int (float): converte um flutuante a inteiro
(arredonda para zero). |
Int (1.2) = 1Int (1.6) = 1Int (-1.2) = -1Int (-1.6) = -1 |
Float (int): converte um inteiro a
flutuante . |
|
Frac (float): retorna a fração do
flutuante . |
Frac (3.7) = 0.7Frac (-1.8) = -0.8 |
Abs (integer) / Abs
(float): valor absoluto para inteiro e flutuante. |
Abs (-3.8) = 1.8 |
Sign (int) / Sign (float):
retorna o sinal do número como -1, 0 ou 1. |
Sign (-3.5) = -1Sign (3.5) = 1Sign (0) = 0 |
HexValue (string) Retorna
o valor de uma string hexadecimal |
HexValue ("FF00") = 65280 |
Sin (float) |
|
Cos (float) |
|
Pi () |
|
Log (float) |
|
Exp (float) |
|
Pow (float base, float power) |
|
Sqrt (float} |
|
Rand ([int max] [, bool scale] [, bool seed]):
retorna aleatório inteiro entre 0 e max.padrões: max = 32768 scale = TRUE ( TRUE = modo normal, FALSE = modo modulus) seed = FALSE (TRUE = usar tempo como semente) |
Rand (100) = número inteiro entre 0 e 99 |
Spline (float X, x1,y1, x2,y2, ....,
bool "cubic"} v2.5 Interpola o valor Y ao ponto X com pontos de controle x1/y1,... Deve ter ao menos 2 pares de x/y. A interpolação pode ser cúbica (o resultado é uma ranhura) ou linear (o resultado é um polígono) |
Spline (5, 0,0, 10,10, 20,0, false) = 5Spline (5, 0,0, 10,10, 20,0, true) = 7 |
UCase (string): retorna a string em
maiúsculas |
UCase ("AviSynth") = "AVISYNTH" |
LCase (string): retorna a string em
minúsculas |
LCase ("AviSynth") = "avisynth" |
RevStr (string): retorna a string
invertida |
RevStr ("AviSynth") = "htnySivA" |
StrLen (string): retorna o comprimento
da string |
StrLen ("AviSynth") = 8 |
Findstr (string1, string2):retorna o offset da string2 dentro da string1. A pesquisa é sensitiva ao caso. |
Findstr ("AviSynth","syn") = 4 |
LeftStr (string, length) / RightStr
(string, length):retorna a porção esquerda ou direita da string especificada pelo comprimento |
LeftStr ("AviSynth",3) = "Avi" |
MidStr (string, start [, length]):retorna a porção da string desde o início (para o primeiro caractere start=1) para o número de caracteres especificados pelo comprimento ou ao fim. |
MidStr ("AviSynth",3,2) = "iS" |
VersionNumber () |
VersionNumber () = 2.07 |
VersionString () |
VersionString () = "AviSynth 2.08 (avisynth.org)
22 nov. 2002" |
Chr (int): retorna o caractere ASCII
v2.5 |
Chr (34) retorna o caractere aspas |
Time (string): retorna uma string
com a hora atual do sistema formatada como definida pela string v2.5 |
Códigos para formatação de saída %a Nome do dia da semana abreviado %A Nome do dia da semana completo %b Nome do mês abreviado %B Nome do mês completo %c Data e hora - representação apropriada para local %d Dia do mês em número decimal (01 – 31) %H Hora no formato 24 horas (00 – 23) %I Hora no formato 12 horas (01 – 12) %j Dia do ano em número decimal (001 – 366) %m Mês em número decimal (01 – 12) %M Minuto em número decimal (00 – 59) %p Atual local‚s A.M./P.M. indicador para 12 horas %S Segundo em número decimal (00 – 59) %U Semana do ano em número decimal, com Domingo o primeiro dia (00 – 53) %w Dia de semana em número decimal (0 – 6; Domingo é 0) %W Semana do ano em número decimal, com Domingo o primeiro dia (00 – 53) %x representação apropriada para local %X Hora, representação para local atual %y Ano sem século, em número decimal (00 – 99) %Y Ano com século, em número decimal %z, %Z Fuso Horário, nome ou abreviação; nenhum caractere se o fuso é desconhecido %% Percentual O sinalizador # pode prefixar qualquer código de formatação. Neste caso, o significado do formato do código é mudado como a seguir: %#a, %#A, %#b, %#B, %#p, %#X, %#z, %#Z, %#%
O sinalizador # é ignorado.
|
Value (string): Retorna o valor de
uma string. |
Value ( "-2.7" ) = 2.7 |
String (float / int / string, format_string):
converte número em string.Se a variável é flut. ou inteira, converte-a para flut e usa format_string para convertê-la em string. A sintaxe de format_string é como a seguir: %[flags][width][.precision]f |
e.g. Subtitle ("a altura do Clip é " + String
(last.height) )String (1.23, "%f") = '1.23'String (1.23, "%5.1f") = ' 1.2'String (1.23, "%1.3f") = '1.230'
|
IsBool(var)
IsInt(var)
IsFloat(var)
IsString(var)
IsClip(var)
Select
(index, item0 [, item1...]): Retorna o item
selecionado pelo índice (0=item0). Os itens podem ser qualquer variável ou clipe
e também podem ser mistos .
Defined
(var): para
definir parâmetros opcionais em funções definidas pelo usuário.
Default
(x, d): retorna x se Defined(x), d caso
contrário.
Exist
(filename): retorna TRUE ou FALSE depois de checar
se o arquivo existe.
NOP
(): retorna NULL, provido
principalmente para execução condicional com itens de valor sem retôrno como
importação e nenhum outro além da condição desejada.
Eval
(string),
Apply
(func-string, arg,...): Eval
("f(x)")
é equivalente a f(x)
é equivalente a Apply
("f",
x)
Você pode usar Eval para algo como: settings = "352, 288" Eval( "BicubicResize(" + ajustes + ")" )
Import
(filename): conteúdos
de evals de outro escrito de avisynth (importa o texto de outro escrito)
Para
informação de erro e pegando entrada ruim para a função definida pelo usuário
você pode usar:
Assert
(bool, string error-message)
Try ... Catch
: esta
é uma função para conferir se surgirá um erro:
Try { AviSource("file.avi") } Catch(err_msg) { Blackness.Subtitle(err_msg) }
Há
Conditional
Filters que agora avaliam escritos quando um quadro é processado, assim você
pode mudar variáveis numa base por quadro.
Para
ter mais aplicações tem que haver Runtime
Functions que avalia o conteúdo do clipe e retorna um valor. v2.5
Um exemplo simples é calcular a média luma para cada quadro e exibi-lo.
Version() # gera um clip de teste
ConvertToYV12 # precisamos de YV12
FadeIn(10) # faça a variável luma assim vemos algo acontecer
ScriptClip(" Subtitle(String(AverageLuma())) ") # avalia Subtitle(...) em cada quadro
# a saída de AverageLuma é convertida em string
# e Subtitulada no clipe de entrada
ConvertToRgb # visualizar em RGB
SetMemoryMax
(int): Fixa a memória máxima que AviSynth
usa (em MB) v2
Em
algumas versões há um ajuste padrão de 5 Mb que é bem baixo. Se você
encontra problemas (por exemplo baixa velocidade) tente fixar este valor em pelo
menos 32 Mb.
SetWorkingDir
(string):
Estabelece o diretório padrão para o Avisynth. v2
Isto
é antes de tudo, para fácil carga dos clipes de fonte, etc. Não afeta auto
carga dos plug-ins. Valor de retôrno: 0 se bem sucedido, -1 em caso contrário.
Estas funções pegam um clipe como entrada e retornam uma propriedade do clipe.
Width
(clip)
Height
(clip)
Framecount
(clip)
Framerate
(clip)
FramerateNumerator
(clip) v2.55
FramerateDenominator
(clip) v2.55
Audiorate
(clip)
Audiolength
(clip) - (nota: 2^31 limite de amostras)
AudiolengthF
(clip) - (retornam
as amostras de número como flutuantes) v2.55
Audiochannels
(clip)
Audiobits
(clip)
IsAudioFloat
(clip) v2.55
IsAudioInt
(clip) v2.55
IsRGB
(clip)
IsRGB24
(clip)
IsRGB32
(clip)
IsYUY2
(clip)
IsYV12
(clip) v2.51
IsYUV
(clip) v2.54
IsPlanar
(clip) v2.51
IsInterleaved
(clip) v2.51
IsFieldBased
(clip)
IsFrameBased
(clip)
GetParity
(clip)
HasAudio
(clip) v2.56
HasVideo
(clip) v2.56
Não esqueça: você pode usar as Propriedades com a variável implícita LAST ou em notação OOP:
BilinearResize(Width/2, Height/2)
é o mesmo que
BilinearResize(Width(Last)/2, Height(Last)/2)
é o mesmo que
BilinearResize(Last.Width / 2, Last.Height / 2)
Você
pode definir suas próprias funções. Isto é explicado melhor por um exemplo:
Function NTSC2PAL( clip c) {
Assert(c.height == 480, "NTSC2PAL: O clipe de entrada deve ter 480 linhas de scan")
Bob(c, height=576)
return Weave()
}
Até funções recursivas podem ser definidas.
function TRANSITION(clip clip, int start, int expo, int overlap) { return ( start >= clip.framecount-expo ? \ Trim(clip,start,0) : \ Dissolve(Trim(clip,start,start+expo-1), \ TRANSITION(clip,start+expo,expo,overlap), \ overlap \ ) }
Há algumas funções que combinam dois ou mais clipes de modos diferentes. Como o conteúdo de vídeo é calculado, é descrito para cada função, mas aqui está um resumo de quais propriedades o clipe resultante terá.
Os clipes de entrada sempre devem ter o mesmo formato de cor e - com a exceção da Camada - as mesmas dimensões.
taxa de quadro |
contador de quadro |
|
|
||
AlignedSplice, UnalignedSplice |
primeiro clipe |
|
veja descrição do filtro |
primeiro clipe |
|
Dissolve |
soma de todos os clipes menos a sobreposição |
veja descrição do filtro |
|||
MergeLuma, MergeChroma |
primeiro clipe |
o último quadro do clipe menor é repetido até o fim |
primeiro clipe |
||
Layer | |||||
Subtract |
clipe maior |
||||
StackHorizontal, StackVertical | |||||
Interleave |
x (número de clipes) |
2x o contador de quadro do clipe maior |
Como
você pode ver as funções não são completamente simétricas, mas contêm
alguns atributos do PRIMEIRO clipe.
Com estas funções você pode acrescentar outras externas ao AviSynth.
LoadPlugin
("filename" [, ...])
Carrega
um ou mais plugins externo do Avisynth (DLLs).
LoadVirtualDubPlugin
("filename",
"filtername", preroll)
Isto carrega um plugin escrito para VirtualDub. “filename” é o nome do arquivo de .vdf. Depois de chamar esta função, o filtro será conhecido como “filename” em Avisynth. Os filtros do VirtualDub só suportam RGB32. Se acontecer o vídeo estar em formato RGB24, então você tem que usar ConvertToRGB32 (ConvertToRGB não será o bastante).
Algumas
saídas de filtro dependem dos quadros anteriores; para isso deve ser fixado
pelo menos o número de quadros que o filtro precisa processar antes, para
encher seus buffers e atualizar suas variáveis internas.
LoadVFAPIPlugin
("filename",
"filtername")
Isto
lhe permite usar plugins VFAPI (plugins de importação TMPGEnc).
LoadCPlugin
("filename" [, ...])
C-plugins deve ser carregado com LoadCPlugin. Conselho: mantenha este plugin fora de seu diretório de auto carga de plugin para prevenir travamentos. [discussão] [AVISynth C API (por kevina20723)]
É possível pôr todos os arquivos de plugins e escritos com funções definidas pelo usuário ou variáveis (globais) em um diretório onde todos os arquivos com a extensão .AVS e .DLL são carregados ao iniciar, descarregados e então carregados dinamicamente quando o escrito precisar deles.
Escritos neste diretório devem conter só definições de função e variáveis globais, nenhuma seção de processo principal (outros erros estranhos podem acontecer), também não é recomendado pôr outros arquivos nesse diretório.
O
diretório é armazenado no registro (a chave de registro mudou para a v2.5).
Você pode usar clicando duas vezes num arquivo.REG com as seguintes linhas e
fixar o caminho (claro, inserindo seu caminho atual):
REGEDIT4 [HKEY_LOCAL_MACHINE\SOFTWARE\Avisynth] "PluginDir2_5"="c:\\program files\\avisynth\\plugins"
A ordem na qual nomes de função têm precedência é como segue:
função definida pelo usuário (sempre tem a mais alta prioridade) função plugin (tem prioridade mais alta que a funções internas - sobrepõe uma função interna) função interna
Dentro desses grupos a função carregada afinal tem precedência, não há nenhum erro num conflito de espaço de nome.
A partir da v2.55 há o suporte à DLLName_function(). O problema é que os dois plugins podem ter funções diferentes que são nomeadas iguais. Para chamar o que é preciso, o suporte DLLName_function () é incluído. Só aceita plugins auto-carregados. Não gera os nomes adicionais para plug-ins carregados com LoadPlugin.
Alguns exemplos:
# usa fielddeinterlace de decomb510.dll AviSource("D:\captures\jewel.avi") decomb510_fielddeinterlace(blend=false)
Suponha ter os plugins mpeg2dec.dll e mpeg2dec3.dll em seu diretório de auto plug-in e você quer carregar um arquivo d2v com mpeg2dec.dll (que produz YUY2):
# usando mpeg2source de mpeg2dec.dll mpeg2dec_mpeg2source("F:\From_hell\from_hell.d2v")
ou com mpeg2dec3.dll (que produz YV12):
# usando mpeg2source de mpeg2dec3.dll mpeg2dec3_mpeg2source("F:\From_hell\from_hell.d2v")
$Date: 2006/03/26 18:11:19 $ Portuguese translation by RoLon