VCB Studio06VapourSynth FR .pdf



Nom original: VCB-Studio06VapourSynth_FR.pdfAuteur: Windows User

Ce document au format PDF 1.7 a été généré par Microsoft® Word 2019, et a été envoyé sur fichier-pdf.fr le 17/10/2020 à 01:31, depuis l'adresse IP 93.5.x.x. La présente page de téléchargement du fichier a été vue 30 fois.
Taille du document: 107 Ko (18 pages).
Confidentialité: fichier public


Aperçu du document


Tutoriel VCB-Studio 06 : Principes de base et démarrage de
VapourSynth
0. préambule
L e c œ u r d u p re s s a g e d e B D R ip e s t le tra ite m e n t p a r lo ts , e t u tilis e ra a v s /v s p o u r p ré tra ite r la s o u rc e , q u i e s t u n e
in tro d u c tio n à u n rip p e r d 'a n im e . A v iS y n th e s t le p re m ie r s y s tè m e n o n é d ito ria l c o n ç u p o u r le s rip p e rs d 'a n im e .
V a p o u rS y n th a é té m is a u p o in t a u d é b u t d e 2 0 1 4 , e t re m p la c e m a in te n a n t p ro g re s s iv e m e n t A v iS y n th .

Les personnes qui veulent apprendre sont confrontées à cette question : si je n'en apprends qu'une, laquelle
dois-je apprendre ? Si j'apprends les deux, qu'est-ce que je dois apprendre en premier ? La réponse à cette
question nécessite une comparaison des avantages et des inconvénients des avs et des vs.
avs à la traîne, par rapport aux avancées.
avs plus de tutoriels, vs moins de tutoriels.
Les partisans de l'avs sont larges, contre les partisans de l'étroitesse.
avs non réglementé, contre réglementé.
avs facile à démarrer, difficile à approfondir, vs difficile à démarrer, facile à approfondir
……

La série de tutoriels VCB-Studio a choisi de présenter VS en premier lieu parce que c'est la principale capacité
de production de vcb-s de nos jours, et parce que la standardisation de VS permet aux débutants de
comprendre et de maîtriser plus facilement les bases.
Page d'accueil de VapourSynth : http://www.vapoursynth.com/

http://www.vapoursynth.com/doc/Documentation officielle d'utilisation : http://www.vapoursynth.com/doc/
http://dict.cn/Dictionnaire en ligne : http://dict.cn/

1. Simple contre scénario
Dans les tutoriels précédents, nous avons donné des exemples.
importer de la vapeur en tant que vs
système d'importation
importer havsfunc en tant que haf
importer mvsfunc en tant que mvff
core = vs.get_core(threads=8)
core.max_cache_size = 2000

source = "00001.m2ts
déchiré = "Symphogear Vol1-1.mkv"
src16 = core.lsmas.LWLibavSource(source,format="yuv420p16")
rip16 = core.lsmas.LWLibavSource(ripped,format="yuv420p16")

res = core.std.Interleave([src16,rip16])
res = mvf.ToRGB(res,full=False,depth=8)
res.set_output()

En tant qu'extension de Python, vs scripting est essentiellement un script Python. Au début, vous devrez
importer les différentes bibliothèques, y compris mvf (fonctions VapourSynth de maven) et haf (fonctions
VapourSynth de holy), en plus du noyau VapourSynth requis.
core = vs.get_core(threads=8)
core.max_cache_size = 2000
Ces deux phrases chargent en fonction de l'environnement d'exécution et précisent le nombre maximum de
threads et de mémoire (Mo) à utiliser.
La partie suivante de vs s'appuie fortement sur les déclarations d'affectation pour y parvenir. Un relevé de
mission a le format suivant.
Variable = Expression
Les variables telles que source, ripped, src16, res, etc. sont des variables. Les variables python n'ont pas besoin
d'être déclarées et déterminent automatiquement s'il s'agit d'une série vidéo (clip), d'un entier (int), d'un
ou d'un type comme une chaîne de caractères.
Les expressions, en revanche, prennent des formes variées.

. Assignation directe, par exemple source = "00001.m2ts", debug = True, res = dbed Ceci est donné directement
avec une valeur, la valeur peut être une valeur spécifique, la valeur peut être une valeur spécifique, ou elle peut
être une autre variable (par exemple res = dbed, dbed est une autre (une variable).
. Des opérations simples telles que strength = 80/100 et output_depth = debug?8:10.
A est appelé un déterminant, et doit être une expression booléenne (seulement Vrai/Faux, ou 1/0), tandis que B
et C sont des valeurs de retour possibles.
x = A?B:C est équivalent si (A) x=B ; sinon x=C ; si A tient, alors x est attribué à B, sinon x est attribué à C
Par exemple.
False?0:1 renvoie 1 parce que le déterminant n'est pas valide, il
renvoie donc la dernière des deux valeurs debug?8:10 renvoie 8 si
le debug est True/1, 10 sinon x<10?10:x<100?100:200 est une
instruction imbriquée ; décomposée : if ( x<10) return 10 ;
sinon si (x<100) renvoie 100
autre retour 200
Retourne 10 lorsque x est inférieur à 10, 100 lorsque x est compris entre 10 et 99, et 200 dans le cas contraire.
. affectation de la fonction, res = core.std.Interleave([src16,rip16]), c'est l'appel à la fonction core.std.Interleave(),
entrez src16

和 rip16 (techniquement, c'est le résultat de leur utilisation de l'opérateur [], qui est leur combinaison
séquentielle) comme variable d'entrée pour calculer une nouvelle valeur.
Enfin, la sortie de vs est effectuée par set_output(). res.set_output() est la sortie de res.

2. Appels de fonction VS
Comme vous pouvez l'imaginer, l'ontologie du vs script est mise en œuvre par un grand nombre d'appels de
fonction. Les fonctions sont généralement appelées de la manière suivante.
domain1.domain2...FunctionName(paramètre1, paramètre2,…… )

est la bibliothèque où se trouve la fonction, par exemple Core.std.
Les paramètres sont des variables entrées dans la fonction, avec des valeurs variables. L'entrée de la fonction
est généralement très clairement définie dans le document. Par exemple, selon le
Doc. de LWLibavSource
LWLibavSource(string source, int stream_index = -1, int threads = 0, int cache = 1, int
seek_mode = 0, int seek_threshold = 10, int dr = 0, int fpsnum = 0, int fpsden = 1,
int variable = 0, string format = "", int repeat = 0, int dominance = 1, string decoder = "")
LWLibavSource peut accepter un total de 14 entrées telles que source, stream_index, ……décodeur.
这 14 entrées avec leurs propres exigences de type, telles que string pour la source, int pour stream_index, etc.
这 Il n'est pas nécessaire d'attribuer une valeur à chacune des 14 entrées au moment de l'invocation. Toutes les
variables, sauf la source, ont des valeurs par défaut, donc si vous ne les définissez pas, ces entrées sont
automatiquement réglées sur des valeurs par défaut.
Il y a deux façons d'entrer les paramètres lorsqu'on les saisit manuellement.
1. Assignation/argument de mot-clé, sous la forme A=B, tel que format="yuv420p16". Avec une telle
affectation, le système cherchera d'abord la présence d'un argument appelé A dans l'entrée de la fonction et, si
c'est le cas, donnera la valeur de B à A.
2. Passage direct/argument de position, qui est représenté en mettant un C directement. par exemple.
nom du fichier = "00001.m2ts".
src16 = core.lsmas.LWLibavSource(filename,format="yuv420p16")
La première entrée dans la fonction est ici le nom de fichier, qui n'est pas saisi avec un relevé d'affectation.
l'expression est évaluée et le nom du fichier est une variable de valeur "00001.m2ts". Le système transmettra
donc "00001.m2ts" à la
Passe la première entrée à la fonction, c'est-à-dire à la source.

Le scénario ci-dessus est également équivalent à.
src16 = core.lsmas.LWLibavSource("00001.m2ts",format="yuv420p16"). Cela se fait en passant directement les
valeurs sous forme d'expressions plutôt que d'utiliser à nouveau les variables.
nom du fichier = "00001.m2ts".
src16 = core.lsmas.LWLibavSource(source=nom du fichier,format="yuv420p16")
Ou src16 = core.lsmas.LWLibavSource(source="00001.m2ts",format="yuv420p16")

C'est le genre de chose qui utilise des passes assumées pour faire la même chose.

source = "00001.m2ts
src16 = core.lsmas.LWLibavSource(source=source,format="yuv420p16")
Ou src16 = core.lsmas.LWLibavSource(source,format="yuv420p16")

Cette façon d'écrire est également légale. Notez la signification de source=source : pour la première source, le
système la cherchera dans la fonction d'entrée, et pour la seconde source, le système fera une expression dans
le script courant. De même, si vous écrivez une source directement, le système calculera la valeur de la source
comme une expression, puis la transmettra à la fonction de manière directe.

3. Mécanismes de passage des paramètres dans les fonctions
vs En ce qui concerne le passage des variables de fonction, il suit le mécanisme suivant.

1. Toutes les passes directes doivent être précédées d'une passe variable. Par exemple,
LWLibavSource(source,format="yuv420p16") est OK, alors que LWLibavSource(format="yuv420p16",source)
a une erreur de syntaxe.

2. Lors du processus de passage, tous les paramètres passés de manière variable sont d'abord passés, et les
paramètres restants qui ne sont pas passés sont affectés aux valeurs directement passées une par une, dans
l'ordre. Par exemple, core.std.MaskedMerge Cette fonction.
std.MaskedMerge(clip clipa, clip clipb, clip mask[, int[] planes, bint first_plane=0])

从 Les trois premiers n'ont pas de valeur par défaut, ils doivent donc être saisis au moment de l'appel ; les deux
derniers sont enveloppés dans [], ce qui signifie qu'ils peuvent être laissés de côté. first_planes a une valeur par
défaut de 0, et first_planes a une valeur par défaut de 0. planes n'a pas de valeur par défaut car il nécessite un
tableau entier de longueur inconnue (lire la doc pour connaître son affectation par défaut lors de l'appel, en
connaissant la longueur réelle du tableau).
Supposons que nous ayons compté les trois clips : bord, non bord et masque.
core.std.MaskedMerge(nonedge, [0,1,2], False, mask=mask, clipb=edge)

Le système passera d'abord la valeur de mask au masque d'entrée de la fonction, puis la valeur de edge au clipb
d'entrée. clipa, [0,1,2] est passé aux avions, False est passé à first_clip. donc il est équivalent à.
core.std.MaskedMerge(clipa=non edge, clipb=edge, mask=mask, planes=[0,1,2], first_plane=False)
ou core.std.MaskedMerge(nonedge, edge, mask, [0,1,2], False)

Si une certaine entrée est saisie deux fois pendant le passage (cela ne peut se produire que si l'entrée est
saisie de manière répétée avec un passage formatif, réfléchissez à la raison) alors vs signalera une erreur.
v s s ig n a le ra é g a le m e n t u n e e rre u r s i la v a ria b le q u i d o it ê tre s a is ie (q u i n 'a p a s d e v a le u r p a r d é fa u t d a n s la d o c e t
q u i n 'e s t p a s e n c a d ré e p a r []) n 'e s t p a s e n tiè re m e n t a s s ig n é e a p rè s la fin d e la p a s s e ; v s s ig n a le ra é g a le m e n t u n e
e rre u r s i le ty p e d e la v a le u r s a is ie n e c o rre s p o n d p a s a u ty p e d e la d é fin itio n d e la v a ria b le p e n d a n t la p a s s e , p a r
e x e m p le s i v o u s d o n n e z u n e c h a în e à u n e v a ria b le d e ty p e e n tie r.
Du point de vue de la lisibilité des codes et de la réduction des erreurs, il faut toujours encourager le passage par
hypothèse.

Le passage de la fonction VS, qui peut permettre l'emboîtement ainsi que la concaténation. Par exemple.
src16 = core.lsmas.LWLibavSource(source="00001.m2ts")
res = core.rgvs.RemoveGrain(src16, 20)

Avec des notes de synthèse imbriquées.
res = core.rgvs.RemoveGrain(core.lsmas.LWLibavSource(source="00001.m2ts"), 20)

est de traiter la fonction directement comme une expression

Écriture en série (doit être une fonction de la vs spec, par exemple tout sous le noyau).
res = core.lsmas.LWLibavSource(source="00001.m2ts").rgvs.RemoveGrain(20)

L e s n o y a u x u lté rie u rs p e u v e n t ê tre o m is e n s é rie . L 'e ffe t e s t d e p re n d re le c lip g é n é ré p ré c é d e m m e n t e t
d e le p a s s e r c o m m e p re m iè re v a le u r d ire c te d e la fo n c tio n s u iv a n te .

4. Un simple montage vidéo
Dans ce chapitre, nous allons aborder quelques utilisations courantes de vs pour vous aider à démarrer.

4.1 Culture et mise à l'échelle
CropRel, mis à l'échelle par redimensionnement.
doc respectivement.
http://www.vapoursynth.com/doc/functions/crop.html
http://www.vapoursynth.com/doc/functions/resize.html

Supposons que nous lisions en 4:3 natif et que nous réalisions une vidéo de 1920x1080 en ajoutant une bordure
noire, que nous la coupions d'abord en 1440x1080 (soit 240 pixels à gauche et à droite) et que nous la mettions
ensuite à l'échelle en 720p :
src = ...
recadré = core.std.CropRel(clip=src, left=240, right=240)
res = core.Resize.Spline36(clip=cropped, width=960, height=720)
res.set_output()

Comme vous pouvez le voir en regardant le document, il se trouve que toutes les entrées sont les trois
premières partielles requises par le filtre, de sorte que le code ci-dessus peut être réduit à (écrit en série).
src = ...
core.std.CropRel(src, 240, 240).Resize.Spline36(960, 720).set_output()

4.2 Divisions et fusions
La scission repose sur la norme Trim (http://www.vapoursynth.com/doc/functions/trim.html)
La fusion s'appuie sur std.Slice(http://www.vapoursynth.com/doc/functions/splice.html)
Voici les numéros de trame que nous avons spécifiés pour les numéros de trame dans tout le système de
tutoriel vcb-s.
Dans la plupart des cas (sauf pour mkvtoolnix), les images vidéo sont numérotées à partir de 0. En termes
simples, si une vidéo comporte 1000 images, toutes les images sont étiquetées comme telles.
0, 1, 2...999

mkvtoolnix est étiqueté à partir de 1 : 1, 2, 3...1000. Cependant, à moins que mkvtoolnix ne soit spécifié, toute
discussion suppose que les images sont étiquetées à partir de 0.
Nombre total d'images à partir de 0 ou 1 = nombre de fin - premier nombre + 1
Si nous disons de la trame a à la trame b, nous incluons le début et la fin par défaut. Par exemple, si nous
disons 20-100 images, c'est 20,21,...99 100 images, c'est 100-20+1=81 images.
Revenons à l'usage de Trim.
std.Trim(clip clip[, int first=0, int last, int length])

clip doit être saisi, en spécifiant d'abord l'image à partir de laquelle on commence à couper (par défaut, 0), puis
la dernière et la longueur en spécifient une de chaque. (Le document vous indique que vous obtiendrez une
erreur si vous indiquez les deux). Si aucune affectation n'est passée, comme std.Trim(clip, 20,100), alors
l'entrée 100 sera jugée comme la dernière, car la dernière est précédée de
Avec le premier et le dernier identifiés, Trim découpe toutes les images du clip du premier au dernier, y compris le
premier et le dernier, pour un total de dernier-premier+1 ;
Si la longueur est spécifiée, Trim découpera le clip du premier pour un total d'images de longueur, ce qui équivaut
à spécifier le dernier comme longueur+premier-1.
Il y a un sucre syntaxique hérité de Python dans vs pour vous aider à écrire Trim facilement :
vidéo = clip [20:101]
Equivalent à la vidéo = core.std.Trim(clip,20,101-1)
Notez que Trim s'écrit de x à y et que le sucre syntaxique est [x:y+1], mais les deux effets coupent le cadre y-x+1
de x à y. L'effet est de couper le cadre y-x+1.

Parce que dans l'avs, le découpage utilise également le nom de la fonction de découpage, l'écriture et les règles de x
à y, il est recommandé de ne pas utiliser l'écriture syntaxique en sucre, mais de s'en tenir à l'usage traditionnel.
Sinon, il est facile de semer la confusion parmi les coéquipiers (car dans la production de masse, les coéquipiers
doivent modifier eux-mêmes les paramètres de la garniture).

La fusion des deux parties est plus simple.
longvideo = core.std.Splice([video1, video2])

Il s'agit de fusionner la vidéo1 et la vidéo2 dans le même ordre. Pour cela, il faut que la vidéo1 et la vidéo2 aient
la même taille et le même type de pixel (par exemple, le même YUV420P8), mais d'autres propriétés comme la
fréquence d'images peuvent être différentes.
Si vous souhaitez fusionner de force deux vidéos de tailles ou de types de pixels différents, vs peut également
être fait.
longvideo = core.std.Splice([video1, video2], mismatch=1)
Mais dans la pratique, il y a peu d'exemples de cela est, après tout, différentes tailles et types de traitement ensemble
beaucoup de restrictions, exigent généralement que vous convertissiez d'abord à un format uniforme.

Re-fusionner.
Si vous voulez fusionner plusieurs vidéos, il suffit d'ajouter le tableau.
longvideo = core.std.Splice([video1, video2, video3])

Les rédactions fusionnées sont plus recommandées pour les sucres grammaticaux (c'est ainsi qu'ils
sont écrits dans les avs).
longvideo = video1+video2+video3

Simple et clair à comprendre. La taille et le type de pixel de la vidéo1, de la vidéo2 et de la vidéo3 doivent être
identiques, et d'autres propriétés telles que la fréquence d'images peuvent être incohérentes.

4.3 Réduction simple du bruit, déshabillage et sous-titrage
RemoveGrain() pour la réduction du bruit, f3kdb.Demand() pour le débanding, assvapour.AssRender() pour le
sous-titrage.
À ce stade, vous devriez être en mesure de trouver le médecin par vous-même. Astuce : Commencez par la
recherche en bas à droite de la page d'accueil de vs doc, si vous ne la trouvez pas, filtrez avec Google
Keywords
镜 vapoursynth
src = ...
nr = core.std.RemoveGrain(src, [11,4])
dbed = core.f3kdb.Demand(nr,12,32,24,24,0,0)
res = core.assvapour.AssRender(dbed, "xxx.ass")
res.set_output()

Essayez de trouver le document vous-même, et voyez par vous-même à quelle entrée chaque argument est
adressé, et ce que l'entrée signifie (au moins littéralement dans le document).

5. VS lit pour la propriété du clip et la propriété de l'image.
Le VS peut lire directement certaines propriétés de la vidéo et de l'image elle-même, telles que la longueur totale de la
vidéo, la fréquence d'images, la longueur et la largeur d'une image, le type, etc. Cette partie de la vidéo peut être lue
directement dans le

Expliqué en détail sur le sitehttp://www.vapoursynth.com/doc/pythonreference.html%23classes-andfunctions nous ne citerons que les
Les plus utilisés.

clip.num_frames renvoie le nombre total d'images dans le clip. Donc pour couper la première image (image 0)
de la vidéo, vous pouvez écrire quelque chose comme ceci.
res = core.std.Trim(clip, 1, clip.num_frames-1)

clip.width, clip.height renvoie la largeur et la hauteur du clip. Par exemple, si nous voulons passer à la taille 1/2.
res = core.Resize.Spline36(clip, clip.width//2, clip.height//2)
#Notez que // est une division entière, qui se traduit par int, sinon // est une division en virgule flottante, qui se
traduit par float.
#Tandis que le filtre de type Redimensionner requiert des données de type int.

Au fait, en ce qui concerne les commentaires Python, # est l'équivalent Python du commentaire de
la dernière ligne, qui est l'équivalent C/C++ de // si vous voulez un gros commentaire, quelque
chose comme /** **/.

Sélection des branches et indentation en Python
P y th o n , e n ta n t q u e la n g a g e d e p ro g ra m m a tio n p o ly v a le n t, s u p p o rte d e n o m b re u x c o n c e p ts u tilis é s d a n s la
p ro g ra m m a tio n m o d e rn e , n o ta m m e n t le s b a s e s te lle s q u e le s b ra n c h e m e n ts s é le c tifs e t le s b o u c le s .
Voici une liste.

Nous mettons un commutateur Debug, si Debug=1/True pour entrelacer src16 et res et les convertir en RGB
8bit, sinon res en YUV - 10bit prêt pour l'encodeur.
Débogage = 0
si Debug :
res = core.std.Interleave([src16,res])

#Interleave affiche la vidéo d'entrée image par image.

res = mvf.ToRGB(res,full=False,depth=8) #ToRGB a pour rôle de passer en RVB, la profondeur
des bits a été spécifiée comme étant 8 else : res = core.fmtc.bitdepth(res,bits=10) #bitdepth est
Effectuer la conversion de précision
S'il était écrit en pseudo-code C, il y ressemblerait probablement :
Debug = 0 ;
si (Debug) {
res = core.std.Interleave([src16,res]) ;
res = mvf.ToRGB(res,full=False,depth=8) ;
}autre
res = core.fmtc.bitdepth(res,bits=10) ;

Comme vous pouvez le voir, Python n'a rien de comparable à {} pour combiner un morceau de code ; Python
utilise l'indentation. Différents niveaux d'indentation sont utilisés pour distinguer différentes combinaisons. Par
exemple.
res = core.std.Interleave([src16,res])
res = mvf.ToRGB(res,full=False,depth=8)
Les deux phrases sont mises en retrait par une tabulation, ce qui équivaut à les encadrer dans un paragraphe
par des parenthèses bouclées. Si c'est le cas.
Débogage = 0
si Debug :
res = core.std.Interleave([src16,res])
res = mvf.ToRGB(res,full=False,depth=8)
ToRGB(res,full=False,depth=8) est parallèle à la déclaration if, et sera certainement exécuté après la
déclaration if.

Python est très strict sur l'indentation, et tout décalage entraînera une erreur. Notez qu'une tabulation et un espace ne
sont pas équivalents, même s'il vous semble que quatre espaces égalent une tabulation.

D'autres utilisations avancées de VS, telles que le mécanisme d'exécution et les fonctions personnalisées,
seront abordées plus en détail dans les prochains tutoriels.


Aperçu du document VCB-Studio06VapourSynth_FR.pdf - page 1/18
 
VCB-Studio06VapourSynth_FR.pdf - page 2/18
VCB-Studio06VapourSynth_FR.pdf - page 3/18
VCB-Studio06VapourSynth_FR.pdf - page 4/18
VCB-Studio06VapourSynth_FR.pdf - page 5/18
VCB-Studio06VapourSynth_FR.pdf - page 6/18
 




Télécharger le fichier (PDF)


VCB-Studio06VapourSynth_FR.pdf (PDF, 107 Ko)

Télécharger
Formats alternatifs: ZIP



Documents similaires


vcb studio06vapoursynthfr
seance2
dossier du jeu de la vie
devoir synthese sujet 1
devoir synthese sujet 2
fortran programs