Encoding-Talk

Zitat von Spieluin

Er hat ja mit 40 FPS enkodiert

Dann solltest du entweder Anpassungen bei der Vorgehensweise vornehmen (Farbraumkonvertierung auslassen, etc.) oder deine Anforderungen überdenken, wenn dir das immer noch zu langsam ist. Gerade mal 50% länger zu kodieren als die eigentliche Videodauer ist schon extrem wenig.

Würde ja schauen ob sich etwas optimieren lässt, aber dafür müssen auch die entsprechenden Infos gezeigt werden.

Zitat von Karmaalp

Wäre der I7 5820K nix ?
Ich weiß neues Board etc, aber von der Power finde ich den sehr gut was Kodierung angeht.

Der hat halt ebenso nur die wenigen ghz. Und für mich wäre auch die Rohkernleistung interessant

Zitat von De-M-oN

Der hat halt ebenso nur die wenigen ghz. Und für mich wäre auch die Rohkernleistung interessant

Die Serie ist aber Super zum Übertakten.
Ganz normal mit Luft gekühlt ohne irgendwelche Probleme und bei 50 Grad sind 4 Ghz da sicher drin.

echt? naja ich mit meinem übertaktungshändchen bekam meine i7 3770k gerad mal auf 4,1 ghz, damit der stabil läuft. Die meisten schaffen im Schnitt 4,5. hmmm entweder ich hab ne doofe cpu erwischt, oder ich hab da noch ne schraube vergessen.

Naja 4 ghz wär natürlich cool ansonsten.

Zitat von De-M-oN

echt? naja ich mit meinem übertaktungshändchen bekam meine i7 3770k gerad mal auf 4,1 ghz, damit der stabil läuft. Die meisten schaffen im Schnitt 4,5. hmmm entweder ich hab ne doofe cpu erwischt, oder ich hab da noch ne schraube vergessen.

Naja 4 ghz wär natürlich cool ansonsten.

Sure Sure kannst dir ja Berichte anschauen dort werden alle locker so hoch getaktet.
Mit dem Wert fängt man sogar manchmal an zu Übertakten
Meiner läuft mit 4,5 Ghz.

Zitat von Karmaalp

Meiner läuft mit 4,5 Ghz.

Und was hast alles dafür getan?

Hab nur Vcore auf fixed 1,18

Bei 4,2 ghz gibts dann langsam in seltensten Fällen Rechenfehler und bei 4,3 fährter nich mehr hoch ohne bluescreens. Das ließ sich auch mit 1,37 Volt nich ändern. Und mehr will ich da nicht mehr reinknallen.

4,1 Ghz scheint ohne weiteres zu tun bei meiner demnach der sweet spot zu sein. Aber vllt überseh ich ja einfach noch was anderes.

Zitat von De-M-oN

Und was hast alles dafür getan?
Hab nur Vcore auf fixed 1,18

Bei 4,2 ghz gibts dann langsam in seltensten Fällen Rechenfehler und bei 4,3 fährter nich mehr hoch ohne bluescreens. Das ließ sich auch mit 1,37 Volt nich ändern. Und mehr will ich da nicht mehr reinknallen.

4,1 Ghz scheint ohne weiteres zu tun bei meiner demnach der sweet spot zu sein. Aber vllt überseh ich ja einfach noch was anderes.

Naja alle auf dem 2011 V3 Sockel sind relativ Übertakt freundlich

Meiner läuft auf 1,38 V mit 4,5 Ghz.
4,0 Ghz war schon mit 1,2 Möglich.

Wenn du dich jetzt wunderst wieso so hoch, es ist einfach möglich mit der CPU

Die VCore mit 1.38 ist aber schon hart an der Grenze, da scheinst du eine top CPU erwischt zu haben.
Man muss aber dazu sagen, dass die Ivy's sich ab und zu sehr zickig verhalten, im Gegensatz zu Sandy's.

Aber con 3.5GHz auf knapp 4GHz ist doch auch schon einmal was!

Mal ganz spontan zur Info, weil mir gerad im Kopf schwirrt, das manche vllt denken bei x264 lossless macht das Preset auch kein dateigrößenunterschied mehr.
Das ging mir so ganz völlig nebenbei durch dem Kopf, weil ich gerad das Thema habe, wegen besten Kompromiss finden mit meinem neuen Uploadspeed.

Also klar qualitätsmäßig ist im lossless mode natürlich ultrafast identisch zu placebo.

Aber es gibt trotzdem noch dateigrößendifferenzen. Nicht das ihr dachtest es gibt vollständig keine Differenz mehr. Schwirrte mir einfach gerad so durch dem Kopf beim überlegen, das das vllt mal hier falsch rüberkam / nicht bedacht wurde von einigen.

Wie groß die Differenz ist zwischen den Presets kann ich euch aber aktuell nicht sagen.

Das Unterschied da sind, ist klar, nur je langsamer das Preset wird umso geringer wird der Unterschied.

Von Ultrafast auf Superfast sind glaub ich so um die 10% durch CABAC, welcher dann unter Ultrafast nicht mehr genutzt wird.
Aber ab einen bestimmten Punkt ist es extrem wenig, da dann nur noch die Kompression der Lossless Verfahren genauer arbeiten.
Wenn ja aber Lossless aufgenommen wird, will man ja Versuchen die Belastung der CPU zu reduzieren und da ist die Dateigröße dann eher das geringere Problem, zudem durch eine stärkere Kompression ja auch das Decoding wieder langsamer wird, was dann die Zeit der Nachbearbeitung erhöht.

Aktuell tu ich mich echt schwer den besten Kompromiss mit meiner Leitung zu finden XD

Lossless wird bei Legendary definitiv vorraussichtlich zu groß laut MeGUI für meine 25 mbit Upload

Und egal ob ich lossless ultrafast oder CRF15 Ultrafast codiere, ich komme nicht über 25 bis 27 fps hinaus. Ich glaub da bremst der Auflösungsskalierer doch noch ganz gut mit hinzu. Weil eig. müsste das m.M.n auf ultrafast etwas zügiger gehen, trotz 2800x1750.

So wird halt weiterhin mein Uploadspeed den Encode überholen.
Es isn Graus XD ich weiß gerad nich wie ich den besten kompromiss finde. Der Encode ist die größte Bremse
Es könnt sonst so schnell sein. Daher ist meine Priorität: Encode so schnell wie nur irgend möglich. Upload ist ja groß genug das man den CRF sehr niedrig halten kann.

Wie ist den die Belastung deiner CPU?

so 90 bis 100.

Zitat von De-M-oN

Bei so niedriger Auflösung würde ich es mal mit nnedi3 probieren. Das hat mir bei einem NFS 3 400x300 video aus alten Zeiten gute Ergebnisse gebracht.

Ich ziehs mal hier rein, damit die Kneipe nicht zugespammt wird.

Hast du denn mal ein Beispiel für nnedi3? Weil in der Avisynth-Wiki steht irgendwie nur, wie man den als Deinterlacer benutzt oder um mit verdoppelter Auflösung zu skalieren..
Pointsize x Spline36 sah gar nicht gut aus..

Zitat von strohi

Pointsize x Spline36 sah gar nicht gut aus..

Vllt falsch eingesetzt

Zitat von strohi

Hast du denn mal ein Beispiel für nnedi3?

SSM hat den eig. schon drin^^

Zitat von De-M-oN

Vllt falsch eingesetzt

Weiß ich ehrlich gesagt nicht.
Das Problem daran ist halt echt, dass der Gamecube es vorher schon mal auf 320p hochskaliert, aber scheinbar nicht so mit dem besten Skalierer. Und da liegt dann wohl auch das Problem. PointSize verstärkt dann halt die mittelmäßige Skalierung und dadurch sieht es nicht so geil aus.
Normalerweise würde ich da ja einfach nen doppelten xBRZ drüberbügeln (erst mit 4x, dann mit 3x, womit man bei 160p auf 160 * 4 * 3 = 1920p kommen würde / Beispiel im Spoiler), allerdings sieht der auf die 320p angewandt mit 3x und dann 2x auch ziemlich shittig aus.

Zitat von De-M-oN

SSM hat den eig. schon drin^^

Ah, ok, dann hab ich ja ein Beispiel. Sieht allerdings nur wenig besser aus, eher sogar ein bisschen unschärfer.

---

Wenn du es selbst mal nachschauen willst, hier der Link zur Aufnahme (etwas mehr als 300 MB groß):
https://www.dropbox.com/s/seum…BA_Vorlage_short.avi?dl=1

Das aktuellste verwendete Skript mit nnedi3 war das hier:

### SagaraS Scriptmaker - Version 6.0 ###


### Lade Plugins und setze die globalen Variablen ###
LoadPlugin("C:\Program Files (x86)\SagaraS Scriptmaker\Plugins\xBRZ.dll")
LoadPlugin("C:\Program Files (x86)\SagaraS Scriptmaker\Plugins\PointSize.dll")
LoadPlugin("C:\Program Files (x86)\SagaraS Scriptmaker\Plugins\nnedi3.dll")
Global breite = 3840
Global hoehe = 2160
Global AR = 0


### Lade Videoquellen ###
SetMTMode(3) 
AVIload("V:\roh\MKTest_480.avi", 0, 100, 80, -96, -80, "Auto", "Auto", 0, 0) 


### Filter Verarbeitungszone ### 


(IsYUY2() == true) ? ConvertToYV24(matrix = "Rec709", ChromaResample = "Spline16") : Last


### Funktion für Video-Laderoutine ###
Function AVIload (String file, int loading, int cl, int co, int cr, int cu, string pixtype, string afps, int fpsn, int fpsd) {
    (loading == 1) ? FFIndex(file) : nop()
    clip0 = (loading == 3) ? LWLibavVideoSource(file) : (loading == 2) ? Import(file).KillAudio() : (loading == 1) ? FFVideoSource(file, threads=1) : (pixtype == "Auto") ? AVISource(file, false).KillAudio() : AVISource(file, false, pixel_type=pixtype).KillAudio()
	clip1 = clip0.SeparateFields().Bob().SelectEven()
	clip1 = clip1.Cropping(cl, co, cr, cu).AutoFPS(afps, fpsn, fpsd)
	clip1 = clip1.ColorYUV(0,0,0,0,0,0,0,0,0,0,0,0,"TV->PC").ColorYUV(0,0,0,0,0,0,0,0,0,0,0,0,"TV->PC")
    clip1 = clip1.nnedi3Resize()  
	Return clip1
}


Function AutoFPS (Clip clip0, string afps, int fpsn, int fpsd) {
    rate1 = (afps == "Auto") ? (Round(Float(clip0.framerate * 1000)) / 1000) / 2 : nop() 
    rate2 = (afps == "Auto") ? Round(clip0.framerate) / 2 : nop()
    rate = (afps == "Auto") ? (rate1 == rate2) ? 1 : 1001 : (afps == "Igno.") ? clip0.frameratedenominator : fpsd
    ratefaktor = (afps == "Auto") ? (rate == 1001) ? 1000 : 1 : nop()
    clip0 = (afps == "Auto") ? (rate == 1001) ? clip0.AssumeFPS(Round(clip0.Framerate) * 1000, rate) : clip0.AssumeFPS(round(clip0.framerate), rate) : (afps == "Igno.") ? clip0.AssumeFPS(clip0.frameratenumerator, rate) : clip0.AssumeFPS(fpsn, rate)
    Return clip0
}


Function Cropping (Clip clip0, int cl, int co, int cr, int cu) {
    clip0 = (clip0.IsRGB32() == True) ? clip0.ConvertToRGB24() : clip0
    Return (cl != 0 || co != 0 || cr != 0 || cu != 0) ? clip0.Crop(cl, co, cr, cu) : clip0
}


Function nnedi3Resize (Clip clip1) {
    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 = (AR == 1) ? (((clip1.width * hoehe) / clip1.height > breite) ? Clip1.nnedi3_rpow2(rfactor=2, nsize=0, nns=3, qual=1, etype=0, pscrn=2, cshift="Spline16Resize", fwidth=breite, fheight=ceil(float(Clip1.height * breite) / clip1.width), threads=0, opt=0, fapprox=15) : Clip1.nnedi3_rpow2(rfactor=2, nsize=0, nns=3, qual=1, etype=0, pscrn=2, cshift="Spline16Resize", fwidth=ceil(float(clip1.width * hoehe) / clip1.height), fheight=hoehe, threads=0, opt=0, fapprox=15)) : clip1.nnedi3_rpow2(rfactor=2, nsize=0, nns=3, qual=1, etype=0, pscrn=2, cshift="Spline16Resize", fwidth=breite, fheight=hoehe, threads=0, opt=0, fapprox=15).ConvertToYV24(matrix = "Rec709", ChromaResample = "Lanczos4")
    back = (AR == 1) ? (0 == 1) ? ImageReader("", 0, clip1.framecount - 1, clip1.framerate).ChangeFPS(clip1.frameratenumerator, clip1.frameratedenominator).nnedi3_rpow2(rfactor=2, nsize=0, nns=3, qual=1, etype=0, pscrn=2, cshift="Spline16Resize", fwidth=breite, fheight=hoehe, threads=0, opt=0, fapprox=15).ConvertToYV24(matrix = "Rec709", ChromaResample = "Lanczos4") : BlankClip(clip1, width = breite, height = hoehe, pixel_type = "YV24").KillAudio() : clip1
    Return (AR == 1) ? Overlay(back, clip1, (back.width - clip1.width) / 2, (back.height - clip1.height) / 2).ConvertToYV24(matrix = "Rec709", ChromaResample = "Lanczos4") : clip1
}

Mit Blackman war es folgendes:

### SagaraS Scriptmaker - Version 6.0 ###


### Lade Plugins und setze die globalen Variablen ###
LoadPlugin("C:\Program Files (x86)\SagaraS Scriptmaker\Plugins\xBRZ.dll")
LoadPlugin("C:\Program Files (x86)\SagaraS Scriptmaker\Plugins\PointSize.dll")
Global breite = 3840
Global hoehe = 2160
Global AR = 0


### Lade Videoquellen ###
SetMTMode(3) 
AVIload("V:\roh\MKTest_480.avi", 0, 100, 80, -96, -80, "Auto", "Auto", 0, 0) 
Spline64Resize(breite, hoehe)


### Filter Verarbeitungszone ### 


(IsYUY2() == true) ? ConvertToYV24(matrix = "Rec709", ChromaResample = "Spline16") : Last


### Funktion für Video-Laderoutine ###
Function AVIload (String file, int loading, int cl, int co, int cr, int cu, string pixtype, string afps, int fpsn, int fpsd) {
    (loading == 1) ? FFIndex(file) : nop()
    clip0 = (loading == 3) ? LWLibavVideoSource(file) : (loading == 2) ? Import(file).KillAudio() : (loading == 1) ? FFVideoSource(file, threads=1) : (pixtype == "Auto") ? AVISource(file, false).KillAudio() : AVISource(file, false, pixel_type=pixtype).KillAudio()
    clip1 = clip0.Cropping(cl, co, cr, cu) 
	clip1 = clip1.SeparateFields().BlackmanResize(clip1.width, clip1.height).Sharpen(0.3).SelectEven().AutoFPS(afps, fpsn, fpsd)
	clip1 = clip1.ColorYUV(0,0,0,0,0,0,0,0,0,0,0,0,"TV->PC").ColorYUV(0,0,0,0,0,0,0,0,0,0,0,0,"TV->PC")
    clip1 = clip1.ConvertToRGB32().BlackmanResize(3840,2160).SameColorAs(clip0)
    (clip1.width == breite && clip1.height == hoehe) ? clip1.ConvertToYV24(matrix = "Rec709", ChromaResample = "Spline16") :  Clip1.Resize()   
	Return clip1
}


Function AutoFPS (Clip clip0, string afps, int fpsn, int fpsd) {
    rate1 = (afps == "Auto") ? (Round(Float(clip0.framerate * 1000)) / 1000) / 2 : nop() 
    rate2 = (afps == "Auto") ? Round(clip0.framerate) / 2 : nop()
    rate = (afps == "Auto") ? (rate1 == rate2) ? 1 : 1001 : (afps == "Igno.") ? clip0.frameratedenominator : fpsd
    ratefaktor = (afps == "Auto") ? (rate == 1001) ? 1000 : 1 : nop()
    clip0 = (afps == "Auto") ? (rate == 1001) ? clip0.AssumeFPS(Round(clip0.Framerate) * 1000, rate) : clip0.AssumeFPS(round(clip0.framerate), rate) : (afps == "Igno.") ? clip0.AssumeFPS(clip0.frameratenumerator, rate) : clip0.AssumeFPS(fpsn, rate)
    Return clip0
}


Function Cropping (Clip clip0, int cl, int co, int cr, int cu) {
    clip0 = (clip0.IsRGB32() == True) ? clip0.ConvertToRGB24() : clip0
    Return (cl != 0 || co != 0 || cr != 0 || cu != 0) ? clip0.Crop(cl, co, cr, cu) : clip0
}


Function SameColorAs (clip clip0, clip clip1) {
    wert1 = (clip0.IsRGB32() == true) ? 0 : (clip0.IsRGB24() == true) ? 1 : (clip0.IsYV24() == true) ? 2 : (clip0.IsYUY2() == true) ? 3 : (clip0.IsYV16() == true) ? 4 : (clip0.IsYV12 == true) ? 5 : (clip0.IsYV411() == true) ? 6 : 7
    wert2 = (clip1.IsRGB32() == true) ? 0 : (clip1.IsRGB24() == true) ? 1 : (clip1.IsYV24() == true) ? 2 : (clip1.IsYUY2() == true) ? 3 : (clip1.IsYV16() == true) ? 4 : (clip1.IsYV12 == true) ? 5 : (clip1.IsYV411() == true) ? 6 : 7
    return (wert1 == wert2) ? clip0 : (wert2 == 0) ? clip0.ConvertToRGB32() : (wert2 == 1) ? clip0.ConvertToRGB24() : (wert2 == 2) ? clip0.ConvertToYV24() : (wert2 == 3) ? clip0.ConvertToYUY2() : (wert2 == 4) ? clip0.ConvertToYV16() : (wert2 == 5) ? clip0.ConvertToYV12() : (wert2 == 6) ? clip0.ConvertToYV411() : clip0.ConvertToY8()
}


Function Resize (Clip clip1) {
    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 = (AR == 1) ? (((clip1.width * hoehe) / clip1.height > breite) ? Clip1.PointResize(breite, ceil(float(Clip1.height * breite) / clip1.width)) : Clip1.PointResize(ceil(float(clip1.width * hoehe) / clip1.height), hoehe)) : clip1.PointResize(breite, hoehe).ConvertToYV24(matrix = "Rec709", ChromaResample = "Spline16")
    back = (AR == 1) ? (0 == 1) ? ImageReader("", 0, clip1.framecount - 1, clip1.framerate).ChangeFPS(Clip1.frameratenumerator, Clip1.frameratedenominator).PointResize(breite, hoehe).ConvertToYV24(matrix = "Rec709", ChromaResample = "Spline16") : BlankClip(clip1, width = breite, height = hoehe, pixel_type = "YV24").KillAudio() : clip1
    Return (AR == 1) ? Overlay(back, clip1, (back.width - clip1.width) / 2, (back.height - clip1.height) / 2).ConvertToYV24(matrix = "Rec709", ChromaResample = "Spline16") : clip1
}

Den rfactor musste bei nnedi schon höher als 2 setzen, sonst skalierter ja nur x2 und den Rest via Spline16 (da du cshift auf spline16 hast)

Ich habs mal geladen und versuch mich später dran. Nun werd ich aber erstmal selber für neue Videos sorgen.

In der Aufnahme ist massives Interlacing vor der Aufnahme schon enthalten. Das heißt das die Aufnahme auch so erfolgen sollte oder ein Deinterlacer zwischengeschaltet werden muss. Sonst habt ihr diesen ekelhaften Salat dadrin und den bekommt ihr mit keinem Deinterlacer mehr raus.

Also das beste was ich aus dem Video da rausholen konnte @strohi war das hier:

• http://www.mediafire.com/downl…ge_short1440p50_10Bit.mp4
• http://www.mediafire.com/downl…ge_short2400p50_10Bit.mp4

Beide mit xBRZ skaliert.

Dein Problem bei deiner Beispielaufnahme ist einfach das du da Interlacing drin hast und das noch auf eine Art die so nicht passieren darf. Da musste aufpassen. Interlaced Material nicht mit einem Codec aufnehmen der kein Interlaced versteht.

Weil bei deiner Testaufnahme ist es so das du Interlaced Material progressiv aufgenommen hast. Und wenn dann noch Schwankungen in der FPS sind, dann gute Nacht. Dann hilft auch kein Deinterlacer mehr.

Bei den Sachen die ich dir da hochgeladen habe, habe ich jede 2te Zeile entfernt und jede 1te Zeile als Referenz für die 2te Zeile verwendet. Daraus entsteht dann ein Progressiv Bild was einem 4:4:4 Muster entspricht, da nun jede Zeile die genauen Informationen enthält, da du ja eh in YUY2 aufgenommen hast. Das war dein Glück bei dieser Aufnahme.

Für die Zukunft: Entweder die Aufnahme absolut in Progressiv gestalten oder einen Deinterlacer Filter während der Aufnahme verwenden, sofern die Quelle in Interlaced sendet. ODER du nimmst mit einem Codec auf der auch Interlaced anwenden kann. z.B. x264. Prüfe dann am besten auch das die Aufnahmesoftware das dann auch als Interlaced interpretiert und nicht als Vollbild. Weil Interlaced in Progressiv aufzuzeichnen ist Hirnlos. Weil du dann nie die genauen Muster wieder rausfiltern kannst. Und das muss nicht sein.

PS:
Der SSM wurde eigentlich für Progressiv Material vorgesehen. Sollte man VFR oder Interlaced Material haben, so ist im SSM der VFR->CFR gedacht gewesen. Weil dort kann man dann TDeint einsetzen als Deinterlacer und kann sofern die Aufnahme VFR hat auch gleich in CFR umkonvertieren.

Das dazu.

Für's Deinterlacen gibts ja die unterschiedlichsten Filter. Der anspruchsvollste wäre QTGMC. Aber natürlich auch der langsamste dann.
Aber gut: Interlaced ist natürlich ein Detail was nie erwähnt wurde ;-D

UTVideo, MagicYUV würden interlaced Aufnahme beherrschen, aber man muss es denen dann auch sagen.