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
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.
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"))
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")
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)
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
Les entrées et les sorties de ces fonctions ne sont pas des clips, mais d'autres variables utilisées dans le script.
MulDiv(int,
int, int) : (m*n+d/2)/d avec
résultat intermédiaire en 64bit |
MulDiv (1,
1, 2) = 1MulDiv (2, 3, 2) = 3 |
Floor(float) :
arrondit à l'entier inférieur |
Floor (1.2)
= 1Floor (1.6) = 1Floor (-1.2) = -2Floor (-1.6) = -2 |
Ceil (float): arrondit
à l'entier supérieur |
Ceil (1.2)
= 2.0Ceil (1.6) = 2.0Ceil (-1.2) = -1Ceil (-1.6) = -1 |
Round (float):
arrondit |
Round (1.2)
= 1Round (1.6) = 2Round (-1.2) = -1Round (-1.6) = -2 |
Int (float): convertit
un float en int (partie entière). |
Int (1.2) =
1Int (1.6) = 1Int (-1.2) = -1Int (-1.6) = -1 |
Float (int): convertit
un int vers un float. |
|
Frac (float): renvoie
la partie décimale du float. |
Frac (3.7)
= 0.7Frac (-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)
= -1Sign (3.5) = 1Sign (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) = 5Spline (5, 0,0, 10,10, 20,0, true) = 7 |
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é. |
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 |
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' |
IsBool(var)
IsInt(var)
IsFloat(var)
IsString(var)
IsClip(var)
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)
}
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
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.
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)
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
\ )
}
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).
|
|
|
du flux audio |
||
AlignedSplice, UnalignedSplice |
|
|
|
|
|
Dissolve |
|
|
|||
Merge, MergeLuma, MergeChroma, Merge(A)RGB |
|
du clip le plus court est répétée jusqu'a la fin du clip |
|
||
Layer | |||||
Subtract |
|
||||
StackHorizontal, StackVertical | |||||
Interleave |
x (nombre de clips) |
|
Comme vous pouvez le voir, ces fonctions ne sont pas
complètement symétriques et prennent certaines
propriétées au PREMIER clip seulement.
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)]
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.
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