Tutorial für die Videobearbeitung mit AVISynth LPer Spezifisch

Wobei es hirnlos erscheint etwas Verlustbehaftetes wie [lexicon]OGG[/lexicon] oder MP3 etc. in AVISynth hinzuzufügen. Der Grund ist der das das Script encodiert werden muss. Video als auch Audio. Demnach wird Audio ja noch mal unnötig encodiert. Bei einer [lexicon]WAV[/lexicon] Datei ist das was anderes. Da ist wieder das Prinzip [lexicon]Lossless[/lexicon] to [lexicon]Lossy[/lexicon].

Der beste Weg wäre wie De-M-oN schon erklärt hat nur das Videofile zum Audio zu machen. Das kann halt auch nur ein normales Bild sein. Man gibt die End Frameposition an (Länge des Audios) und fertig ist das Ding.

Zitat von CruelDaemon

Image = ImageSource("Pfad", 0, 0, 30, false).Loop(Dauer des Videos * 30)
return Image

Ein return ist überflüssig ;D Das ist wie gesagt etwas für Funktionen oder wenn etwas abgeschlossen sein soll local für sich. Weil alle Variablen die vor dem Return stehen werden nach dem Return außer Kraft gesetzt. Da der Rückgabewert durch das Return geschieht was als nächstes passiert.

Es reicht also: ImageSource("Pfad + Dateiname + Endung", start = 0, end = 59 * 30, fps = 30, false)

Die 30 stehen für die FPS des Videos und die 60 für die Sekunden. Denn Sekunden mal FPS = Frames. Für ein Standbildvideo kann man auch glatt nur 1 [lexicon]FPS[/lexicon] nutzen. Das Bild bewegt sich ja eh nicht. xD

Daher: ImageSource("Pfad + Dateiname + Endung", start = 0, end = 59, fps = 1)

Jetzt dauert das Video nur 60 Sekunden bei 1 FPS. Das ist sehr sehr Platzsparend ;D Vor allem da sich das Bild ja eh nicht ändert xD

60sek weil von 0 bis 59 sind 60.

Noch kürzer wäre also: ImageSource("Pfad + Dateiname + Endung", 0, 59, 1)

Als Funktion hätte ich das Beispiel von CruelDaemon vllt so verpackt:

Zitat

# Use a still-frame image with audio:
audio = DirectShowSource("Gina La Piana - Start Over.flv")
video = ImageSource("Gina La Piana.jpg", fps=25, start=1, end=ceil(25*AudioLengthF(audio)/AudioRate(audio)))
return AudioDub(video, audio)

Musikbild("Final Fantasy VI - Terra's Theme (Orchestrated with Lyrics).mp3", "FF6 - Tina.png", 25)


Function Musikbild(string soundpfad, string bildpfad, float fps2) {
    audio = DirectShowSource(soundpfad)
    video = ImageSource(bildpfad, 1, ceil(fps2*AudioLengthF(audio)/AudioRate(audio)), fps2)
    return AudioDub(video, audio)
}

Damit können nun so fast jede Sounddatei geladen werden. Die FPS ist hier nun sehr wichtig. Je größer die FPS Rate, desto genauer wird das Video zur Audiospur angepasst. Das fällt dann nachher im Millisekundenbereich. Beispiel:
25 FPS ergibt 1sek und 200 ms Video. Audiolänge ist aber 1sek und 152 ms

Bei 60 FPS ergibt das Video 1sek und 183 ms
Bei 120 FPS = 1sek und 166 ms
usw...

Bis ein Wert erreicht ist der exakt der Audiospur ist. Wie gesagt, das sind Millisekunden und sind nicht groß tragend.

Der Skript ist einfach und handlich. Kopieren, Pfade und Datein austauschen und fertig. Bilder wären BMP, JPG, PNG und GIF bei ImageSource. Ebenso bei ImageReader.

Zitat von Achim455

Beim 2. Script hast du soweit ich sehe beim Resizefilter einmal , und einmal x angegeben. Ich habe das jetzt bei meinen Script einfach auch auf , abgeändert (wobei ich auch als 2. ein AviSource genommen hatte). Geht das mit dem x also auch oder muss es , sein (also so wie ich es nun gemacht habe)?

Danke für den Hinweis Bin halt auch nur ein Mensch der Fehler macht. xD
Es muss ein , hin und kein x. Ich hab es noch mal korrigiert.

Wenn ihr weitere kleine Fehler sehen solltet, könnt ihr mich auch per PN oder hier im Thread drauf aufmerksam machen

Eine weitere Lade Funktion wäre halt noch das was De-M-oN Vorgeschlagen hatte mit FFVideoSource. Sieht dann halt so aus:

LoadPlugin("D:\MeGUI\tools\ffms\ffms2.dll")
FFVideoSource("C:\Test\xyz.avi")

Wenn Fehler auftreten sollten dabei mal das ganze so ergänzen:

LoadPlugin("D:\MeGUI\tools\ffms\ffms2.dll")
FFVideoSource("C:\Test\xyz.avi", threads = 1)

Diese Ladefunktion von Videos ist der von AVISource oder DirectShowSource weit überlegen und ist in den meisten Fällen auch besser geeignet.

Sound kann man darüber auch laden wenn man das möchte und zwars mit FFAudioSource. Sieht dann so aus:

LoadPlugin("D:\MeGUI\tools\ffms\ffms2.dll")
video = FFVideoSource("L:\Test\Aufnahmen\Test.avi")
audio = FFAudioSource("L:\Test\Aufnahmen\Test.avi")
AudioDub(Video, Audio)

Hier wird ein [lexicon]Lagarith[/lexicon] codiertes Videos geladen und die Soundspur gleich mit aus der Datei. Man kann auch andere Quellen angeben wie MP3 oder was weiß ich Mit FFVideosSource und FFAudioSource kann man so gut wie fast alles laden. Das ganze basiert dann auf FFmpeg.

Erstmal schon ein Anfang, nicht?

Als erstes zu deinem Skript:

Bei dem Befehl MonoToStereo musst du davon absolut sicher sein, das es sich wirklich um Mono Waves handelt. Ansonsten wenn es Waves sind die Stereo enthalten und du diese durch MonoToStereo jagst, dann hast du 4 Channels anstatt 2. Das ist erst mal sehr sehr wichtig, weil du die Audiospuren ja auch mischen willst. Und 4 Channels auf 2 Channels ist halt ein bisschen blöd und fürt zu Fehlern

Dann sollten beide Wavespuren die du mischen willst die gleiche [lexicon]Bitrate[/lexicon] aufweisen und die gleiche Samplerate.

Sprich deine Wave Quellen müsste so aussehen mit deinem Skript:

Spur1 = Stereo, 44100 Hz, 16Bit
Spur2 = Mono, 44100 Hz, 16Bit + Mono, 44100 Hz, 16Bit = Stereo, 44100 Hz, 16Bit

Das kannst du dann mischen.

Meine Empfehlung ist aber den Audioanteil in [lexicon]Audacity[/lexicon] zu schneiden und zu mischen und dann als eine [lexicon]PCM[/lexicon] Wave Spur zu exportieren. Stereo, 44100 Hz, 16Bit sollten reichen. Diese kann man dann im Skript ohne viel Umstände mit WaveSource reinladen.

Glaub mir, du machst dir mit dem Ton einfach zu viel Arbeit und zu viel Stress im Skript.

Ich mach dir mal deinen Skript da:

Zitat von Keijin

Video = AVISource("D:\Aufnahmen\test1.avi", audio=False).AssumeFPS(30).Lanczos4Resize(1920,1080)
Spur1 = WAVSource("D:\Aufnahmen\test1 st0.wav")
Spur2 = MonoToStereo(WAVSource("D:\Aufnahmen\test1 st1.wav"),WAVSource("D:\Aufnahmen\test1 st1.wav"))
Bild1 = ImageSource("C:\Users\Keijin\Pictures\test.png")
Gemischt = MixAudio(Spur1,Spur2,1,1)
ApplyRange(Video,0,90,"Overlay",Bild1,Video.width-Bild1.width,0)
AudioDub(Video,Gemischt)

Alles anzeigen

AVISource("D:\Aufnahmen\test1.avi", audio=False).AssumeFPS(30,1).Lanczos4Resize(1920,1080)
Bild1 = ImageSource("C:\Users\Keijin\Pictures\test.png")
Spur1 = WAVSource("D:\Aufnahmen\test1 st0.wav")
Spur2 = WAVSource("D:\Aufnahmen\test1 st1.wav")
Spur2 = MonoToStereo(Spur2, Spur2)
Spur = MixAudio(Spur1, Spur2)


AudioDub(Spur)
ApplyRange(0,90,"Overlay",Bild1,last.width-Bild1.width,0)

Das wäre erst mal Übersichtlicher und Sparsamer ;D
ApplyRange zeigt etwas von [lexicon]Frame[/lexicon] a bis [lexicon]Frame[/lexicon] b an. Das sind im Skript die ersten Zahlen 0 und 90. Overlay ist der Filter der in diesem Bereich wirken soll. Bild1 ist dein Bild was du zeigen möchtest, und last.width-Bild1.width ist die Rechnung von Gesamtbreite-Breite des Bildes.

Bei Overlay wird immer von der linken oberen Ecke x und y angegeben. Das Bild erstreckt sich dann wie bei einem Rechteck auch nach x2 und y2.

Sprich wenn du ein Rechteck hast zeichnest du von (x, y) nach (x2, y2)

x und y gibst du als Position auf dem Gesamtbild an bei Overlay. x2 und y2 ergibt sich aus der [lexicon]Auflösung[/lexicon] des Bildes was du draufsetzen möchtest. Das kann man auch mit einem Resizer nachträglich ändern.

Für eine Bauchbinde hätte ich also geraten:
ApplyRange(0,90,"Overlay",Bild1,0, (last.height-Bild1.height)/2)

Jetzt sollte das Bild in der Mitte der y Achse sein und ganz Links am Rand dran.
Das kann man halt durch Rechnungen sehr gut platzieren. Mathe lässt grüßen ;D

Wenn du dein Bild noch strecken willst oder weiter skalieren willst, kannst du das in der nächsten Zeile machen wo du dein Bild lädst.
Darin schreibst du dann Bild1 = Bild1.Spline64Resize(Breite, Höhe)
Dann wird eine Instanz von Bild1 erstellt und gleich wieder in Bild1 gespeichert.

Propotional Skalieren tust du z.B. mit Spline64Resize(Bild1.width + 10, Bild1.Height + 10)
Oder du zerrst es indem du sagst Spline64Resize(last.width, 30)

Letzteres zerrt das Bild auf die Länge des Gesamtvideos und hat eine Höhe von 30. Also sehr Schmal.

Wenn du ein zweite Bauchbinde einbringen willst, dann erstellst du einfach ein neues ApplyRange mit den gleichen Werten unter dem anderen. Außer das du den Framebereich nimmst wo dieses angezeigt werden soll. Also nicht mehr 0,90 sondern vllt 300, 390 oder so.

Wenn du mit [lexicon]Audacity[/lexicon] mischen solltest, weil es vllt leichter ist, sieht dein Skript dann so aus (Inklusive der nächsten Bauchbinde):

AVISource("D:\Aufnahmen\test1.avi", audio=False).AssumeFPS(30,1).Lanczos4Resize(1920,1080)
Bild1 = ImageSource("C:\Users\Keijin\Pictures\test.png")
Audio = WAVSource("D:\Aufnahmen\Gemischt.wav")


AudioDub(Audio)
ApplyRange(0,90,"Overlay",Bild1,0, (last.height-Bild1.height)-100)
ApplyRange(150,210,"Overlay",Bild1,0, (last.height-Bild1.height)-100)

Das ist natürlich auch kein Problem. Dazu muss man nur wissen was man braucht um es zu realisieren.

Als erstes brauchen wir dieses Konstrukt von Overlay:

Overlay(?, x=0, y=0, mask=?, opacity=1.0)

opacity ist die Transparenz die wir benötigen. 1.0 ist absolut sichtbar und 0.0 ist absolut nicht sichtbar. Bedeutet: 0.5 währe Transparent

Dann brauchen wir ApplyRange das ein Filter braucht und ein Start Argument
Und Animate für die Fadein und Fadeout Realisierung das wie ApplyRange auch ein Filter nutzt aber dafür ein Start und ein End Argument benötigt.

Um ein Fadein zu realisieren muss Overlay innerhalb von Animate erzeugt werden was innerhalb von ApplyRange läuft.
Das sieht dan so aus:
ApplyRange(563, 587, "Animate", 563, 587, "Overlay", p1, 468, 270, p2mask, 0.0, p1, 468, 270, p2mask, 1.0)

Die 563 und 587 sind für ApplyRange und ebenso für Animate die Bereiche von den die Blende geht. Ab p1 stehen die Overlay Argumente zur Verfügung. Also von p1 bis 0.0 sind die Startargumente und vom zweiten p1 bis 1.0 die Endargumente für Animate. ApplyRange braucht nur ein Argument und das sind die Argumente von Animate.

ApplyRange und Animate kann man dank das man Filter in ihnen anwenden kann beliebig groß verschachteln. Diese Konstruktion aber reicht völlig für viele Sachen.
p2mask ist übrigens der Maskenfilter, wenn ein Bild über ein [lexicon]Alphakanal[/lexicon] verfügt. Dieser wird dann nicht angezeigt dank der Maske.

Aus diesem ganzen Gedöns, kann man sich auch eine Funktion bauen die dann ein Fadein und ein Fadeout realisiert. Was brauchen wir für Angaben?
clip clip0 - Das Bild auf das gezeichnet wird
clip clip1 - Das Bild was gezeichnet werden soll
clip clip1mask - Die Maske für Clip1
int sframe - Der Startframe wo das ganze anfangen soll
int eframe - Der Endframe wo das ganze aufhören soll
int fadeinframe - Die Framelänge die das Fadein benötigt
int dadeoutframe - Die Framelänge die das Fadeout benötigt
int x2 - Der x Wert für Clip1 in Overlay an welcher Breitenposition positioniert werden soll
und
int y2 - Der y Wert für Clip1 in Overlay an welcher Höhenposition positioniert werden soll

Damit sind alle Angaben vertreten die wir brauchen.

Daraus entsteht die Funktion:

Function Blende (clip clip0, clip clip1, clip clip1mask, int sframe, int eframe, int fadeinframe, int fadeoutframe, int x2, int y2) {
}

Jetzt wird sie noch ausgefüllt mit den Sachen die diese Funktion machen soll. Also das was ich weiter oben erklärt habe kommt nun in die Funktion rein und wird mit den Variablen gefüttert die für die Funktion zur Verfügung stehen.

Das sieht dann so aus:

Function Blende (clip clip0, clip clip1, clip clip1mask, int sframe, int eframe, int fadeinframe, int fadeoutframe, int x2, int y2) {
    clip0 = ApplyRange(clip0, sframe, eframe-fadeoutframe-1, "Animate", sframe, sframe+fadeinframe, "Overlay", clip1, x2, y2, clip1mask, 0.0, clip1, x2, y2, clip1mask, 1.0)
    clip0 = ApplyRange(clip0, eframe-fadeoutframe, eframe, "Animate", eframe-fadeoutframe, eframe,"Overlay", clip1, x2, y2, clip1mask, 1.0, clip1, x2, y2, clip1mask, 0.0)
    return clip0
}

Diese Funktion erzeugt nun eine Einblende und eine Ausblende. Das reicht eigentlich auch schon für deine Zwecke. Aufrufen würde ich die Blende nach dem Beispielmuster von oben mit exakt den gleichen Werten wie folgt:

Blende (Bild1, Bild1maske, 563, 790, 24, 24, 468, 270)


Function Blende (clip clip0, clip clip1, clip clip1mask, int sframe, int eframe, int fadeinframe, int fadeoutframe, int x2, int y2) {
    clip0 = ApplyRange(clip0, sframe, eframe-fadeoutframe-1, "Animate", sframe, sframe+fadeinframe, "Overlay", clip1, x2, y2, clip1mask, 0.0, clip1, x2, y2, clip1mask, 1.0)
    clip0 = ApplyRange(clip0, eframe-fadeoutframe, eframe, "Animate", eframe-fadeoutframe, eframe,"Overlay", clip1, x2, y2, clip1mask, 1.0, clip1, x2, y2, clip1mask, 0.0)
    return clip0
}

Clip0 muss nicht angegeben werden, wenn es sich um Last handelt. Also des letzten Wiedergabeclips. In der Funktion ist das aber unabdingbar das es angegeben wird. Zurückgeliefert wird Clip0 wo sich dann das Geschehen auf die Blende überträgt.

Bild1maske ist das Maskenbild von Bild1.

Das löst du entweder mit

Blende(Bild1, Bild1.Levels(255,10,255,255,255,false), 563, 790, 24, 24, 468, 270)

Also mit dem Levles Filter indem du dein Bild1 komplett weiß gestaltest. Weil 255 im [lexicon]Alphakanal[/lexicon] Weiß ist. Und Weiß ist so das Standart für eine normale Anzeige.

Wenn du ein Bild mit [lexicon]Alphakanal[/lexicon] hast, musst du auch eine Maske erstellen. Das geht in der Ladesektion so:
Bild1 = ImageSource("C:\Users\Keijin\Pictures\test.png", pixel_type = "RGB32")
Bild1mask = Bild1.ShowAlpha(pixel_type = "RGB32")

Eine Funktion brauchst du nur einmal

Blende(Bild1, Bild1mask, 5, 100, 24, 24,0,(last.height-Bild1.height)-100)
Blende(Bild2, Bild2mask, 150, 250, 30, 30,0,(last.height-Bild1.height)-100)
Blende(Bild3, Bild3.Levels(255,10,255,255,255,false), 350, 550, 30, 30,0,(last.height-Bild1.height)-100)


Function Blende (clip clip0, clip clip1, clip clip1mask, int sframe, int eframe, int fadeinframe, int fadeoutframe, int x2, int y2) {
clip0 = ApplyRange(clip0, sframe, eframe-fadeoutframe-1, "Animate", sframe, sframe+fadeinframe, "Overlay", clip1, x2, y2, clip1mask, 0.0, clip1, x2, y2, clip1mask, 1.0)
clip0 = ApplyRange(clip0, eframe-fadeoutframe, eframe, "Animate", eframe-fadeoutframe, eframe,"Overlay", clip1, x2, y2, clip1mask, 1.0, clip1, x2, y2, clip1mask, 0.0)
return clip0
}

3 unterschiedliche Bilder mit der gleichen Funktion aufgerufen. Desshalb heißt es auch Funktion ;D

Für dein anderes Problem sollte dir dieses Bild behilflich sein es zu verstehen was da nun passiert:

Hier siehst du Die Overlayfunktion mal Bildlich betrachtet.

Wir haben bei Overlay die Angabe von x und y. Das sind die Werte auf dem Orangen Feld für x und y. Ab da zeichnet er das Bild so wie du es siehst auf der Anschauhung.

Clip1 hat eine feste [lexicon]Auflösung[/lexicon]. Nämlich die Bildbreite und Bildhöhe. Das sind Clip1.width und Clip1.height.

Dein Videobesitzt auch eine Breite und eine Höhe und ist bei dieser Anschauhung das Grüne Bild. Es startet immer von der Position 0,0 und wird auch als Hauptfenster bezeichnet.

Die Rechnungen für x und y in Overlay beziehen sich aus den Werten die zur Verfügung stehen.

Willst du ein Bild zentrieren muss man halt Clip0.width - Clip1.width rechnen und diesen Betrag dann durch 2 teilen.

Du kannst auch jede andere Position wählen die du willst. Das heißt das da auch nur Zahlen stehen können.

Beispiel: Dein Hauptfenster und auch Hintergrundvideo (Grüne Fläche) betragt 640x480
dein anderes Fenster (in deinem Fall ein Bild) (Oranges Kästchen) hat nur 320x240

Wenn ich das Bild auf dem Hauptfenster zeichnen will habe ich alle Werte von 0 - 640 und von 0 - 480 zur Verfügung wo ich das Bild auch sehen würde.
Alle Werte die unter der Position 0,0 sind und über 640, 480 würden aus dem Hauptfensterbereich verschwinden.

Bedeutet für Overlay kann man bei einem 320x240 Bild alle Werte nehmen die von 0,0 bis hin zu (640-320) und (480-240) gehen würden. Damit das Bild nicht aus dem Hauptfensterbereich verschwindet. Ist doch eigentlich logisch, oder? ;D

Wenn ich also Overlay sage 55, 100 setzt Overlay mir das Bild auf der x Position 55 und y Position 100 hin. Das ist das x und y was du auch in der Anschauhung siehst.

BlankClip(length=1860, width=1920, height=1080, fps=30, color=$000000, audio_rate=44100)
ImageSource("PFAD+DATEINAME+ENDUNG", start = 0, end = 59, fps = 1)

Dein ImageSource erzeugt diese 59 Frames. Du musst ImageSource in eine Variable legen und eventuell mit Overlay auf den BlankClip zeichnen.

BlankClip(length=1860, width=1920, height=1080, fps=30, color=$000000, audio_rate=44100)
pic1 = ImageSource("PFAD+DATEINAME+ENDUNG", start = 0, end = 59, fps = 1)
Overlay(last, pic1, x=0, y=0)

last wäre dann was vor pic1 als Ausgabe gedient hat. In diesem Fall BlankClip.

Das machst du mit ApplyRange

BlankClip(length=1860, width=1920, height=1080, fps=30, color=$000000, audio_rate=44100)
pic1 = ImageSource("PFAD+DATEINAME+ENDUNG", fps = last.framerate)
ApplyRange(last, 0,59,"Overlay", pic1, x=0, y=0)

Zitat von DarkHunterRPGx

und würde das auch mit mehreren bildern funktionieren die nacheinander erscheinen sollen?

Klar Machste einfach weiter dann wie grad erklärt:

BlankClip(length=1860, width=1920, height=1080, fps=30, color=$000000, audio_rate=44100)
pic1 = ImageSource("PFAD+DATEINAME+ENDUNG", fps = last.framerate)
pic2 = ImageSource("PFAD+DATEINAME+ENDUNG", fps = last.framerate)
pic3 = ImageSource("PFAD+DATEINAME+ENDUNG", fps = last.framerate)
ApplyRange(last, 0,59,"Overlay", pic1, x=0, y=0)
ApplyRange(last, 60,119,"Overlay", pic2, x=0, y=0)
ApplyRange(last, 120,179,"Overlay", pic3, x=0, y=0)

Das kannst du beliebig fortsetzen Erst erscheint Bild 1 von [lexicon]Frame[/lexicon] 0 - 59, dann Bild 2 von [lexicon]Frame[/lexicon] 60 bis 119 und dann Bild 3 von [lexicon]Frame[/lexicon] 120 bis 179 Alles auf dem gleichen Video

Oder du machst daraus eine Funktion, da das ganze sich eh immer wiederholt:

BlankClip(length=1860, width=1920, height=1080, fps=30, color=$000000, audio_rate=44100)


ShowPic("Bild1.bmp", 0, 59, 100, 100)
ShowPic("Bild2.png", 60, 119, 600, 600)


Function ShowPic ( clip clip0, string file, sframe, eframe, x, y) {
  pic = ImageSource(file, fps = clip0.framerate)
  return ApplyRange(clip0, sframe, eframe,"Overlay", pic, x, y)
}

Erst wird das Bild geladen, dann der Framebereich angegeben wo das Bild gezeigt werden soll und dann x und y wo das Bild dann halt angezeigt werden soll ;D

Kann man noch modifizieren das ganze wenn man das möchte
Aufrufen tust du dann das ganze mit ShwoPic nur noch hintereinander weg

Zitat von DarkHunterRPGx

Danke funktioniert, bis auf einen kleinen fehler - die variablen für höhe und breite x und y müssen weggelassen werden ansonsten gibts nen Fehler.

Zitat von Sagaras

ApplyRange(last, 0,59,"Overlay", pic1, x=0, y=0)

Du meinst bestimmt diese Zeile ;D

Ja, mein Fehler xD Innerhalb von ApplyRange dürfen nur Argumente stehen und keine Bezeichnungen Bedeutet: x= oder y= darf da gar nicht stehen, ledeglich nur die Werte dafür ;D

Das kannst du mit Overlay alles lösen

Wenn dein aktuelles Video zuende ist nutzt du entweder ein neues Video oder ein Standbild um es dann zu verlängern. Und mit Overlay packst du deine 2 Videos oder halt auch Bilder rauf die du haben möchtest und positionierst sie so wie du es haben möchtest auf dem Gesamtbild.

Die Videos lassen sich dann natürlich wieder auf den Hintergrund gerichtet ein und Ausblenden.

Es ist also möglich. Kommt jetzt bei dir an was du genau machen möchtest. Weil Video und Bilder sind zwei unterschiedliche Quellen und müssen demnach auch entsprechend behandelt werden.

Also mal ansagen was wie wo hinkommen soll und wie lang die Videos sind die du hinzufügen möchtest. Also die richtige Rohvideolänge die du lädst und auf welche Länge genau gekürzt werden soll.

Wie gesagt, das geht sehr exakt und genau

Hast du schon alleine probiert mit dem Skript? Weil dann weiß ich schon mal das du dir Gedanken gemacht hast und schon was probiert hast