Beiträge von Sagaras

Zitat von Zantos

Importiere die [lexicon]Lagarith[/lexicon] AVI mal in [lexicon]VirtualDub[/lexicon] und encodiere wieder als [lexicon]Lagarith[/lexicon] mit YV12 und Multithreading. Dann erstell ein Avisynth Script, in dem du die encodierte AVI lädst und eine Info ausgibst.

Ok, das klappt jetzt. Ist aber irgendwie doppelte Arbeit. Bestimmt ein Fehler des [lexicon]Lagarith[/lexicon]. Ich werd doch nicht jedesmal die Aufnahmen noch mal mit [lexicon]Lagarith[/lexicon] encodieren lassen xD

Zitat von Zantos

Histogram und Info deuten allerdings klar auf YV12 hin:

Zitat von DerET

Mach mal eine ganz normale AviSource und danach direkt Info. Die Info Funktion gibt ja die Information zum Bild aus, wie sie an der Stelle sind, an der Info auf den [lexicon]Frame[/lexicon] angewendet wird.

Wie du auf YV12 da kommst jetzt weiß ich auch nicht Zantos. Ich kann mir vorstellen das irgendwo vorher noch zu YV12 umgewandelt wird

Ich hab das jetzt mal wie DerET es gesagt hat gemacht und die Info nach AVISource hingeschrieben. Folglicherweise kommt sowas hier:

AVISynthScript ist:

AVISource("L:\Test\Testaufnahme\Aladdin.avi", audio=false).AssumeFPS(30,1)
Info()

Die [lexicon]Mediainfo[/lexicon] ist von der Rohdatei. [lexicon]Lagarith[/lexicon] - Mode: YV12 + "Use Multithreading"

Dann sieht man das Problem jetzt.

Wenn ich encodieren will fragt mich [lexicon]MeGUI[/lexicon] hilflich ob ich ConvertToYV12() dran hängen möchte oder nicht. Tuhe ich es nicht, konvertiert der [lexicon]Encoder[/lexicon] das so oder so in YV12. Ob das nun in Skript steht oder nicht. Die [lexicon]Mediainfo[/lexicon] müsste mir ja RGB Farbraum anstatt YUV ansagen, was es aber nicht tut, auch wenn ConvertToYV12() weggelassen wird. Er macht daraus wieder ein YUV Farbraum. Wobei es sich wieder um YV12 handelt.

Das geht schon ohne ConvertToYV12()

Allerdings macht der [lexicon]Encoder[/lexicon] daraus trotzdem ein YUV Video, weil der nun mal eine YUV Ausgabe besitzt.

Bedeutet das Problem bleibt bestehen und man hat YV12 - > RGB32 -> YV12

Egal wie man das wendet und dreht ;D

Könnt ihr selbst ausprobieren, indem ihr im Skript vor dem ConvertToYV12() den Befehl Info() setzt.

Zitat von Zantos

Also bei mir steht da mit aktuellstem [lexicon]MeGUI[/lexicon] und einem Input Video im [lexicon]Lagarith[/lexicon] [lexicon]Codec[/lexicon] nach dem Encode kein ConvertToYV12 im Avisynth Script.

Reproduzierbar wenn du das Video encodieren willst, [lexicon]MeGUI[/lexicon] versucht ein ConvertToYV12 dranzuhängen ;D

Eigentlich jetzt keine Frage, sondern eher eine Feststellung die ich gestern mit De-M-oN gemacht habe.

Und zwars betrifft es erst mal den [lexicon]Lagarith[/lexicon] [lexicon]Codec[/lexicon] den man ja auf YV12 stellt und auf "Use Multithreading".

Bei [lexicon]MeGUI[/lexicon] passiert jetzt folgendes das dieser ein ConvertToYV12 am Ende des Scriptes schreibt, sobald man encodieren will. In AVISynth selbst passiert mit dem Video nähmlich folgendes:

YV12 -> RGB32 -> YV12

Was natürlich für Verluste sorgt bezüglich des Chromas. Und das nur weil in RGB32 Farbraum umgewandelt wird im Skript, obwohl das Video YV12 sein müsste.

Das ist wieder eine Qualitätsfrage bezüglich der Farben. Der [lexicon]Encoder[/lexicon] encodiert eh mit YV12. Schöner wäre es nämlich YV12 -> YV12 ohne RGB32 drin zu haben. Bedeutet das AVISynth und [lexicon]MeGUI[/lexicon] kein ConvertToYV12 Befehl drin enthalten sein dürften. Weil warum noch mal in YV12 konvertieren wenn das Video eh in YV12 ist? ;D

Das Phänomen ist für jeden reproduzierbar. Also ihr könnt es selbst ausprobieren ;D Wer ne Lösung finden sollte, kann es ja mal posten xD

Zitat von MrsLittletall

In was für einem Ordner speichert [lexicon]Camtasia[/lexicon] denn die Dateien, bevor sie zu einem camrec verpackt werden? Ich hab mir den kompletten Ordner angesehen, aber irgendwie nichts passendes gefunden...

Im [lexicon]Camtasia[/lexicon] Recorder selbst hast du (Ich bleib mal bei Englisch) unter Tools Options unter dem Reiter General ganz unten den Menüpunkt des Savings.

Dort steht Camrec. Und da drunter müsste der Temporäre Pfad sein wo deine Aufnahmen aufgenommen werden, bevor diese gespeichert werden.

Der Temporäre Pfad ist somit die Aufnahmeablage wärend du aufnimmst beim spielen. Da wird alles gespeichert. Und da sollte auch der CamRec Ordner zu finden sein dann

Wie gesagt: Die Vorschau auf dein Video pausieren lassen und minimieren (nicht schließen). Die Aufnahmen aus dem CamRec Ordner dann auf der gleichen [lexicon]Festplatte[/lexicon] in ein anderes Verzeichnis verschieben. Es darf sich nicht mehr im CamRec Ordner befinden. Und dann kannst du in der Vorschau auf delete klicken oder das Programm ganz beenden.

Der Effekt das das Video erst verpackt wird ist damit umgangen und du hast keine Arbeit damit es zu entpacken. Wenn man mal überlegt bei 6GB oder in dem Dreh das das Video erst verpackt wird und dann noch mal entpackt ist das echt Zeitaufwendig ;D Und so hat man den Salat nicht mehr, sondern seine Rohdatein pur.

Zitat von MrsLittletall

Es ist wirklich schade, dass man den nicht allein kriegt, denn das Programm ist sowas von teuer...

Ja leider. Schade ist eigentlich das es mit nem Key gesichert ist, es Geld kostet und die Rechte der Firma gehören. Denn für mich selbst hab ich den Recoder schon längst vom Hauptprogramm entkoppelt und steht mir nun als Stand Alone Programm zur Verfügung. Dafür hab ich auch ein eigenes Setup zusammengestellt mit InnoSetup. Bedeutet das ich den Recorder nur noch drauf habe, aber das eigentliche Studio nicht mehr. Lieber 30MB für den Recorder, als 300MB oder was das waren für das komplette Programm was mir eh nix bringt ;D

Ja, das [lexicon]Camtasia[/lexicon] Studio bugt gerne mal bei der Entpackung der entsprechenden Streams. Deshalb entweder mit einem ZIP Programm entpacken (7zip ist hervorragend dafür) oder der bessere Weg wäre sich das verpacken und entpacken der Aufnahme sparen. Dafür gibt es einen Trick. Und zwars ist das der, wo dir bei dem [lexicon]Camtasia[/lexicon] Recorder die Vorschau auf deine Aufnahme gezeigt wird.

Die Pausierst du erst mal und lässt das Fenster offen. Gehst in dein Aufnahmeverzeichnis und schneidest dir aus dem CamRec Ordner die AVI und die [lexicon]WAV[/lexicon] Datei aus und fügst sie auf der gleichen [lexicon]Festplatte[/lexicon] wieder woanders ein. Oder Verschiebst die zwei Datein.

Du darft aber nicht kopieren, da sonst noch mal der Kopiervorgang sehr lange dauert. Beim Verschieben der Datein aber nicht. Das geht Ratz Fatz.

Danach kannste im Vorschaufenster auf Delete klicken und umgehst damit das verpacken und entpacken was enorm viel Zeit frisst.

Und bitte niemals über [lexicon]Camtasia[/lexicon] Studio entpacken. Da sind unter anderem auch wieder so viele Bugs die dort auftreten können. Also wer das Programm programmiert hat, müsste man erschlagen. Damit meine ich nicht die Firma, sondern den Programmierer xD

Zitat von De-M-oN

DirectShowSource sollte eig. von Haus aus existieren. Wundert mich gerad, das du da extra noch die dll laden musst.

Liegt daran das ich das nicht von Haus aus in der Plugin Liste von AVISynth habe ;D Hatte ich seltsamer weise noch nie.

FFVideoSource ist auch ein Plugin den man erst laden muss/erst mal runterladen muss ;D

Danach sollte damit genauso wieder verfahren werden wie mit allen anderen Ladefunktionen von Quellmaterialien

Zitat von De-M-oN

Vllt solltest du noch einbringen, das Verlustformate nicht mit DirectShow geladen werden sollten, sondern eher mit FFMPEGSource (File index + FFVideoSource)
Zum einen unterstützt es sehr viel mehr Codecs, zum anderen umgeht man damit systeminstallierte decoder/filter, und es hat frameexaktes seeking, was directshowsource nicht hinkriegt.

[lexicon]Lossy[/lexicon] Formate also auf jeden Fall immer per FFVideoSource einlesen.

Eingebracht ;D
Wieso noch mal erklären, wenn du das so wunderschön schon machst? Generell sollte auch erwähnt werden das sowas erst genutzt werden sollte, sollte eine [lexicon]MP4[/lexicon], [lexicon]MKV[/lexicon] oder sowas noch mal reencodiert werden. Wer sowieso [lexicon]Lossless[/lexicon] aufnimmt mit [lexicon]FRAPS[/lexicon] oder [lexicon]Lagarith[/lexicon], wird sowieso AVISource nehmen. Und ganz verquerte Codecs wie [lexicon]KGV1[/lexicon] oder Zib Motion Block Video sind auch immer sehr kurios zu laden Sollte man auch mit bedenken.

Animationen und Alphamasken mittels AVISynth

Da wir die Grundlagen bereits kennen kommen wir nun zu etwas schwierigerem, nämlich wie wir mit AVISynth Animationen erzeugen können und wie wir Alphamasken ausnutzen können um beispielsweise eine Bildfreistellung zu zaubern damit. Ok, eine Bildfreistellung wäre doch ein bisschen extrem ausgedrückt, wenn man bedenkt das wenn man einen Blauen Vorhang hinter sich hat, es aufnimmt und nur den blauen Hintergrund entfernen möchte. Da gehört schon einiges mehr zu. Was ich hier erkläre beschränkt sich auf ein Farbmuster dann.

Aber erst mal zu den Animationen. In AVISynth gibt es zwei Filter die es uns erlauben andere Filter zu verwenden. Bedeutet man könnte diesen Filter mehrmals verkapseln. Ich hab mich beim Probieren selbst erst mal damit beschäftigt und hab es auch beim x male nicht geschafft den Filter ApplyRange und Animate zu koppeln. Erst im Gleitzforum konnte mich einer aufklären was das anging. Aber erst mal: Was ist überhaupt dieser Animate und ApplyRange Filter eigentlich? Nun um es kurz zu sagen: Animate gibt einen anderen Filter wieder der sich von [lexicon]Frame[/lexicon] x nach [lexicon]Frame[/lexicon] y ändern kann. Dabei darf aber die Größe des Clips nicht geändert werden. ApplyRange hingegen lässt uns einen anderen Filter von [lexicon]Frame[/lexicon] x bis [lexicon]Frame[/lexicon] y anzeigen. Ist [lexicon]Frame[/lexicon] y abgelaufen, sorgt ApplyRange dafür das dieser nicht mehr angezeigt wird.

Das ist eigentlich eine schöne Sache, da man eventuell die Webcam während das Video abspielt sich bewegen lassen kann von a nach b. Oder wir erschaffen damit eine Blende wie sie in StarWars zu sehen ist, dank der Alphamasken auf die ich dann noch kommen werde.

Fangen wir also damit an, das ich euch wieder eine Übungsvorlage gebe mit v1 und v2. Denkt dran das ihr die Blankclips jeder Zeit mit Videos austauschen könnt ;D

#Quellen Ladesektion
v1=BlankClip(length=901, width=800, height=600, fps=30, color=$0000ff).KillAudio()
v2=BlankClip(length=901, width=160, height=120, fps=30, color=$FFFF00).KillAudio()

Ich habe hier jetzt einen Befehl hinzugefügt, nämlich KillAudio(). Damit wird erreicht das beim angegebenen Clip die Audiospur entfernt wird. Also ganz Simple.
v1 ist hier jetzt Blau und v2 ist ein kleines gelbes Kästchen. Für die Webcam z.B. .

Wir legen also los indem wir unter der Quellen Ladesektion unsere Bearbeitungssektion erzeugen und mit Animate dafür sorgen das v2 von rechts bis nach links wandert ohne v1 zu verlassen. Ich werde hier ein dynamischen Code verwenden um dafür zu sorgen das sich alles nach der [lexicon]Auflösung[/lexicon] und Länge des geladeten Videos anpasst. Damit v2 v1 nicht verlässt rechnet man Zahlenmäßig: Für x = 800 - 160 = 640 und für y = 600 - 120 = 480 . Um es dynamisch zu machen für jede x belibige [lexicon]Auflösung[/lexicon] wird jetzt folgendermaßen gerechnet: x = v1.Width - v2.Width und für y = v1.Height - v2.Height . Die Informationen wie groß der Clip ist holen wir uns also mit den Befehlen Width und Height. Ändert sich also v1 oder v2, ändern sich diese Werte bei der Rechnung, was das ganze halt dynamischer macht. Das dazu. Nun zu Animate. Hier erst mal der Code:

#Bearbeitungssektion
Animate(v1,0,100,"Overlay",v2,0,v1.height-v2.height,v2,v1.width-v2.width,0)

Hier passiert nun folgendes: Auf v1 wird der Filter Animate angewendet und soll von [lexicon]Frame[/lexicon] 0 bis [lexicon]Frame[/lexicon] 100 den Filter Overlay animieren. Nach dem Overlayeintrag der als Zeichenfolge geschehen muss kommen Optionale Argumente die den angesprochenen Filter betreffen. Hier nun Overlay.

Overlay haben wir ja schon kennen gelernt und wissen das ein Clip auf ein anderen Clip gesetzt werden kann. Bei Animate wird nun v1 an Overlay übergeben als Clip auf den wir dann v2 setzen und dann die x und y Koordinaten der Startposition angeben. Danach kommt das gleiche Spiel hinterher mit der Angabe des Clips gefolgt von der entsprechenden Endposition.

Wenn ihr das Video nun abspielt, läuft die gelbe Box von links/unten nach recht/oben von [lexicon]Frame[/lexicon] 0 bis [lexicon]Frame[/lexicon] 100 und verhaart dort bis der gesamte Clip zuende ist.

Gleiches Spiel mit ApplyRange, nur mit weniger Angaben und den Effekt innerhalb eines bestimmten Framefensters ein Filter wirken zu lassen.

#Bearbeitungssektion
ApplyRange(v1,101,200,"Overlay", v2,v1.width-v2.width,0)

Hier erreichen wir das von [lexicon]Frame[/lexicon] 101 bis 200 v2 auf einer Position angezeigt wird. Der Befehl ApplyRange ist mit dem Befehl Animate fast identisch, nur das Animate eine Endbedingung haben möchte und ApplyRange die Bedingung innerhalb der Frames nur macht. Animate würde somit den Clip weiter auf der Endposition ablaufen lassen.

Sofern Fragen dazu noch offen sein sollten, könnt ihr mir diese gerne stellen ;D Weil jetzt wird es Verwirrender, denn ich möchte nun beide Filter auf einmal anwenden. Weil ich möchte das v2 von links nach rechts wandert und dann verschwindet vom Bild. Da wir mit ApplyRange und Animate Filter ansprechen können, kann man diese Filter selbst als Filter aufrufen und somit das ganze Verkapseln.

Ich zeig euch das mal an einem Beispiel wieder:

#Bearbeitungssektion
ApplyRange(v1, 0, 100, "Animate", 0, 100, "Overlay", v2, 0, 0, v2, v1.width - v2.width, 0)

Ich hoffe man sieht jetzt was damit gemeint ist. Anstatt Overlay, hätte man wieder Animate nehmen können usw. Was somit endlos weitergeführt werden könnte. Für unsere Zwecke reicht dieses Gebilde vollkommen aus.
Wie funktioniert nun das ganze? Also (Und das musste mir auch erst jemand aus dem Gleitz Forum erklären ;D) v1 ist unser Hintergrundclip auf dem wir alles projekzieren. Von [lexicon]Frame[/lexicon] 0 bis [lexicon]Frame[/lexicon] 100 soll nun Animate ausgeführt werden und Animate soll ebenfalls auf v1 von [lexicon]Frame[/lexicon] 0 bis [lexicon]Frame[/lexicon] 100 den Overlay Filter dazu bewegen eine Animation auszuführen. Hiermit erreichen wir nun das v2 wärend der Wiedergabe von links nach rechts wandert und dann verschwindet.

Sieht doch schon mal ganz Praktisch aus. Lassen wir v2 doch einmal um den Bildschirm wandern. Hierzu ist euer eigener Kopf gefragt, damit möchte ich erreichen das ihr mitdenkt und es versteht. Ihr könnt dazu gerne hier ins Tutorial schreiben und euch drüber austauschen ;D Kleiner Tipp von mir: Übergebt ApplyRange an den nächsten Filter, indem ihr es in eine Variable sichert.

Habt ihr alles fertig sollt ihr das ganze so anpassen, das egal wie lang der Clip ist, diese komplette Animation so lange geht wie der Gesamtclip. Bedeutet: Wenn ich die Länge von Clip v1 und v2 ändere, soll die Komplette Animation auch so lange gehen. Auch hier als Tipp: Die Maximale Frameanzahl könnt ihr durch "FrameCount" ermitteln. Einfach dann an v1 oder v2 anhängen wie so z.B. : v1.FrameCount oder v2.FrameCount , um die maximale Frameanzahl zu ermitteln.

Baut euch daraus etwas um die Start und EndFrames der Filter Animate und ApplyRange zu ändern ;D

Jetzt kommen wir zu Alphamasken. Alphamasken sind spezielle Bilder die im [lexicon]Alphakanal[/lexicon] die Transparente Farbe speichern. Das kann jede mögliche Farbe sein. Im Austausch für diese Farbe wird diese mit einem anderen Bild getauscht. Bedeutet: Wir tauschen eine spezifische Farbe mit einem Videoclip aus.

Ein schönes Beispiel auf Youtube: https://www.youtube.com/watch?v=M9FcjU7dF44

Und hier kommt auch die Verwendung von Blankclips ins Spiel. Ich möchte nämlich jetzt kein gewöhnliches Bild mit Alphamaske erzeugen, sondern ein Animiertes. Und zwar mächte ich eine StarWars Szenen Blende haben. Also das von Links nach Rechts das Bild durch ein anderes ersetzt wird. Trefflich gewählt also können wir unsere neu erworbene Kenntniss mit Animate anwenden um diesen Effekt zu erziehlen. Also bauen wir uns erst einmal eine Blende Farblich mit Blankclips. Nehmt am besten Farben die im Video nachher nicht zu sehen sind. Sowas wie ein grelles Grün oder ein grelles Pink.

Das ganze sieht im Endeffekt dann so aus:

#Quellen Ladesektion
v1=BlankClip(length=101, width=800, height=600, fps=30, color=$80FF80).KillAudio()
v2=BlankClip(length=101, width=800, height=600, fps=30, color=$FF80FF).KillAudio()


#Bearbeitungssektion
Animate(v1,0,100,"Overlay",v2,-v2.width,v1.height-v2.height,v2,v1.width-v2.width,0)

Hiermit erzeugen wir mit BlankClip solch eine simple Blende. v1 und v2 haben nun entsprechende Farben die unwahrscheinlich in einem richtigen Clip Grossflächig zu sehen sind.

Allerdings müssen wir die Blende vorher encodieren lassen, damit sie für uns brauchbar ist. Das machen wir am besten mit Virtual Dub und dem [lexicon]Lagarith[/lexicon] [lexicon]Codec[/lexicon]. Ladet dazu einfach die AVS Datei rein und lasst diese mit dem [lexicon]Lagarith[/lexicon] encodieren. Das müssen wir leider so machen, da das Video was wir im Code erzeugt haben uns das ganze im Zusammenhang mit unserer Alphamaskte zerstören würde und wir etwas völlig anderes haben dadurch, was nicht gewollt war.

Übrigens könnt ihr solche Masken überall erstellen. Sogar mit Schrottasia. Beachtet aber dabei das ihr so [lexicon]Lossless[/lexicon] wie Möglich das ganze exportiert. Bei [lexicon]Camtasia[/lexicon] 8 wäre das der TSC2 [lexicon]Codec[/lexicon] und bei allen anderen wenn es geht der [lexicon]Lagarith[/lexicon] [lexicon]Codec[/lexicon]. Halt irgendwas was [lexicon]Lossless[/lexicon] ist ;D Muss ja nur eine Animation sein die aus zwei unterschiedlichen Farben besteht.

Weiter im Text... wir haben also unsere Blende fertig encodiert und ein Buntes Etwas erzeugt. Auf diese zwei Farben projekzieren wir mit dem nächsten Script unsere Clips. Das sieht dann folgendermaßen aus:

#Quellen Ladesektion
v1=AVISource("Blende.avi", audio=false).AssumeFPS(30,1).ConvertToRGB32().Spline64Resize(800, 600)
v2=AVISource("Game1.avi", audio=false).AssumeFPS(30,1).Spline64Resize(800,600)
v3=AVISource("Game2.avi", audio=false).AssumeFPS(30,1).ConvertToRGB32().Spline64Resize(800,600)


#Bearbeitungssektion
m1=ColorKeyMask(v1,$FF80FF,100).ShowAlpha(pixel_type="RGB32")
o1=Overlay(v2,v1,mask=m1).ConvertToRGB32()


m2=ResetMask(o1).ColorKeyMask($80FF80,100)
Layer(v3,m2).ConverttoYV12()

So, was passiert hier nun? Als erstes laden wir unsere Quellen v1 - v3. v1 unsere Blende und die 2 Aufnahmen die verblendet werden sollen. Das ganze muss im RGB32 Farbraum stattfinden und deshalb werden hier die Aufnahmen in RGB32 umgewandelt. Das müssen wir machen, da wir sonst mit den Maskenfiltern nicht arbeiten können.

Als erstes wird nun mit ColorKeyMask die Farbe selektiert die wie austauschen möchten auf v1 und setzen gleich den [lexicon]Alphakanal[/lexicon] dafür damit diese Farbe nicht angezeigt wird. Hier nicht vergessen den Pixel_Type auf RGB32 zu setzen, da sonst wieder Fehler auftreten. Diese Maske wird jetzt mit Overlay ersetzt, da die Farbe ja jetzt Transparent ist erscheint das Video durch. Im Overlay geben wir dann unsere Maske m1 an und convertieren das ganze auch da in RGB32. Da ja v2 oben noch nicht convertiert wurde, können wir das hier gleich machen für den nächsten Schritt. Denn dieser Overlay dient jetzt als Blaupause für unsere nächste Farbe. Wir reseten die Maske vom Overlay und wählen eine neue Farbe aus die wir für die Nächste Maske nehmen. Danach brauch nur noch Layer dafür sorgen das auf die letzte Maske unser letztes Video kommt. Und fertig ist der Zauber. Danach wieder alles in YV12 convertieren und [lexicon]MeGUI[/lexicon] kann encodieren.

Aber Vorsicht: Bei selbsterstelten Blenden oder Dessolve laufen beide Clips in der Blendzeit gleichzeitig ab. Bedeutet das ihr eure Audiospur auch abändern müsst um die entsprechende Zeit.

So. Das wars erst mal dazu. Alles wichtige ist damit eigentlich gesagt zu AVISynth. Sollte jemanden noch etwas einfallen was er vllt bräuchte oder realisieren möchte damit kann das in diesen Tutorial Thread gerne tun Ich denke mal da es weitere schlaue Köpfe gibt was AVISynth angeht und ich auch nicht alles wissen kann

Das hier sind nur die Grundlegensten Sachen jetzt die man mit internen Filtern zaubern kann. Sachen wie Restoration von Videos oder Nachbearbeitung etc... sind alles weitere Sachen die man machen kann.

Gut zu wissen währe noch bestimmt wie man Bilder ladet, oder? Nun, da ich denke das ihr euch durch das Tutorial gekämpft habt und euch damit schon beschäftigt habt, könnt ihr euch das mit den Bildern anhand meiner Templates anschauen die bei [ Text-Tutorial ] Der große AviSynth-Guide zu finden sind ;D

Und wie gesagt, bei Fragen oder weiteren Wünschen wie man was machen kann, könnt ihr euch hier drüber die Finger blutig schreiben ;D Die die in AVISynth dann etwas bewandert sind, werden euch dann sicher weiter helfen ;D

Videos per AVISynth schneiden, croppen und Positionen ansprechen

Gleich vorweg, bevor wir loslegen mit dem schneiden gebe ich euch für das bessere Verstehen eine Vorgefertigte AVS Test Datei die A) Zum Croppen dienen soll und B) zum schneiden gut geeignet ist. Ihr braucht dafür einfach nur den Code hier kopieren. Der Clip geht ca. 13,5 Sekunden lang und beinhaltet sowohl zentrierte aufeinanderliegende farblich unterschiedliche Clips, als auch eine Frameanzeige die uns den aktuellen [lexicon]Frame[/lexicon] mitteilt.

#Quellen Ladesektion
v1=BlankClip(length=400, width=800, height=600, fps=30, color=$0000ff)
v2=BlankClip(length=400, width=640, height=480, fps=30, color=$00ff00)
v3=BlankClip(length=400, width=320, height=240, fps=30, color=$ff0000)


#Bearbeitungssektion
o1=Overlay(v1,v2,x=(v1.width-v2.width)/2, y=(v1.height-v2.height)/2)
Overlay(o1,v3,x=(v1.width-v3.width)/2, y=(v1.height-v3.height)/2)


ShowFrameNumber(false,1,(v1.width/2)-40,(v1.height/2)+20,"Arial",40,$FFFF00,$000000)

Für Übungszwecke sollte das Beispiel ausreichen. Sollte der letzte Videofilter keine Variable besitzen, so ist dieser in der Variable "last" immer gesichert. Wir ergänzen jetzt nur unter ShowFrameNumber die AVS Datei und fangen erst mal mit dem Croppen an. Als Test habe ich die Auflösungen 800x600 (Blau), 640x480 (Grün) und 320x240 (Rot) vorgegeben. Zu sehen im BlankClip Eintrag. Der Befehl zum Croppen ist ganz einfach und erschließt sich aus dem Befehl Crop und den Parametern Links, Oben, Rechts und Unten. Wir Croppen also unser Video mal auf 640x480. In [lexicon]MeGUI[/lexicon] könnt ihr das auch Wunderschön machen mit Vorschaubild.

Die Frage ist bei AVISynth wieviel muss ich jetzt wegschnibblen an den Seiten. Wieder leichte Mathematik: (800 - 640) / 2 = 80 (für Links und Rechts) und (600 - 480) / 2 = 60 (für Oben und Unten) . Beachtet aber das Links und Oben mit Positiven Werten gefüttert werden muss beim Croppen und Rechts und Unten mit negativen Werten. Bedeutet für Links = 80, Oben = 60, Rechts = -80 und Unten = -60
Das geben wir auch im Code genauso ein:

#... Hier kommt das Videobeispiel hin ...


Crop(80, 60, -80, -60)

Damit ist unser aktuelles Bild die Grüne Fläche und beträgt anstatt 800x600, nur noch 640x480. Croppen wird dazu verwendet um bestimmte Sachen wie unschöne Ränder oder Bildvergleiche zu erzeugen. Jetzt croppen wir mal die Rote 320x240 Fläche nur auf die Hälfte. Also 160x240. Die Frage ist jetzt wo wir das machen. Das muss noch vor dem eigentlichen Overlay passieren. Bedeutet, ihr könnt den Clip den ihr ladet sofort croppen indem ihr den Cropbefehl einfach mit einen Punkt dranhängt. Ich Zeig das mal am Gesamten Beispiel wieder:

#Quellen Ladesektion
v1=BlankClip(length=400, width=800, height=600, fps=30, color=$0000ff)
v2=BlankClip(length=400, width=640, height=480, fps=30, color=$00ff00)
v3=BlankClip(length=400, width=320, height=240, fps=30, color=$ff0000).Crop(0,0,-160,0)


#Bearbeitungssektion
o1=Overlay(v1,v2,x=(v1.width-v2.width)/2, y=(v1.height-v2.height)/2)
Overlay(o1,v3,x=(v1.width-v3.width)/2, y=(v1.height-v3.height)/2)


ShowFrameNumber(false,1,(v1.width/2)-40,(v1.height/2)+20,"Arial",40,$FFFF00,$000000)


Crop(80, 60, -80, -60)

Was wir jetzt sehen, ist das der rote Clip geschrumpft und es so aussieht als ob er an beiden Seiten gecroppt wurde. Dem ist aber nicht so, denn es wurde nur die rechte Seite gecroppt auf die Hälfte des eigentlichen Clips. Das es in der Mitte wieder ist, hängt durch den dynamischen Overlay zusamm wo ihr eine Rechnung seht bezüglich x und y Koordinaten. Diese Rechnung bewirkt das die Bilder egal wie groß sie sind immer zentriert im Gesamtbild liegen. Ändert sich also die [lexicon]Auflösung[/lexicon] eines der Clips, wird diese automatisch zentriert im Bild.

Kommen wir nun zum schneiden. Das Schneiden in AVISynth ist etwas kompliziert für den Anfang und [lexicon]MeGUI[/lexicon] erzeugt bei einem Schnitt sowas hier z.B.:

__film = last
__t0 = __film.trim(41, 89)
__t1 = __film.trim(132, 191)
__t2 = __film.trim(218, 258)
__t0 ++ __t1 ++ __t2

Was macht dieser verwirrende Abschnitt eigentlich? Hier nun die [lexicon]Auflösung[/lexicon] dazu
Wie etwas weiter oben beschrieben wird in "last" der letzte Videoclip der angezeigt wird gespeichert. Hier wird last in die Variable "__film" gelegt. Im nächsten Schritt geschiet der erste Schnitt mit dem Befehl Trim. Und zwars wird hier nur die Fläche herausgeschnitten die man weiter verwenden möchte. Hier also von [lexicon]Frame[/lexicon] 41 - [lexicon]Frame[/lexicon] 89. Bedenkt dabei das der eigentliche Anfangs [lexicon]Frame[/lexicon] 1 ist und bei AVISynth 0 . Bedeutet dieser erste Schnitt zeigt uns nachher auf der [lexicon]Frame[/lexicon] Anzeige im Video die Werte 42 - 90 für den ersten Schnitt.
Hier wird nun die Variable "__t0" dazu verwendet den ersten Schnitt zu sichern aus dem Gesamtclip der in last war und nun in __film drin ist. Der Schnitt wird einfach an der Variable angehangen mit einen Punkt (__film.trim(Anfangs [lexicon]Frame[/lexicon], End Frame)). Und das kann man so oft wiederholen bis man alles fertig hat.
Im letzten Schritt werden alle Schnitte die gemacht wurden in die Globale Variable "last" gespeichert. Diese brauch nicht angegeben werden als Variableziel, sondern es reicht wenn die Variablen oder Filter eine Videoausgabe erzeugen können. Hier haben __t0 bis __t2 Videoinformationen gesichert die auch als Ausgabe dienen können und werden nun mit dem Operator "++" zusammengesetzt zu einem Clip.

Diese Trimmethode verwendet [lexicon]MeGUI[/lexicon] zum schneiden von Videos. Für manchen jetzt doch etwas mehr verständlich warum man nur einen Schnitt machen sollte damit ;D

Das Schneiden wird auch als Trick benutzt um Positionen leichter innerhalb eines Videos anzusprechen. Weil was nützt uns ein Fadein oder Fadeout nur am Anfang und am Ende des gesamt Videos?

Der Trick ist eigentlich ganz Simple. Ihr legt euch dafür mehrere AVS Datein an die euer Video laden. Croppt diese zurecht. Und dann kommt der Clou mit dem Schneiden. Da wo Blenden erscheinen sollen, macht ihr schnitte. Oder halt da wo bestimmte Bilder nur angezeigt werden sollen. Bedenkt aber das das gesamte Video wieder auf die gleiche Länge kommen muss. Bedeutet wenn das erste AVS von 0 bis 100 getrimmt wird, muss der nächste Abschnitt logischerweise von 101 weitergehen. Habt ihr alles erledigt kommt ein sogenanntes Makefile. Diese Makefile ist auch eine AVS Datei und ladet nun alle anderen AVS Datein wieder, damit es ein Video wieder ist. Während die einzelnen zerschnittenen AVS Files ganz normal aussehen, sieht das Makefile in der Ladesektion etwas anders aus. Das könnte dann so aussehen:

#Plugin und Importsektion
v1=Import("Abschnitt_1.avs")
v2=Import("Abschnitt_2.avs")
v3=Import("Abschnitt_3.avs")
v4=Import("Abschnitt_4.avs")

Damit laden wir wie bei der Schnittfunktion auch jeden Abschnitt in eine Variable. Und wie bei der Schnittfunktion mit Trim auch kommt nun der Operator "++" ins Spiel um die einzelnen Szenen wieder zusammenzusetzen.

#Plugin und Importsektion
v1=Import("Abschnitt_1.avs")
v2=Import("Abschnitt_2.avs")
v3=Import("Abschnitt_3.avs")
v4=Import("Abschnitt_4.avs")


v1++v2++v3++v4

Damit ist unser Video wieder komplett und eine komplette Bearbeitung des Gesamtvideos kann im Makefile stattfinden. Ihr könnt halt das Video ganz normal weiter verwenden und bearbeiten. Oder ihr wollt nur ein Abschnitt bearbeiten, dann macht man das halt im entsprechenden Abschnitt dazu. Bedenkt aber das alle anderen AVS Datein (Sprich die Abschnitte) keine Farbkonvertierung brauchen. Dies kann man jetzt ganz gepflegt 1 mal machen im Makefile. Ihr könnt das Makefile aber auch wieder mit Trim und Crop weiterverarbeiten. Bedenkt aber das das was schon in den Abschnitt AVS Datein entfernt wurde im Makefile nicht wieder erscheinen kann.

Mit diesem Trick bedient man sich eine Frameposition ohne viel Tara zu verändern. Ihr könnt auch eine Überblende im Makefile zwischen den einzelnen Abschnitten machen mit Dissolve. Das sieht dann so aus:

#Plugin und Importsektion
v1=Import("Abschnitt_1.avs")
v2=Import("Abschnitt_2.avs")
v3=Import("Abschnitt_3.avs")
v4=Import("Abschnitt_4.avs")


v1=Dissolve(v1,v2,100)
v1++v3++v4

Hier wird zwischen v1 und v2 das Bild zunehmend überlagert bis v2 endgültig zu sehen ist. Das passiert in diesem Code über eine Framedauer von 100 [lexicon]Frame[/lexicon].

Mit der Importfunktion können auch AVS Datein geladen werden die Funktionen besitzen um diese in der aktuellen AVS auch aufzurufen. Was man dafür nehmen könnte um sich viel Codegeschreibsel zu ersparen ;D

Wenn dazu noch Fragen sein sollten, könnt ihr diese gerne stellen, falls noch etwas unklar sein sollte.

Videos laden, anpassen und ein Bild im Bild erzeugen mit Hilfe von Overlay (Erklärung von Variablen)

Heute zeig ich euch wie ihr Videos ladet, sie anpasst und wie man eine Bild in Bild Darstellung zaubert. (Wird oftmals für Outros verwendet zur Darstellung zu anderen Videos oder für eine Webcam)

Bevor wir loslegen sollten die vorliegenden Videos für diesen Teil des Tutorials die gleiche Länge haben in etwa. Weil zum Thema schneiden und croppen werde ich noch im nächsten Thema bezug nehmen, da sowas ja halt extrem wichtig ist. Hier will ich euch aber vorbereiten mit Variablen umzugehen und wie diese sich untereinander unterscheiden.

Diesmal benötigen wir kein Blankclip, sondern laden unser Video mit AVISource (Ganz wichtig: Die Quellvideos müssen ein encodiertes Material haben das passt. [lexicon]Lagarith[/lexicon], [lexicon]FRAPS[/lexicon], DXTory) Für korrekte Einstellungen der Aufnahmen, bitte das entsprechende Tutorial lesen dazu. Für Aufnahmen wie dem [lexicon]KGV1[/lexicon] [lexicon]Codec[/lexicon] (Sega Emulator Fusion) oder dem TSCC / TSC2 [lexicon]Codec[/lexicon] (Camtasia 7 / 8 ) wird das Laden mit DirectShowSource bewerkstelligt.

Ich werde euch beide etwas nährbringen, damit ihr nicht ewig rätseln müsst, warum das Video nicht richtig geladen wird.

Fangen wir also damit an das Video 1 mit AVISource geladen wird und Video 2 mit DirectShowSource. (Zwei Fliegen mit einer Klappe ;D)

AVISource("D:\test\screen.avi")
DirectShowSource("D:\test\screen2.avi")

Was wir jetzt feststellen, ist das DirectShowSource einen Fehler ausgibt. Das liegt daran das dieser Befehl ein Plugin ist, den wir erst laden müssen und noch vor der eigentlichen Ladesequenz steht. Also fügen wir hinzu:

#Plugin und Importsektion
LoadPlugin("{Pfad}\MeGUI\tools\avs\directshowsource.dll")


#Quellen Ladesektion
AVISource("D:\test\screen.avi")
DirectShowSource("D:\test\screen2.avi")

Damit sollte die AVS geladen werden können, aber wir stellen fest das hier etwas total schief gelaufen ist. Denn nur das letzte Video was wir mit DirectShowSource geladen haben wurde geladen. Also brauchen wir Variablen und realisieren so unsere Spuren/Tracks. Die Variablen sollten mit einen Buchstaben beginnen und keine Sonderzeichen enthalten. Für Videospuren empfehle ich als Kürzel "v" + Nummer. Für Bilder "p" + Nummer. P für Picture halt. Bei zusätzlichen änderungen wie Masken etc. werde ich entsprechend die Variable auch so nennen wie "p1mask" . Damit ich nicht durcheinander komme. Die Bezeichnungen wie er die Variablen nennt, ist jedem selbst überlassen. ;D

#Plugin und Importsektion
LoadPlugin("{Pfad}\MeGUI\tools\avs\directshowsource.dll")


#Quellen Ladesektion
v1 = AVISource("D:\test\screen.avi")
v2 = DirectShowSource("D:\test\screen2.avi")

Die Fehlermeldung "Not a clip" müsste erscheinen, da wir unsere Videos noch keinen Ausgang/Output haben. Da wir ein Bild in Bild haben wollen kommt nun der Befehl Overlay ins Spiel. Overlay dient wie der Name schon sagt, zur Überlagerung. Genau das wollen wir ja erreichen. Also ergänzen wir wieder:

#Plugin und Importsektion
LoadPlugin("{Pfad}\MeGUI\tools\avs\directshowsource.dll")


#Quellen Ladesektion
v1 = AVISource("D:\test\screen.avi")
v2 = DirectShowSource("D:\test\screen2.avi")


#Bearbeitungssektion
Overlay(v1,v2)

Wir haben hier jetzt v2 auf v1 geladen und v2 sollte jetzt vor v1 zu sehen sein. Bedenkt aber das die FPS genommen werden auf den das andere Video gelegt werden. Hier werden z.B. die FPS von v1 genommen. Würde man bei Overlay v1 und v2 tauschen, dann würden die FPS von v2 genommen. Die Ausgabe des Farbkanals ist standartmäßig auf RGB32 gesetzt. Auch wenn in YV12 aufgenommen wurde. Das hatte ich im letzten Tutorialabschnitt schon erklärt das sowas [lexicon]MeGUI[/lexicon] automatisch für euch hinsetzt an letzter Stelle. Ihr könnt aber auch jeden anderen Farbkanal als Ausgang wählen. Für uns reicht aber YV12 dicke aus. Diesmal brauchen wir nicht ConvertToYV12() eingeben, sondern können es im Overlay angeben.

#Plugin und Importsektion
LoadPlugin("{Pfad}\MeGUI\tools\avs\directshowsource.dll")


#Quellen Ladesektion
v1 = AVISource("D:\test\screen.avi")
v2 = DirectShowSource("D:\test\screen2.avi")


#Bearbeitungssektion
Overlay(v1, v2, output="YV12")

Das sieht doch schon mal recht schick aus, oder? Natürlich möchte ich aber noch etwas Kontrolle darüber haben was die Quellvideos angeht. Das ein Video 30FPS hat und das zweite 25FPS stört mich und könnte eventuell zu Konflikten kommen. Daher werde ich beide so anpassen, das die Zeitlänge nicht geändert wird, aber die FPS geändert wird. Das kann man mit zwei Mitteln machen. Einmal mit ConvertFPS und einmal mit ChangeFPS. Nehmt am besten wenn es geht nur ChangeFPS. Anstatt die FPS erneut zu konvertieren werden sie mit ChangeFPS nur abgeändert. v2 hat in diesem Tutorial 25FPS und v1 hat 30FPS. Also werde ich nur v2 abändern.

#Plugin und Importsektion
LoadPlugin("{Pfad}\MeGUI\tools\avs\directshowsource.dll")


#Quellen Ladesektion
v1 = AVISource("D:\test\screen.avi")
v2 = DirectShowSource("D:\test\screen2.avi").ChangeFPS(30)


#Bearbeitungssektion
Overlay(v1, v2, output="YV12")

Ein AssumeFPS benötigt ihr erst, wenn sich ein Video das ihr ladet entweder zu schnell abgespielt wird oder zu langsam. Dazu braucht ihr aber Werte wie Zeitlänge der Audiospur. Das hat was mit Assynchronität zu tun. Die neue FPS bei AssumeFPS ergibt sich aus numerator und denominator.
Bedeutet numerator / denominator = FPS. Als Beispiel: AssumeFPS(30,1) = hier wird die Framerate auf 30FPS geändert. Das heißt das ein 25FPS Video somit kleiner wird von der Zeitlänge. Assume(2997,100) wären dann logischerweise eine 29.97 FPS Änderung. Sofern ihr aber immer Progressiv aufnehmt ohne Halbbilder, braucht ihr das nicht zu verwenden. Bei AssumeFPS kann auch der Ton ans Video angepasst werden, sollte die Länge des Videos stimmen. Das macht ihr dann mit: AssumeFPS(sync_audio=true) . Bedenkt das eure Quelle dann eine Audiospur geladen haben muss. AssumeFPS wird aus Analysen Gründen des Quellvideos mit angegeben. Daher werde ich das auch mit angeben. (Wie gesagt: Muss nicht, sofern man ordentlich aufgenommen hat wie mit [lexicon]FRAPS[/lexicon] oder [lexicon]Lagarith[/lexicon] z.B.). In Bezug auf sync_audio, worauf ich auch zum nächsten Abschnitt komme, nämlich die Audiospur laden. Das geht wie folgt in der Quellen Ladesektion in den entsprechenden Ladefiltern.

#Plugin und Importsektion
LoadPlugin("{Pfad}\MeGUI\tools\avs\directshowsource.dll")


#Quellen Ladesektion
v1 = AVISource("D:\test\screen.avi", audio=true).AssumeFPS(30,1)
v2 = DirectShowSource("D:\test\screen2.avi", audio=true).ChangeFPS(30).AssumeFPS(30,1)


#Bearbeitungssektion
Overlay(v1, v2, output="YV12")

Dieses audio=true läd nun von der screen.avi intern die Audiospur ein. Ledeglich die erste Spur. Ihr könnt auch in AVISynth eure Audiospuren laden, mixen, anpassen etc. Das ist zum einen viel Arbeit und würde euch nur unnötig belasten. Daher meine Empfehlung für euch, da ihr eh mit [lexicon]MeGUI[/lexicon] arbeitet. Bearbeitet eure Audiospur mit [lexicon]Audacity[/lexicon] und achtet ledeglich nur bei der AVISynth Videobearbeitung drauf das die Länge in Ordnung ist. Sprich: Videobearbeitung komplett mit AVISynth und Audiobearbeitung komplett mit [lexicon]Audacity[/lexicon]. Dann habt ihr nicht so ein Stress hinterher im Skript wegen Ladefehler oder Anpassungsfehler.

Also schalte ich jetzt die Audiospuren bewusst wieder aus hier, so das keine erst geladen werden und wir mit dem Blanken Video arbeiten nur:

#Plugin und Importsektion
LoadPlugin("{Pfad}\MeGUI\tools\avs\directshowsource.dll")


#Quellen Ladesektion
v1 = AVISource("D:\test\screen.avi", audio=false).AssumeFPS(30,1)
v2 = DirectShowSource("D:\test\screen2.avi", audio=false).ChangeFPS(30).AssumeFPS(30,1)


#Bearbeitungssektion
Overlay(v1, v2, output="YV12")

Jetzt wollen wir aber noch das ganze unseren gewünschten Größen anpassen. Weil v1 beträgt 1280x720 vllt und eure Webcam v2 nur 640x480. Sieht natürlich etwas doof aus wenn das zusammengepappt ist. Hier benötigen wir unsere Resize Filter. Den entsprechenden Resize Filter sollte man jedoch nach eigenem Ermessen wie das Bild gerade aussieht nehmen. Ich werde hier jetzt den Spline64Resize Filter anwenden. Wer genauer wissen will wo die Unterschiede zwischen den einzelnen Resizer Filtern sind, kann sich das auf http://avisynth.org/mediawiki/Resize anlesen.

Ich werde hier jetzt v1 auf 1920x1080 resizen und v2 etwas kleiner auf 320x240 und ich werde auch v2 an die untere rechte Ecke platzieren mit einen Seitenabstand von 30px.

Das wir die Position anhand der oberen linken Ecke nur bestimmen können, muss gerechnet werden wieder. Wir haben nach dem Resize ein Bild von 1920x1080 und ein kleines Bild von 320x240. Und der Abstand soll 30px betragen vom Rand.

Also muss v2 an Position 1570, 810 positioniert werden. Das geschieht im Overlay. Da wo v2 auf v1 gelegt wird. Nur das wir jetzt noch sagen wo genau das passieren soll.

#Plugin und Importsektion
LoadPlugin("{Pfad}\MeGUI\tools\avs\directshowsource.dll")


#Quellen Ladesektion
v1 = AVISource("D:\test\screen.avi", audio=false).AssumeFPS(30,1).Spline64Resize(1920,1080)
v2 = DirectShowSource("D:\test\screen2.avi", audio=false).ChangeFPS(30).AssumeFPS(30,1).Spline64Resize(320,240)


#Bearbeitungssektion
Overlay(v1, v2, x=1570, y=810, output="YV12")

Das wars erst mal dazu. Variablen zu einzelnen Clips müssen identisch sein, sollten diese miteinander verknüpft werden. Bei Overlay ist das nicht der Fall. Im nächsten Tutorialabschnitt zeig ich euch was ich damit meine, indem wir schneiden und croppen, aber auch mit welchen Tricks man Positionen anspricht innerhalb des AVS Skriptes. Weil bei AVS hatte ich ja schon erwähnt das alles (wenn man sich eine Timeline vorstellt) nach Links angeklatscht wird. Also brauchen wir ja noch die Möglichkeit bestimmte Positionen anzusprechen. Das aber wie gesagt beim nächsten mal.

Zitat von tortelini66

Einen Punkt habe ich aber doch zu bemängeln. So richtig LPer Spezifisch ist das mMn nämlich nicht. Welcher LPer braucht denn schon "BlankClip"?

Das mit dem Blankclip erkläre ich nicht ohne Grund und wird im späteren Tutorialverlauf noch mal für etwas anderes aufgegriffen ;D

Stand: 24. August 2013 (Noch im Aufbau) | Die einzelnen Videos zu den entsprechenden Abschnitten kommen im September definitiv jetzt und werden euch Visuel durch das Tutorial führen. Damit ist es euch überlassen, ob ihr euch das anlesen tut hier oder euch das anschauen wollt. ;D

Index

• Einleitung +
  Grundlegende Sachen die man Wissen muss (Mathematik bleibt nicht aus) +
  Das erste Skript soll ein Intro sein ohne etwas zu laden.
• Videos laden, anpassen und ein Bild im Bild erzeugen mit Hilfe von Overlay (Erklärung von Variablen)
• Videos per AVISynth schneiden, croppen und Positionen ansprechen
• Animationen und Alphamasken mittels AVISynth
• Funktionen und ihre Nutzung + If Then Else - Abfragen

Einleitung
So, ein herzliches Willkommen schon mal hier, für das Tutorial zur Videobearbeitung mit AVISynth.

AVISynth wird euch hier im Forum ständig gegen den Kopf geworfen in Zusammenhang mit [lexicon]MeGUI[/lexicon]. Doch was ist dieses AVISynth eigentlich erst mal?

AVISynth ist in erster Linie ein [lexicon]Frameserver[/lexicon] der per Script gesteuert wird. Sogenannte AVS Skripte. Bedeutet das AVISynth keine Grafische Benutzeroberfläche benötigt um eine Videobearbeitung zu realisieren. Zudem ist AVISynth vollkommen kostenlos und kann wie auch schon oft erwähnt im Forum, Sachen machen wo andere kostenpflichtige Programme scheitern.

Warum eigentlich Frameserver? Weil AVISynth mittels der AVS Skripte alle Frames die entweder geladen wurden oder erzeugt wurden von A nach B liefert, damit andere Programme die mit AVISynth zusammenarbeiten diese auch verarbeiten können.

Ich werde euch in diesem Tutorial nicht nur per Video Beispiele und Tricks zeigen, sondern euch auch Skripte hier direkt erklären.

Das wird so in etwa die Tiefe haben für euch, das es für LPer 100% ausreichen wird.

Für das editieren des Scriptes kann jeder Texteditor genommen werden. Ich empfehle euch aber den kostenlosen AvsP Editor mit dem ihr auch gleich eine Vorschau habt und zusätzliche Infos in der Unteren Leiste.

Downloaden könnt ihr den AvsP Editor auf der Hauptseite von AVISynth
Oder den AvsPmod von der Doom9 Seite - Sogar um einiges besser ;D

Grundlegende Sachen die man Wissen muss (Mathematik bleibt nicht aus)
Wer mit AVISynth arbeiten will hat keine Zeitangaben, da das Skript mit Frames arbeitet. Um sich aber nich zu verrennen mit Frames bedient man sich folgender Rechnungen:

Das sollte den Leuten in Elektrotechnik bekannt vorkommen mit Wiederstand, Spannung und Stromstärke. Man könnte es hier genauso machen und es in ein Dreieck stecken

Dann gibt es noch Rechnungen bezüglich der Positionen. Wir haben ein Bild mit x und y Koordinaten. Diese werden in Pixelpositionen angegeben. (Abkürzung px). Dabei ist die Position 0,0 in der oberen linken Ecke und die max x und max y Position an der unteren rechten Ecke.

Bei Zentrierungen für Bild in Bild, Thumbnails, Schriftzeichen etc. muss oft mit dem Mittelwert gerechnet werden. Als Beispiele werde ich das immer an einem 1080p Videos machen. Natürlich sind die Rechnungen alle identisch zu jeder anderen [lexicon]Auflösung[/lexicon].

Um eine Aufnahme so Seitenverhältnismäßig genau zu skalieren bedient man sich wieder einer Rechnung die wie folgt aussieht:

Unser [lexicon]Quellvideo[/lexicon] hat jetzt mal ganz dämliche Werte von 224x400 und wir wollen das auf 1080p hochskalieren.
Also rechnen wir:

Also beträgt die exakte neue [lexicon]Auflösung[/lexicon] 604,8 x 1080 . Da Kommastellen aber unschön sind und meist zu Fehlern führen rundet man am besten auf die nächst gerade Zahl. Hier währe es also 604 x 1080. Ich hab bewusst 604 genommen, da 605 ungerade ist und bei vielen Programmen wie [lexicon]MKV[/lexicon] Merge zu abstürzen führen kann.

Die Rechnung sollte aus der Mathematik bekannt sein indem man den Fehlenden Wert durch ein Kreuzverfahren ermittelt.
224/400 = x/1080 in diesem Fall. Hier wird einfach nach x aufgelöst. ;D

Farbangaben werden Hexadezimal angegeben. Das klingt jetzt komplizierter als es ist. Ihr habt einen bestimmten Farbraum zur Verfügung der durch R G und B bestimmt wird. Diese Werte können für R, G oder auch für B von 0 - 255 gehen.

Um aber Speicher zu sparen haben sich Programmierer damals gedanken gemacht und bedienen sich Hexadezimalzahlen mit der Baisis 16. Um nicht weiter ins Detail zu gehen um euch zu langweilen warum und wieso das so gemacht wird (Weil kann man auf Wikipedia nachlesen wunderschön), hier mal ein Beispiel wie so eine Umrechnung aussieht:

Immer den Restbetrag von hinten nach vorne lesen um den Wert zu erhalten. Die Farbangabe wird dann durch ein $ Zeichen gekennzeichnet und sieht im Script dann so aus z.B.: $FF0EEB . Also R 255, G 14, B 235

Das wars erst mal zur Grundrechnung die man benötigt in AVISynth. Taschenrechner von Vorteil ;D

Das erste Skript soll ein Intro sein ohne etwas zu laden.

Es geht weiter. Und ich werde euch hier selbstverständlich auch noch ein Video dazu machen. ;D

Wir sitzen also vor unserem leeren AVS Script und wollen uns ein Intro erstellen wo ganz simple nur ein Schriftzug eingeblendet und ausgeblendet werden soll. Aber es soll nix geladen werden, sondern einfach komplett neu im Script entstehen.

Dafür brauchen wir erst einmal ein Bild auf das wir arbeiten können. Sozusagen unsere Spielwiese ;D

Hier müssen wir wissen wie groß der Clip werden soll und wievel FPS das ganze haben soll und wie lang der Clip gehen soll. Ich werde das mit 30 Sekunden machen mit 30FPS bei einer [lexicon]Auflösung[/lexicon] von 1920x1080.
Also rechnen wir mit 30 * 30 = 900
Also wird das Video 900 Frames betragen. Das Bild erzeugen wir mit Blankclip wie folgt:

Jetzt haben wir schon mal ein leeren schwarzen Clip von 30 Sekunden und 900 Frames.
Die Hintergrundfarbe kann man natürlich ändern, indem man den Befehl mit color erweitert.

Jetzt haben wir anstatt einer schwarzen Fläche, eine blaue. Die Farbe könnt ihr natürlich bestimmen wie ihr wollt.
Um Fehler zu entgehen durch spätere Video und Sound zusammknüpfungen, legen wir uns hier eine leere Audiospur an für diesen Clip.
Dafür ergänzen wir einfach den Befehl mit Audio_rate

Jetzt haben wir schon einen Clip mit 900 Frames, eine [lexicon]Auflösung[/lexicon] von 1920x1080, 30 FPS, einer blauen Videofläche wo noch nix drauf ist und eine leere Audiospur erzeugt. Zudem beträgt das Video haargenau unsere 30 Sekunden. Audioinfo ist momentan 44.1Khz Mono mit 8bit.

Jetzt kommt die Schrift hinzu die wir zentriert auf die Fläche haben wollen. Also eröffnen wir eine nächste Zeile mit Subtitle.

Damit wird ein gelber Sub oben in die linke Ecke auf Position 0, 0 geschrieben. Um Untertitel zu positionieren gibt es 9 unterschiedliche Ausrichtungen. Einmal 1 = unten/links, 2 = unten/mitte, 3 = unten/rechts, 4 = mitte/links, 5 = mitte/mitte, 6 = mitte/rechts, 7 = oben/links, 8 = oben/mitte und 9 = oben/rechts
Diese Werte werden in der Funktion align eingetragen, den wir jetzt mal hinzufügen werden:

Ihr könnt die Position aus selbst bestimmen mit x und y Werten. Wenn ihr das machen solltet, ist eine Ausrichtung mit align total überflüssig. Um das mit x und y Werten an eine bestimmte Position zu setzen macht man folgendes:

So könnt ihr das manuell da hinsetzen wo ihr den Text haben wollt.
Als nächstes kommt das hinzufügen von Farbe, Schriftgröße und Schriftzeichen(Font). Dafür ändern wir wieder unseren Subtitle Befehl wie folgt:

Hinzugekommen sind die Parameter font, size und text_color
Damit ist unser Schriftzug erst mal fertig soweit.

Der letzte Schritt betrifft das einblenden und ausblenden. Mit einem zweiten Clip hätte man auch ganz einfach eine Überblendung machen können mit dem Befehl Dissolve. Den werd ich im späteren Tutorialverlauf noch verwenden. Hier reichen uns für den Anfang Fadein und Fadeout. Bei der internen Fadein und Fadeoutfunktion wird eine Bildblende gemacht. Bedeutet: Nicht die Subs werden angesprochen bei diesem Befehl, sondern das entsprechende aktuelle Overlay in dem das ganze passiert. (Zu Overlay werd ich auch später noch kommen)

Wir haben unser Hintergrundvideo blau gemacht. Demnach sollten wir, wenn wir nur den Text Effektmäßig ansprechen wollen auch in Blau blenden.
Dazu machen wir eine neue Zeile mit Fadein und Fadeout

Damit wird der Text für 100 Frames ein und Ausgeblendet. Also insgesamt 200 Frames. Das passiert am Anfang und am Ende des Gesamt Overlay Clips.

Damit ist das Intro fertig und euer erstes selbst erstelltes Video mit AVISynth. Eine Farbconvertierung seitens [lexicon]MeGUI[/lexicon] sollte automatisch geschehen. Ansonsten setzt man den Befehl ConvertToYV12() noch an letzter Stelle.

Hier noch mal alles im Überblick:

BlankClip(length=900, width=1920, height=1080, fps=30, color=$0000FF, audio_rate=44100)
Subtitle("Mein erstes AVISynth Video", font="Comic Sans MS", size=60, text_color=$FFFFFF, align=5)
Fadein(100, color=$0000FF).Fadeout(100,color=$0000FF)
ConvertToYV12()

Damit beende ich erst mal das Anfangstutorial und werde die nächsten Tage bestimmt das nächste starten und euch weiter in die Materie einführen ;D

Bis dahin... viel Spaß mit AVISynth

Gib uns doch erst mal deine Settings durch, damit wir anhand dieser Settings Ratschläge geben können

Also... Ich möchte mich jetzt eigentlich nicht einmischen wie du das präsentierst. Aber es sieht sehr schlecht aus und ich würde mir das nicht mal ne Minute ansehen wollen. Allein schon vom Aspect her. Du verschleuderst viel Potential des Spiels durch schlechte Präsentation des Videos schon. Dein Kommentar und Spielstil im Spiel lass ich dabei mal außen vor. Ich selbst bin ein Zelda Fan und schaue mir auch gerne mal die älteren Teile an. Aber deins würde ich mir nicht antun wollen.

Deswegen schlage ich dir einfach mal Tipps vor wie man das verbessern könnte. In den folgenden Videos wirst du in der Beschreibung ein Qulltext bezüglich AVS finden. Bei jedem Video. Dazu möchte ich sagen das die Beispiele auch auf dieses Zelda basieren. Und du sagst mir dann, welches davon das bessere ist.

Beispiel 1
Beispiel 2
Beispiel 3
Beispiel 4

Beispiel 5 - Dieses Beispiel ist in einem Text Tutorial noch mal genauer erklärt wie man das macht. Das findest du hier: [ Text-Tutorial ] Der große AviSynth-Guide
Auch mal weiter runterscrollen und schauen.

Und dann sagste mir mal welches dieser Beispiele sich Zuschauer am meisten ansehen werden. ö.ö

Und richtige Künstler machen sowas dann noch: Beispiel 6 - Sowas ist halt schwierig zu gestalten im AVS, und es ist halt auch die Frage ob das nicht schon wieder übertrieben ist für ein LP.

Mal durch den Kopf gehen lassen ;D Ist nur mal so ein Ratschlag von mir. Damit deine LPs besser werden auch und du vllt mehr Zuschauer bekommst.

Ich frage mich generell was das bringen soll. Gut, bei [lexicon]Minecraft[/lexicon] spielt der Arbeitsspeicher eine große Rolle, aber einen Virtuellen Arbeisspeicher zu erschaffen bringt dir auch nix da. Ist das gleiche wie mit ReadyBoost wo man sowas auf externe Festplatten oder USB Sticks setzen um den Arbeitsspeicher etwas höher zu setzen. Bei [lexicon]Minecraft[/lexicon] bringt mir das aber relativ wenig. Warum? Weil eigentlich bei diesem Spiel mehr die [lexicon]CPU[/lexicon] belastet wird und diese eigentlich ausschlaggebend ist für die Verarbeitung der Welt.

Du hast einen minimalen Leistungsanstieg weil du 1,5 GB RAM nur verbaut hast. Vllt arbeitet deine [lexicon]CPU[/lexicon] nur mit einen Kern, weil du vllt kein CoreDuo hast. In diesem Fall kann es tatsächlich die Performance etwas erhöen. Aber die wird nicht beträchtlich hoch sein. Bei mir auf meinen CoreDuo 2Ghz mit 2GB RAM würde das schon wieder keinen Sinn machen. Im Gegenteil. Ich würde damit [lexicon]Minecraft[/lexicon] nur noch weiter ausbremsen mit solch einer Methode. Also bei mir hat es keinen Effekt. Und die meisten haben schon einen besseren Rechner als ich ihn habe. Wenn ich bedenke wie Alt mein Steinzeitlapi ist, bin ich erstaunt das es noch die ganz alten Modelle aus Urzeit noch gibt ;D

Ich schließe mich mein beiden Vorgängern hier an. [lexicon]x264vfw[/lexicon] und dann noch ohne Kontrolle darüber was das Teil eigentlich macht, ganz zu schweigen das es in AVIs gesteckt werden kann. Die Leute müsste man erschlagen dafür die sowas gestatten. H264 gehört in [lexicon]MP4[/lexicon] Formate und ist dafür auch extra vorgesehen.

Ganz zu schweigen von den Einstellungsmöglichkeiten dieses [lexicon]x264vfw[/lexicon] Encoders in [lexicon]Magix[/lexicon], würde es dem Video und auch der restlichen Qualität nicht zu gute kommen. Exportiere es lieber als [lexicon]Lagarith[/lexicon] oder mit mit was weiß ich für ein lossless [lexicon]Codec[/lexicon] und encodiere es richtig in [lexicon]MeGUI[/lexicon] mit den richtigen und sauberen [lexicon]x264[/lexicon] [lexicon]Encoder[/lexicon]. Damit tust du deinem Video mehr gutes als sowas. Vor allem da man per AVISynth die Framezahl bestimmen kann die man haben möchte. Und man kann halt noch weitere Sachen machen mit AVISynth. Wenn du aber auf die Effekte etc. von [lexicon]Magix[/lexicon] nicht verzichten willst, würde ich dir zum [lexicon]Lagarith[/lexicon] raten. Ansonsten encodiere gleich mit [lexicon]MeGUI[/lexicon] und mach die Videobearbeitung gleich an der Quelle mit dem AVS Skript.

Das ist weitaus effektiver. Weil den reinen [lexicon]x264[/lexicon] [lexicon]Encoder[/lexicon] kannst du genau einstellen und das gewünschte Ergebnis kannst du auch hervorragend kontrollieren wie es sein soll. Bei dem [lexicon]x264vfw[/lexicon] [lexicon]Encoder[/lexicon] da sieht es recht Mau aus an Einstellungsmöglichkeiten. Optimal wird es nie damit.

Und WARUM 29.97 Schieß mich Tod? Das ist unsinn, es sei denn du bist ein Amerikaner und machst DVDs oder BluRays in NTSC Format, damit es Amerekanische Player abspielen können. Youtube ist das aber völlig Schnuppe. Nimm gleich 30FPS und keine Periodischen Gleitkomma FPS Zahlen da. 29 und 97/100 Bilder pro Sekunde. Das muss man sich mal reinziehen. Das ist nix ganzes und nix halbes.

Wenn deine Aufnahmesoftware das Video mit 29.97FPS erzeugt, dann kann man es in AVS Skript in [lexicon]MeGUI[/lexicon] halt auf glatte 30FPS noch Changen lassen ohne Zeitänderungen am Video.

Der [lexicon]Encoder[/lexicon] ist halt total unbrauchbar für sehr gute Encodierungen. Nimm [lexicon]Lagarith[/lexicon] falls du Effekte nutzen willst, ansonsten encodiere es gleich in [lexicon]MeGUI[/lexicon]. Du fährst deutlich besser damit.

Wird mal wieder Zeit für AVISynth Spielerein ;D

Heute möcht ich euch zeigen wie ihr mit 2 Video und einem sogenanntes Vorlagevideo ein wirklich tollen Effekt erziehlen könnt. Es handelt sich um einen sehr einfachen Effekt, aber dennoch in AVISynth machbar. Weil der Trick bezieht sich wie man aus den Bildern schon unschwer erkennen kann um Masken. Sogenannte Alphamasken. Hier erzeugen wir eine Alphamaske auf ein Vorlagevideo. Bedeutet: Der Stern rotiert an sich und ist somit selbst ein Video. Der Sternclip besitzt ledeglich die Farben grün und weiß die dann entferntwerden und das eigentliche Video kann dafür ersetzt werden. Sollten eigentlich viele schon mal gemacht haben mit Bildern.

##############################
# 2 Videos mit ein Alphavideo
# ---------------------------
# v1 - das was in der Mitte angezeigt wird
# v2 - der rotierende mehrzackige Stern
#      (Bestehend aus nem grünen Hintergrund und einem weißen Stern)
# m1 - Alphamaske für v2 wird gesetzt auf weiß
# vv - v1 wird jetzt dank der Maske im rotierenden Stern angezeigt
# v3 - der Clip für das Hintergrundvideo
# m2 - Die Alphamaske wird resetet und neu auf grün gesetzt
# 
# Zum Schluss wird v3 als Hintergrundvideo spielen und das Video
# v1 wird im rotierenden Stern angezeigt.
#
##############################


v1=AVISource("Clip1.avi",Audio=false)
v2=AVISource("Alphaclip.avi").ConverttoRGB32()
m1=ColorKeyMask(v2,$FFFFFF,20).ShowAlpha(pixel_type="RGB32")


vv=Overlay(v1,v2,mask=m1).ConverttoRGB32()


v3=AVISource("Clip2.avi",Audio=false).ConverttoRGB32()
m2=ResetMask(vv).ColorKeyMask($00FF00,100)


Layer(v3,m2).ConverttoYV12()

V2 könnt ihr auch mit ein Bild ersetzen das die gleichen Eigenschaften aufweißt und ein [lexicon]Alphakanal[/lexicon] besitzt. Dann ist V2 nicht mehr dynamisch, sondern statisch und sieht wie folgt aus:

##############################
# 2 Videos mit ein Alphavideo
# ---------------------------
# v1 - das was in der Mitte angezeigt wird
# v2 - das Statische Bild mit dem mehrzackige Stern
#      (Bestehend aus nem grünen Hintergrund und einem weißen Stern)
# m1 - Alphamaske für v2 wird gesetzt auf weiß
# vv - v1 wird jetzt dank der Maske im rotierenden Stern angezeigt
# v3 - der Clip für das Hintergrundvideo
# m2 - Die Alphamaske wird resetet und neu auf grün gesetzt
# 
# Zum Schluss wird v3 als Hintergrundvideo spielen und das Video
# v1 wird im Stern angezeigt.
#
##############################


v1=AVISource("Clip1.avi",Audio=false)
v2=ImageReader("Alphabild.png")
m1=ImageReader("Alphabild.png", pixel_type="RPG32").ShowAlpha(pixel_type="RGB32")


vv=Overlay(v1,v2,mask=m1).ConverttoRGB32()


v3=AVISource("Clip2.avi",Audio=false).ConverttoRGB32()
m2=ResetMask(vv).ColorKeyMask($00FF00,100)


Layer(v3,m2).ConverttoYV12()

Die Funktionsweise bleibt aber die selbe. Ich wünsch euch viel Spaß beim ausprobieren und rumtüfteln ;D

Zitat von VikingGe

Deswegen nur nochmal eine Sache zu den FPS und der Festplatte: Ich hab Crysis nie gespielt, aber die Platte kann ja nur dann ein Flaschenhals sein, wenn die gerade auch benutzt wird. Und es gehört eigentlich nicht zum guten Ton, ständig Dateien nachzuladen. Und ich kenne auch kein Spiel, das das tut - Crysis habe ich allerdings nicht gespielt. Und selbst in Skyrim kann man doch ziemlich weit ohne einen einzigen HDD-Zugriff laufen, und das Spiel hat ja nun wirklich nicht gerade wenig an Daten. Gut, wenn das gerade so nen Burst hat, weil man mit nem Pferd quer durch die Welt heizt, dann ruckelt es auch schonmal stellenweise. Aber das ist ja auch irgendwann wieder vorbei. Deswegen finde ich es immer wieder lustig, wenn jemand seiner [lexicon]Festplatte[/lexicon] magische, FPS verbessernde Kräfte zuspricht oder am besten noch ankommt "yoyoyo bau dir ne [lexicon]SSD[/lexicon] ein gibt 3x so viele Frames!!!einseins" - nichts persönliches, ich kann es nur aus eigener Erfahrung einfach nicht bestätigen.

Ist schon richtig. Magie ist hier keines Falls am Werke. Du kannst ja auch mit Defragmentierungen ein Spiel besser zum Laufen bekommen. Sprich die Dateianordnung sortieren lassen. Damit besser und schneller gelesen werden kann. Damals auf meiner ganz alten Mühle konnte ich GTA2 nur Ruckelfrei zocken, wenn die [lexicon]Festplatte[/lexicon] defragmentiert wurde. Damit die Daten einfach schneller gelesen werden konnten und die [lexicon]Festplatte[/lexicon] besser arbeiten konnte.

Bei Crysis ist eigentlich genau das gleiche bei mir. Ich weiß das ich geschrieben habe die das die FPS steigt. Aber das hat damit zu tun wie gut gelesen werden kann von der [lexicon]Festplatte[/lexicon]. Sprich wenn Stellen nachgeladen werden wie Texturen etc., dann läd er wohl oder Übel Datein um diese aufzurufen um sie dann in den Zwischenspeicher zu kloppen. Wenn die Datein aber nun sonstwo auf der [lexicon]Festplatte[/lexicon] verstreut sind in einer Partition kann es halt zum laggen kommen bei langsamen Festplatten. Sprich die FPS geht kurz runter, weil er die benötigte Information nicht schnell genug laden kann um sie dann zu verarbeiten. Das laden dauert so lange an bis die Datei verarbeitet ist und die Karte weitergerendert hat. Wenn die [lexicon]Festplatte[/lexicon] aber schon was anderes schreibt oder ließt, dann dauert der Vorgang länger, selbst bei einer Defragmentierten [lexicon]Festplatte[/lexicon]. Folge sind dann laggs weil er nicht schnell genug laden kann. Heißt die FPS geht dann schon mal kurz in den Keller.

Anders als wenn eine [lexicon]Festplatte[/lexicon] ungenutzt ist und defragmentiert. Die ladegeschwindigkeit ist nun so optimal das sie auch ununterbrochen verarbeitet werden kann. Folge ist dann das die Laggs verschwinden.

Wie gesagt, das ist bei Spielen wo die Festplattengeschwindigkeit ihr Limit erreicht. Da könnte man noch so ein tollen Rechner haben, wenn die [lexicon]Festplatte[/lexicon] nicht mehr hergibt damit es schnell genug verarbeitet wird. Sprich der Rechner kann es super verarbeiten und Darstellen. Die [lexicon]Festplatte[/lexicon] brauch aber Zeit um die Gewünschten Infos zu senden. Je mehr Datein beansprucht werden, desto langsamer wird das Spiel. Ist nun mal so. Da kannste mir schon glauben.

Ich bin kein Magier. Es handelt sich um Logik die man verstehen sollte. Und die Frames können nur sehr minimal verbessert werden durch Defragmentierung und durch Arbeiten einer einzelnen [lexicon]Festplatte[/lexicon]. Und mit Minimal meine ich vllt. 2 Frames. Und das könnte meist auch schon der entscheidene Faktor sein.

Wenn ich immer schon höre das man sonst was für Geschwindigkeiten brauch um LPs aufzunehmen. Meine interne [lexicon]Festplatte[/lexicon] schaffen nur 26-27MB/s , genauso wie meine externen Festplatten, da diese auch noch mit USB 2 betrieben werden. Wie gesagt, mein Rechner ist nicht grad der beste. Aber es ist merkwürdig das ich viele Games in 720p sogar aufnehmen kann mit [lexicon]Lagarith[/lexicon] oder [lexicon]FRAPS[/lexicon] und zwars Laggfrei sogar. Wo andere sich die Zähne ausbeißen und fragen warum das bei ihnen laggen tut. Ich hab nun mal Schwache Festplatten, auch durch diese Vernetzung mit USB 2 ist das alles recht Suboptimal. Laggfrei kann ich es erst machen, wenn getrennt wird und jede [lexicon]Festplatte[/lexicon] für ein System arbeitet. Damit diese zwars am Limit sind, aber sich untereinander nicht in die Quere kommen.

Ich sag nur das die [lexicon]Festplatte[/lexicon] ein Teil für die FPS darstellt. Fällt aber für gewöhnlich sehr Gering aus. 1 oder 2 FPS. Ist die [lexicon]Festplatte[/lexicon] nicht das Problem, sind es andere Elemente die an der FPS zerren. [lexicon]Grafikkarte[/lexicon] etc. Wenn die [lexicon]Festplatte[/lexicon] vor dem Einbau genauso gearbeitet hat ohne FPS Unterschied wie zur neuen anderen [lexicon]Festplatte[/lexicon], dann liegt es nicht an der [lexicon]Festplatte[/lexicon], sondern eher an der Verarbeitung des Rechners.

@zu VikingGe: Ich bin mir sicher das das alles zustimmen mag und ich könnte mit dir auch darüber sehr gerne Debattieren, aber das würde den Rahmen sprengen hier. Ich hab auch gesagt es soll das Grundgerüst verständlich machen erst mal. Du hast recht das da noch mehr passiert auf der [lexicon]Festplatte[/lexicon] um mal auf diese Fragmentierung zurückzukommen. Das wollte ich nun aber nicht so Ausführlich hier beschreiben weil sonst nur wieder Verwirrung gestifftet wird.
Das Windows nicht nur jeweils ein paar KB schreibt etc. ist auch soweit richtig.
Wir müssen aber davon auch ausgehen das der DAU nicht weiß was er umzustellen hat an sein System um die Windows Partition zu entlasten. Somit wird vermutlich fast jeder User unnötige Dienste und Anwendungen im Hintergrund laufen haben und auch sonstigen Schnickschnack was das System RAM Spezifisch und Festplattenspezifisch ausbremsen wird. Da ich aber selbst nicht von jedem verlangen kann das er sein Betriebsystem nicht so nutzen soll wie eine Spielkonsole werden die meisten halt den Standartmist drin haben.

Zitat von VikingGe

Mal ab davon, dass ich den Zusammenhang zwischen [lexicon]Festplatte[/lexicon] und FPS im laufenden Spiel nach wie vor nicht nachvollziehen kann und mich das doch sehr wundern würde - ich meine, ich sitze auch nicht erst seit gestern am PC und zwischen meiner Barracuda und der alten WD-Platte liegen spürbar Welten, FPS-Unterschiede gabs trotzdem exakt 0 - ich hab auch nie gesagt, dass 2 Platten nicht schneller wären als eine, ich habe hier die ganze Zeit von einer Platte geredet. Und wenn du Crysis jemals von C laufen lassen solltest, wirst du wahrscheinlich keinen Unterschied feststellen, aber schneller wird es dadurch auf keinen Fall.

Die Unterschiede fallen erst auf wenn bestimmte Limits erreicht sind. Die FPS würde sinken wenn entweder die [lexicon]Grafikkarte[/lexicon] nicht mehr her gibt, die [lexicon]CPU[/lexicon] und einige andere Faktoren. Darunter auch die [lexicon]Festplatte[/lexicon]. Wenn das Spiel auf der ersten schon mit 60FPS lief, wird sie vermutlich auch auf der neuen Platte mit 60FPS abspielen.
Mein Crysis allerdings bekam Laggs weil das Spiel mit 40 - 57 gelaufen ist. Mein Schwäche Faktor liegt nicht nur an der [lexicon]Grafikkarte[/lexicon] und am Speicher, sondern auch an der Geschwindigkeit der Platte. Um diese nicht zusätzlich zu beanspruchen hab ich es halt auf eine externe Platte installiert und die FPS waren im Rahmen von 50 - 60 FPS. Also recht flüssig. Nicht aber 100% Flüssig. Die nächsten Faktoren wären [lexicon]Grafikkarte[/lexicon] und Speicher gewesen.

Und Partitionen können schnell arbeiten. Sofern diese auf der [lexicon]Festplatte[/lexicon] einzeln angesprochen werden und nicht gleichzeitig. Effektiv wäre es wenn sich das Betriebssystem auf der inneren Spur befindet. Sprich auf der letzen Partition und die anderen Sachen jeweils auch auf der inneren Spur auf jeweils eine [lexicon]Festplatte[/lexicon]. So läuft das aber leider nicht.

Ich möchte hier wirklich nicht den Rahmen sprengen. Weil ich weiß genau wie du auch das noch weitaus mehr Faktoren eine Rolle spielen. Für das Grundgerüst ist die Erklärung aber ausreichend. Und ich selbst hab mit den Urschleim damals angefangen und weiß was noch alles dazugehört damit Festplatten langsamer oder schneller arbeiten. Aber für die, die sich halt nicht auskennen, sollte dieses Tutorial als Grundlage dienen. Wer mehr wissen will darüber kann sich auch auf den Wikipedia Seiten sich anlesen, sofern er das alles verstehen kann. Ist auch gut erklärt dort. Und es gibt einige andere Seiten wo das ausführlicher Behandelt wird. Für den Rahmen von LP allerdings sollte man hier nicht zu sehr ins Detail gehen. Ansonsten hätte ich noch andere Sachen angesprochen hier wo dann keiner mehr mitkommt. Und solche Debatten wollte ich vermeiden damit. Deshalb hab ich diese auch nicht angesprochen.