Produktionsauflösung herausfinden & skalieren

Anime werden oftmals Bikubisch oder Bilinear in 1080p hochskaliert. Wenn man Pech hat, ist es Bikubisch mit Überschärfe (lässt sich aber noch relativ einfach beheben) oder ein Field-Upscale (lässt sich mit ein wenig Mühe beheben).
Wenn man besonders Pech hat, ist es Nächster Nachbar/Nearest Neighbour mit noch paar unbekannten Zeugs und sofern ihr kein Encode-Gott seid, ist jede Hoffnung verloren.
Nur weil dort 1920×1080 steht, muss es der Anime nicht wirklich sein!
Heutzutage beträgt die Produktionsauflösung oft 1280×720, weshalb manche Encoder diese 720p Hi444PP encoden und keine 1080p anbieten.
Texte oder andere Overlays in Anime liegen jedoch meistens in 1920×1080 vor, weshalb es da zu Unschönheiten kommen kann, wenn man nichts dagegen tut. Aber dazu später mehr.

 

Wie finde ich die Produktionsauflösung heraus?

Nachlesen:
1) http://anibin.blogspot.jp/ (Automatisiert, kann ungenau sein)

2) „Find_ProductionResolution.bat“ (liegt im Encode-Pack bei) nutzen

3) Manuell über Avisynth + avspmod:

#w/h ändern, immer -2 runtergehen und Vergleiche mit der Source machen
w=1920
h=1080
#Zu 99% liegt ein Bilinear oder Bicubic Upscale vor
#(wenn die Produktionsauflösung nicht 1920x1080 ist)
#Muss man also ebenfalls durchtesten
#Debilinear(w, h).BilinearResize(1920,1080)
#Debicubic(w, h).BicubicResize(1920,1080)

Wie erkenne ich, ob jetzt Bikubisch oder Bilinear skaliert wurde?

Erfahrene Encoder erkennen das ohne gewisse Techniken. Man erkennt es einfach (unten sind auch Bilder verlinkt, damit man diese mal sehen kann).
Anfänger hingegen tun sich da ein wenig schwer, weshalb es da ein paar Tricks gibt.

(Beispielweise mit Produktionsauflösung 1280×720)
w=1280
h=720

Upscale herausfinden:
– Screenshot von der Source
– Screenshot von „Debilinear(w,h).BilinearResize(1920,1080)“
– Screenshot von „Debicubic(w,h).BicubicResize(1920,1080)“
Welches sieht der Source identisch aus?

Findet eine Überschärfung statt?
– Screenshot von der Source
– Screenshot von „Debicubic(w,h,b=0,c=1).BicubicResize(1920,1080)“
Ist die Überschärfung behoben?

Findet eine Ünterschärfung statt?
– Screenshot von der Source
– Screenshot von „Debicubic(w,h,b=1,c=0).BicubicResize(1920,1080)“
Ist die Ünterschärfung behoben?

Ist evtl. die Farbe Rot/Orange das Problem?
Das liegt daran, dass kein Hi444PP genutzt wird bzw. Chroma nicht getrennt von Luma skaliert wird. Kann man für diesen Test ignorieren.

Ist es nicht und es ist noch immer nicht behoben:
– Es liegt ein Field-Upscale vor (unten schauen für mehr Infos)
– Screenshot von „PointResize(w,h,1,1).PointResize(1920,1080)“
– Die Source hat eine höhere Produktionsauflösung oder wurde nachgeschärft
– Es liegt eine Mischung aus mehreren Upscales vor
– Es ist ein Upscle mit viel Schärfe (dann „DeOS16(1280,720)“ nutzen)

Bei einer Mischung von mehreren Upscales bei verschiedenen Frames:
– Szenenfiltern (siehe „Und wenn z.B. Ending anders skaliert wurde als der Rest?“)
– ConditionalResize() probieren
– SplineMod() oder OS_Bilinear() testen

 

Doch wie skaliert man jetzt richtig runter?

Bikubisch Upscale:

Debicubic(x,y)

Bilinear Upscale:

Debilinear(x,y)

Bikubisch Upscale (mit Überschärfe):

Debicubic(x,y,b=0,c=1)

Nearest Neighbour Upscale:

PointResize(x,y,1,1)

Field-Upscale:

even = separatefields().selecteven().debilinear(1280,360)
odd = separatefields().selectodd().debilinear(1280,360)
interleave(even,odd).weave()

Sofern man Chroma anders skalieren will, dann folgendes (dieses ist ja nicht hochskaliert worden):

ly = DebicubicY(1280,720)
lu = utoy().dither_resize16(1920/2,1080/2,kernel="blackman",u=1,v=1)
lv = vtoy().dither_resize16(1920/2,1080/2,kernel="blackman",u=1,v=1)
ytouv(lu,lv,ly)

Und wenn z.B. Ending anders skaliert wurde als der Rest?

a = Debicubic(1280, 720)
b= Debilinear(1280, 720)
ReplaceFramesSimple(a, b, mappings="[31767 33924]")

Alles wird mit „a“ skaliert, außer …
Die Szenen von 31767 bis 33924, diese werden mit „b“ skaliert.

Man kann das ganze auch ein wenig weiter ausbauen, wenn es mehrere Szenen im Anime sind und nicht nur das Opening/Ending:

mappings="[1120 1270][1343 1646][1736 1758][21944 22217][22480 22777][22867 22950][24018 24443][30990 35049]"

Sollte ich das bei einer TV-Version/Airing-Source ebenfalls tun?

Bedingt. Bei einer guten Source, ja  (wäre z.B. Crunchyroll in den meisten Fällen).
Bei einer eher schlechteren Source wohl weniger.
Methoden wie Debilinear/Debicubic polieren die Artefakte einer schlechten Source mit und machen das Bild eher schlechter als gut.

Was wäre denn bei einer TV-Version/Airing-Source die Alternative?

[16-Bit]:

Bicubic (modifiziert):

BicubicMod16(1280,720)

Gauss (modifiziert):

GaussMod16(1280,720)

Spline16 (modifiziert) aka „SplineMod“:

SplineMod16(1280,720)

Bei Bicubic a1/a2-Wert je nach Source ändern.
Bei Gauss a1-Wert je nach Source ändern
SplineMod liefert im Gesamten zuverlässige Ergebnisse ab.

[8-Bit]:

Spline36Resize(1280,720)

Aber was ist eigentlich mit modernen DVDs, liegt da die Auflösung nicht höher?

Ja, das tut sie. Moderne DVDs werden höher produziert und dann für die DVD runterskaliert. Natürlich kann man verlorene Details nicht mehr herstellen. Jedoch kann man die DVD wenigstens ein wenig ansehlicher machen.

[16-Bit]:

nnedi3_rpow2(2).Dither_convert_8_to_16().Dither_resize16(1024,576,kernel="spline16",invks=true, invkstaps=6)
Dither_convert_8_to_16().nnedi3_resize16(1024,576,kernel_u="Spline16",kernel_d="Spline16",invks_u=false,invks_d=true,invkstaps=6,lsb_in=true,lsb=true)

[8-Bit]:

nnedi3_rpow2(2).Spline36Resize(1024,576) #langsam
nnedi3_resize16(1024,576,kernel_u="Spline16",kernel_d="Spline16",invks_u=false,invks_d=true,invkstaps=6,lsb_in=false,lsb=false) #schnell

Aber was ist jetzt mit Texten/Overlays, welche 1920×1080 sind?

Bikubisch Upscale:

DebicubicM(x,y)

Bilinear Upscale:

DebilinearM(x,y)

Bikubisch Upscale (mit Überschärfe):

DebicubicM(x,y,b=0,c=1)

(Per Masking wird 1920×1080 Text via Spline16 runterskaliert)

Und… wenn die Produktionsauflösung z.B. 876p oder 914p ist?

So releasen wäre ja komisch. Dann solltest du entweder einen 900p Release (1. Fall) oder 1080p (2. Fall) machen.

(1. Fall hier als Beispiel)
Dafür kann man sich nnedi3 herholen:

Debicubic(x,y) #Auf Produktionsauflösung skalieren
nnedi3_resize16(1600,900,kernel_u="Spline16",kernel_d="Spline16",invks_u=false,invks_d=true,invkstaps=6,lsb_in=false,lsb=false)
MergeChroma(sourcefix)
sourcefix = LWLibavVideoSource("I:\Sub\Encode\test.m2ts").BlackmanResize(1600,900)
MergeChroma(sourcefix)

(2. Fall hier als Beispiel)
Dafür kann man sich nnedi3 herholen:

Debicubic(x,y) #Auf Produktionsauflösung skalieren
nnedi3_resize16(1920,1080,kernel_u="Spline16",kernel_d="Spline16",invks_u=false,invks_d=true,invkstaps=6,lsb_in=false,lsb=false)
unberuehrte1080psource = LWLibavVideoSource("I:\Sub\Encode\test.m2ts")
MergeChroma(unberuehrte1080psource)

Eine Alternative wäre nur die Konturen zu skalieren (gibt es auch bei  „resizer=“ in gradfun3mod).
Bikubisch Upscale:

lineart_rpow2(x,y,1920,1080,bicubic=true)

Bilinear Upscale:

lineart_rpow2(x,y,1920,1080,bicubic=false)

Und was ist, wenn man mit 16bit arbeitet?

Da kann man einfach die Option „resizer=“ in gradfun3mod nutzen + lsb=true).
Möchte man dies aber manuell machen, bietet sich folgendes an:

Dither_convert_8_to_16()

und dann:
Bikubisch Upscale:

Debicubic16(w,h,lsb_inout=true, b=b, c=c)
Debicubic16M(w,h,lsb_inout=true, b=b, c=c) # Mit Maske für 1080p Credits

Bilinear Upscale:

Debilinear(x,y,lsb_inout=true)
DebilinearM(x,y,lsb_inout=true) # Mit Maske für 1080p Credits

Bikubisch Upscale (mit Überschärfe):

Debicubic16(w,h,lsb_inout=true, b=0, c=1)

Field-Upscale:

FieldMod16(x,y,crco=0.25) #crco = Die Verschiebung, muss auf die Source angepasst werden

Und das ganze mit zurück auf 1080p (sofern man möchte):

nnedi3_resize16(1920,1080,kernel_u="Spline16",kernel_d="Spline16",invks_u=true,invks_d=false,invkstaps=6,lsb_in=true,lsb=true)
unberuehrte1080psource = LWLibavVideoSource("I:\Sub\Encode\test.m2ts").Dither_convert_8_to_16()
MergeChroma(unberuehrte1080psource)

Hier ein Beispiel mit zurück auf 900p:

nnedi3_resize16(1600,900,kernel_u="Spline16",kernel_d="Spline16",invks_u=true,invks_d=false,invkstaps=6,lsb_in=true,lsb=true)
sourcefix = LWLibavVideoSource("I:\Sub\Encode\test.m2ts").Dither_convert_8_to_16().Dither_resize16(1600,900,kernel="spline16",invks=true, invkstaps=6)
MergeChroma(sourcefix)

Hinweis zu MergeChroma:

Da man das Chroma ziemlich beschädigt hat mit dem Downscale, wird das unangefasste Chroma genommen. (Im Falle von 900p ein etwas beschädigtes Chroma,
kann nur im Fall von Hi444PP unbeschädigt bleiben)

Hinweis zu Bikubisch:

Der Parameter b regelt die Schärfe, der c die Unschärfe (Debicubic).

Hinweis zu Gauss:

Der Parameter p regelt die Unschärfe (kleiner Wert)/Schärfe (hoher Wert).

Beispiele
(Rechtsklick -> „Bild in neuem Tab öffnen“ -> „?w=1216“ entfernen):

Bicubic

Beispiel eines bikubischen Upscales

Bilinear

Beispiel eines bilinearen Upscales

Bicubic b0, c1

Beispiel eines bikubischen Upscales (mit Überschärfe)

fieldupscale

Beispiel eines Field-Upscales

Nearest Neighbour

Beispiel eines Nearest Neighbour Upscales + ???