## Começando

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

#### Edição Linear:

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.

#### Edição Não Linear:

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"))

## Sintaxe

#### Expressões:

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")

#### Variáveis:

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)

## Operadores

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

## Funções de Script

A entrada e saída destas funções não são clipes, mas algumas outras variáveis usadas no escrito.

#### Funções Numéricas:

`Floor(float)`: converte de flutuante a inteiro | `Floor` (1.2) = 1 `Floor` (1.6) = 1 `Floor` (-1.2) = -2 `Floor` (-1.6) = -2
`Ceil` (float): converte de flutuante a inteiro | `Ceil` (1.2) = 2.0 `Ceil` (1.6) = 2.0 `Ceil` (-1.2) = -1br> `Ceil` (-1.6) = -1
`Round` (float): converte de flutuante a inteiro | `Round` (1.2) = 1 `Round` (1.6) = 2 `Round` (-1.2) = -1 `Round` (-1.6) = -2
`Int` (float): converte um flutuante a inteiro (arredonda para zero). | `Int` (1.2) = 1 `Int` (1.6) = 1 `Int` (-1.2) = -1 `Int` (-1.6) = -1
`Float` (int): converte um inteiro a flutuante . |
`Frac` (float): retorna a fração do flutuante . | `Frac` (3.7) = 0.7 `Frac` (-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) = -1 `Sign`(3.5) = 1 `Sign`(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) = 5 `Spline` (5, 0,0, 10,10, 20,0, true) = 7

#### Funções de String:

`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. %#c Data e hora completa, apropriada para local atual. Por exemplo: “Terça feira, Março 14, 1995, 12:41:29„. %#x Data completa, apropriada para local atual. Por exemplo: “Terça feira, Março 14, 1995„. %#d, %#H, %#I, %#j, %#m, %#M, %#S, %#U, %#w, %#W, %#y, %#Y Remove zeros iniciais (se houver).

#### Conversões:

`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 width: a mínima largura (a string nunca é truncada) precision: o número de dígitos impressos Sinalizadores: `-` alinha à esquerda (em vez de à direita) `+` imprime sempre o sinal +/- `0` enche o início com zeros `' '` imprime em branco em vez de "+" `#` sempre imprime o ponto decimal | 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'

#### Funções de Teste:

`IsBool(var)`
`IsInt(var)`
`IsFloat(var)`
`IsString(var)`
`IsClip(var)`

#### Outras funções:

`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)
    }

## Funções em tempo de execução

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

## Funções de Controle

`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.

## Propriedades do Clipe

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)

## Funções Definidas pelo Usuário

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
       \      )
    }

## Funções com mais de um clipe de entrada

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 | conteúdo de áudio | taxa de amostra de áudio
AlignedSplice, UnalignedSplice | primeiro clipe | soma de todos os clipes |  | 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 | (fps do primeiro clipe) 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.

## Plugins

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)]

## Auto carga e precedência de nome de Plugin v2

É 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.

## Auto carga e nomes de funções de conflitos de Plugin v2.55

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)

S uponha 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`