### Los geht`s

Ganz kurz gesagt arbeitet AviSynth so: Zuerst erstellt man eine einfache Textdatei (.txt) mit speziellen Befehlen darin, das nennt man dann das Skript. Diese Befehle erzeugen Verweise auf ein oder mehrere Videos und Filter, die man dafür verwenden möchte. Als nächstes wird eine Videoanwendung wie z.B. VirtualDub, gestartet und damit die Skript-Datei geöffnet. Hier tritt jetzt AviSynth in Aktion. AviSynth öffnet die Videos, auf die verwiesen wurde, bearbeitet das Video mit den Filtern und gibt das Ergebnis zurück an die Videoanwendung. Diese merkt aber gar nicht, dass im Hintergrund AviSynth arbeitet. Für die Anwendung sieht es so aus, als ob eine gefilterte AVI-Datei auf der Festplatte vorhanden ist.
Es gibt viel Neues und Wiederentdecktes in AviSynth2 (d.h. alle Versionen über 2.00). Diese Teile sind mit v2 gekennzeichnet.
Diese Version bringt große interne Änderungen. Lese AviSynth 2.5 sorgfältig bevor du mit dieser Version arbeitest. Relevante Änderungen sind mit v2.5 gekennzeichnet.
Lineare Editierung / Schnitt:
Das einfachste, was mit AviSynth gemacht werden kann, ist die Verwendung als linearer Videoeditor. Das sind die Möglichkeiten, die auch mit VirtualDub möglich sind. Die Skripte dafür sind recht einfach, weil keine Variablen oder komplizierten Ausdrücke notwendig sind.
Zum Testen erzeugt man eine Datei test.avs (das ist nur eine umbenannte Text-Datei) und schreibt folgende Zeile hinein:

`Version`

Wenn man nun diese Datei z.B. mit dem Windows Media Player öffnet, sieht man ein zehn Sekunden langes Video mit der Versionsnummer und einem Copyright von AviSynth.
`Version` nennt man einen Quell-Filter, das heißt, dieser Filter modifiziert nicht ein Video, sondern erzeugt selber einen Videoclip. Der erste Befehl in einem AviSynth Skript wird immer ein Quell-Filter sein.
Jetzt kommt noch eine zweite Zeile zum Skript:

`Version ReduceBy2`

Wenn man diese Datei nochmals im Media Player öffnet, sieht man wieder die Copyright-Meldung, jetzt allerdings halb so groß wie vorher.
`ReduceBy2` ist ein Transformations-Filter, welches den vorhergehenden Clip nimmt und in irgendeiner Weise umwandelt. Viele dieser Filter können zu einer Filterkette zusammengehängt werden, genauso wie in VirtualDub.
Noch eine Zeile dazu, um das Video am Schluss auf Schwarz auszublenden:

`Version ReduceBy2 FadeOut(15)`

Nach dem Wiederöffnen sollte das Video während den ersten 9 Sekunden gleich ausschauen wie vorher und dann in der letzten Sekunde sanft auf Schwarz ausblenden.
Das `FadeOut` Filter verwendet ein numerisches Argument, mit dem die Anzahl der Bilder (Frames) angegeben wird, die für das Ausblenden verwendet werden. Das Video, das von `Version` erzeugt wird, läuft mit 15fps, daher beginnt das Ausblenden eine Sekunde vor dem Ende.
Angenommen es dauert zu lange bis das Ausblenden beginnt. Dann kann man den Anfang wegschneiden. Der Clip, den `Version` erzeugt, ist 150 Frames lang (15 fps mal 10 sec).
AviSynth beginnt die Nummerierung der Frames bei 0.
Daher haben die Frames die Nummern 0 bis 149. `FadeOut` hängt einen Frame zusätzlich dran, daher gehen die Frames nach diesem Skript von 0 bis 150. Um die ersten 120 davon zu entfernen, schreibt man dies:

`Version ReduceBy2 FadeOut(15) Trim(120,150)` # Schneidet die ersten achten Sekunden weg

In diesem Beispiel wurde zum ersten Mal ein Kommentar verwendet.
Kommentare starten mit einer Raute # und sind dann die ganze Zeile gültig. Sie werden von AviSynth völlig ignoriert.
Der `Trim` Filter verwendet zwei Argumente, getrennt mit einem Komma: der erste und der letzte Frame, die vom Clip verwendet werden sollen. Wenn man als letzten Frame 0 einsetzt, bedeutet das "Ende vom Clip", daher hätte man auch schreiben können: `Trim(120,0)`.
Die Frame-Nummern auf diese Art zu verfolgen ist sehr mühsam. Es ist wesentlich einfacher, ein halbfertiges Skript in VirtualDub zu öffnen, wo die Frame-Nummer auch angezeigt wird. Man kann auch den internen ShowFrameNumber Filter verwenden, der auf jeden Frame die Frame-Nummer schreibt.
Ein in der Praxis sehr viel häufiger genutzter Quell-Filter als `Version` ist `AVISource`, womit eine AVI-Datei (oder diverse andere Dateitypen) von der Festplatte geöffnet werden kann.
Falls du eine AVI-Datei parat hast, kannst du dieselben Filter auf die AVI-Datei anwenden.

`AVISource("C:\Dateiname.avi")` # Passe den Dateinamen und den Dateipfad an `ReduceBy2 FadeOut(15) Trim(120,0)`

Sogar ein einzeiliges Skript, das nur aus dem `AVISource` Befehl besteht, kann schon sinnvoll sein. Nämlich dann, wenn man AVI-Dateien, die größer als 2GB sind, auch mit Applikationen öffnen möchte, die eigentlich nur Daten bis 2GB unterstützen.

Nichtlineares Editieren:
Nun zum wirklich interessanten Teil. Schreibe in ein Skript folgendes:

`StackVertical(Version, Version)`

Wenn man dieses Skript öffnet, ist das Ergebnis ein Video mit zweimal der Versions-Info übereinander gestellt.
Die Funktion `StackVertical` verwendet nicht Zahlen oder Zeichenfolgen als Argumente sondern Video-Clips. In diesem Skript wird der `Version` Filter zweimal aufgerufen. Jedes Mal gibt es eine separate Kopie des `Version`-Clips zurück. Diese zwei Clips werden an `StackVertical` übergeben, das sie dann zusammenfügt (ohne sich darum zu kümmern, woher die Eingangsclips kommen).
Eines der am meisten verwendeten Filter dieses Typs ist `UnalignedSplice`, diese Funktion fügt Clips (zeitlich) aneinander. So schaut ein Skript aus, das drei AVI-Dateien lädt und aneinanderfügt:

`UnalignedSplice(AVISource("C:\Datei1.avi"), AVISource("C:\Datei2.avi"), AVISource("C:\Datei3.avi"))`

Beide Filter (`StackVertical` und `UnalignedSplice`) können mit nur zwei oder auch bis zu sechzig Argumenten verwendet werden.
Der Operator `+` kann als Abkürzung für `UnalignedSplice` verwendet werden.
Dieses Beispiel macht das gleiche als das vorhergehende:

`AVISource("C:\Datei1.avi") + AVISource("C:\Datei2.avi") + AVISource("C:\Datei3.avi")`

Für den Fall, dass z.B. von einem Aufnahme-Programm die AVIs in mehreren Segmenten, der Ton aber als einzelne separate WAV-Datei gespeichert wurde, kann so alles wieder in ein Video mit Ton kombiniert werden:

`AudioDub(AVISource("C:\Datei1.avi")+AVISource("C:\Datei2.avi")+AVISource("C:\Datei3.avi"), WAVSource("C:\Audio.wav"))`

## Syntax

Ausdrücke:
Ein AviSynth Skript besteht aus mehreren Zeilen, die folgende Form haben:

`Variablenname = Ausdruck`

In diesem Beispiel wird `Ausdruck` ausgewertet und das Ergebnis einer Variablen `Variablenname` zugewiesen.
In diesem Zusammenhang ist die Kurzform dafür wichtig:

`Ausdruck`

In diesem Fall wird `Ausdruck` ausgewertet und der speziellen Variablen `last` zugewiesen.
Das ist das gleiche wie:

`last = Ausdruck`

Das Ende eines Skripts schaut immer so aus:

`return Ausdruck`

Hier wird `Ausdruck` ausgewertet und als Rückgabewert des Skripts verwendet, d.h. als Video welches die Anwendung zu sehen bekommt, die die AVS-Datei öffnet.
Die einfachste Form eines Ausdrucks, der eine Funktion aufruft, ist:

`Funktion(Argumente)`

Clip-Funktionen erzeugen als Ergebnis immer ein neues Clip, es wird also nicht das vorhandene Clip verändert.
`Argumente` ist eine Liste von Funktions-Argumenten getrennt durch Kommas. Diese Liste kann leer sein (was bedeutet, dass alle oder manche Argumente optional sind).
Wenn die Filter-Funktion als erstes Argument ein Video-Clip erwartet und dieses Argument nicht angegeben wird, wird die spezielle Variable `last` verwendet.
Bei manchen AviSynth Filtern können auch "benannte Argumente" verwendet werden. Diese benannten Argumente können in einer beliebigen Reihenfolge angegeben werden, und der Filter verwendet Standard (default) Werte für nicht angegebene Argumente (benannte Argumente sind daher immer optional).
Das vereinfacht die Benutzung mancher Filter stark.

Man kann schreiben: `Subtitle("Hallo, Leute!", text_color=$00FF00, x=100, y=200)` anstatt von `Subtitle("Hallo, Leute!", 100, 200, 0, 999999, "Arial", 24, $00FF00)`

Eine alternative Syntax ("OOP-Notation") für Clip Funktionen ist

Ausdruck.Funktion(Argumente), z.B.: `Version.ReduceBy2.FadeOut(15)`

Das ist das gleiche wie:

Funktionen(Ausdruck, Argumente), z.B.: `FadeOut(15, ReduceBy2(Version))`

,was man sich vorstellen kann als `Funktion` angewendet auf `ausdruck`.
Ein Nachteil dieser OOP-Notation ist, dass sie nur für Filter verwendet werden kann, die ein einzelnes Videoclip-Argument haben und nicht mit Filtern, die mehrere Argumente erwarten.
Alle AviSynth Funktionen erzeugen eine fest definierte Anzahl an Frames, auch die Framerate wird durch das Skript eindeutig bestimmt, auch wenn die Befehle sehr komplex aussehen.
AviSynth weiß nach dem Lesen des Skripts, wie lange das erzeugte Video sein wird, welche Framerate es hat und ermittelt die komplette Schnittsequenz von allen Quell-Videos.
Dies geschieht beim Öffnen des Skripts. Nur das Filtern an sich geschieht zur Laufzeit auf Anforderung durch das Video-Programm.

Kommentare: AviSynth ignoriert alles ab einem # Zeichen bis zum Ende der Zeile.
Groß- und Kleinschreibung wird ignoriert: `aViSouRCe` ist das gleiche wie `AviSource`.
Fortsetzen auf der nächsten oder von der vorherigen Zeile durch einen Schrägstrich \:

`Subtitle("Test-Text")` | `Subtitle ( \ "Test-Text")` | `Subtitle ( \ "Test-Text")`

Variablen:
Ein Variablenname kann bis zu 50 Zeichen lang sein und aus Buchstaben, Ziffern und Unterstrichen _, aber keinen anderen Zeichen bestehen. Desweiteren darf er nicht mit einer Ziffer beginnen.
Folgende Variablen-Typen können verwendet werden:
`clip`: Ein Videoclip enthält das Video und / oder Audio. Mindestens eine solche Variable muss verwendet und als Ergebnis zurückgegeben werden.
`string`: Ist umgeben von "Anführungszeichen" oder ``TeX-Style Anführungszeichen''. Eine Zeichenkette kann alle Zeichen enthalten außer die genannten Anführungszeichen. Falls du Anführungszeichen in der Zeichenkette verwenden musst, dann nutze ausschließlich die TeX-Notation. Alternativ kannst du auch die typografische Anführungszeichen aus dem erweiterten ASCII Zeichensatz von Windows anstatt der geraden verwenden, um diese Beschränkung auszuhebeln.
`int`: Ist eine Ganzzahl, die als eine Folge von Ziffern eingegeben wird, optional mit einem + oder - am Anfang.
`float`: Ist eine Dezimalzahl, eingegeben als Folge von Ziffern mit einem Punkt (.) innerhalb der Ziffernfolge und optional mit einem + oder - . Zum Beispiel wird +1. als `float` behandelt.
`val`: Wird als Typ eines Funktionsarguments genutzt, wo es egal ist, ob `int` oder `float`.
`bool`: Kann `TRUE` (wahr) oder `FALSE` (falsch) sein.
`Hexadezimal-Werte`: Können mit einem vorangestellten $ eingegeben werden. Intern wird diese Variable als Ganzzahl behandelt. Manche Filter verwenden diese Schreibweise zur Angabe von Farbwerten. So ist z.B. $FF8800 ein Orange-Ton.
`global`: Definiert eine globale Variable, die von allen benutzerdefinierten Funktionen und dem Hauptskript gemeinsam benutzt werden kann. v2
So schaut eine andere Version des Beispiels von oben aus, die besser handhabbar und leichter verständlich ist:

`a = AVISource("C:\Datei1.avi") b = AVISource("C:\Datei2.avi") c = AVISource("C:\Datei3.avi") sound_track = WAVSource("C:\Audio.wav") AudioDub(a+b+c, sound_track)`

## Operatoren

Mit allen Typen von Operanden (clip, int, float, string, bool) können verwendet werden:
`==` ist gleich
`!=` ist nicht gleich
`||` oder
`&&` und
Nur mit numerischen Operanden (int, float):
`+` Addieren
`-` Subtrahieren
`*` Multiplizieren
`/` Dividieren
`%` Modulo (Rest)
`>=` größer oder gleich als
`<=` kleiner oder gleich als
`<` kleiner als
`>` größer als

In früheren Versionen von AviSynth wurden Ausdrücke von rechts nach links zerlegt, was zu ungewohnten Ergebnissen führte: `a = 10 - 5 - 5` ergab 10 - (5 - 5) = 10 anstatt von (10 - 5) - 5 = 0 ! Dieser Fehler ist seit AviSynth v2.53 beseitigt. Alle Ausdrücke werden nun von links nach rechts ausgewertet.

Mit Operanden vom Typ `string` (Groß- / Kleinschreibung wird ignoriert):
`+` Addieren (Zeichenketten zusammenhängen)
`>=` größer oder gleich als
`<=` kleiner oder gleich als
`<` kleiner als
`>` größer als
Mit Typ clip:
`+` das gleiche wie die Funktion`UnalignedSplice`
`++` das gleiche wie die Funktion `AlignedSplice`
Mit Operanden vom Typ bool:
`?:` bedingte Ausführung von Code:

`b = (a==true) ? 1 : 2` Übersetzt in Pseudo-Basic: `wenn (a=true) dann b=1 sonst b=2`

## Skript Funktionen

Die Argumente und das Ergebnis dieser Funktionen sind nicht Clips, sondern andere Variablen, die im Skript verwendet werden.
Numerische Funktionen:

`Floor(float)`: Konvertiert eine Dezimalzahl in Integer (rundet alle Dezimalstellen ab). | `Floor(1.2) = 1` `Floor(1.6) = 1` `Floor(-1.2) = -2` `Floor(-1.6) = -2`
`Ceil(float)`: Konvertiert eine Dezimalzahl in Integer (rundet alle Dezimalstellen auf). | `Ceil(1.2) = 2.0` `Ceil(1.6) = 2.0` `Ceil(-1.2) = -1` `Ceil(-1.6) = -1`
`Round(float)`: Konvertiert eine Dezimalzahl in Integer (rundet alle Dezimalstellen zur nächesten Integerzahl auf oder ab). | `Round(1.2) = 1` `Round(1.6) = 2` `Round(-1.2) = -1` `Round(-1.6) = -2`
`Int(float)`: Konvertiert von Dezimalzahl zu Integer (rundet ab). v2.07 | `Int(1.2) = 1` `Int(1.6) = 1` `Int(-1.2) = -1` `Int(-1.6) = -1`
`Float(int)`: Konvertiert von Integer zu Dezimalzahl. v2.07 |
`Frac(float)`: Gibt den entsprechenden Bruch der Dezimalzahl zurück. v2.07 | `Frac(3.7) = 0.7` `Frac(-1.8) = -0.8`
`Abs(integer)` / `Absx(float)`: Absoluter Wert eines Integer oder Dezimalzahl. v2.07 | `Abs(-3.8) = 1.8`
`Sign(int)` / `Sign(float)`: Gibt das Vorzeichen der Zahl als -1, 0 oder 1 zurück. v2.07 | `Sign(-3.5) = -1` `Sign(3.5) = 1` `Sign(0) = 0`
`HexValue(string)`: Gibt den Wert einer hexadezimaler Zeichenkette zurück. v2.07 | `HexValue ( "FF00" ) = 65280`
`Sin(float)` v2 |
`Cos(float)` v2 |
`Pi()` v2 |
`Log(float)` v2 |
`Exp(float)` v2 |
`Pow(float base,float power)` v2 |
`Sqrt(float}` v2 |
`Rand([int max] [,bool scale] [,bool seed])`: Gibt eine Zufallszahl als Integer zwischen 0 und dem Maximum zurück. v2.07 Standard: Maximum = 32768 scale = TRUE ( TRUE = normaler Modus, FALSE = modulierender Modus) seed = FALSE (TRUE = nutze Zeit als Start) | `Rand(100) = Integer zwischen 0 und 99`
`Spline(float X, x1,y1, x2,y2, ...., bool "cubic"}` v2.5 Interpoliert den Y Wert am Punkt X unter Verwendung der Kontrollpunkte x1/y1,... Man muss mindestens zwei x/y-Paare angeben. Die Interpolation kann kubisch (das Ergebnis ist dann ein Spline) oder linear (das Ergebnis ist ein Polygon) sein. | `Spline(5, 0,0, 10,10, 20,0, false) = 5` `Spline(5, 0,0, 10,10, 20,0, true) = 7`

Zeichenketten Funktionen:

`UCase(string)`: Gibt die Zeichenkette in Großbuchstaben zurück. v2.07 | `UCase("AviSynth") = "AviSynth"`
`LCase(string)`: Gibt die Zeichenkette in Kleinbuchstaben zurück. v2.07 | `LCase("AviSynth") = "AviSynth"`
`RevStr(string)`: Gibt die Zeichenkette in umgedrehter Reihenfolge zurück. v2.07 | `RevStr("AviSynth") = "htnySivA"`
`StrLen(string)`: Gibt die Länge der Zeichenkette zurück. v2.07 | `StrLen("AviSynth") = 8`
`Findstr(string1,string2`): v2.07 Gibt den Versatz an string2 innerhalb von string1 zurück. Die Suche berücksichtigt die Groß- und Kleinschreibung. | `Findstr("AviSynth","syn") = 4`
`LeftStr(string,length)` / `RightStr(string,length)`: v2.07 Gibt den linken oder rechten Teil von der angegebenen Länge der Zeichenkette zurück. | `LeftStr("AviSynth",3) = "Avi"`
`MidStr(string,start [,length])`: v2.07 Gibt einen Teil der Zeichenkette zurück, der bei start (für den ersten Buchstaben start=1) beginnt und die angegebene Länge hat oder bis zum Ende der Zeichenkette. | `MidStr("AviSynth",3,2) = "iS"`
`VersionNumber()` v2.07 | `VersionNumber() = 2.07`
`VersionString()` v2.07 | `VersionString() = "AviSynth 2.08 (AviSynth.org) 22 nov. 2002"`
`Chr(int)`: Gibt das ASCII Zeichen zurück. v2.5 | `Chr(34) gibt das Anführungszeichen zurück`
`Time(string)`: Gibt eine Zeichenkette mit der aktuellen Systemzeit in einem vorgegeben Format zurück. v2.5 | Abkürzung für das Ausgabeformat: %a Kürzel des Wochentages %A Voller Name des Wochentages %b Kürzel des Monats %B Voller Name des Monats %c Datum und Zeit im lokalen Format %d Tag und Monat als Dezimalzahlen (01 - 31) %H Stunde im 24-Stunden Format (00 - 23) %I Stunde im 12-Stunden Format (01 - 12) %j Tag des Jahres als Dezimalzahl (001 - 366) %m Monat als Dezimalzahl (01 – 12) %M Minute als Dezimalzahl (00 – 59) %p Aktuelle locale‚s A.M./P.M. indicator for 12-hour clock %S Sekeunde als Dezimalzahl (00 – 59) %U Woche des Jahres als Dezimalzahl mit Sonntag als erstem Wochentag (00 – 53) %w Wochentag als Dezimalzahl (0 – 6; Sonntag ist 0) %W Wochentag des Jahres als Dezimalzahl mit Montag als erstem Wochentag (00 – 53) %x Date representation for current locale %X Time representation for current locale %y Jahr ohne Jahrhundertangabe als Dezimalzahl (00 – 99) %Y Jahr mit Jahrhundertangabe als Dezimalzahl %z, %Z Zeitzonen Name oder Kürzel; es wird nichts zurückgegeben, wenn die Zeitzone unbekannt ist %% Prozent Zeichen Das # Zeichen kann vor jeden Formatierungs-Code vorangestellt werden. In diesem Fall wird die Deutung des Formatierungs-Codes wie folgt geändert: %#a, %#A, %#b, %#B, %#p, %#X, %#z, %#Z, %#% # Zeichen werden ignoriert. %#c Long date and time representation, appropriate for current locale. For example: "Tuesday, March 14, 1995, 12:41:29". %#x Long date representation, appropriate to current locale. For example: "Tuesday, March 14, 1995". %#d, %#H, %#I, %#j, %#m, %#M, %#S, %#U, %#w, %#W, %#y, %#Y Remove leading zeros (if any).

Konvertierungen:

`Value(string)`: Gibt den Wert einer Zeichenkette zurück. v2.07 | `Value( "-2.7" ) = 2.7`
`String(float/int/string)`: Konvertiert eine Zahl in eine Zeichenkette.v2 | `z.B. Subtitle( "Clip Höhe ist " + String(last.height))`

Test Funktionen:
`IsBool(var)` `IsInt(var)`
`IsFloat(var)`
`IsString(var)`
`IsClip(var)`
Andere Funktionen:
`Select(index, item0 [,item1...])`: Gibt item zurück, ausgewählt durch index (0=item0). Items können beliebige Variablen, Clips oder beides sein. v2.07 `Defined(var)`: um optionale Parameter in benutzer-definierten Funktionen definieren zu können.
`Default(x,d)`: ergibt x, wenn Defined(x), ansonsten d.
`Exist(Dateiname)`: Gibt TRUE oder FALSE zurück, je nachdem ob die Datei existiert oder nicht. v2.07
`NOP`: Gibt NULL zurück, wird hauptsächlich für bedingte Ausführung wie z.B. Importieren genutzt, wobei kein Rückgabewert ausgegeben wird. v2.07
`Eval(string)`
`Apply(func-string,arg,...)`: Eval("f(x)") ist äquivalent zu f(x) ist äquivalent zu Apply("f", x).

Man kann Eval für sowas verwenden: `settings = "352, 288" Eval( "BicubicResize(" + settings + ")" )`

Es kann auch der Text von einem anderen Skript importiert werden:
`Import` (Dateiname): verarbeitet den Inhalt von einem andern AviSynth Skript.
Für Fehlermeldungen und das Auffangen von falschen Benutzereingaben kann folgendes verwendet werden:
`Assert(bool, string "Fehlermeldung")`: Fehlermeldungen erzeugen
`AssertEval(string)`
Es gibt auch eine Funktion, mit der man überprüfen kann, ob ein Fehler auftreten WIRD:

`Try { AviSource("C:\Dateiname.avi") } catch(Fehlermeldung) { nbsp; Blackness.Subtitle(Fehlermeldung) }`

## Laufzeit Funktionen

Es gibt Conditional Filter, die ein Skript auswerten, während ein Frame bearbeitet wird, so dass man Variablen von Frame zu Frame ändern kann.
Es gibt für diverse Anwendungen mehrere Laufzeit Funktionen, die den Inhalt eines Clips auf ihre Weise auswerten und einen Wert zurückgeben. v2.5

Ein einfaches Beispiel, um die durchschnittliche Helligkeit eines Frames zu ermitteln und diese anzuzeigen. `Version() # Erzeugt einen Testclip ConvertToYV12() # konvertiert ihn in YV12 FadeIn(10) # Verändert die Helligkeit, so dass man auch etwas beobachten kann ScriptClip(" Subtitle(String(AverageLuma())) ") # Wertet Subtitle(...) für jeden Frame aus # Das Ergebnis von AverageLuma wird in einen String # konvertiert und als Untertitel im Clip angezeigt. ConvertToRGB() # Zum Betrachten wird nach RGB konvertiert`

## Steuerfunktionen

`SetMemoryMax(int)`: Setzt die maximale Speichergröße, die AviSynth verwendet (in MB) v2
In manchen Versionen ist die Standardgröße 5MB, was recht wenig ist. Wenn Probleme auftreten (besonders langsame Geschwindigkeit), sollte dieser Wert auf mindestens 32MB gesetzt werden.
`SetWorkingDir(string)`: Setzt das Standard-Verzeichnis für AviSynth (normalerweise sonst das Verzeichnis in dem sich das Skript befindet). v2
Das kann vor allem für das einfache Laden von Quell-Clips verwendet werden und hat keinerlei Auswirkung auf das automatische Laden der Plugins. Das Ergebnis ist 0 wenn erfolgreich, sonst -1 (wenn z.B. der Pfad nicht existiert)

## Clip-Eigenschaften

Diese Funktionen haben als Argument ein Clip, als Rückgabewert eine Eigenschaft des Clips.
`Width(clip)` Breite
`Height(clip)` Höhe
`Framecount(clip)` Anzahl der Frames
`Framerate(clip)` Framerate (Bilder pro Sekunde)
`Audiorate(clip)` Samplingfrequenz des Tones
`Audiolength(clip)` Länge des Tones
`Audiochannels(clip)` Anzahl der Kanäle
`Audiobits(clip)` Bitanzahl
`IsRGB(clip)` Videoformat ist RGB
`IsRGB24(clip)` Videoformat ist RGB24 v2.07
`IsRGB32(clip)` Videoformat ist RGB32 v2.07
`IsYUY2(clip)` Videoformat ist YUY2
`IsYV12(clip)` Videoformat ist YV12 v2.51
`IsPlanar(clip)` Videoformat ist eben v2.51
`IsInterleaved(clip)` Videoformat ist interleaved v2.51
`IsFieldBased(clip)` Video basiert auf Feldern (interlaced)
`IsFrameBased(clip)` Video basiert auf Frames (progressive)
`GetParity(clip)` Welches Feld (Halbbild) wird zuerst angezeigt (gerade/ungerade)

Nicht vergessen: die Clip-Eigenschaften können auch mit der impliziten Variablen LAST oder mit der OOP-Notation verwendet werden: `BilinearResize(Width/2, Height/2)` ist das gleiche wie: `BilinearResize(Width(Last)/2, Height(Last)/2)` ist das gleiche wie: `BilinearResize(Last.Width / 2, Last.Height / 2)`

## Benutzerdefinierte Funktionen

Man kann auch selber Funktionen definieren. Das kann am Besten anhand eines Beispiels erklärt werden:

`function NTSC2PAL(clip c) { # Ziemlich gut für NTSC->PAL Konvertierungen. Noch besser wäre es mit Smart Bob. :-) Assert(c.height == 480, "NTSC2PAL: Quell-Clip muss 480 Zeilen haben") Bob(c, height=576) return Weave() }`

Sogar rekursive Funktionen können definiert werden:

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

## Funktionen mit mehr als einem Quell-Clip

Manche Funktionen kombinieren zwei oder mehrere Clips auf verschiedene Art. Wie der Videoinhalt berechnet wird, ist bei den jeweiligen Funktionen beschrieben, hier ist eine Zusammenfassung welche Eigenschaften das Ergebnis-Clip haben wird.
Das Quell-Clip muss immer im gleichem Farbraum vorliegen und - mit Ausnahme von `Layer` - auch die gleichen Abmessungen haben.

| Framerate | Frame Anzahl | Audio Inhalt | Audio Samplingrate
AlignedSplice, UnalignedSplice | Erster Clip | Summe aller Clips |  | Siehe Filter Beschreibung | Erster Clip
Dissolve | Summe aller Clips abzüglich der Überlappung |  | Siehe Filter Beschreibung
MergeLuma, MergeChroma | Erster Clip | Der letzte Frame des kürzeren Clips wird wiederholt bis zum Ende des Clips | Erster Clip
Layer
Subtract | Längster Clip
StackHorizontal, StackVertical
Interleave | (fps des ersten Clips) x (Anzahl der Clips) | Doppelte Frameanzahl des längsten Clips

Wie man sehen kann, sind die Funktionen nicht völlig symmetrisch, sondern nehmen manche Eigenschaften vom ERSTEN Clip.

## Plugins

Mit diesen Funktionen können externe Filter zu AviSynth hinzugefügt werden.
Die Reihenfolge, in welcher gleichlautende Funktionen aufgerufen werden, ist: v2
1. Funktionen aus externen Plugins
2. Benutzerdefinierte Funktionen
3. AviSynth-interne Funktionen
`LoadPlugin`("Dateiname"[,...])
Lädt ein oder mehrere externe AviSynth Plugins (Dll`s).

`LoadVirtualDubPlugin`("Dateiname", "Filtername", preroll)
So wird ein Plugin geladen, das für VirtualDub geschrieben wurde. "Dateiname" ist der Name der .vdf-Datei. Nach dem Aufruf dieser Funktion kann das Filter mit "Filtername" in AviSynth benutzt werden. VirtualDub Filter unterstützen nur den RGB32-Farbraum. Wenn das Video in einem anderen Format vorliegt, muss man `ConvertToRGB32` verwenden (`ConvertToRGB` reicht nicht aus).
Das Ergebnis mancher Filter hängt von vorhergehenden Frames ab, für diese muss `preroll` mindestens die Anzahl der Frames sein, die der Filter zum Auffüllen seiner internen Speicher benötigt und/oder um seine internen Variablen zu aktualisieren.

`LoadVFAPIPlugin`("Dateiname", "Filtername")
So können VFAPI Plugins (TMPGEnc Import Plugins) verwendet werden.

Automatisches Laden von Plugins und Funktionsnamen Priorität v2
Es ist möglich, alle Plugins und Skripte mit benutzerdefinierten Funktionen oder globalen Variablen in einem Verzeichnis abzulegen, aus dem dann alle Dateien mit den Endungen .AVS and .DLL beim Starten von AviSynth geladen werden (dynamisch, d.h. wenn sie wirklich vom Skript benötigt werden).
Skripte in diesem Verzeichnis sollten nur Funktions-Definitionen und globale Variable, aber nicht den Teil der Videobearbeitung beinhalten (also kein `AviSource` usw.), sonst können seltsame Fehler auftreten. Auch sollten keine anderen Dateien in diesem Verzeichnis gespeichert werden.
Der Verzeichnisname ist in der Registry gespeichert (der Registry-Schlüssel hat sich bei v2.5 geändert). Man kann eine .REG-Datei mit folgendem Inhalt doppelklicken, um den Pfad zu setzen (natürlich vorher den wirklichen Pfad einsetzen):

`REGEDIT4 [HKEY_LOCAL_MACHINE\SOFTWARE\AviSynth] "PluginDir2_5"="C:\\Programme\\AviSynth\\Plugins"`

Die Reihenfolge, in der gleichnamige Funktionen aufgerufen werden, ist:
1. Funktionen aus externen Plugins (haben immer die höchste Priorität)
2. Benutzerdefinierte Funktionen (haben eine höhere Priorität als eingebaute Funktionen - so kann man eingebaute Funktionen durch eigene ersetzen)
3. eingebaute Funktionen
Innerhalb dieser Gruppen hat die am letzten geladene Funktion Vorrang, es gibt keine Fehler durch ein Problem mit Funktionsnamen.