## Začínáme

V zásadě AviSynth pracuje takto: Nejdříve vytvoříte jednoduchý textový dokument se speciálními příkazy, nazývaný skript. Tyto příkazy se vztahují k jednomu nebo více video-klipům s filtry, kterými si přejete klipy zpracovat. Potom spusťte některý videoeditor, jako VirtualDub a otevřete v něm skriptový soubor. Nyní začíná AviSynth pracovat. Otvírá videa, na která se odkazuje skript, upravuje video pomocí filtrů a předává výstupní video videoeditoru. Videoeditor ani neví, že AviSynth zpracovává video na pozadí. Naopak, videoeditor si myslí, že přímo otvírá a filtruje AVI soubor uložený na pevném disku.

Ve verzích AviSynth 2 je zavedena nová funkcionalita a část funkcí je přetvořena. Aby byli jasněji viditelné body týkající se nové funkcionality (zvláště nedostatečně popsané v dřívější dokumentaci) jsou označeny značkou v2

Verze 2.5 obsahuje velké vnitřní změny. Před jejím použitím si pozorně přečtěte AviSynth 2.5 . Odpovídající změny jsou označeny značkou v2.5

#### Lineární editace:

Nejjednodušší věci, které můžete s AviSynthem provádět jsou operace, které lze provést např. také ve VirtualDubu. Skripty jsou pro to jednoduché, nemusíte se obávat proměnných a složitých výrazů, pokud to nechcete.

Pro vyzkoušení vytvořte soubor nazvaný test.avs a vložte do něj následující jednoduchý textový řádek:

    Version

Nyní otevřete soubor například ve Windows Media Playeru a uvidíte 10-ti sekundový videoklip ukazující číslo verze AviSynthu a informaci o autorských právech.

`Version` je to co je možné nazvat "zdrojový filtr", rozumí se tím, že vytváří nový klip místo modifikace stávajícího. První příkaz ve skriptu AviSynthu bude vždy zdrojový filtr.

Nyní přidáme druhý řádek do skriptového souboru, který bude vypadat takto:

    Version
    ReduceBy2

Znovu otevřeme soubor v Media Playeru. Měli by jste znovu vidět informaci o verzi, ale v poloviční velikosti proti předchozí.
`ReduceBy2` je "transformační filtr", to znamená, že bere původní klip a nějakým způsobem ho upraví. Můžete za sebe poskládat několik transformačních filtrů, stejně jako ve VirualDubu.
Přidejme ještě jeden řádek, který vytvoří stmívání na konci videa. Doplníme do skriptu následující řádek:

    Version
    ReduceBy2
    FadeOut(10)

Znovu otevřeme soubor. Klip bude stejný prvních 9 vteřin, v poslední vteřině plynule přejde do černa.
Filtr FadeOut bere celočíselný argument, který udává číslo snímků, ve kterých proběhne stmívání.

Trvá hodně dlouho než začne stmívání, a proto vystřihneme začátek klipu pro zkrácení čekání před stmíváním.
Zahoďme prvních 120 snímků, a zachovejme snímky 120-150:

    Version
    ReduceBy2
    # Odřízne prvních 119 snímků a nechá snímky 120-150
    # (AviSynth začíná číslování snímků od 0)
    Trim(120,150)
    FadeOut(10)

V tomto příkladu poprvé používáme komentář.
Komentář začíná symbolem # a pokračuje do konce řádku a je AviSynthem úplně ignorován.
Filtr Trim vyžaduje dva argumenty, oddělené čárkou: první a poslední snímek klipu, který bude zachován. Jestli zadáme 0 jako poslední snímek, je to jako "konec klipu", takže pokud chcete odstranit prvních 119 snímků můžete použít příkaz Trim(120,0).

Pamatovat si čísla snímků takovým způsobem je otravné. Mnohem snadnější je otevřít částečně vytvořený skript např. ve VirtualDubu, který zobrazuje čísla daných snímků. Můžete také použít filtr ShowFrameNumber , který natiskne do snímků klipu jejich čísla.

V praxi mnohem více využívaným zdrojovým filtrem než Version je AVISource, který čte AVI soubory (nebo jeden z několika jiných typů souborů) z disku. Jestli máte po ruce nějaký AVI soubor, můžete zkusit použít stejné filtry na váš soubor:

    AVISource("d:\capture.avi")  # uvede se cesta k danému souboru
    ReduceBy2
    FadeOut(15)
    Trim(120,0)

Dokonce jednořádkový skript, obsahující pouze jednořádkový příkaz AVISource může být užitečný pro doplnění podpory pro AVI soubory >2GB v editorech, které podporují jen soubory <2GB .

#### Nelineární editace:

Nyní se dostáváme k zábavnější části. Vytvořte AVS soubor s následujícím skriptem:

    StackVertical(Version, Version)

Otevřete jej. Výsledek: Výsledné video má dva stejné řádky s informací o verzi, jeden nad druhým.
Místo aby bral čísla nebo řetězce jako argumenty, bere StackVertical videoklipy jako argumenty. V tomto skriptu je filtr Version volán dvakrát. Po každé se vrací kopie verze. Tyto dva klipy se předávají filtru StackVertical , který je spojí dohromady (bez znalosti jejich původu).

Jeden z nejpoužívanějších filtrů takového typu je UnalignedSplice , který spojí videoklipy jeden za druhým. Zde je skript, který načítá tři AVI soubory (které mohou být vytvořeny jako AVI_IO) a spojuje je dohromady. Obrácené lomítko znamená, že funkce pokračuje na dalším řádku.

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

Oba filtry StackVertical i UnalignedSplice mohou mít minimálně dva a maximálně šestnáct argumentů.
Můžete používat operátor `+` jako zkratku pro UnalignedSplice.

Například, tento skript provede to samé jako předchozí:

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

Nyní předpokládejme, že zachytáváte pomocí videoeditoru video ve více AVI segmentech, ale audio se ukládá v odděleném WAV souboru.
Můžeme vše znovu spojit? Vaše volba je:

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

## Syntaxe

#### Výrazy:

Skript AviSynthu obsahuje množství řádků údajů takovéhoto typu:

    variable_name = expression

V tomto příkladu je vyhodnocen výraz expression a výsledek je zapsán do proměnné variable_name.

Velmi důležitá je běžná zkrácená forma příkazu:

    expression

V tomto případě probíhá vyhodnocení expression a výsledek se přiřadí speciální proměnné klipu last.
Je to stejné jako:

    last = expression

Konec skriptu často vypadá takto:

    return expression

Zde probíhá vyhodnocení a jeho výsledek je použit jako "vrácená hodnota" skriptu - to je videoklip, který zobrazí videoeditor, ve kterém otvíráme AVS soubor.

Jestli příkaz "return" není výslovně uveden, vrátí skript na konci své práce klip last použitý jako "vrácená hodnota" ("return value").

Základní forma výrazu, který vyvolá funkci je:

    Function(args)

Funkce pro klipy vždy produkují nový videoklip a nikdy nemodifikují stávající,
Args je seznam argumentů funkce oddělených čárkou. Seznam může být prázdný (rozumí se tím, že všechny nebo některé argumenty mohou být volitelné - nepovinné).

Jestli funkce filtru očekává videoklip jako svůj první argument a tento argument není uveden, pak bude použit klip ze speciální proměnné last .

Filtry AviSynthu mohou brát také jmenné argumenty. Jmenné argumenty mohou být ukázány v libovolném pořadí,
a filtr bude vybírat přednastavené (default) hodnoty pro všechny vynechané argumenty (jmenné argumenty jsou vždy volitelné-nepovinné).
To pomáhá u určitých filtrů podstatně zjednodušit práci s nimi.

     Můžete napsat

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

    namísto

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

Alternativní syntaxe (nazývaná "OOP notation") pro klipové funkce je:

    expression.Function(args)

    např.:
    Version.ReduceBy2.FadeOut(15)

To je ekvivalentní k

    Function(expression, args)

    např.:
    FadeOut(15, ReduceBy2(Version))

a rozumí se tím použití funkce `Function` na `expression`.
Jednou z nevýhod OOP notation je možnost jejího využití pouze pro filtry s jediným argumentem typu klip, a ne pro filtry s několika argumenty.

Všechny funkce AviSynthu vytváří určitý počet snímků s určitou frekvencí snímků (framerate), dokonce i když výraz vypadá velmi složitě.
AviSynth po přečtení skriptu ví jakou délku bude mít výstupní klip, jakou bude mít frekvenci snímků a posloupnost všech vstupních snímků
To vše se vyhodnocuje při otevření skriptu. V době zpracování se při vyžádání snímku provádí pouze skutečné filtrování.

Komentáře: AviSynth ignoruje jakýkoliv text následující za symbolem # až do konce řádku:

    # komentář

Ve v2.58 je možné přidat blok a vložený blok komentářů následujícím způsobem:

    # blok komentáře:
    /*
    komentář 1
    komentář 2
    */

    # vložený blok komentářů:
    [* [* smysluplný příklad s pozdějším následováním :) *] *]

AviSynth ignoruje cokoliv od slova `__END__` (se dvěma podtržítky) do konce skriptového souboru. Může to být použito pro vypnutí některých posledních příkazů ve skriptu.

    Version()
    __END__
    ReduceBy2()
    Výsledek není zmenšený a my sem můžeme psát jakýkoliv text

Ignorování velkých-malých písmen: aViSouRCe znamená to samé jako AVISource.

Pokračování na následujícím řádku nebo pokračování z předchozího řádku: \

    Subtitle ("Test-Text")

    Subtitle ( \
              "Test-Text")

    Subtitle (
           \ "Test-Text")

#### Proměnné:

Jména proměnných mohou mít délku 50 znaků (ve skutečnosti více než 4000 znaků Avisynth v2.56 ) a mohou obsahovat (anglická) písmena, čísla a podtržítka (_), ale žádné jiné znaky. Jméno nemůže začínat číslem.

Smíte použít znaky z kódu vašeho jazykového systému (lokálně) v řetězcích (strings) a názvech souborů (pouze ANSI 8 bit, ne Unicode).

Mohou být použity následující typy proměnných:

clip : video klip obsahující video a / nebo audio. Nejméně jedna proměnná musí být pro skriptem použita a vrácena.
string : řetězec - uzavřený v "uvozovkách" nebo v trojitých uvozovkách jako zde """tento případ""". Textový řetězec může obsahovat libovolné znaky kromě uvozovek nebo dvojitého apostrofu. Pokud potřebujete vložit do řetězce uvozovky použijte trojité uvozovky:

    Subtitle ("""Tohle zobrazí "hello world" v uvozovkách""")

int: celočíselné - vstupuje se jako řetězec čísel, volitelně s + nebo - na začátku.
float: desetinné - vstupuje se jako řada čísel s desetinnou tečkou (.) mezi číslicemi, a doplňuje se volitelně + nebo -. Například s +1. se zachází jako s číslem s desetinnou tečkou.
val: typ argumentu funkce pro který je jedno jestli je hodnota int nebo float
bool: logická - může být pravda TRUE nebo lež FALSE
hexadecimal numbers: zadává se s předcházejícím znakem $. Tato proměnná je celočíselná (integer). Některé filtry využívají takové označení pro specifikování barev. Například, $FF8800 je tmavě oranžová.

global: definuje globální proměnnou, která může být využívána všemi uživatelem definovanými (user-defined) funkcemi stejně jako i základním skriptem.

Zde je jiná verze dříve uvedeného příkladu, která je ovladatelnější a snadnější pro pochopení:

    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)

## Barvy

V některých filtrech (BlankClip, Letterbox, AddBorders a FadeXXX) může být zadán argument barvy. V každém případě má být zadán v RGB formátu, dokonce i když je formát barev vstupního klipu YUV. Parametr může být zadán jak v šestnáctkovém tak i v desítkovém tvaru. V šestnáctkovém tvaru vypadá následovně: první dvě cifry určují kanál červené barvy R, další dvě zelený kanál G a poslední dvě modrý kanál B. Před šestnáctkovým číslem musí být symbol $. V desítkovém tvaru je číslo následující: hodnota červeného kanálu je násobena číslem 65536 (2 na 16), hodnota zeleného kanálu je násobena 256 (2na 8) a oba dva výsledné produkty jsou doplněny do hodnoty modrého kanálu.

Ukažme si příklad. Hnědá barva se zadává R= $A5 (165), G= $2A (42), B= $2A (42). Takovým způsobem dá `BlankClip(color= $A52A2A)` hnědý snímek. Převedení do desítkové číselné soustavy (pamatujme, že A=10, B=11, C=12, D=14, E=14, F=15) nám dá

    R = $A5 = 10*16^1 +  5*16^0 = 165
    G = $2A =  2*16^1 + 10*16^0 =  42
    B = $2A =  2*16^1 + 10*16^0 =  42

    165*65536 + 42*256 + 42 = 10824234

Takovým způsobem, pro vytvoření hnědého snímku v desítkové soustavě použije `BlankClip(color=10824234)`.

Běžná přednastavení barev najdete v souboru colors_rgb.avsi, který by měl být ve vaší složce autonačítaných pluginů (podívejte se do souboru na seznam přednastavení). Proto `BlankClip(color=color_brown)` dává stejné hnědé snímky.

Všimněte si, že černá RGB=$000000 bude převedena do Y= 16,U=V= 128 pokud je barevný formát vstupního videa YUV, protože je použit výchozí (defaultní) převod barev RGB [0,255] -> YUV [16,235].

## Operátory

Pro všechny typy proměnných (clip, int, float, string, bool) se kterými lze provádět operace lze použít tyto operátory:
`==` je rovno
`!=` není rovno

Pro číselné typy (int, float):
`+` přidat
`-` odečíst
`*` násobit
`/` dělit
`%` zbytek po dělení
`>=` větší nebo rovno
`<=` menší nebo rovno
`<` menší než
`>` větší než

AviSynth v dřívějších verzích zpracovával výrazy zprava doleva, což vedlo k neočekávaným výsledkům:

    a = 10 - 5 - 5
    výsledek byl 10 - (5 - 5) = 10
    místo (10 - 5) - 5 = 0 !

Tento nedostatek byl opraven! Od verze v2.53 se zpracovávají zleva doprava také násobení a dělení (namísto zprava doleva).

Pro řetězcový typ:
`+` přidat
`>=` větší nebo rovno než (nerozlišuje malá a velká písmena)
`<=` menší nebo rovno než (nerozlišuje malá a velká písmena)
`<` menší než (nerozlišuje malá a velká písmena)
`>` větší než (nerozlišuje malá a velká písmena)

Pro klipy:
`+` stejné jako funkce `UnalignedSplice`
`++` stejné jako funkce `AlignedSplice`

Pro logické (pravda/lež - true/false):
`||` nebo (or)
`&&` a (and)
`?:` podmíněné vyplnění kódu (operátor jazyka C)

    b = (a==true)  ?  1 : 2

    To znamená jako by v pseudo-basic:

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

## Skriptové Funkce

Vstupní a výstupní hodnoty těchto funkcí nejsou klipy, ale některé další proměnné použité ve skriptu.

#### Numerické funkce:

`Max(int, int[, ...])` / `Max(float, float[, ...])` : Maximální hodnota řady čísel. | `Max` (1, 2) = 2 `Max` (5, 3.0, 2) = 5.0
`Min(int, int[, ...])` / `Min(float, float[, ...])` : Minimální hodnota řady čísel. | `Min` (1, 2) = 1 `Min` (5, 3.0, 2) = 2.0
`MulDiv(int, int, int)` : (m*n+d/2)/d s 64 bitovým mezivýsledkem. | `MulDiv` (1, 1, 2) = 1 `MulDiv` (2, 3, 2) = 3
`Floor(float)`: převádí z float do int (zaokrouhlení dolů). | `Floor` (1.2) = 1 `Floor` (1.6) = 1 `Floor` (-1.2) = -2 `Floor` (-1.6) = -2
`Ceil` (float): převádí z float do int (zaokrouhlení nahoru). | `Ceil` (1.2) = 2.0 `Ceil` (1.6) = 2.0 `Ceil` (-1.2) = -1 `Ceil` (-1.6) = -1
`Round` (float): převádí z float do int (zaokrouhlení podle pravidel). | `Round` (1.2) = 1 `Round` (1.6) = 2 `Round` (-1.2) = -1 `Round` (-1.6) = -2
`Int` (float): převádí z float do int (zahodí údaj za desetinnou tečkou = round towards zero). | `Int` (1.2) = 1 `Int` (1.6) = 1 `Int` (-1.2) = -1 `Int` (-1.6) = -1
`Float` (int): převádí z int do float. | `Float` (1) = 1.0
`Frac` (float ): Vrací část za desetinnou tečkou. | `Frac` (3.7) = 0.7 `Frac` (-1.8) = -0.8
`Abs` (integer) / `Abs` (float): Vrací absolutní hodnotu (vrací desetinné pro desetinné, celé pro celé). | `Abs` (-6) = 6 `Abs` (-1.8) = 1.8
`Sign` (int) / `Sign` (float): vrací znak čísla (kladné, nulové nebo záporné ve tvaru 1, 0 nebo -1). | `Sign`(-3.5) = -1 `Sign`(3.5) = 1 `Sign`(0) = 0
`HexValue` (string) Vyčíslí řetězec jako šestnáctkovou hodnotu. | `HexValue` ("FF00") = 65280
`Sin` (float ) Vrací sinus argumentu (argument se zadává v radiánech). | Sin(Pi()/4) = 0.707 Sin(Pi()/2) = 1.0
`Cos` (float ) Vrací kosinus argumentu (argument se zadává v radiánech). | Cos(Pi()/4) = 0.707 Cos(Pi()/2) = 0.0
`Pi` () Vrací číslo "Pí" - konstanta (jako podíl obvodu a průměru kružnice). | d = Pi() # d == 3.141593
`Log` (float ) Vrací přirozený logaritmus argumentu (základ-e). | Log(1) = 0.0 Log(10) = 2.30259
`Exp` (float ) Vrací přirozený exponent argumentu (základ-e). | Exp(1) = 2.718282 Exp(0) = 1.0
`Pow` (float base, float power ) Vrací základ (první argument - "base" ) umocněný druhým argumentem. | Pow(2, 3) = 8 Pow(3, 2) = 9 Pow(3.45, 1.75) = 8.7334
`Sqrt` (float ) Vrací druhou odmocninu argumentu. | Sqrt(1) = 1.0 Sqrt(2) = 1.4142
`Rand` ([int max] [, bool scale] [, bool seed]): vrací náhodné celé číslo mezi 0 a maximem. Výchozí (defaults):max = 32768, scale = TRUE, seed = FALSE Scale = FALSE, modulus mode, (Rand(32768)%limit) Seed = TRUE, využívá čas pro zadání počáteční hodnoty náhodného generátoru | `Rand`(100) = celé číslo mezi 0 a 99, všechna čísla jsou stejně pravděpodobná. `Rand`(32767, False) = celé číslo mezi 0 a 32766, s 0 dvakrát pravděpodobnější než ostatní čísla.
`Spline` (float X, x1,y1, x2,y2, ...., bool "cubic"} v2.5 Interpoluje hodnotu Y pro bod X při využívání kontrolních bodů x1/y1,... Jsou nutné minimálně 2 x/y-páry. Interpolace může být kubická (výsledkem je spline) nebo lineární (výsledkem je polygon) | `Spline` (5, 0,0, 10,10, 20,0, false) = 5 `Spline` (5, 0,0, 10,10, 20,0, true) = 7

#### Řetězcové funkce:

`UCase` (string ): vrací řetězec ve velkých písmenech | `UCase` ("AviSynth") = "AVISYNTH"
`LCase` (string): vrací řetězec v malých písmenech | `LCase` ("AviSynth") = "avisynth"
`RevStr` (string ): vrací řetězec v pozpátku | `RevStr` ("AviSynth") = "htnySivA"
`StrLen` (string ): vrací délku řetězce | `StrLen` ("AviSynth") = 8
`Findstr` (string1, string2): Vrací pozici řetězce string2 uvnitř string1. Při hledání se zohledňují velká a malá písmena. | `Findstr` ("AviSynth","syn") = 4
`LeftStr` (string, length) / `RightStr` (string, length): vrací levou nebo pravou část řetězce dané délky | `LeftStr` ("AviSynth",3) = "Avi"
`MidStr` (string, start [, length]): vrací část řetězce od pozice start (pro první znak je start= 1) v délce -počtu znaků- dané parametrem length nebo do konce řetězce (není-li délka zadaná). | `MidStr` ("AviSynth",3,2) = "iS"
`Chr` (int ): vrací znak podle tabulky znaků ASCII v2.5 | `Chr` (34) vrátí symbol uvozovek
`Time` (string ): vrací řetězec se systémovým časem ve tvaru řetězce daného formátu v2.5 | Kódy výstupního formátu: %a Zkratka dne v týdnu %A Celý název dne v týdnu %b Zkratka měsíce %B Celý název měsíce %c Datum a čas v příslušném časovém pásmu %d Den měsíce jako desítkové číslo (01 - 31) %H Hodina ve 24-hodinovém formátu (00 - 23) %I Hodina ve 12-hodinovém formátu (01 - 12) %j Den v roce jako desítkové číslo (001 - 366) %m Měsíc jako desítkové číslo (01 - 12) %M Minuta jako desítkové číslo (00 - 59) %p Indikátor času ve 12-hod. formátu A.M./P.M. %S Vteřiny jako desítkové číslo (00 - 59) %U Týden v roce jako desítkové číslo, s nedělí jako prvním dnem v týdnu (00 - 53) %w Den v týdnu jako desítkové číslo (0 - 6; Neděle je 0) %W Týden v roce jako desítkové číslo, Pondělí je prvním dnem v týdnu (00 - 53) %x Datum v místním časovém pásmu %X Čas v místním časovém pásmu %y Rok bez století, jako desítkové číslo (00 - 99) %Y Rok se stoletím, jako desítkové číslo %z, %Z Jméno časového pásma nebo jeho zkratka; žádné symboly je-li pásmo neznámé %% Znak procenta Značka # může předcházet jakýkoliv formátový kód. V daném případě se význam může měnit následovně: %#a, %#A, %#b, %#B, %#p, %#X, %#z, %#Z, %#% znak # je ignorován. %#c Použije se dlouhé místní nastavení data a času. Například: "Úterý, 14 Března, 1995, 12:41:29". %#x Použije se dlouhé místní nastavení data. Například: "Tuesday, March 14, 1995". %#d, %#H, %#I, %#j, %#m, %#M, %#S, %#U, %#w, %#W, %#y, %#Y Odstraní úvodní nulu (pokud nějaká je).

#### Převody (konverze):

`Value` (string ): Vrací hodnotu řetězce. | `Value` ( "-2.7" ) = -2.7
`String` (float / int / string, format_string ): Převede číslo na řetězec. Je-li proměnná typu float nebo integer, převede ji na float a použije převod formátového řetězce format_string na řetězec. Syntaxe formátového řetězce format_string je následující: %[flags][width][.precision]f width: minimální šířka (řetězce se nikdy neořezává) precision: počet tištěných cifer flags: `- zarovnání vlevo` (namísto pravého zarovnání) `+` vždy tisknout (zobrazovat) znak +/- `0` vypisovat úvodní nuly `' '` tisknut (zobrazovat) mezeru namísto "+" `#` vždy tisknout (zobrazovat) desetinnou tečku | např. `Subtitle` ("Výška snímku je" + `String` (last.height) ) `String`(1.23, "%f") = '1.23' `String`(1.23, "%5.1f") = ' 1.2' `String`(1.23, "%1.3f") = '1.230'

#### Funkce kontroly verze:

`VersionNumber` () Vrací číslo verze AviSynthu jako desetinné číslo | `VersionNumber` () = 2.56
`VersionString` () Vrací číslo verze AviSynthu jako řetězec (první řádek je použit v příkazu `Version` ). | `VersionString` () = "AviSynth 2.56, build:Oct 28 2005 [18:43:54]"

#### Testovací funkce:

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

#### Další funkce:

`Select` (index, item0 [, item1...]): Vrací pozici vybranou podle indexu (0= item0). Pozicí může být jakákoliv proměnná nebo klip, mohou být dokonce smíchány.
`Defined` (var ): Pro zadání volitelných funkcí definovaných uživatelem.
`Default` (x, d): Vrací x jestliže je určeno funkcí Defined(x), jinak vrací d.
`Exist` (filename): Vrací TRUE nebo FALSE po kontrole zda soubor existuje.
`NOP` (): Vrací NULL, při provádění operací podmíněného plnění v ručním režimu pro členy nevracející žádné hodnoty, jako import a podmíněných konstrukcí bez "else".
`Eval` (string),
`Apply` (func-string, arg,...): `Eval` ("f(x)") je ekvivalentní k `f(x)` což je také ekvivalentní k `Apply` ("f", x)

    Můžete využít Eval například takto:
    settings = "352, 288"
    Eval( "BicubicResize(" + settings + ")" )

`Import`(filename ): plní obsah jiného skriptu AviSynthu (importuje text z jiného skriptu)

Pro sdělení o chybách a přehmatech některých uživatelem zadaných vstupních hodnot, je možné použít:
`Assert`(bool, string error-message)

`Try ... Catch` : Toto je funkce prověřující jestli nedojde k chybě:

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

## Runtime Funkce (Funkce časového plnění )

Existují Podmíněné filtry (Conditional filters), které vyhodnocují skripty při zpracování snímku a tím vám umožňují měnit proměnné pro různé snímky.
Pro řešení většiny úloh je nutné využívat Runtime Funkce (funkce časového plnění), které zpracovávají obsah klipu a vrací hodnoty. v2.5

Zde je jednoduchý příklad, vyhodnocující střední hodnotu jasu (luma) u každého snímku a zobrazující výsledek.

    Version()      # Generuje textový klip
    ConvertToYV12()# Převádíme do potřebného formátu YV12
    FadeIn(10)     # vytváříme změnu jasu
                   # vidíme, že se něco děje

                   # Vyhodnocujeme titulky (...) u každého snímku
                   # výstup středního jasu (Luma) je převeden na
                   # řetězec a vložený ve formě titulků do vstupního klipu
    ScriptClip(" Subtitle(String(AverageLuma())) ")
    ConvertToRgb   # sledujeme výsledek v RGB

## Ovládací funkce

`SetMemoryMax` (int ): Nastavuje maximální využitelnou paměť (v MB). Nastavení na nulu vrátí aktuální hodnotu Memory Max. v2, (=0) v2.5.8

V řadě 2.5 je výchozí hodnota Memory Max 25% volné fyzické paměti, s minimem 16MB. Od revize 2.5.8 RC4, je výchozí Memory Max také limitováno na 512MB.

Volná paměť | <64 | 128 | 256 | 512 | 1024 | 2048 | 3072
Výchozí Max v2.5.7 a starší: | 16 | 32 | 64 | 128 | 256 | 512 | 768
Výchozí Max od v2.5.8 RC4: | 16 | 32 | 64 | 128 | 256 | 512 | 512

V některých starších verzích je přednastavená hodnota 5MB, což je dost málo. Pokud pozorujete problémy (např. nízkou rychlost) zkuste nastavit hodnotu aspoň na 32MB. Příliš vysoké hodnoty mohou vést k padání z důvodu 2GB adresového limitu místa. Vrácená hodnota: Skutečná nastavená hodnota velikosti paměti.

`SetPlanarLegacyAlignment` (clip, bool): Nastaví režim zarovnání planárních snímků. v2.5.6

Některé starší pluginy nesprávně rozmisťují snímky videa v paměti. Tento speciální filtr vynutí rozmístění planárních snímků v paměti tak, aby byly kompatibilní s dřívějšími verzemi AviSynthu. Filtr pracuje se zásobníkem funkce GetFrame(), takže jeho činnost se vztahuje na filtry umístěné ve skriptu před ním.

    Příklad : Použití staré verze Mpeg2Source()

    LoadPlugin("...\Mpeg2Decode.dll")
    Mpeg2Source("test.d2v")         # Plugin nesprávně zadává rozmístění
    SetPlanarLegacyAlignment(true)  # Nastavujeme správné zarovnání
                                    # pro dřívější výrazy
    ConvertToYUY2()                 # Výrazy jsou správné do konce
                                    # skriptu a mají pokročilý typ
    ...                             # zarovnání paměti.

`SetWorkingDir` (string ): Nastavuje pracovní složku Avisynthu. v2

Používá se pro snadnější načtení vstupních klipů, atd. Nemá vliv na auto načítání pluginů. Vrací 0 při úspěchu, jinak vrací -1.

`global OPT_AllowFloatAudio=True`: v2.57
Tato možnost povoluje výstupní formát audia WAVE_FORMAT_IEEE_FLOAT (s desetinnou tečkou). Výchozí je automatický převod Float do 16 bitového (celočíselného) audia.

`global OPT_UseWaveExtensible=True`: v2.58
Tato možnost zapíná audio výstup WAVE_FORMAT_EXTENSIBLE. Výchozí je WAVE_FORMAT_EX.

Poznámka: Výchozí DirectShow komponenta pro .AVS soubory, "AVI/WAV File Source ", nesprávně implementuje WAVE_FORMAT_EXTENSIBLE zpracování, takže mnoho aplikací nemusí být schopno detekovat audio stopu. Existují DirectShow čtecí programy třetích stran, které pracují správně. Mezisoubory zapsané použitím AVIFile rozhraní pro pozdější DirectShow zpracování budou pracovat správně, pokud použijí DirectShow "File Source (async)" komponentu nebo ekvivalentní.

## Vícevláknové (Multithreading) funkce

- GetMTMode | v2.6 | GetMTMode(threads)
- SetMTMode | v2.6 | SetMTMode(mode, threads)

Tyto funkce umožňují AviSynthu použít více než jedno vlákno při práci filtrů. To je užitečné pokud máte více než jedno cpu/jádro nebo hyperthreading. Tato funkce je stále experimentální.

GetMTMode(bool threads):

Pokud je threads nastaveno na true, GetMTMode vrátí počet použitých vláken, jinak je vrácen aktuální režim (viz níže). Výchozí je false.

SetMTMode(int mode, int threads):

Umístěte toto do prvního řádku v avs souboru, aby jste zapnuli časový (to je, že více než jeden snímek je zpracován v jednom okamžiku) multithreading. Použijte to dále ve skriptu pro změnu režimu u filtrů pod ním.

mode: Existuje 6 režimů 1 až 6. Výchozí je 2.

- Mode 1 je nejrychlejší, ale pracuje jen s několika filtry.
- Mode 2 by měl pracovat s většinou filtrů, ale vyžívá více paměti.
- Mode 3 by měl pracovat s některými filtry, které nefungují s mode 2 , ale je pomalejší.
- Mode 4 je kombinací mode 2 a 3 a měl by pracovat s ještě více filtry, ale je pomalejší a využívá více paměti.
- Mode 5 je nejpomalejší, ale měl by pracovat se všemi filtry, které nevyžadují lineární frameserving (to je, že snímky přichází popořadě (snímek 0,1,2 ... poslední).
- Mode 6 je upravený mode 5 , který by měl být mírně rychlejší.

threads: Počet použitých vláken. Nastavte na 0 pro nastavení na počet dostupných procesorů. Není možné měnit počet vláken jinde než v prvním SetMTMode. Výchozí je 0.

Příklad:

    SetMTMode(2,0)                      # zapíná multihreading použitím thread = počtu
                                        # dostupných procesorů a mode 2
    LoadPlugin("...\LoadPluginEX.dll")  # potřebné pro načtení avisynth 2.0 pluginů
    LoadPlugin("...\DustV5.dll")        # Načte Pixiedust
    Import("limitedsharpen.avs")
    src = AviSource("test.avi")
    SetMTMode(5)                        # změní mode na 5 pro řádky níže
    src = src.ConvertToYUY2.PixieDust() # Pixiedust potřebuje mode 5 aby fungoval.
    SetMTMode(2)                        # změna mode zpět na 2
    src.LimitedSharpen()                # protože LimitedSharpen pracuje dobře s mode 2
    # zobrazení režimu mode a počtu použitých vláken
    Subtitle("Pocet pouzitych vlaken: " + String(GetMTMode(true))
     \ + " Current MT Mode: " + String(GetMTMode()))

## Vlastnosti klipu

Tyto funkce berou jako vstup klip, jako výstup vrací jeho vlastnosti.

`Width` (clip) | Vrací šířku klipu v pixelech (typ: int).
`Height` (clip) | Vrací výšku klipu v pixelech (typ: int).
`Framecount` (clip) | Vrací počet snímků klipu (typ: int).
`Framerate` (clip) | Vrací počet snímků za sekundu klipu (typ: float).
`FramerateNumerator` (clip) v2.55 | Čitatel zlomkového zápisu snímkové frekvence.
`FramerateDenominator` (clip) v2.55 | Jmenovatel zlomkového zápisu snímkové frekvence.
`Audiorate` (clip) | Vrací vzorkovací frekvenci audia klipu.
`Audiolength` (clip) | Vrací počet vzorků audia klipu (typ: int). Pamatujte, že je zde možnost přetečení u velmi dlouhých klipů ( 2^31 vzorků limit).
`AudiolengthF` (clip) v2.55 | Vrací počet vzorků audia klipu (typ: float).
`Audiochannels` (clip) | Vrací počet kanálů audia klipu.
`Audiobits` (clip) | Vrací bitovou hloubku audia klipu.
`IsAudioFloat` (clip) v2.55 | Vrací true když bitová hloubka audia klipu je float.
`IsAudioInt` (clip) v2.55 | Vrací true když bitová hloubka audia klipu je integer.
`IsRGB` (clip) | Vrací true když je klip RGB, jinak false (typ: bool).
`IsRGB24` (clip) | Vrací true když je klip RGB24, jinak false (typ: bool).
`IsRGB32` (clip) | Vrací true když je klip RGB32, jinak false (typ: bool).
`IsYUY2` (clip) | Vrací true když je klip YUY2, jinak false (typ: bool).
`IsYV12` (clip) v2.51 | Vrací true když je klip YV12, jinak false (typ: bool).
`IsYUV` (clip) v2.54 | Vrací true když je klip YUV, jinak false (typ: bool).
`IsPlanar` (clip) v2.51 | Vrací true když je barevný formát klipu planární, jinak false (typ: bool).
`IsInterleaved` (clip) v2.51 | Vrací true když je barevný formát klipu prolínaný, jinak false (typ: bool).
`IsFieldBased` (clip) |
`IsFrameBased` (clip) |
`GetParity` (clip, int "n") | Vrací true když snímek n (výchozí 0) je horní pole klipu založeného na polích, nebo je to plný snímek s horním polem jako prvním z klipu založeného na snímcích (typ: bool).
`HasAudio` (clip) v2.56 | Vrací true když má klip audio, jinak false (typ: bool).
`HasVideo` (clip) v2.56 | Vrací true když má klip video, jinak false (typ: bool).

Nezapomeňte: můžete použít vlastnosti s implicitní (vestavěnou) proměnnou LAST nebo ve variantě OOP-zápisu:

    BilinearResize(Width/2, Height/2)
       je stejné jako
    BilinearResize(Width(Last)/2, Height(Last)/2)
       je stejné jako
    BilinearResize(Last.Width / 2, Last.Height / 2)

## Uživatelem definované funkce

Můžete definovat své vlastní funkce. Nejlepší to bude vysvětlit na příkladu:

    Function NTSC2PAL( clip c) {
        Assert(c.height == 480, \
               "NTSC2PAL: vstupní klip musí mít rozlišení 480 řádků")
        Bob(c, height=576)
        return Weave()
    }

Je možné vytvořit dokonce rekurzivní (zahrnující vlastní výzvu) funkci.

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

## Funkce pro více klipů

Jsou některé funkce, které různě kombinují práci se dvěma nebo více klipy. Jakým způsobem se vytváří video závisí na konkrétní funkci, a zde je přehled jaké vlastnosti bude mít výsledný klip.

Vstupní klipy musí mít vždy stejný formát barev a s výjimkou Layer - stejné rozměry.

| snímková frekvence (frame-rate) | počet snímků | obsah zvuku | vzorkovací frekvence zvuku
AlignedSplice, UnalignedSplice | první klip | suma všech klipů |  | viz popis filtru | z prvního klipu
Dissolve | suma všech klipů bez překrytí |  | viz popis filtru
Merge, MergeLuma, MergeChroma, Merge(A)RGB | první klip | poslední snímek kratšího klipu se opakuje do konce klipu | první klip
Layer
Subtract | delší klip
StackHorizontal, StackVertical
Interleave | (fps prvního klipu) x (počet klipů) | N x počet snímků nejdelšího klipu

Jak vidíte funkce nejsou úplně symetrické, ale berou některé atributy z PRVNÍHO klipu.

## Pluginy

S těmito funkcemi můžete přidat do Avisynthu vnější funkce.

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

Načítá jeden nebo více externích pluginů Avisynthu ve formě DLL modulů.

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

Tato funkce načítá pluginy napsané pro VirtualDub. "filename" zde znamená jméno .vdf souboru. Po vyvolání této funkce budou filtry VirtualDubu dostupné pro Avisynth pod jménem zadaným ve "filtername". Filtry VirtualDubu podporují pouze RGB32. Pokud se stane, že video bude ve formátu RGB24, pak jej musíte převést pomocí `ConvertToRGB32` (`ConvertToRGB` nestačí).

Výstupní hodnoty některých filtrů závisí na předchozích snímcích; pro ně je nutné stanovit předběžné zpracování údajů pro zaplnění jejich bufferů a/nebo aktualizování jejich vnitřních proměnných.

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

Umožní vám využít pluginy VFAPI (TMPGEnc importí pluginy).

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

Načítá tzv. Avisynth C-pluginy (DLL).
Load_Stdcall_Plugin() je synonymem pro LoadCPlugin().
C-pluginy jsou pluginy vytvořené v jazyce C a využívající "AviSynth C API" (na rozdíl od obyčejných pluginů Avisynthu, které jsou vytvořeny v MS C++). C-pluginy musí být načteny pomocí funkcí LoadCPlugin() nebo Load_Stdcall_Plugin().

Kevin vytvořil LoadCPlugin.dll , pro přeurčení funkce LoadCPlugin() s cílem podpory C-pluginů zkompilovaných s C subroutine calling sequence, použijte Load_Stdcall_Plugin() k načtení pluginů se standardním souhlasem výzvy (stdcall) v případě použití verze od Kevina. Rada: nechte tyto C-pluginy mimo Vaši autonačítací složku pluginů, vyhnete se tak vážným problémům. [discussion] [AVISynth C API (by kevina20723)]

## Autonačítání pluginů a priorita názvů v2

Je možné umístit všechny soubory pluginů i soubory skriptů s uživalelem definovanými funkcemi nebo (globálními ) proměnnými do složky, ze které budou všechny soubory s příponami .AVSI (v2.08, v2.5 , ve verzích v2.05-2.07 typ byl .AVS ) a .DLL načítány při startu, dynamicky se vyprazdňovat a znovu načítat podle potřeby skriptu.

.AVSI skripty v této složce smí obsahovat pouze definice funkcí a globální proměnné, žádné hlavní prováděcí sekce (jinak se mohou objevit chyby), také se nedoporučuje ukládat jiné soubory do této složky.

Cesta k této složce je uchována v systémovém registru (klíče registru byly změněny pro v2.5 ). Dvojklikem na .REG-soubor s následujícími řádky nastaví cestu (samozřejmě je-li uvedena správná cesta):

    REGEDIT4

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

Pořadí plnění funkcí se řídí následujícími pravidly:

      uživatelem definované funkce (mají vždy
       nejvyšší prioritu) plugin-funkce (mají vyšší prioritu
       než vestavěné funkce, budou nahrazovat vestavěné funkce)
          vestavěné funkce

V rámci těchto skupin se bude načítání těchto skupin provádět podle pořadí, (poslední má přednost), konflikt jmen není chybou.

## Autonačítací pluginy a konflikty funkcí jmen v2.55

Počínaje verzí v2.55 se podporuje zápis DLLName_function(). Problém nastává pokud se načítají dva pluginy různých funkcí ale stejných názvů. K vyvolání potřebné funkce z nich je určen DLLName_function(). Automaticky generuje doplňková jména jak pro auto načítané pluginy tak i pro pluginy načítané pomocí funkce LoadPlugin.

Některé příklady:

    # použití funkce fielddeinterlace z decomb510.dll
    AviSource("D:\captures\jewel.avi")
    decomb510_fielddeinterlace(blend=false)

Předpokládá se, že ve složce autonačítání jsou pluginy mpeg2dec.dll a mpeg2dec3.dll, a vy chcete načíst soubor d2v s mpeg2dec.dll (který produkuje YUY2):

    # použít mpeg2source z mpeg2dec.dll
    mpeg2dec_mpeg2source("F:\From_hell\from_hell.d2v")

nebo s pomocí mpeg2dec3.dll (který produkuje YV12):

    # použít mpeg2source z mpeg2dec3.dll
    mpeg2dec3_mpeg2source("F:\From_hell\from_hell.d2v")

`$English Date: 2008/12/06 16:37:26 $`

`Český překlad:12.2.2009`