MeGUI [2015] -- x264 - bester Encoder, beste Videoqualität auf Youtube ;-)

    Wo ich dann auch so viel von verstehe.... also sorry wenn ich mir das angucke sehe ich da nur einen Salat von Zeichen und zwischen durch mal bekannte Wörter, aber wie das dann alles im genauen Zusammenhang steht.... äh keine Ahnung


    Wenn ich auf einen Output von 4:2:2 gehe müsste das nicht dann auch im Konsolen befehl angepasst werden?


    P.s. 10Bit Encod werde ich mir sparen weil ich dann anstatt 4,5 Fps nur noch 1,5 Fps habe.

    Ich picke dir das mal raus aus der Funktion, damit du das siehst:



    So, Zeile 29 geht es los:
    Und zwars wird in Zeile 29 erfragt ob bei der neuen [lexicon]Auflösung[/lexicon] unter Berücksichtigung des Seitenverhältnisses ein ungerader Wert entsteht. Ein ungerader Wert darf zum Beispiel nicht auftreten bei YV12 Material und YUY2 Material. Eines der Werte muss immer Mod 2 Fähig sein. Würde eine [lexicon]Auflösung[/lexicon] einen ungeraden Wert ergeben, dann wird es in RGB24 konvertiert. Die Zeile 29 ist aber ledeglich nur für den Aspect Ratio Teil da und auch nur dann wirksam wenn der Haken dafür gesetzt wurde.


    Zeile 30:
    Der Clip wird hier in allen Bereichen (Sprich auch unter der Aspect Ratio Voraussicht) Resized auf die neue Größe.
    Hier findeste 2 Konstelationen für den Resize. Einmal wenn AR an ist und einmal wenn es aus ist. Der Resize sieht in dieser Zeile dann so aus:
    Einmal mit AR:
    Clip1.Spline100Resize(breite, ceil(float(Clip1.height * breite) / clip1.width)) : Clip1.Spline100Resize(ceil(float(clip1.width * hoehe) / clip1.height), hoehe))


    Und einmal ohne AR:
    clip1.Spline100Resize(breite, hoehe).ConvertToYUY2(matrix = "Rec601")


    Zeile 31:
    Ist wieder für den AR Teil interessant. Hier wird ein Hintergrundbild oder ein BlankClip dfür genutzt um das Video aus Zeile 30 draufzupacken. Zeile 31 ist erst dann aktiv, wenn AR an ist.
    Hier wird nun das Hintergrundbild (Oft im RGB Mode) auf eine neue [lexicon]Auflösung[/lexicon] skaliert und dann in den entsprechenden Farbraum konvertiert. Wärend bei Blankclip gleich die feste größe und der Farbraum bestimmt werden kann.
    Hintergrundbild (Jetzt leer, weil im [lexicon]SSM[/lexicon] nicht angekreuzt):
    ImageReader("", 0, clip1.framecount, clip1.framerate).ChangeFPS(round(clip1.framerate) * ratefaktor, rate).Spline100Resize(breite, hoehe).ConvertToYUY2(matrix = "Rec601")


    Und BlankClip:
    BlankClip(clip1.framecount, breite, hoehe, "YUY2", round(Clip1.framerate) * ratefaktor, rate).KillAudio()


    Tritt keines dieser beiden Sachen ein, liegt der Clip ohne AR vor. Dann wird der Clip 1:1 durchgezogen. (Darum wurde in Zeile 30 auch schon in Farbraum xyz konvertiert, wenn AR nicht aktiv ist)


    Zeile 32:
    Sollte ein Clip einen anderen Farbraum haben, aber Ziel und Quellauflösung identisch sein, so wird hier auch so ein Clip in den gewünschten Farbraum konvertiert.
    (clip1.width == breite && clip1.height == hoehe) ? clip1.ConvertToYUY2(matrix = "Rec601")


    Sollte AR aktiv sein, wird nun Hintergrund und Clip zusammengeführt mit Overlay. Sprich: Ein Hintergrundbild oder das Blankclip aus Zeile 31 wird nun mit dem Clip aus Zeile 30 zusammengesetzt.
    Da in Zeile 31 sowohl Hintergrundbild und BlankClip im gewünschten Farbraum vorlagen wie man es im [lexicon]SSM[/lexicon] eingestellt hatte, so wird nun durch das aufsetzen des auf diese durch das Clip, das Clip selbst nun in diesen Farbraum konvertiert.
    (AR == 1) ? Overlay(back, clip1, (back.width - clip1.width) / 2, (back.height - clip1.height) / 2)


    Sollte AR nicht aktiv sein, so wird nur der Clip zurückgegeben. Und der ist ja schon seit Zeile 30 im gewünschten Farbraum ^^



    Du siehst also: Zuerst wird skaliert, dann konvertiert. Nur in Sonderfällen unter der Bedingung das AR aktiv ist, kann es sein das in ein höheren Farbraum konvertiert wird, um auch in ungeraden nicht Mod 2 Fähigen Auflösungen zu skalieren.


    Daher wird in Zeile 29 auch geprüft für AR ob die entsprechende neue [lexicon]Auflösung[/lexicon] Mod 2 Fähig ist.
    Es ist selten der Fall, aber auch ich habe Videos hier die für eine AR Skalierung später nicht Mod 2 Fähig waren.


    Als Beispiel mal ein Video mit folgender [lexicon]Auflösung[/lexicon]:
    720 x 416 YV12


    Das soll nun auf 1080p 16:9 hochskaliert werden unter AR Voraussetzung:
    (720 * 1080) / 416 = 1869,2307692307692307692307692308


    Und schon gibt es ein Fehler. YV12 kann das nicht erkennen. Selbst wenn es gerundet wird auf 1869.
    Also müsste bei diesem Video in einen höheren Farbraum konvertiert werden. Und da bietet sich RGB halt an. Denn nur im RGB / YV24 Farbraum ist alles Mod 1 Fähig und kann so die 1869 verwerten. Daher siehst du im Skript oftmals dieses ceil zu stehen. Das ist nur zum runden da. Und wie gesagt: Nur für den AR Modus wichtig alles.


    Ist AR deaktiviert wird knallhart wie immer das Video auch aussehen mag in 16:9 1080p skaliert.


    Zitat von GelberDrache92

    Wenn ich auf einen Output von 4:2:2 gehe müsste das nicht dann auch im Konsolen befehl angepasst werden?


    Jap. Statt i444 nimmste dann i422

    3 FPS weniger durch 10 bit-Encode? Happig. Ist bei meiner alten Kiste nicht so extrem spürbar.
    Sonstige Einstellungen sind sicher identisch?

    Ok... muss ich mir jetzt sorgen machen das ich das verstanden habe? xD


    Aber wie sieht des jetzt aus im Skript kommt ja am Ende 4:2:2 raus.
    Im Konsolenbefehl steht aber noch das der Output 4:4:4 sein soll, muss das nicht noch angepasst werden?


    Und ich hab momentan das Problem das ich fehlerhafte Videos bekomme:
    http://img5.fotos-hochladen.net/uploads/test1duajg9obn.png


    Werde gleich mal gucken ab welcher Veränderung des Skriptes dieses Problem ensteht.


    Naja es sind nicht nur 3 Fps sondern 66% und das ist heftig, aber alles gleiche Einstellungen.

    Zitat von GelberDrache92

    Und ich hab momentan das Problem das ich fehlerhafte Videos bekomme:
    img5.fotos-hochladen.net/uploads/test1duajg9obn.png


    Dieses Problem kann entstehen durch das Abspielen des Videos dessen Farbunterabtastung nicht richtig decodiert werden kann für den entsprechenden Codecs.


    Da wird dir De-M-oN denk ich weiterhelfen können bezüglich des [lexicon]MPC-HC[/lexicon].


    Im Skript selbst denk ich mal das es da kein Problem gibt ;D Das wird wie gesagt ein Decodierproblem sein.


    Zitat von GelberDrache92

    Aber wie sieht des jetzt aus im Skript kommt ja am Ende 4:2:2 raus.
    Im Konsolenbefehl steht aber noch das der Output 4:4:4 sein soll, muss das nicht noch angepasst werden?


    Hatte ich schon geschrieben im Edit. Du musst ledeglich i444 in i422 umbenennen im Konsolenbefehl.

    Tja der Edit war doch nicht bei als ich es gelesen habe :D
    Ich hab aber auch jetzt das Problem beim Standardskript das Problem.
    Und da wird ja keine Farbraum verändert und es ist eine Ausgabe in RGB o.o
    Und wenn ich einen Cutbefehl mit einbringe wird nur die Hälfte der Frames erstellt


    Skript:


    [lexicon]Mediainfo[/lexicon]


    Batchdatei

    Nicht gut, wenn da steht das er in YV12 konvertiert, damit ist der Effekt hinfällig.


    Hab eben mal nachgeschaut. avs4x264mod kann AVS Datein nur im Farbraum YV12, YV16 und YV24 erkennen.


    YV12 - 4:2:0 (Standard)
    YV16 - 4:2:2
    YV24 - 4:4:4


    Sprich dein RGB Video muss in YV24 konvertiert werden. Erst dann bekommste von der Pipeline nicht die entsprechende Warnung das dein Video in YV12 konvertiert wird. Dann hätteste den Effekt für ein reinen 4:4:4 Encode.


    Dann erkennt er aber auch 101 Frames. Das sind die, die du angegeben hast im Skript. Nämlich von 0 bis 100 sind 101 Frames.


    Was ich aber jetzt auch nicht verstehe warum er 1 I, 14 P und 35 B Frames nur erkennt. Hmm...


    Mach aber erst mal den einen Fehler da weg. Vllt erledigt sich das andere von alleine. Wenn nicht, müssen wa mal schauen woran es liegt bei dir da.

    Also noch mal von vorne:


    RGB Aufnahme -> Im [lexicon]SSM[/lexicon] laden und in YV24 konvertieren (RGB und YV24 haben beide eine Farbunterabtastung von 4:4:4. Aber nur YV24 wird von der Pipeline als 4:4:4 erkannt, wärend RGB in YV12 konvertiert wird, da die Pipeline darauf standardmäßig ausgelegt ist.)


    Und dann encodierste dieses Skript.


    Müsste dann ungefähr so aussehen dieser 4:4:4 Encode: Bild

    Das hat geklappt, keine Fehler,
    Dann muss jetzt der Befehl für YUY2 rein damit ich [lexicon]Motion Blur[/lexicon] nutzen kann
    Wo muss das ins Skript rein damit es keinen Fehler gibt?
    Also so das es nach dem Skalierer kommt


    Skript


    Bat


    Encode


    [lexicon]Mediainfo[/lexicon]

    Bei YUY2 machste folgendes:


    YUY2 oder RGB24 Aufnahme -> In den [lexicon]SSM[/lexicon] laden und auf YUY2 Konvertierung gehen.


    Dann wenn MB und alle [lexicon]Filter[/lexicon] eingestellt sind, gehst du in die AVS Sektion im [lexicon]SSM[/lexicon] und gibst ein als letztes in die [lexicon]Filter[/lexicon] Verarbeitungszone:
    ConvertToYV16()


    Das wars dann.
    Denn YUY2 und YV16 haben beide eine Farbunterabtastung von 4:2:2


    Im [lexicon]SSM[/lexicon] wird immer nach dem Skalieren konvertiert. Darum kann man auch wenn das Video im Skript als YUY2 vorliegt ohne Verlust in YV16 konvertieren. Es ändert sich ledeglich der Aufbau des Farbraumes, jedoch nicht die Farbunterabtastung.


    Und im [lexicon]Encoder[/lexicon] halt statt i444 nur i422 angeben:
    avs4x264mod.exe --x264-binary "x264_64.exe" --preset slow --crf 18.0 --aq-strength 1.25 --output-csp "i422" --output "C:\Temp\Test_YV16_422.264" "C:\Temp\Test_YV16_422.avs"

    Wenn erst nach der Skalierung der Farbraum verändert wird, warum hat er dann das RGB24 Skript genommen obwohl erst nach der Skalierung auf YV24 geändert wurde?
    Weil wenn die Piplin ja nur YV12, YV16 und YV24 sieht, dürft doch sowieso kein RGB24 [lexicon]Rohmaterial[/lexicon] erkannt werden.
    Oder hab ich da jetzt einen riesengroßen Denkfehler?
    Weil ich geh davon aus das ein Skript von links nach rechts abgearbeitet wird.
    Das heißt erst kommt die Piplin und dann das Skript o.o


    So hab es gerade gemacht wie du gesagt hast also im [lexicon]SSM[/lexicon] direkt auf YUY2 und am Ende auf YV16
    Dabei kommen dann wieder Fehler


    Encod


    Skript

    Zitat von GelberDrache92

    Wenn erst nach der Skalierung der Farbraum verändert wird, warum hat er dann das RGB24 Skript genommen obwohl erst nach der Skalierung auf YV24 geändert wurde?


    Hatte das Skript doch gar nicht erst. Dein erstes Skript was ich gesehen hatte am Anfang war das da in deinem Beitrag:
    MeGUI -- x264 - bester Encoder, beste Videoqualität auf Youtube ;-)


    Dort hatte dein Skript ein RGB24 Output. Folglich erkennt die Pipeline es nicht unt konvertiert es in YV12 und dann encodierste das YV12 Material wieder in YV24 hoch. Effekt halt nicht erziehlt.


    Dein Encode hier:
    MeGUI -- x264 - bester Encoder, beste Videoqualität auf Youtube ;-)


    war schon wesentlich besser. Weil dort haste in YV24 konvertiert das Skript. Folglich erkennt die Pipeline das nun und konvertiert da nix rum. Damit ist der Output in YV24 auch besser gegeben.



    Das [lexicon]Rohmaterial[/lexicon] wie es aus der AVS kommt muss passen.
    [lexicon]x264[/lexicon].exe würde so ziemlich jeden Farbraum der AVS erkennen.
    Aber die Pipeline um AVS Datein für den 64Bit [lexicon]Encoder[/lexicon] nutzbar zu machen benötigt YV12, YV16 und YV24 Input.


    Und nun zum ganzen:
    RGB32, RGB24, YV24 = Farbunterabtastung von 4:4:4
    YUY2, YV16 = Farbunterabtastung von 4:2:2
    YV12 = Farbunterabtastung von 4:2:0


    Somit sind YUY2 und YV16 zwars identisch von der Farbunterabtastung, jedoch nicht vom Aufbau. Genauso wie RGB32, RGB24 und YV24 identisch sind in der Farbunterabtastung aber halt nicht vom Aufbau.


    Was du eigentlich machst ist diese Farbunterabtastung beizubehalten so gut es geht. Denn 4:4:4 ist das schärfste und akkurateste was es gibt.
    4:2:2 verschmiert Farben (Chromaanteil) Horizontal
    4:2:0 verschmiert die Farben in allen Ausrichtungen.


    Also: RGB Aufnahme (4:4:4) in den [lexicon]SSM[/lexicon] geladen wird im RGB24 Mode Skaliert und dann erst in die neue Farbauflösung konvertiert. Sprich nach der Skalierung wird z.B. in YUY2 konvertiert.


    Da YUY2 nicht von der Pipeline erkannt wird machste aus YUY2 halt YV16 und hast somit eine 4:2:2 Encode.


    Von einer höheren Farbauflösung in eine niedriegeren zu gehen ist ok. Jedoch nicht umgekehrt. Umgekehrt sollte man es versuchen zu vermeiden wenn es sich vermeiden lässt.


    So sollte es Qualitativ angeordnet sein. Von Hoch auf niedrig:
    RGB32 (Samt [lexicon]Alphakanal[/lexicon]) -> RGB24 = YV24 -> YUY2 = YV16 -> YV12 -> Y8 (Y8 = ohne Chroma. Reines Luma Video)


    RGB32 und RGB24 unterscheidet nur den [lexicon]Alphakanal[/lexicon]. Der ist aber bei Aufnahmen meist überflüssig, da man ja bei einer Aufnahme meist nie eine Farbe wählen kann die Transparent sein soll. Üblich also das man von RGB32 für Videobearbeitungen es in RGB24 ändert.


    Zitat von GelberDrache92

    Weil ich geh davon aus das ein Skript von links nach rechts abgearbeitet wird.
    Das heißt erst kommt die Piplin und dann das Skript o.o


    Denkfehler deinerseits. Die Parameter kann man anordnen wie man lustig ist.


    [lexicon]MeGUI[/lexicon] macht es folgendermaßen:
    programm --preset slow --crf 18.0 --output "output" "input"


    Und du machst das halt so in der Command:
    x264.exe --preset slow --crf 18.0 --output "output" "input"


    oder halt mit der Pipeline:
    avs4x264.exe --x264-binary "x264.exe" --preset slow --crf 18.0 --output "output" "input"


    Aus dem Input bezieht er dann seine Informationen alleine und ruft sich selbst noch mal auf. Nur halt mit Angabe von Frames, FPS, [lexicon]Auflösung[/lexicon] und Farbraum. Sprich alle Inputwerte zieht er sich alleine aus der AVS.


    Und dann erst nimmt er sich die Parameter vor die angegeben wurden.


    Du darfst da nicht Stur von links nach rechts lesen. Es sind Parameter die sonstwie stehen dürfen ^^

    Warum hab ich dann jetzt aber wieder einen Fehler?


    [quote='GelberDrache92','http://www.letsplayforum.de/index.php/Thread/18295-MeGUI-x264-bester-Encoder-beste-Videoqualität-auf-Youtube/?postID=1777028#post1777028']So hab es gerade gemacht wie du gesagt hast also im [lexicon]SSM[/lexicon] direkt auf YUY2 und am Ende auf YV16
    Dabei kommen dann wieder Fehler


    Encod



    Skript
    [spoiler]### Lade Plugins und setze die globalen Variablen ###
    LoadPlugin("C:\Program Files (x86)\[lexicon]SagaraS Scriptmaker[/lexicon]\Plugins\SplineResize.dll")
    Global breite = 3200
    Global hoehe = 1800
    Global AR = 0


    ### Lade Videoquellen ###
    SetMTMode(3,2)
    AVIload("A:\Test\Aufnahme\25fps_2560x1440_RGB24.avi", 0, 0, 0, -0, -0)


    ### [lexicon]Filter[/lexicon] Verarbeitungszone ###


    ### Funktion für Video-Laderoutine ###
    Function AVIload (String file, int loading, int cl, int co, int cr, int cu) {
    (loading == 1) ? FFIndex(file) : nop()
    clip0 = (loading == 3) ? LWLibavVideoSource(file) : (loading == 2) ? Import(file).KillAudio() : (loading == 1) ? FFVideoSource(file, threads=1) : AVISource(file, false)
    rate1 = (Round(Float(clip0.framerate * 1000)) / 1000) / 2
    rate2 = Round(clip0.framerate) / 2
    rate = (rate1 == rate2) ? 1 : 1001
    ratefaktor = (rate == 1001) ? 1000 : 1
    clip1 = (rate == 1001) ? clip0.AssumeFPS(Round(clip0.Framerate) * 1000, rate) : clip0.AssumeFPS(round(clip0.framerate), rate)
    clip1 = clip1.Crop(cl, co, cr, cu)
    clip1 = (clip1.width == breite && clip1.height == hoehe) ? clip1 : (AR == 1) ? ((float(Clip1.height * breite) / clip1.width) / 2 == round((float(Clip1.height * breite) / clip1.width) / 2)) ? ((float(Clip1.width * hoehe) / clip1.height) / 2 == round((float(Clip1.width * hoehe) / clip1.height) / 2)) ? clip1 : clip1.ConvertToRGB24() : clip1.ConvertToRGB24() : clip1
    clip1 = (clip1.width == breite && clip1.height == hoehe) ? clip1 : (AR == 1) ? (((clip1.width * hoehe) / clip1.height > breite) ? Clip1.Spline100Resize(breite, ceil(float(Clip1.height * breite) / clip1.width)) : Clip1.Spline100Resize(ceil(float(clip1.width * hoehe) / clip1.height), hoehe)) : clip1.Spline100Resize(breite, hoehe).ConvertToYUY2(matrix = "Rec601")
    back = (clip1.width == breite && clip1.height == hoehe) ? clip1 : (AR == 1) ? (0 == 1) ? ImageReader("", 0, clip1.framecount, clip1.framerate).ChangeFPS(round(clip1.framerate) * ratefaktor, rate).Spline100Resize(breite, hoehe).ConvertToYUY2(matrix = "Rec601") : BlankClip(clip1.framecount, breite, hoehe, "YUY2", round(Clip1.framerate) * ratefaktor, rate).KillAudio() : clip1
    Return (clip1.width == breite && clip1.height == hoehe) ? clip1.ConvertToYUY2(matrix = "Rec601") : (AR == 1) ? Overlay(back, clip1, (back.width - clip1.width) / 2, (back.height - clip1.height) / 2) : clip1
    }


    ConvertToYV16()


    __film = last
    __t0 = __film.trim(0, 100)
    __t0

    Hei da kann ich doch nichts für :D
    Ich mach nur Copy & Paste xD
    Aber der Output soll auf i422 bleiben?


    Edit: So hat schon mal geklappt, mit [lexicon]Motion Blur[/lexicon] hat es auch geklappt :D
    So jetzt wird ein Vollvideo gemacht mit 3 Minuten etwas länge :D


    P.s. Ist das mit dem 10Bit Encod Normal das es mir 66% Leistung frisst?


    So hier ist das mal das Ergebnis


    RGB24


    YV12

    Mal ne Frage, ich möchte testweise mal ein Full HD 30 FPS Konsolenmaterial auf 4k bringen auf YT. Bisher steht das in [lexicon]Megui[/lexicon] bzw [lexicon]Avisynth[/lexicon] drin, was muss ich da nun reinschreiben? Und welcher Resizer für die beste Qualität<>Größe?


    AVISource("pfad zur Datei", audio=true).AssumeFPS(30,1)
    #deinterlace
    #crop
    #resize
    #denoise

Jetzt mitmachen!

Du hast noch kein Benutzerkonto auf unserer Seite? Registriere dich kostenlos und nimm an unserer Community teil!

Benutzerkonto erstellen Anmelden