Der AviSynth Scriptgenerator

Jo hab ich mir dann schon gedacht und editiert bevor du es geschrieben hast

Wollte nur mal nachfragen, bevor ich den Rechner wieder 6 Stunden arbeiten lasse ...

Ich habs einfach mit Notepad geöffnet ... sollte das gleiche ohne Umweg sein oder?

Hat [lexicon]MeGUI[/lexicon] nicht so eine Vorschau? Kann man bei [lexicon]VirtualDub[/lexicon] das Ganze mit Ton sich anzeigen lassen?

Weil mit der falschen FPS ist natürlich der Ton nicht synchron mit dem Bild.

Deine FPS Rate klingt nach variable Framerate.

Ist das eine verlustquelle? Dann bitte FFVideoSource (file indexer) nehmen, statt AVISource/DirectShowSource.

Du kannst.

Ich hab den Server neugestartet. Darum konntest du auch nicht laden

mal ne doofe frage...bei fps gebe ich 25 fps ein...so nehme ichs auch auf..jedoch sind die fps unterschiedlich bei mir..weil bei
meinem androidemulator sinds manchmal auf 10 fps und halt sehr wechselnd...gibts dann beim codieren keine probleme dann ?

Wenn du mit 25fps aufnimmst hast du ein 25fps Video.

Sollte in den Optionen möglich sein.

Soweit ich weiß nicht.
Das gespeicherte Video kommt in den selben Ordner wie der ausgewählte Script.

/EDIT
Ok Demon weiß es besser

Da ich Lucki im Skriptbereich etwas helfen werde um den Skriptgenerator etwas einfacher zu machen werde ich ihn hier ein paar Skripte geben die er dafür nehmen kann. Wenn jemand noch Fehler, Verbesserungen oder andere tolle Skriptbeispiele hat dafür wäre das vllt auch interessant ;D

Youtube FPS Schalter

(Last.Framerate > 30) ? Last.ChangeFPS(30) : Last.AssumeFPS(Float(Round(Last.Framerate*1000))/1000)

Diese Zeile könnte man als Youtubeschalter verwenden für FPS Raten.
Beispiel: Hat ein Video über 30 FPS wird das Video durch diese Zeile auf genau 30 FPS limitiert, da Youtube eh nicht mehr macht. FPS Raten die 30 und darunter betragen bleiben wie sie sind. Bedeutet: Ein 25 FPS Video bleibt 25 FPS. Ein 29.97 FPS Video bleibt 29.97. 45 FPS werden in 30 FPS geändert.
Das macht diese Zeile da. Angewendet nach dem Videoinput am besten.

Mit dieser Funktion muss nie wieder eine FPS Rate manuell eingetragen werden.

Bilderthumpnails erstellen in Folge und in Random

SaveRandPic(30)


Function SaveRandPic(clip clip0, int picnumber) {
    Global clip0a=clip0
    picnumber=(picnumber==1) ? 0 : picnumber
    clip1 = ScriptClip(Trim(clip0a, 0, picnumber - 1), "Trim(clip0a, Rand(clip0a.framecount), -1)").ConverttoRGB24()
    clip1 = ImageWriter(clip1, "D:\Test\Thumpnail", 0, type="PNG")
    clip2 = Overlay(clip0, clip1).Trim(0, picnumber - 1)
    clip3 = Overlay(clip2, clip0).Trim(0, picnumber - 1)
    clip0 = clip3 ++ clip0.Trim(picnumber, clip0.framecount-1)
    return clip0
}

Diese Funktion ist entstanden als jemand hier im Forum danach gefragt hatte ob man Thumpnails per Skript speichern kann. Also das Beispielsweise 30 Bilder die rein zufällig aus dem Gesamtvideo entstehen zusammengesetzt werden und gespeichert werden.
Das obere Skript hier erzeugt zufällig 30 Bilder aus dem letzten zurückgegebenen Video und speichert diese als PNG. Also eigentlich steht da SaveRandPic(Last, 30)
Gespeichert werden können eine Menge Formate. Das eigentliche Video wird bei der ganzen Prozedur nicht beeinflusst nach dieser Funktion. Sie dient nur zur Bildergenerierung.

Thumpnails in geordneten gleichmäßigen Abständen kann man mit dieser Funktion erreichen:

SaveEveryPic(30)


Function SaveEveryPic(clip clip0, int picnumber) {
    frame = round(float(clip0.framecount) / picnumber) - 1
    clip1 = clip0.SelectEvery(frame)
    clip1 = ImageWriter(clip1, "D:\Test\Thumpnail", 0, type="PNG")
    clip2 = Overlay(clip0, clip1).Trim(0, picnumber - 1)
    clip3 = Overlay(clip2, clip0).Trim(0, picnumber - 1)
    clip0 = clip3 ++ clip0.Trim(picnumber, clip0.framecount-1)
    return clip0
}

Automatische Auflösungserkennung und Änderung
Für Auflösungen könnte man eine Auswahlliste machen die für Youtubeauflösungen gilt. Denn... in AVISynth ist uns die Breite und die Höhe des geladenen Videos bekannt. Ebenso die Zielauflösung der Höhe. Die einzige Unbekannte ist die Breite die Errechnet werden müsste dabei.
Ein Beispiel dafür:

Spline64Resize((last.width * 720) / last.height, 720)

Das kann mit jeder anderen [lexicon]Auflösung[/lexicon] auch gemacht werden. Für Youtube wären 144p, 240p, 360p, 480p. 720p. 1080p und 1152p (Original) interessant. Im Beispielskript wird für 720p skaliert propotional. Vllt das man dann noch auswählen kann zwischen den Einzelenen Resizern.

Soundspur der Videospur exakt angleichen

correctaudio("D:\Spiele\LucasArts\01-02A.avi", "D:\Spiele\LucasArts\01-02A_track1.wav")


function correctaudio (string video, string audio) {
    video = AVISource(video, false)
    video = video.AssumeFPS(Float(Round(video.Framerate*1000))/1000)
    audio = WAVSource(audio)
    Track = audio++Tone(float(((video.Framecount/(video.framerate))*audio.audiorate - audio.audiolength)/audio.audiorate), 0, audio.audiorate, audio.audiochannels, "Silence").ConvertAudioTo16bit()
    return Track
}

Dieser Skript sorgt dafür das die Audiospur exakt der Videospur angepasst wird. Zurückgeliefert wird nur die Audiospur von der Funktion. Ist also die Audiospur länger als die Videospur, wird sie gekürzt. Ist sie kleiner als die Videospur wird sie verlängert und die fehlende Länge wird mit Leeren Sound gefüllt.
Das wäre interessant wenn man mehrere Videos zusammenknüpfen will. ;D

Rahmen für Videos lassen sich auch berechnen und dynamisch gestalten. Dazu aber erst, wenn ich Lucki sich dazu bereit erklärt sowas auch zu nehmen. Bin eh erst mal gespannt darüber wie das Prog mit diesen neuen Funktionen aussieht.

Selbst das Splitten eines Videos könnte man mit Trim und mehreren Scripten genauer machen lassen, als wenn man eine [lexicon]MKV[/lexicon] über MKVmerge splitten würde. Könnte man auch realisieren.

Eine weitere Funktion die mir gestern in den Kopf kam war mehrere Videos zu laden die eine Unterschiedliche [lexicon]Auflösung[/lexicon] haben. Hier mal ein Beispiel:

Global breite=1280
Global hoehe=720


AVIload("Video1.avi") ++ AVIload("Video2.avi")


Function AVIload(string file) {
    clip0 = AVISource(file, audio=true)
    clip1 = (clip0.Framerate > 30) ? clip0.ChangeFPS(30) : clip0.AssumeFPS(Float(Round(clip0.Framerate*1000))/1000)
    clip1 = ((clip1.width * hoehe) / clip1.height > breite) ? Clip1.Spline64Resize(breite, (Clip1.height * breite) / clip1.width) : Clip1.Spline64Resize((clip1.width * hoehe) / clip1.height, hoehe)
    #clip1 = Clip1.Spline64Resize(breite, hoehe) # Incorrect Aspect Ratio to 16:9 (all Videos)
    back = BlankClip(length=clip1.framecount, width=breite, height=hoehe, fps=Clip1.framerate).KillAudio()
    clip1 = Overlay(back, clip1, x=(back.width - clip1.width) / 2)
    Track1 = clip0.KillVideo()
    Track1 = Track1++Tone(float(((clip0.Framecount/(clip0.framerate))*Track1.audiorate - Track1.audiolength)/Track1.audiorate), 0, Track1.audiorate, Track1.audiochannels, "Silence")
    Track1 = Track1.StereoChannel().SSRC(44100).ConvertAudioTo16bit()
    return Audiodub(clip1, Track1) }


Function StereoChannel(clip audio) {
	Try { return audio.GetChannel(1,2) } #Generate Stereo of first 2 Channels
	Catch (Error_1) { Return audio.GetChannel(1,1) } } #Mono to Stereo

Erklärung: Breite und Höhe geben die Zielauflösung an für das Gesamtvideo. Mit AVIload läd man nun eine AVI Datei (samt den ersten Track.)
Der Clou dabei ist: Youtube Videos haben meist ein 16:9 Bild. Bei alten Spielen kann es sein, das das Spiel 16:9 [lexicon]Auflösung[/lexicon] hat, aber die Cutscenes oder Menüs in 4:3 vorliegen. Auch die Tatsache das es unterschiedliche Auflösungen sind. Das Spiel hat vllt 1280x720 und das Menü oder die Cutscenes vllt nur 640x480. Viele Aufnahmeprogramme die sowas aufnehem erzeugen dabei jedesmal ein neues File. Wenn man die Files mit dieser Funktion da oben die Videos ladet, werden alle auf ein einheitliches Bild gebracht und entsprechend Skaliert.

Beispiel:
Video1.avi -> 4:3 640x480 - Menüaufnahme
Video2.avi -> 4:3 800x600 - Cutscene
Video3.avi -> 16:9 2048x1152 - Spielaufnahme

Im Skript wird jetzt mittels AVIload die Videos geladen.

AVIload("Video1.avi") ++ AVIload("Video2.avi") ++ AVIload("Video3.avi")

Genau so. Wenn eine 16:9 [lexicon]Auflösung[/lexicon] angegeben wurde, dann werden alle Video mit korrektem Seitenverhältnis auf die gewünschte Zielauflösung skaliert und zentriert.
Ihr braucht nur noch eine Zielgröße angeben bei Global. Des weiteren kann man BlankClip austauschen mit einem Bild. Dann hat man ein Hintergrund sogar wenn sich die [lexicon]Auflösung[/lexicon] der Videos die man geladen hat ändert.