## Per Iniziare

AviSynth sostanzialmente funziona in questo modo: Per prima cosa si deve creare un semplice documento di testo con i comandi, detto script. Questi comandi fanno riferimento ad uno o più video ed ai filtri che volete applicare loro. Successivamente, lanciate una applicazione video , come VirtualDub, ed aprite il file di script . E' questo il momento in cui AviSynth entra in gioco. Esso apre i video citati nello script, applica i filtri specificati, ed alimenta l'applicazione video . L' applicazione, tuttavia , non è consapevole del fatto che AviSynth stia lavorando in background. Piuttosto, l' applicazione pensa di aprire direttamente un file avi filtrato che sta sull' hard drive.

Ci sono molte funzionalità in AviSynth2 sia nuove che riscoperte . Per renderle più evidenti (specialmente quando in passato la funzionalità non era stata ben documentata) sono segnate con v2

La versione 2.5 costituisce un grande passo avanti. Leggete con attenzione AviSynth 2.5 prima di usarla. Cambiamenti importanti sono segnati con v2.5

#### Linear Editing:

La cosa più semplice che si possa fare con AviSynth è quel tipo di editing che si può fare in VirtualDub. Gli scripts per fare ciò sono facili da costruire perché se non lo si desidera, non ci si deve preoccupare di variabili ed espressioni complicate.

A scopo di test create un file chiamato test.avs e scriveteci dentro questa semplice riga di testo:

    Version

Ora aprite questo file ad esempio con Windows Media Player e potrete vedere un video clip di dieci second che mostra il numero di versione di AviSynth ed un avviso sul copyright.

`Version` è quello che si dice un "source filter", a significare che esso genera un clip invece di modificarlo. Il primo comando in uno script di sarà sempre un source filter.

Ora aggiungete una seconda riga allo script in modo che assomigli a questo:

    Version
    ReduceBy2

Riaprite il file in Media Player. Vedrete di nuovo l'avviso sul copyright , ma con dimensioni la metà di prima.
`ReduceBy2` è un " filtro di trasformazione," significando che esso prende il clip precedente e lo modifica in qualche modo. Potete concatenare assieme una moltitudine di filtri di trasformazione , proprio come in VirtualDub.
Aggiungiamone un altro per generare alla fine una dissolvenza in nero. Aggiungiamo un'altra riga:

    Version
    ReduceBy2
    FadeOut(10)

Riapriamo il file. Il clip dovrebbe essere lo stesso per i primi 9 secondi, quindi nell'ultimo secondo sfumare lentamente verso il nero.
Il filtro di FadeOut accetta un argomento numerico che indica il numero di frames da sfumare.

Ci vuole un tempo troppo lungo prima che la dissolvenza abbia inizio, sicchè per ridurre l'attesa tagliamo l'inizio del clip e dissolviamo.
Scartiamo i primi 120 frames e teniamoci quelli da 120 a 150:

    Version
    ReduceBy2
    Trim(120,150) # taglia i primi 119 frames, e mantiene i frames 120-150 (AviSynth inizia a contare i frames dallo 0)
    FadeOut(10)

In questo esempio abbiamo usato per la prima volta un commento.
I commenti iniziano col caratter # e continuano fino alla fine della riga e sono completamente ignorati da AviSynth.
Il filtro Trim accetta due argomenti, separati da una virgola: il primo e l'ultimo frame da conservare . Se si mette 0 come ultimo frame, questo significa "fine del clip," sicchè se volete tagliare i primi 119 frames dovete usare Trim(120,0).

Seguire la numerazione dei frame in questo modo è un lavoro ingrato . E' molto più facile aprire uno script incompleto in una applicazione come VirtualDub che mostrerà i numeri dei frames. Si può anche usare il filtro ShowFrameNumber che imprime il frame number sul frame stesso.

In pratica un source filter molto più pratico di Version è AVISource, che legge dal disco un file AVI (o uno dei molti altri tipi di files). Se avete un file AVI sotto mano, potete provare ad applicare gli stessi filtri:

    AVISource("d:\capture.avi")   # o qualunque altro pathname
    ReduceBy2
    FadeOut(15)
    Trim(120,0)

Anche uno script composto dal solo comando AVISource può risultare utile per far supportare AVI files >2GB ad applicazioni che supportano solo quelli <2GB .

#### Non-Linear Editing:

Ed ora la parte più divertente. Create un file AVS con dentro questo script:

    StackVertical(Version, Version)

Apritelo. Resultato: Un video in output con due righe identiche di info sulla versione, una sopra l'altra.
Al posto di accettare come argomenti numeri o stringhe , StackVertical prende come argomenti video clips . Nello script, il filtro Version è chiamato 2 volte. Ogni volta restituisce una copia del version clip. Questi 2 clips vengono poi passati a StackVertical, che li unisce (senza sapere da dove vengano).

Uno dei più utili filtri di questo tipo è UnalignedSplice, che accoda video clips uno all'altro. Ecco uno script che carica 3 AVI files (come potrebbero essere prodotti da AVI_IO) e li concatena.

    UnalignedSplice(AVISource("d:\capture.00.avi"), AVISource("d:\capture.01.avi"), AVISource("d:\capture.02.avi"))

Sia StackVertical che UnalignedSplice accettano come minimo 2 argomenti e come massimo sessanta.
Si può usare l'operatore `+` come abbreviazione di UnalignedSplice.

Ad esempio, questo script fa la stessa cosa del precedente:

    AVISource("d:\capture.00.avi") + AVISource("d:\capture.01.avi") + AVISource("d:\capture.02.avi")

Ora supponiamo che stiate catturando usando una applicazione che salva il video in numerosi segmenti AVI , ma mette l'audio in un WAV file separato.
Si può rimettere assieme il tutto? Ma certo:

    AudioDub(AVISource("d:\capture.00.avi")+AVISource("d:\capture.01.avi")+AVISource("d:\capture.02.avi"), WAVSource("d:\audio.wav"))

## Sintassi

#### Espressioni:

Uno script di AviSynth consiste di una sequenza di linee del tipo:

    variable_name = expression

In questo esempio "expression" viene calcolata ed il risultato assegnato a "variable_name".

Molto importante è la forma ridotta:

    expression

In questo caso, expression è calcolata ed il risultato è assegnato alla variabile speciale che identifica un clip last.
Il che equivale a

    last = expression

La fine dello script di solito assomiglia a questo:

    return expression

Qui expression è calcolata ed è usata come "valore di ritorno" dello script cioè il video clip che sarà visto dall'applicazione che ha aperto il file AVS.

La forma base di un'espressione che chiama una funzione è

    Function(args)

Le funzioni Clip producono sempre un video clip e mai ne modificano uno esistente,
Args è una lista di argomenti della funzione separati da virgola. La lista può essere vuota(il che significa che tutti o solo alcuni argomenti possono essere opzionali)

Se la filter function si aspetta un video clip come primo argomento e questo non viene fornito, il clip è quello dentificato dalla variabile speciale last

I filtri di AviSynth possono ricevere argomenti in chiaro. Questi argomenti possono essere specificati in qualunque ordine, ed il filtro assumerà i valori di default per ognuno di essi che tralascerete (gli argomenti in chiaro sono sempre opzionali).
Questo semplifica molto l'uso di alcuni filtri.

    Potete scrivere

    Subtitle("Hello, World!", text_color=$00FF00, x=100, y=200)

    al posto di

    Subtitle("Hello, World!", 100, 200, 0, 999999, "Arial", 24, $00FF00)

Una sintassi alternativa (detta "OOP notation") per le clip functions è

    expression.Function(args)
    es.:
    Version.ReduceBy2.FadeOut(15)

Che equivale a

    Function(expression, args)

    e.g.:
    FadeOut(15, ReduceBy2(Version))

e può essere applicata a `expression` tramite l'uso di `Function` .
Uno svantaggiodella notazione OOP è che essa può essere usata con filtri che assumono come argomento un solo video-clip argument e non di più.

Tutte le funzioni di AviSynth producono un numero definito di frames e di framerate, anche se il comando sembra molto complesso.
AviSynth sa, dopo aver letto lo script, quanto l'output durerà, quale framerate avrà e le sequenze da tagliare di tutti gli input specificati.
Tutto questo è calcolato all'apertura dello script. Solo il filtraggio effettivo è fatto al runtime e su richiesta.

Commenti: AviSynth ignora tutto quello che segue un carattere # fino alla fine della riga..

Ignora Maiuscolo/Minuscolo: aViSouRCe va bene tanto quanto AVISource.

Continuazione sulla successiva o dalla precedente riga: \

    Subtitle ("Test-Text")

    Subtitle ( \
              "Test-Text")

    Subtitle (
           \ "Test-Text")

#### Variabili:

Un nome di variabile può essere lungo fino a 50 caratteri e può contenere lettere, cifre, e underscores (_), ma non altri caratteri. I nome non possono cominciare con una cifra.

Si possono usare i seguenti tipi di variabile:

clip: un video clip contenete video e / o audio. Almeno una variabile indicante un clip deve essere usata e restituita dallo script.
string: delimitata o da "quotation marks" (doppie virgolette) o da 3 quotation marks del tipo """this example""". Una stringa di testo può contenere qualunque carattere eccetto il quotation mark di fine o un doppio-apostrofo. Se ci fosse l'esigenza di inserire un quotation mark dentro una string, usare il triple quote-notation:

    Subtitle ("""This displays "hello world" with quotes""")

int: inserita come un insieme di cifre, opzionalmente con un + o - iniziale.
float: inserita come un insieme di cifre con un punto (.) da qualche parte e un + o - opzionale. Ad esempio , +1. è considerato come un numero floating-point .
val: tipo di argomento di una funzione dove non ha importanza se si tratta di un intero o di un floating
bool: può essere TRUE (vero) o FALSE (falso)
hexadecimal numbers: inseriti preceduti da $. Questa variabile è trattata come un intero. Diversi filtri usano questa notazione per specificare i colori. Ad esempio, $FF8800 è un arancione.

global: definisce una global variable, che può essere usata in comuna da tutte le funzoni definite dall'utentee dallo script principale.

Ecco un'altra versione degli esempi sopracitati che è più gestibile e facile da capire :

    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)

## Operatori

Per ogni tipo di operandi (clip, int, float, string, bool) potete usare:
`==` uguale
`!=` diverso
`||` or
`&&` and

Per i tipi numerici (int, float):
`+` somma
`-` sottrai
`*` moltipica
`/` dividi
`%` mod
`>=` maggiore o uguale a
`<=` minore od uguale a
`<` minore di
`>` maggiore di

    AviSynth nelle versioni precedenti analizzava le espressioni da destra a sinistra,
    il che produceva risultati strani:

     a = 10 - 5 - 5 risultava  10 - (5 - 5) = 10 invece di (10 - 5) - 5 = 0 !

    Questo bug è stato corretto!
    A partire dalla v2.53 anche le multiplicazioni e le divisioni sono analizzate da sinistra a destra
    (invece che da destra a sinistra).

Per le stringhe:
`+` add
`>=` maggiore o uguale a (case-insensitive)
`<=` minore od uguale a (case-insensitive)
`<` minore di (case-insensitive)
`>` maggiore di(case-insensitive)

Per i clip :
`+` si comporta come la funzione `UnalignedSplice`
`++` si comporta come la funzione`AlignedSplice`

Per le variabili booleane:
`?:` esegue il codice in modo condizionato

    b = (a==true) ? 1 : 2
    In pseudo-basic sarebbe:

    if (a=true) then b=1 else b=2

## Script Functions

L' input e l'output di queste funzioni non sono clips, ma latre variabili usate nello script.

#### Funzioni numeriche:

`Floor(float)`: converte da float a int | `Floor` (1.2) = 1 `Floor` (1.6) = 1 `Floor` (-1.2) = -2 `Floor` (-1.6) = -2
`Ceil` (float): converte da float a int | `Ceil` (1.2) = 2.0 `Ceil` (1.6) = 2.0 `Ceil` (-1.2) = -1br> `Ceil` (-1.6) = -1
`Round` (float): converte da float a int | `Round` (1.2) = 1 `Round` (1.6) = 2 `Round` (-1.2) = -1 `Round` (-1.6) = -2
`Int` (float): converte un float in int (arrorondato a zero). | `Int` (1.2) = 1 `Int` (1.6) = 1 `Int` (-1.2) = -1 `Int` (-1.6) = -1
`Float` (int): converte un int in float. |
`Frac` (float): restituisce la parte decimale di un float. | `Frac` (3.7) = 0.7 `Frac` (-1.8) = -0.8
`Abs` (integer) / `Abs` (float): valore assoluto per interi e float. | `Abs` (-3.8) = 1.8
`Sign` (int) / `Sign` (float): restituisce il segno di un numero come -1, 0 o 1. | `Sign`(-3.5) = -1 `Sign`(3.5) = 1 `Sign`(0) = 0
`HexValue` (string) restituisce il valore di una stringa hex | `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]): restituisce un intero casuale compreso tra 0 e max. defaults: max = 32768 scale = TRUE ( TRUE = normal mode, FALSE = modulus mode) seed = FALSE (TRUE = use time as seed) | `Rand`(100) = integer number between 0 and 99
`Spline` (float X, x1,y1, x2,y2, ...., bool "cubic"} v2.5 Interpola il valore Y at point X using the control points x1/y1,... There have to be at least 2 x/y-pairs. The interpolation can be cubic (the result is a spline) or linear (the result is a polygon) | `Spline` (5, 0,0, 10,10, 20,0, false) = 5 `Spline` (5, 0,0, 10,10, 20,0, true) = 7

#### String functions:

`UCase` (string): restituisce la stringa in maiuscole | `UCase` ("AviSynth") = "AVISYNTH"
`LCase` (string): restituisce la stringa in minuscole | `LCase` ("AviSynth") = "avisynth"
`RevStr` (string): restituisce la stringa a rovescio | `RevStr` ("AviSynth") = "htnySivA"
`StrLen` (string): restituisce la lunghezza della stringa | `StrLen` ("AviSynth") = 8
`Findstr` (string1, string2): restituisce la posizione della string2 all'interno di string1. La ricerca è case-sensitive. | `Findstr` ("AviSynth","syn") = 4
`LeftStr` (string, length) / `RightStr` (string, length): restituisce la parte sinistra o destra (della lunghezza specificata) di una stringa | `LeftStr` ("AviSynth",3) = "Avi"
`MidStr` (string, start [, length]): restituisce una porzione di una stringa partendo dalla posizione start (per il primo carattere start=1) per un numero di caratteri specificati da length o fino alla fine. | `MidStr` ("AviSynth",3,2) = "iS"
`VersionNumber` () | `VersionNumber` () = 2.07
`VersionString` () | `VersionString` () = "AviSynth 2.08 (avisynth.org) 22 nov. 2002"
`Chr` (int): restituisce un carattere ASCII v2.5 | `Chr` (34) restituisce il carattere virgolette (")
`Time` (string): restituisce una stringa col system time formattata come definito da string v2.5 | Codes for output formatting %a Nome del giorno in forma abbreviata %A Nome del giorno in forma estesa %b Nome del mese in forma abbreviata %B Nome del mese in forma estesa %c Data ed ora secondo la rappresentazione locale %d Giorno del mese come numero decimale (01 – 31) %H Ora in formato 24-hour (00 – 23) %I Ora in formato 12-hour (01 – 12) %j Giorno dell'anno come numero decimale (001 – 366) %m Mese come numero decimale (01 – 12) %M Minuto come numero decimale (00 – 59) %p Indicatore A.M./P.M. per l'orologio di 12-hour %S Secondi come numero decimale (00 – 59) %U Settimana dell'anno come numero decimale, con Domenica come primo giorno della settimana (00 – 53) %w Giorno della settimana come numero decimale (0 – 6; Sunday is 0) %W Settimana dell'anno come numero decimale, con Lunedì come primo giorno della settimana (00 – 53) %x Data in rappresentazione locale %X Tempo in rappresentazione locale %y Anno senza secolo, come numero decimale (00 – 99) %Y Anno col secolo, come numero decimale %z, %Z Nome della Time-zone o abbreviazione; nessun carattere se time-zone sconosciuta %% Segno percentuale Il segno # può precedere qualunque testo formattato. In questo caso, il significato combia nel seguente modo. %#a, %#A, %#b, %#B, %#p, %#X, %#z, %#Z, %#% # il # è ignorato %#c Rappresentaione localizzata lunga di data e tempo . Esempio: “Tuesday, March 14, 1995, 12:41:29„. %#x Rappresentaione localizzata lunga di data. Esempio : “Tuesday, March 14, 1995„. %#d, %#H, %#I, %#j, %#m, %#M, %#S, %#U, %#w, %#W, %#y, %#Y Toglie gli zeri iniziali (se ci sono).

#### Conversioni:

`Value` (string): Returns the value of an string. | `Value` ( "-2.7" ) = 2.7
`String` (float / int / string, format_string): converte un numero in una stringa. Se la variabile è float o intera, la converte in float e usa la format_string per convertirla in una stringa. La sintassi della format_string è la seguente: %[flags][width][.precision]f width: larghezza minima (la string non viene mai troncata) precision: il numero delle cifre stampate flags: `-` allineamento a sinistra (invece che a destra) `+` stampa sempre il segno +/- `0` aggiunge zeri a sinistra `' '` stampa un blank al posto del "+" `#` stampa sempre il punto decimale | e.g. `Subtitle` ("Clip height is " + `String` (last.height) ) `String`(1.23, "%f") = '1.23' `String`(1.23, "%5.1f") = ' 1.2' `String`(1.23, "%1.3f") = '1.230'

#### Funzioni di Test:

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

#### Altre funzioni:

`Select` (index, item0 [, item1...]): Restituisce l' item individuato dall'indice (0=item0). Gli Items possono essere qualunque variabile o clip e possono anche essere mischiate.
`Defined` (var): per definire parametri opzionale all'interno di funzioni create dall'utente.
`Default` (x, d): restituisce x se Defined(x), d in caso contrario.
`Exist` (filename): restituisce TRUE o FALSE dopo un test di esistenza del file.
`NOP` (): restituisce NULL, previsto principalmente per esecuzioni condizionali senza items di ritorno come ad esempio "import" e non si desidera inserire una condizione "else".
`Eval` (string),
`Apply` (func-string, arg,...): `Eval` ("f(x)") è equivalente a `f(x)` è equivalente a `Apply` ("f", x)

    Si può usare  Eval per qualcosa del tipo:
    settings = "352, 288"
    Eval( "BicubicResize(" + settings + ")" )

`Import`(filename): elabora il contenuto di un altro script visynth (importa un altro script)

Per la segnalazione degli errori e la cattura di input errati alle funzioni user-defined si può usare:
`Assert`(bool, string error-message)

`Try ... Catch`: questa funzione per testare se si verificherà un errore:

    Try {
      AviSource("file.avi")
    }
    Catch(err_msg) {
       Blackness.Subtitle(err_msg)
    }

## Funzioni Runtime

Ci sono ora Conditional Filters che analizzano script quando un frame viene elaborato, sicchè si possono modificare le variabili sulla base del singolo frame.
To have more applications there have to be Runtime Functions which evaluate the content of the clip and return a value. v2.5

    Semplice esempio è quello di calcolare il luma medio per ogni frame e di stamparlo.

    Version()       # genera un test clip
    ConvertToYV12   # serve YV12
    FadeIn(10)      # rende il luma variabile in modo da avere qualcosa da vedere

    ScriptClip(" Subtitle(String(AverageLuma())) ")  # per ogni frame calcola Subtitle(...)
                                                     # l' output di AverageLuma è convertito in stringa
                                                     # e sottotitolato sull' input clip
    ConvertToRgb    # vediamolo in RGB

## Funzione di Controllo

`SetMemoryMax` (int): Imposta il massimo di memoria che AviSynth può usare (in MB) v2
In alcune versioni c'è un'impostazione di default di 5MB, che è assolutamente bassa. Se si hanno problemi (es. bassa velocità) impostate questo valore almeno a 32MB.

`SetWorkingDir` (string): Imposta la direttrice di Avisynth. v2
Questo serve principalmente per un facile caricamento di source clips, etc. Non influenza l'autocaricamento dei plugins. Restituisce : 0 se esiste, -1 in caso contrario.

## Proprietà del Clip

Queste funzioni prendono in input un clip e ne restituiscono le proprietà .

`Width` (clip)
`Height` (clip)
`Framecount` (clip)
`Framerate` (clip)
`FramerateNumerator` (clip) v2.55
`FramerateDenominator` (clip) v2.55
`Audiorate` (clip)
`Audiolength` (clip) - (note: 2^31 samples limit)
`AudiolengthF` (clip) - (will return the samplenumber as float) 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)

    Da non dimenticare: si possono usare le proprietà con la variabile implicita LAST o in OOP-notation:

    BilinearResize(Width/2, Height/2)
       equivale a
    BilinearResize(Width(Last)/2, Height(Last)/2)
       equivale a
    BilinearResize(Last.Width / 2, Last.Height / 2)

## Fuzioni User-Defined

Potete definire funzioni vostre. Un esempio:

    Function NTSC2PAL( clip c) {
        Assert(c.height == 480, "NTSC2PAL: input clip must have 480 scan lines")
        Bob(c, height=576)
        return Weave()
    }

Si possono definire anche funzioni ricursive.

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

## Funzioni con più di un input clip

Ci sono alcune funzioni che combinano in vari modi uno o più clips. Come viene calcolato il contenuto del video è descritto per ogni funzione, ma quì c'è un sommario di quali proprietà avrà il clip risultante.

Le clips di input devono avere lo stesso formato colore e - con l'eccezione di Layer - le stesse dimensioni.

| frame-rate | frame-count | audio content | audio sampling rate
AlignedSplice, UnalignedSplice | primo clip | somma dei clips |  | vedere la descrizione del filtro | primo clip
Dissolve | somma dei clips meno l'overlap |  | vedere la descrizione del filtro
MergeLuma, MergeChroma | primo clip | l'ultimo frame del clip più corto è ripetuto fino alla fine del clip | primo clip
Layer
Subtract | clip più lungo
StackHorizontal, StackVertical
Interleave | (fps del primo clip) x (numero dei clips) | 2x frame-count del clip più lungo

Come si vede le funzioni non sono completamente simmetriche ma prendono alcuni attributi dal PRIMO clip.

## Plugins

Con queste funzioni si possono aggiungere ad AviSynth funzioni esterne.

`LoadPlugin` ("filename" [, ...])

Carica uno o più plugin esterni (DLLs).

`LoadVirtualDubPlugin` ("filename", "filtername", preroll)

Questo carica plugin scritti per VirtualDub. "filename" è il nome del file .vdf . Dopo aver chiamato questa funzione, avisynth riconoscerà il filtro come "filtername" . I filtri di VirtualDub supportano solo RGB32. Se capita che il video sia in formato RGB24, allora si deve usare `ConvertToRGB32` (`ConvertToRGB` non basta).

L'output di qualche filtro dipende dal frame precedente; per questi il preroll dovrebbe essere impostato almeno al numero di frames che il filtro pre-processa per riempire i suoi buffera e/o per aggiornare le sue variabili interne.

`LoadVFAPIPlugin` ("filename", "filtername")

Questo consente di usare i plugins di VFAPI (TMPGEnc import plugins).

`LoadCPlugin` ("filename" [, ...])

C-plugins devono essere caricati con LoadCPlugin. Consiglio: tenete questo plugin al di fuori della vostra auto plugin loading directory per evitare crashes. [discussion] [AVISynth C API (by kevina20723)]

## Autoload dei Plugin e priorità dei nomi v2

E' possibile mettere tutti i plugins ed i files di script con le funzioni user-defined o variabili (globali) in una directory dalla quale tutti i files con estensione .AVS e .DLL sono caricate allo startup, scaricate e successivamente ricaricate dinamicamente quando servono.

Gli Scripts in questa directory dovrebbero contenere solo definizione di funzioni e di global variables, ma nessuna sezione principale di elaborazione (pena il verificarsi di strani errori), come pure non è consigliato mettere altri files in questa directory.

La directory è memorizzata nel registro (la chiave di registro è cambiata con la v2.5). Per impostare il path, si può usare il doppio click su un file .REG con le seguenti righe (ovviamente modificando il path):

    REGEDIT4

    [HKEY_LOCAL_MACHINE\SOFTWARE\Avisynth]
    "PluginDir2_5"="c:\\program files\\avisynth\\plugins"

L'ordine di precedenza delle funzioni è il seguente:

    user-defined function (hanno sempre la più alta priorità)
       plugin-function (hanno priorità più alta delle built-in functions - esse hanno la precedenza sulle built-in function)
          built-in function

All'interno di ogni gruppo l'ultima funzione caricata ha la precedenza , non c'è segnalazione di errore in caso di conflitto di nomi.

## Autocaricamento dei Plugin e function name in conflitto v2.55

A partire dalla v2.55 c'è un supporto DLLName_function(). Il problema è che 2 plugins possono avere funzioni diverse con lo stesso nome. Per richiamare quella richiesta è stato aggiunto il supporto a DLLName_function(). Funziona solo per plugins autocaricati. Non genera i nomi aggiuntivi per i plug-ins caricati con LoadPlugin.

Alcuni esempi:

    # using fielddeinterlace from decomb510.dll
    AviSource("D:\captures\jewel.avi")
    decomb510_fielddeinterlace(blend=false)

Supponiamo voi abbiate i plugins mpeg2dec.dll e mpeg2dec3.dll nella auto plugin dir e vogliate caricare un file d2v con mpeg2dec.dll (che produce YUY2):

    # using mpeg2source from mpeg2dec.dll
    mpeg2dec_mpeg2source("F:\From_hell\from_hell.d2v")

o con mpeg2dec3.dll (che produce YV12):

    # using mpeg2source from mpeg2dec3.dll
    mpeg2dec3_mpeg2source("F:\From_hell\from_hell.d2v")

`$Date: 2004/10/07 21:32:28 $`