## Démarrer avec Avisynth

A la base, Avisynth travaille de la manière suivante: premièrement, vous créez un simple document texte avec des commandes spéciales, appelé script. Ces commandes font références à une ou plusieurs videos et aux filtres que vous souhaitez utiliser sur elles. Puis, vous lancez une application video, telle que VirtualDub, et vous ouvrez le fichier script. C'est alors qu'AviSynth rentre en action. Il ouvre les videos que vous avez référencé dans votre script, applique les filtres spécifiés, et fourni un fichier video de sortie pour l'application video. L'application , de quelques manières que ce soit,ne sait pas qu'avisynth travaille en fond. Au lieu de cela, l'application pense qu'elle ouvre directement un fichier AVI filtré placé sur votre disque dur.

Il y a beaucoup de nouvelles fonctions ou de fonctions retravaillées dans AviSynth2. Pour que cela soit clairement visible (particulièrement quand ces fonctionnalités n'étaient pas bien documentées dans le passé) elles sont indiquées par v2

La version 2.5 est une mise à jour interne importante. Lisez AviSynth 2.5 prudemment avant de l'utiliser. Des changements importants sont indiqués par v2.5

#### Édition Linéaire:

La chose la plus simple que vous pouvez faire avec Avisynth est que vous pouvez faire de l'édition de la même manière que dans VirtualDub. Il est facile d'écrire des scripts de ce type parce que si vous voulez, vous pouvez ne pas vous préoccuper des variables et des expressions compliquées.

Pour tester, créez un fichier appelé test.avs en y incluant la simple ligne suivante :

    Version

Maintenant, ouvrez le fichier avec Windows Media Player par exemple et vous devriez voir une video de 10 secondes afficher le numéro de la version d'Avisynth installé sur votre système et un avis de copyright.

`Version` est ce qui s'appelle un "filtre de source", signifiant qu'il produit un clip au lieu d'en modifier un. La première commande dans un script Avisynth sera toujours un filtre de source.

Maintenant, ajoutez une seconde ligne à votre fichier script, de sorte qu'il soit lu comme ceci:

    Version
    ReduceBy2

Ré-ouvrez le fichier dans Windows Media Player. Vous devriez voir à nouveau l'avis de copyright, mais maintenant à moitié moins grand qu'avant.
`ReduceBy2` est un "filtre de transformation," signifiant qu'il prend le clip précédent et qu'il le modifie d'une quelconque manière. Vous pouvez enchaîner simultanément un bon nombre de filtres de transformation, de la même manière que dans VirtualDub.
Ajoutons une nouvelle fonction pour obtenir un fondu au noir à la fin de la video. Ajoutez une ligne à votre script, de sorte qu'il soit lu ainsi:

    Version
    ReduceBy2
    FadeOut(10)

Maintenant, ré-ouvrez le fichier dans votre player. Le clip devrait être identique pendant les 9 premières secondes, et s'effacer doucement vers le noir dans la dernière seconde.
Le filtre FadeOut prend un argument numérique, qui indique le nombre de frames à inclure dans le fondu.

Le fondu commence assez tard, nous allons donc couper le début du clip pour réduire l'attente, et faire un fondu après.
Coupons les 120 premières images, et gardons les images allant de 120 à 150:

    Version
    ReduceBy2
    Trim(120,150) # supprime les 119 premières images, et conserve les images de 120 à 150 (AviSynth commence la numérotation à 0)
    FadeOut(10)

Dans cet exemple, nous utilisons pour la première fois un commentaire.
Les commentaire débutent avec le caractère # et continuent jusqu'à la fin de la ligne. Ils sont complètement ignorés par Avisynth.
Le filtre Trim prend deux arguments, séparés par une virgule: la première et la dernière image du clip que vous souhaitez conserver. Si vous mettez 0 pour la dernière image, c'est comme si vous mettiez " fin de clip". Ainsi, Si vous voulez supprimer les 119 première images d'un clip, vous devriez utiliser la commande Trim(120,0).

S'y retrouver dans la numérotation des images de cette manière est une corvée. Il est beaucoup plus facile d'ouvrir un script partiel dans une application comme VirtualDub qui vous indiqueras les numéros d'images. Vous pouvez également utilisez le filtre ShowFrameNumber qui écrit le numéro de l'image sur l'image elle même.

Dans la pratique un filtre de source beaucoup plus utile que Version est AVISource, qui lit le contenu des fichier AVI (ou de plusieurs autres types de fichiers) à partir du disque. Si vous disposez d'un fichier AVI à porter de main, vous pouvez essayer d'appliquer les filtres suivants à votre fichier:

    AVISource("d:\capture.avi")   # où vous indiquez le chemin d'accès actuel de votre fichier
    ReduceBy2
    FadeOut(15)
    Trim(120,0)

Même un script d'une seule ligne contenant la commande AVISource peut être utile pour ajouter le support de fichiers AVI supérieurs à 2GO pour des applications qui ne les supportent habituellement pas.

#### Édition Non-Linéaire :

Maintenant nous allons en venir à la partie amusante. Faites un fichier AVS avec le script suivant :

    StackVertical(Version, Version)

Maintenant ouvrez le. Résultat: Une sortie video avec deux lignes identiques de version, l'une au dessus de l'autre.
Au lieu de prendre des nombres ou des chaînes de caractères comme arguments, StackVertical prends le clip vidéo comme argument. Dans ce script le filtre Version est appelé deux fois. A chaque fois que, il renvoie une copie de de la version du clip . Ces 2 clips sont ensuite transmis à StackVertical, qui les assemble (sans savoir d'où ils sont venus).

Un des filtres du même type les plus utiles est UnalignedSplice, qui joint les clips video bout à bout. Voici un script qui charge trois fichiers AVI (tels qu'ils pourraient être produits par AVI_IO) et les met bout à bout.

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

StackVertical et UnalignedSplice peuvent prendre aussi bien deux arguments qu'une soixantaine.
Vous pouvez utiliser l'opérateur + comme raccourci pour UnalignedSplice.

Par exemple, ce script agit de la même manière que le précédent exemple:

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

Maintenant supposons que vous capturiez avec une application qui sauvegarde également la vidéo dans de multiples segments AVI, mais qui mets l'audio dans un fichier wav indépendant.
Pouvons nous recombinez le tout? Bien sûr que oui:

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

## Syntaxe

#### Expressions:

Un script Avisynth se compose de multiples lignes de déclarations ressemblant à ceci:

    variable_name = expression

Dans cet exemple l'expression est évalué et le résultat est assigné à la variable_name.

La forme commune du raccourci est très importante :

    expression

Dans ce cas l'expression est évalué et le résultat est assigné au clip particulier variable last.
Ce qui est identique à :

    last = expression

La fin du script est toujours semblable à :

    return expression

Ici l'expression est évaluée, et est employée comme "la valeur de retour" du script -- c'est-à-dire, le clip vidéo qui sera vue par l'application qui ouvre le fichier AVS.

La forme de base d'une expression qui appelle une fonction est:

    Fonction(args)

Les fonctions de clip produisent toujours un nouveau clip et ne modifient jamais celui existant,
Args est une liste d'arguments de la fonction qui sont séparés par des virgules. La liste peut être vide (ce qui signifie que tout les arguments, ou quelques uns seulement peuvent être facultatifs).

Si la fonction attend un clip comme son premier argument, et que cet argument n'est pas fourni, alors le clip dans la variable particulière last sera utilisé.

Les filtres Avisynth peuvent prendre des arguments nommés. Les arguments nommés peuvent être indiqués dans n'importe quel ordre, et le filtre choisira les valeurs par défaut pour ceux que vous ne préciserez pas (les arguments nommés sont toujours facultatifs). Ceci permet une utilisation beaucoup plus facile de certains filtres.

    Vous pouvez écrire

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

    à la place de

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

Une syntaxe alternative (appelée "OOP notation") pour des fonctions de clip est: [OOP = Object Oriented programming-- programmation orienté objet]

    expression.Fonction(args)

    Par ex.:
    Version.ReduceBy2.FadeOut(15)

Ce qui équivaut à:

    Fonction(expression, args)

    Par ex.:
    FadeOut(15, ReduceBy2(Version))

et peut être considéré comme la `Fonction` appliquée à l'`expression`.
L'un des inconvénients de la notation OOP est qu'elle peut seulement être employée avec les filtres qui prennent un seul argument clip, et non pas avec les filtres qui en prennent plusieurs.

Toutes les fonctions d'avisynth produisent un nombre précis d'images et une fréquences d'images(fps) en sortie, même si cette idée semble très complexe.
Avisynth sait, après avoir lu le script , de combien de temps sera le fichier de sortie, quelle est la fréquence d'images et quel est "l'ordre de découpage" de toutes les sources utilisées.
Tout ceci est calculé à l'ouverture du script. Seul le filtrage est fait en phase d'exécution de la requête.

Commentaires: Avisynth ignore tout ce qui suit le caractère # et ce jusqu'à la fin de la ligne.

Ignore la casse: aViSouRCe est aussi bon que AVISource.

Continue à la ligne suivante ou précédente: \

    Subtitle ("Test-Text")

    Subtitle ( \
              "Test-Text")

    Subtitle (
     \ "Test-Text")

#### Variables:

Le nom d'une variable peut contenir jusqu'à 50 caractères et peut également contenir des lettres, des chiffres, et des soulignages (_), mais aucun autres caractères. Le nom ne peut pas commencer par un chiffre.

Les types de variables suivants peuvent être employés:

clip: un clip video contenant vidéo et/ou audio . Au moins une variable pour un clip doit être employée et retournée par le script.
string: chaîne de caractère entouré soit par des "guillemets" ou par des triples guillemet comme """cet exemple""". Un texte string peut contenir n'importe quel caractère excepté les guillemets de fin ou double-apostrophe. Si vous devez mettre des guillemets à l'intérieur d'une variable string, employez la notation triple guillemets:

    Subtitle ("""Cela affiche "hello world" entre guillemets""")

int: nombre entier entré comme une chaîne de chiffres, avec au choix un + ou - au début.
float: nombre à virgule entré comme une chaîne de chiffres avec un point (.) quelque part dans la chaîne et un facultatif + ou -. Par exemple, +1. est traité comme nombre à virgule-flottante.
val: type d'un argument de fonction où cela n'a pas d'importance si c'est entier ou flottant
bool: peut être TRUE (vrai) ou FALSE (faux)
hexadecimal numbers: nombre hexadécimal. L'entrer en le précédant d'un $. cette variable est traitée comme un nombre entier. Plusieurs filtres emploient cette notation pour indiquer des couleurs. Par exemple, $$FF8800 est une nuance d'orange.

global: définit une variable globale, qui peut être employée en commun par toutes les fonctions définies pour l'utilisateur et le script principal.

Voici une autre version de l'exemple utilisé un peu plus tôt sous une forme plus maniable et plus facile à comprendre:

    a = AVISource("d:\capture.00.avi")
    b = AVISource("d:\capture.01.avi")
    c = AVISource("d:\capture.02.avi")
    Piste_audio = WAVSource("d:\audio.wav")

    AudioDub(a+b+c, sound_track)

## Opérateurs

Pour tout types d'opérandes (clip, int, float, string, bool) vous pouvez utiliser:
`==` est égal
`!=` n'est pas égale
`||` ou
`&&` et

Pour des types numériques(int, float):
`+` additionner
`-` soustraire
`*` multiplier
`/` diviser
`%` module
`>=` supérieur ou égal à
`<=` inférieur ou égal à
`<` moins grand que
`>` plus grand que

    Dans ses anciennes versions, AviSynth analysait de droite à gauche les expressions, ce qui a donné des résultats inattendus:

     a = 10 - 5 - 5 donnait 10 - (5 - 5) = 10 au lieu de (10 - 5) - 5 = 0 !

    Ce bug a été corrigé!
    A partir de v2.53 les multiplications et les divisions sont également analysées de la gauche vers al droite (au lieu de la droite vers la gauche).

Pour des types string:
`+` additionner
`>=` supérieur ou égal à (non sensible à la casse)
`<=` inférieur ou égal à (non sensible à la casse)
`<` moins que (non sensible à la casse)
`>` plus que (non sensible à la casse)

Pour des types clip:
`+` la même que la fonction `UnalignedSplice`
`++` la même que la fonction `AlignedSplice`

Pour des types bool:
`?:` exécute le code conditionnellement

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

    Cela peut être traduit par:

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

## Fonctions

Les entrées et les sorties de ces fonctions ne sont pas des clips, mais d'autres variables utilisées dans le script.

#### Fonctions numériques:

`MulDiv(int, int, int)`: (m*n+d/2)/d avec résultat intermédiaire en 64bit | `MulDiv` (1, 1, 2) = 1 `MulDiv` (2, 3, 2) = 3
`Floor(float)`: arrondit à l'entier inférieur | `Floor` (1.2) = 1 `Floor` (1.6) = 1 `Floor` (-1.2) = -2 `Floor` (-1.6) = -2
`Ceil` (float): arrondit à l'entier supérieur | `Ceil` (1.2) = 2.0 `Ceil` (1.6) = 2.0 `Ceil` (-1.2) = -1 `Ceil` (-1.6) = -1
`Round` (float): arrondit | `Round` (1.2) = 1 `Round` (1.6) = 2 `Round` (-1.2) = -1 `Round` (-1.6) = -2
`Int` (float): convertit un float en int (partie entière). | `Int` (1.2) = 1 `Int` (1.6) = 1 `Int` (-1.2) = -1 `Int` (-1.6) = -1
`Float` (int): convertit un int vers un float. |
`Frac` (float): renvoie la partie décimale du float. | `Frac` (3.7) = 0.7 `Frac` (-1.8) = -0.8
`Abs` (integer) / `Abs` (float): valeur absolue pour nombre entier et float. | `Abs` (-3.8) = 1.8
`Sign` (int) / `Sign` (float): renvoie le signe du nombre comme-1, 0 ou 1. | `Sign`(-3.5) = -1 `Sign`(3.5) = 1 `Sign`(0) = 0
`HexValue` (string): renvoie la valeur d'une chaîne hexadécimale. | `HexValue` ("FF00") = 65280
`Sin` (float): sinus d'un float |
`Cos` (float): cosinus d'un float |
`Pi` (): Pi |
`Log` (float): logarithme d'un float |
`Exp` (float): exponentiel d'un float |
`Pow` (float base, float puissance): puissance d'un float par un float |
`Sqrt` (float}: racine carrée d'un float |
`Rand`([int max] [, bool scale] [, bool seed]): renvoie un entier aléatoire entre 0 et max. Par défaut: max = 32768 scale = TRUE ( TRUE = mode normal, FALSE = mode module) seed = FALSE (TRUE = utilise le temps comme point de départ) | `Rand`(100) = nombre entier entre 0 et 99
`Spline` (float X, x1,y1, x2,y2, ...., bool "cubic"} v2.5 Interpole la valeur de Y au point X en utilisant les points de control x1/y1, ... Il doit y avoir au moins 2 paires x/y L'interpolation peut être cubique(le résultat est une spline) ou linéaire (le résultat est un polygone) | `Spline` (5, 0,0, 10,10, 20,0, false) = 5 `Spline` (5, 0,0, 10,10, 20,0, true) = 7

#### Fonctions de chaînes:

`UCase` (string): renvoie la chaîne en majuscules | `UCase` ("AviSynth") = "AVISYNTH"
`LCase` (string): renvoie la chaîne en minuscules | `LCase` ("AviSynth") = "avisynth"
`RevStr` (string): renvoie la chaîne à l'envers | `RevStr` ("AviSynth") = "htnySivA"
`StrLen` (string): renvoie la longueur de la chaîne | `StrLen` ("AviSynth") = 8
`Findstr` (string1, string2): renvoie le décalage de la chaîne string2 par rapport à string1. La recherche est sensible à la casse | `Findstr` ("AviSynth","syn") = 4
`LeftStr` (string, length) / `RightStr` (string, length): renvoie une certaine longueur (donnée par length) de la partie droite ou gauche d'une chaîne | `LeftStr` ("AviSynth",3) = "Avi"
`MidStr` (string, start [, length]): renvoie une partie de la chaîne en commençant à start (pour le premier caractère, start=1) dont la longueur est donnée par length (ou alors jusqu'à la fin si length n'est pas spécifié) | `MidStr` ("AviSynth",3,2) = "iS"
`VersionNumber` () | `VersionNumber` () = 2.07
`VersionString` () | `VersionString` () = "AviSynth 2.08 (avisynth.org) 22 nov. 2002"
`Chr` (int): renvoie le caractère ASCII correspondant v2.5 | `Chr` (34) renvoie le caractère guillemet (")
`Time` (string): renvoie une chaîne correspondant au temps donné par le système formaté sous la forme défini par le paramètre string v2.5 | Codes pour le formatage du texte de sortie: %a Jour le la semaine abrégé %A Jour le la semaine complet %b Mois abrégé %B Mois complet %c Date et heure approprié pour votre localisation %d Jour du mois au format nombre décimal (01 – 31) %H Heure au format 24 heures (00 – 23) %I Heure au format 12 heures (01 – 12) %j Jour de l'année au format nombre décimal (001 – 366) %m Mois au format nombre décimal (01 – 12) %M Minute au format nombre décimal (00 – 59) %p Localisation actuelle‚ indicateurs A.M./P.M. pour les systèmes au format 12 heures. %S Secondes au format nombre décimal (00 – 59) %U Semaine de l'année au format nombre décimal, avec dimanche comme premier jour de la semaine (00 – 53) %w Jour de la semaine au format nombre décimal(0 – 6; Dimanche est 0) %W Semaine de l'année au format nombre décimal, avec lundi comme premier jour de la semaine (00 – 53) %x Date pour la localisation actuelle %X Heure pour la localisation actuelle %y Année sans le siècle, au format nombre décimal (00 – 99) %Y Année avec le siècle, au format nombre décimal %z, %Z Nom du fuseau horaire ou abbréviation. Pas de caractère si la zone est inconnue. %% Signe pour cent (%) Le signe # peut précédé n'importe lequel des codes de formatage. Dans ce cas, leur signification devient la suivante: %#a, %#A, %#b, %#B, %#p, %#X, %#z, %#Z, %#% Le signe # est ignoré. %#c Format long pour l'indication de date et d'heure, correspondant à la localisation actuelle. Par exemple: “Mardi, Mars 14, 1995, 12:41:29„. %#x Format long pour l'indication de date, correspondant à la localisation actuelle. Par exemple: “Mardi, Mars 14, 1995„. %#d, %#H, %#I, %#j, %#m, %#M, %#S, %#U, %#w, %#W, %#y, %#Y Supprime les zéros en début de nombre (s'il y en a).

#### Conversions:

`Value` (string): Renvoie la valeur d'une chaîne | `Value` ( "-2.7" ) = -2.7
`String` (float / int / string, format_string): convertit un nombre en chaîne: Si la variable est un flottant ou un entier, la fonction la convertit en flottant est utilise l'argument format_string pour la convertir en chaîne. La syntaxe pour l'argument format_string est la suivante: %[balise][largeur][.precision]f width: la largeur minimum (la chaîne n'est jamais tronquée) precision: le nombre de chiffre conservés après la virgule balise: `-` alignement à gauche (sinon alignement à droite) `+` affiche toujours le signe +/- `0` remplir avec des zéros au début `' '` ajoute un blanc à la place de "+" `#` affiche toujours la virgule de la décimale | e.g. `Subtitle` ("La hauteur du clip est: " + `String` (last.height) ) `String`(1.23, "%f") = '1.23' `String`(1.23, "%5.1f") = ' 1.2' `String`(1.23, "%1.3f") = '1.230'

#### Fonctions de test:

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

#### Autres fonctions:

`Select` (index, item0 [, item1...]): Renvoie le composant sélectionné par l'index (0=item0). Les composant peuvent être n'importe quelle variable ou clip. Ils peuvent même être mélangés.
`Defined` (var): pour définir un paramètre optionnel dans une fonction utilisateur.
`Default` (x, d): renvoie x si Defined(x), d sinon.
`Exist` (filename): renvoie TRUE ou FALSE après avoir vérifié si le fichier existe.
`NOP` (): renvoie NULL, utilisé principalement pour des actions conditionnelles avec des composants qui n'ont pas de valeur de retour (tel que la fonction import) et sans utilisation de la condition "else".

`Eval` (string),
`Apply` (func-string, arg,...): `Eval` ("f(x)") est équivalent à `f(x)` est équivalent à `Apply` ("f", x)

    Vous pouvez utiliser Eval pour des chose telles que:
    settings = "352, 288"
    Eval( "BicubicResize(" + settings + ")" )

`Import`(filename): évalue le contenu d'un autre script avisynth (importe le texte d'un autre script)

Pour le signalement d'erreurs et pour le transfert de messages d'erreurs vers une fonction utilisateur, vous pouvez utiliser:
`Assert`(bool, string error-message)

`Try ... Catch`: c'est une fonction qui vérifie si une erreur SURVIENDRA:

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

## Fonctions d'exécution

Depuis quelques temps, Avisynth intègre Conditional Filters qui évalue le script pendant qu'une image est traitée. Vous pouvez donc changer des variables sur l'échelle de temps de l'image.
Pour plus d'applications, il y a les Runtime Functions qui évaluent le contenu d'un clip et renvoient une valeur. v2.5

    Un exemple simple est de calculer la luminosité moyenne et de l'afficher sur chaque image.

    Version()       # génère un clip pour ce test
    ConvertToYV12   # conversion dans l'espace de couleur YV12
    FadeIn(10)      # fondu qui va créer un changement de luminosité sur le clip version

    ScriptClip(" Subtitle(String(AverageLuma())) ")  # utilise Subtitle(...) pour chaque image
                                                     # la valeur de sortie de AverageLuma est convertit en chaîne
                                                     # et affichée sur le clip d'entrée
    ConvertToRgb    # conversion dans l'espace de couleur RGB

## Fonctions de contrôle

`SetMemoryMax` (int): Force le maximum de mémoire qu'AviSynth utilisera (en Mo) v2

Dans certaines version, le paramètre par défaut est de 5Mo, ce qui est relativement faible. Si vous rencontrez des problèmes (par ex. une faible vitesse) essayez de mettre cette valeur à 32Mo. Valeur de retour: Actual MemoryMax value set.

`SetPlanarLegacyAlignment` (clip, bool): Passe en mode d'alignement pour les images planes. v2.5.6

Quelques plugins assez anciens font des suppositions sur la structure des images en mémoire. Ce filtre force la structure en mémoire des images planes à être compatible avec de précédentes versions d'avisynth. Ce filtre agit sur la pile d'appel GetFrame(), et il intervient donc sur les filtres avant qu'ils ne soient appliqués.

    Exemple : Utiliser une ancienne version de Mpeg2Source()
    LoadPlugin("...\Mpeg2Decode.dll")
    Mpeg2Source("test.d2v") 	# Un plugin qui suppose (de manière incorrecte) la structure de la mémoire
    SetPlanarLegacyAlignment(true) 	# Défini l'alignement mémoire pour contourner la supposition du filtre
    ConvertToYUY2() 		# Cette moficfication sur l'alignement mémoire est répercutée
    ... 				# jusqu'à la fin du script.

`SetWorkingDir` (string): Définir le repertoire par defaut d'Avisynth. v2

Ceci est principalement utilisé pour le chargement de video sources, etc. N'affecte pas le chargement automatique des plugins. Valeur de retour: 0 si ça marche, -1 sinon.

## Porpriétés d'une video

Ces fonction prennent un clip en entrée et renvoie une propriété de ce clip.

`Width` (clip), largeur
`Height` (clip), hauteur
`Framecount` (clip), nombre d'image
`Framerate` (clip), fréquence de lecture des images ( en images par seconde)
`FramerateNumerator` (clip), numérateur pour la fréquence de lecture des images (un framerate à virgule du type, 23.976 est en fait décrit comme une fraction: 23976/1000, 23976 réprésente le numérateur, 10000 le dénominateur) v2.55
`FramerateDenominator` (clip), dénominateur pour la fréquence de lecture des images v2.55
`Audiorate` (clip), fréquence d'échantillonnage du flux audio
`Audiolength` (clip) - longueur du flux audio, limitée à 2^31 échantillons
`AudiolengthF` (clip) - renvoie le nombre d'échantillons sous forme de flottant v2.55
`Audiochannels` (clip), nombre de canaux du flux audio
`Audiobits` (clip), nombre de bits sur lesquelles sont codées les information audio
`IsAudioFloat` (clip) v2.55
`IsAudioInt` (clip) v2.55
`IsRGB` (clip), test si un clip est au format de couleur RGB
`IsRGB24` (clip), test si un clip est au format de couleur RGB24
`IsRGB32` (clip), test si un clip est au format de couleur RGB32
`IsYUY2` (clip), test si un clip est au format de couleur YUY2
`IsYV12` (clip), test si un clip est au format de couleur YV12 v2.51
`IsYUV` (clip), test si un clip est au format de couleur YUV v2.54
`IsPlanar` (clip), test si un clip est a format de couleur plan v2.51
`IsInterleaved` (clip), test si un clip est contieent de la video et de l'audio entrelacés v2.51
`IsFieldBased` (clip), test si un clip est sous forme de champs
`IsFrameBased` (clip), test si un clip est sous forme d'images
`GetParity` (clip)
`HasAudio` (clip) v2.56
`HasVideo` (clip) v2.56

    N'oubliez pas: vous pouvez utiliser les propriétés des clip avec la notation LAST ou la notation OOP:

    BilinearResize(Width/2, Height/2)
       est la même chose que
    BilinearResize(Width(Last)/2, Height(Last)/2)
     est la même chose que
    BilinearResize(Last.Width / 2, Last.Height / 2)

## Fonctions utilisateur

Vous pouvez définir vos propres fonctions. Le mieux est encore de l'expliquer à l'aide d'un exemple:

    Function NTSC2PAL( clip c) {
        Assert(c.height == 480, "NTSC2PAL: le clip d'entrée doit avoir 480 lignes")
        Bob(c, height=576)
        return Weave()
    }

Même des fonctions récursives peuvent être définies.

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

## Fonctions avec plus d'un clip en entrée

Il y a des fonctions qui combinent deux videos ou plus de différentes manières. La manière donc la video de sortie est calculée est décrite pour chaque fonction, mais voici un résumé des propriétées que les videos auront.

Les videos d'entrée doivent toujours avoir le même format de couleur et les même dimensions (à l'exception de Layer).

| fréquence des images | nombre d'images | audio | fréquence d'echantillonnage du flux audio
AlignedSplice, UnalignedSplice | premier clip | somme de tous les clips |  | voir la description du filtre | premier clip
Dissolve | somme de tous les clips moins la durée du fondu |  | voir la description du filtre
Merge, MergeLuma, MergeChroma, Merge(A)RGB | premier clip | la dernière image du clip le plus court est répétée jusqu'a la fin du clip | premier clip
Layer
Subtract | clip le plus long
StackHorizontal, StackVertical
Interleave | (fps du premier clip) x (nombre de clips) | N x nombre d'images du clip le plus long

Comme vous pouvez le voir, ces fonctions ne sont pas complètement symétriques et prennent certaines propriétées au PREMIER clip seulement.

## Plugins

Avec ces fonctions, vous pouvez ajouter des fonctions externes à AvisynthWith these functions you can add external functions to AviSynth.

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

Charge un ou plusieurs plugins extérieurs à Avisynth (DLLs).

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

Cela charge un plugin écrit pour VirtualDub. "filename" est le nom du fichier .vdf. Après avoir appelé cette fonction, le filtre est connu dans avisynth sous le nom "filtername". Les plugin VirtualDub supportent seulement l'espace de couleur RGB32. Si la video est dans le format RGB24, vous devez faire un conversion en utilisant `ConvertToRGB32` (`ConvertToRGB` ne suffira pas).

Certains filtres dépendent des images précédentes; pour ceux ci, le pré chargement doit être défini pour un nombre d'image au minimum égal au nombre d'images nécessaires au filtre pour remplir son buffer ou pour mettre à jour ses variables internes.

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

Cela vous permet d'utiliser des plugins VFAPI (les plugins d'importation de TMPGEnc).

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

Les plugins C doivent être chargés avec LoadCPlugin. Conseil: garder ces plugins en dehors du répertoire de chargement automatique pour éviter les crashs. [discussion] [AVISynth C API (by kevina20723)]

## Chargement automatique des plugins et priorités entre fonctions v2

Il est possible de mettre tous les plugins, les scripts avec des fonctions utilisateurs et les variables (gobales) dans un repertoire d'où tous les fichiers .AVS et .DLL sont chargés à l'ouverture du script, déchargées et ensuite chargées dynamiquement quand le script en a besoin.

Les scripts dans ce repertoire doivent uniquement contenir des définitions de fonctions et des variables globales, et pas de section de traitement (sinon, d'étranges erreurs pourraient se produire). Il n'est pas recommandé non plus de mettre d'autres fichiers dans ce repertoire.

Ce repertoire est enregistré dans le registre (la clé de registre à changé depuis v2.5). Vous pouvez double cliquer sur un fichier .REG avec les lignes suivante pour changer ce chemin:

    REGEDIT4

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

L'odre dans lequel sont appelés les noms de fonction est le suivant:

    Les fonctions utilisateurs (ont toujours la priorité la plus haute)
     Les fonctions des plugins externes (ont une plus haute priorité que les filtres internes - ils écraseront la définition d'une fonction interne)
       Les fonctions internes (ont la priorité la plus basse)

A l'intérieur des ces groupes, la fonction appelé en dernier prend la priorité, il n'y a donc pas d'erreur lors d'un conflit de noms de fonction.

## Chargement automatique des plugins et conflits entre fonctions v2.55

A partir de v2.55, la fonctionnalité DLLName_function() à été introduite. Le problème est que deux plugins différents peuvent avoir deux fonctions différentes mais qui ont le même nom. Pour appeler la bonne fonction, DLLName_function() doit être ajouté. Des noms de fonctions sont génèrés automatiquement à la fois pour les plugins qui se chargent automatiquement et pour ceux chargés avec la commande LoadPlugin.

Quelques exemples:

    # Utiliser fielddeinterlace du plugin decomb510.dll
    AviSource("D:\captures\jewel.avi")
    decomb510_fielddeinterlace(blend=false)

Supposez que vous ayez les plugins mpeg2dec.dll et mpeg2dec3.dll dans votre repertoire de chargement automatique de plugins, et que que vous voulez charger un fichier .D2V avec mpeg2dec.dll (qui renvoie une image dans l'epace de couleur YUY2), vous procédez de la manière suivante:

    # Utiliser mpeg2source du plugin mpeg2dec.dll
    mpeg2dec_mpeg2source("F:\From_hell\from_hell.d2v")

ou avec mpeg2dec3.dll (qui renvoie une image dans l'epace de couleur YV12):

    # Utiliser mpeg2source du plugin mpeg2dec3.dll
    mpeg2dec3_mpeg2source("F:\From_hell\from_hell.d2v")

`$English date: 2005/07/13 17:53:59 $
First French Translation by jernst. Last update: 2005/10/09 JasonFly macpaille@users.sourceforge.net`