[Résolu] J'aimerais pouvoir utiliser le filtre de redimensionnement Jinc

Hello

J'ai juste mis à jour un tout petit truc de mon script. J'explique ici (en Anglais) pourquoi :

I want to upscale a Super Nes video in HD - Page 12 - Doom9's Forum

Le sujet complet : I want to upscale a Super Nes video in HD - Page 11 - Doom9's Forum

En gros, j'ai juste remplacé ça :

"pscrn=3"

par ça :

"pscrn=2"


C'est dans la fonction du Nnedi3 ! J'ai fait d'autres tests en essayant de modifier :

"nsize=4"

ou bien :

"nns=3" ou "nns=4"


Mais au final, j'ai trouvé que c'était trop clean et qu'on perdait l'apport du Spline16 qui donne un peu ce côté analogique.

Donc avec le Nnedi3, je garde définitivement ceci :

nnedi3_rpow2(rfactor=2, nsize=0, nns=2, qual=1, etype=0, pscrn=2, threads=0, opt=0, fapprox=0)


Voici les screenshots et les scripts :

Jeux Super Nintendo en 4:3







AviSource()
Spline16Resize(512, 448)
nnedi3_rpow2(rfactor=2, nsize=0, nns=2, qual=1, etype=0, pscrn=2, threads=0, opt=0, fapprox=0)

GaussResize2(5640, 4320, px=50, py=50)
BicubicResize(2820, 2160)
return Last

##################################
function GaussResize2(clip C, int target_width, int target_height,
\ float "src_left", float "src_top", float "src_width", float "src_height",
\ float "px", float "py")
{
px = Default(px, 30.0)
py = Default(py, px)
R = C.GaussResize(target_width, C.Height,
\ src_left, 0, src_width, 0, px)
\ .GaussResize(target_width, target_height,
\ 0, src_top, 0, src_height, py)
return R
}

 

Jeux Super Nintendo en 8:7







AviSource()
Spline16Resize(512, 448)
nnedi3_rpow2(rfactor=2, nsize=0, nns=2, qual=1, etype=0, pscrn=2, threads=0, opt=0, fapprox=0)

GaussResize2(4936, 4320, px=50, py=50)
BicubicResize(2468, 2160)
return Last

##################################
function GaussResize2(clip C, int target_width, int target_height,
\ float "src_left", float "src_top", float "src_width", float "src_height",
\ float "px", float "py")
{
px = Default(px, 30.0)
py = Default(py, px)
R = C.GaussResize(target_width, C.Height,
\ src_left, 0, src_width, 0, px)
\ .GaussResize(target_width, target_height,
\ 0, src_top, 0, src_height, py)
return R
}





Et la vidéo YouTube refaite (à voir en 1080p ou 2160p plein écran si possible) :

 

Et cadeau, d'autres exemples de scripts similaires avec des vidéos de jeux vidéo PS1, PS2 et PC :

AviSource()
ChangeFPS(30)
Spline16Resize(640, 416)
ConvertToRGB24
nnedi3_rpow2(rfactor=2, nsize=0, nns=2, qual=1, etype=0, pscrn=2, threads=0, opt=0, fapprox=0)

GaussResize2(6646, 4320, px=50, py=50)
AddBorders(517, 0, 517, 0)
BicubicResize(3840, 2160)
return Last

##################################
function GaussResize2(clip C, int target_width, int target_height,
\ float "src_left", float "src_top", float "src_width", float "src_height",
\ float "px", float "py")
{
px = Default(px, 30.0)
py = Default(py, px)
R = C.GaussResize(target_width, C.Height,
\ src_left, 0, src_width, 0, px)
\ .GaussResize(target_width, target_height,
\ 0, src_top, 0, src_height, py)
return R
}



AviSource()
ChangeFPS(30)
Spline16Resize(640, 320)
ConvertToRGB24
nnedi3_rpow2(rfactor=2, nsize=0, nns=2, qual=1, etype=0, pscrn=2, threads=0, opt=0, fapprox=0)

GaussResize2(7680, 3840, px=50, py=50)
AddBorders(0, 240, 0, 240)
BicubicResize(3840, 2160)
return Last

##################################
function GaussResize2(clip C, int target_width, int target_height,
\ float "src_left", float "src_top", float "src_width", float "src_height",
\ float "px", float "py")
{
px = Default(px, 30.0)
py = Default(py, px)
R = C.GaussResize(target_width, C.Height,
\ src_left, 0, src_width, 0, px)
\ .GaussResize(target_width, target_height,
\ 0, src_top, 0, src_height, py)
return R
}




AviSource()
ChangeFPS(30)
Spline16Resize(640, 480)
ConvertToRGB24
nnedi3_rpow2(rfactor=2, nsize=0, nns=2, qual=1, etype=0, pscrn=2, threads=0, opt=0, fapprox=0)

GaussResize2(5760, 4320, px=50, py=50)
BicubicResize(2880, 2160)
return Last

##################################
function GaussResize2(clip C, int target_width, int target_height,
\ float "src_left", float "src_top", float "src_width", float "src_height",
\ float "px", float "py")
{
px = Default(px, 30.0)
py = Default(py, px)
R = C.GaussResize(target_width, C.Height,
\ src_left, 0, src_width, 0, px)
\ .GaussResize(target_width, target_height,
\ 0, src_top, 0, src_height, py)
return R
}



AviSource()
Spline16Resize(1280, 960)
ConvertToRGB24
nnedi3_rpow2(rfactor=2, nsize=0, nns=2, qual=1, etype=0, pscrn=2, threads=0, opt=0, fapprox=0)

GaussResize2(5760, 4320, px=50, py=50)
BicubicResize(2880, 2160)
return Last

##################################
function GaussResize2(clip C, int target_width, int target_height,
\ float "src_left", float "src_top", float "src_width", float "src_height",
\ float "px", float "py")
{
px = Default(px, 30.0)
py = Default(py, px)
R = C.GaussResize(target_width, C.Height,
\ src_left, 0, src_width, 0, px)
\ .GaussResize(target_width, target_height,
\ 0, src_top, 0, src_height, py)
return R
}



AviSource()
Spline16Resize(1280, 720)
ConvertToRGB24
nnedi3_rpow2(rfactor=2, nsize=0, nns=2, qual=1, etype=0, pscrn=2, threads=0, opt=0, fapprox=0)

GaussResize2(7680, 4320, px=50, py=50)
BicubicResize(3840, 2160)
return Last

##################################
function GaussResize2(clip C, int target_width, int target_height,
\ float "src_left", float "src_top", float "src_width", float "src_height",
\ float "px", float "py")
{
px = Default(px, 30.0)
py = Default(py, px)
R = C.GaussResize(target_width, C.Height,
\ src_left, 0, src_width, 0, px)
\ .GaussResize(target_width, target_height,
\ 0, src_top, 0, src_height, py)
return R
}



AviSource()
Crop(0, 60, 0, -60)
Spline16Resize(1280, 720)
ConvertToRGB24
nnedi3_rpow2(rfactor=2, nsize=0, nns=2, qual=1, etype=0, pscrn=2, threads=0, opt=0, fapprox=0)

GaussResize2(7680, 4320, px=50, py=50)
BicubicResize(3840, 2160)
return Last

##################################
function GaussResize2(clip C, int target_width, int target_height,
\ float "src_left", float "src_top", float "src_width", float "src_height",
\ float "px", float "py")
{
px = Default(px, 30.0)
py = Default(py, px)
R = C.GaussResize(target_width, C.Height,
\ src_left, 0, src_width, 0, px)
\ .GaussResize(target_width, target_height,
\ 0, src_top, 0, src_height, py)
return R
}



AviSource()
Crop(0, 80, 0, -80)
Spline16Resize(1280, 640)
ConvertToRGB24
nnedi3_rpow2(rfactor=2, nsize=0, nns=2, qual=1, etype=0, pscrn=2, threads=0, opt=0, fapprox=0)

GaussResize2(7680, 4320, px=50, py=50)
BicubicResize(3840, 2160)
return Last

##################################
function GaussResize2(clip C, int target_width, int target_height,
\ float "src_left", float "src_top", float "src_width", float "src_height",
\ float "px", float "py")
{
px = Default(px, 30.0)
py = Default(py, px)
R = C.GaussResize(target_width, C.Height,
\ src_left, 0, src_width, 0, px)
\ .GaussResize(target_width, target_height,
\ 0, src_top, 0, src_height, py)
return R
}

 

J'admire votre entêtement à progresser dans la conversion d'images de jeux anciens, mais je serai curieux de savoir si une seule autre personne sur le forum tire parti de vos expériences.

Olivier

 

@ SuperLumberjack : ça faisait longtemps que tu n'avais plus posté de script "définitif"

 

En tout cas, sur le forum Doom9, il y en a que ça intéresse. Nah !

De toute façon, si on se base sur le réel, le définitif n'est en général que temporaire !

 

Hello les z'amis !

Il y a 2 jours, j'ai découvert un truc ! La plupart des programmes permettant de convertir les vidéos de jeux PS1 en AVI n'affichent en réalité pas les bonnes couleurs. Ça se remarque notamment dans tous ce qui est rouge et orange, qui virent plutôt au orange et jaune.

Pour tout vous dire, je l'avais déjà remarqué il y a longtemps. Mais j'ai fini par me convaincre que c'était une limitation technique de l'époque. De plus, beaucoup de vidéos sur YouTube affichaient ces mêmes couleurs faussées.

Mais pour que tout cela soit plus clair, je vais tout de suite vous montrer la différence en images (couleurs incorrectes/couleurs correctes) :














Bon, il y a évidemment des images où ça frappe beaucoup plus. Là on n'a pratiquement que des couleurs froides

Mais j'ai supprimé les vidéos avec les couleurs faussées entre temps, donc il faudrait carrément que je reparte des fichiers d'origine (je le ferai peut-être plus tard).

Bref, je suppose que vous constatez quand même la différence

Voilà, donc en gros, les screenshots de jeux PS1 ci-dessous n'étaient pas bonnes

Évidemment, pour que ce soit bon, encore fallait-il avoir les bons programmes ! Ben il est là le souci, car les 3/4 que j'ai pu testé ne me donnaient pas les bonnes couleurs (y compris certains émulateurs) ou alors ne me permettaient pas de convertir les vidéos en AVI.

J'avais fini par trouver une méthode en exportant les fichiers STR à partir de PSmplay et les exporter ensuite en AVI grâce à PSXVideo. Le résultat était très bien !

Sauf qu'un gars sur le forum Doom9 m'a proposé un programme encore meilleur !

Il n'est pas simplement meilleur au niveau de la justesse des couleurs et de la propreté de l'image (car oui, il y a moins de défauts d'après ce que j'ai constaté), mais il est aussi plus précis au niveau du framerate (pour certaines vidéos, j'ai obtenu du 14,985 fps au lieu de 15 fps, et franchement, ça a l'air beaucoup plus naturel, surtout avec la fonction d'émulation de la syncho A/V de la PS1) et surtout beaucoup plus simple et rapide pour faire tout le boulot.

Voici le lien du programme : GitHub - m35/jpsxdec: jPSXdec: cross-platform PlayStation 1 audio and video converter

Voici les paramètres que j'ai personnellement appliqué pour l'ensemble des vidéos à extraire (je préfère être au plus proche de ce que c'était à l'origine, donc pas de chroma upscaling) :

 

Encore des comparatifs avant (couleurs incorrectes) /après (couleurs correctes) :

 

Vu que tu passes par Avisynth, pourquoi ne pas utiliser Virtual Dub pour faire l'encodage (et exporter en avi lossless) ? Et ensuite tu compresses en h264 avec n'importe quel encodeur.
Dans Virtual Dub, il faut juste bien faire attention aux réglages d'espace de couleurs dans video, color depth.

Et pour tes vidéos 4/3, je mettrais le AddBorders après le BicubicResize.

 

C'est ce que je fais en fait

Ce que je viens de montrer, c'est uniquement pour extraire les vidéos de jeux PS1. Ensuite, j'ouvre le script AviSynth dans VirtualDub et j'exporte tout en AVI grâce au codec "UtVideo YUV420 BT.709 VCM".

Après, soit je passe par Sony Vegas pour faire du montage et je ressors tout en AVI grâce au même codec (aucune recompression nécessaire, sauf au niveau des transitions, fondus et autres, bref, là où l'image est modifiée) et puis j'encode tout avec Handbrake à la fin, soit j'encode directement avec Handbrake si je n'ai pas besoin de faire de montage.


Pour le AddBorders, c'est vrai, je pourrais le mettre après le BicubicResize. Mais je pars du principe que l'image finale est une image en 4320p qu'ensuite je réduis en 2160p, c'est pour ça que je préfère le mettre avant

De toute façon, le jour où je dois faire une vidéo, je regarderai de toute façon plus attentivement ce qui donne les meilleurs résultats.

 

Je pense que c'est toujours mieux d'éviter de faire un resize sur des bandes noires, rien n'empêche de resizer du 4/3 en HD, même en 4320p, puis de rajouter les bandes noires à la dernière étape.

 

Tu n'as pas tort !

 

Ce n'est pas juste pour le principe, c'est parce que ça peut créer un léger souci : quand on redimensionne une image à une réso supérieure (upscale), les pixels sont mélangés avec les pixels voisins pour en créer d'autres et la limite entre 2 lignes risque de ne plus être tout aussi nette, la première ligne de la bande noire étant répartie sur 2 lignes.
Pour éviter ça, on rajoute les bandes noires après l'upscale (ou le downscale).
Et je me demande s'il n'y aurait pas aussi un léger changement de couleur lors de l'upscale, donc ta bande noire pourrait n'être plus tout à fait noire (différence subtile).

 

Oui, en réalité je sais, mais je t'avoue que j'ai fait ça un peu à la va-vite Trop d'images !

Ce sont des scripts que j'ai dû créer en vitesse juste pour les captures et pour mettre en valeur la logique de ce que je faisais avec différents exemples. Mais sinon, pour les vidéos que je veux réellement upscaler, j'ai stocké mes scripts qui sont béton

Et dans ces derniers, à aucun moment je ne dois ajouter de bandes noires, donc c'est bon

Mais au cas où, oui, je sais bien que t'as raison, et j'écouterai effectivement ton conseil. Merci arnuche !

 

Et quel est l'intérêt de tout cela?