Dependeremos bastante de scripts, por lo que tendremos que importarlos para poder trabajar con ellos. Una vez tenemos el .vpy creado, lo primero que importaremos será vapoursynth:
import vapoursynth as vs
Ahora, para tener más fácil acceso a plugins internos de VapourSynth, declararemos:
core = vs.core
Y para importar scripts, simplemente tendremos que hacer como con vapoursynth:
import fvsfunc as fvf #con “as” estamos indicando el nombre con el que llamaremos al script
También podemos importar una única función:
from fvsfunc import Depth
Por último, también podemos establecer un límite de memoria para el filtrado. Se recomienda establecerlo en 2000 menos de la RAM de la que se dispone. Por ejemplo, yo tengo 16 GiB, así que:
core.max_cache_size = 14000
Importar vídeo
Para importar prácticamente cualquier vídeo utilizaremos L-SMASH-Works. Además, trabajaremos el vídeo en 16 bits, así que usaremos Depth de fvsfunc, mvsfunc, o cualquier otro.
#source
src = core.lsmas.LWLibavSource(r"G:\Encode\.vscode\Scripts\[WEB]\Bocchi the Rock!\src\01.mkv")
video = src #declaramos que “video” es igual a “src”
video = Depth(video, 16) #pasamos el vídeo a 16 bits. Primero llamamos a la función y, dentro de ella, primero ponemos qué pasar a 16 bits, y segundo la profundidad en bits, 16.
Por otro lado, para DVD en los que un mismo vídeo está repartido en varios archivos, tendremos que crear un archivo .d2v para luego poder importarlo como un único vídeo. Para crear el archivo, usaremos D2VWitch. Una vez ejecutado el programa, arrastramos todas las partes que formen el vídeo completo, seleccionamos que extraiga el audio y hacemos click en “Engage”. Cuando haya finalizado, tendremos el audio y un archivo .d2v.
Ahora, de vuelta en VapourSynth, para importar el .d2v pondremos lo siguiente:
src = core.d2v.Source(r"G:\Encode\.vscode\Scripts\[BD-DVD]\Romeo x Juliet\src\01-02\VTS_01_1.d2v")[0:42558]
video = src
video = Depth(video, 16)
Al final, los números que están entre corchetes son los frames de inicio y final+1. Es decir, el episodio comienza en el fotograma 0 y acaba en el 42557. Para el siguiente episodio sería igual:
src = core.d2v.Source(r"G:\Encode\.vscode\Scripts\[BD-DVD]\Romeo x Juliet\src\01-02\VTS_01_1.d2v")[42558:85986]
El episodio empieza cuando acaba el previo, y finaliza en el último fotograma del vídeo, el cual podemos ver en D2VWitch.
Exportar vídeo
Por último, exportaremos el vídeo para procesarlo con x264 o poder previsualizarlo con vs-preview:
#Final
out = video #declaramos “video” como “out”
final = Depth(out, 16) #declaramos “final” como “out” a 16 bits
final.set_output() #establecemos “final” como la salida
El vídeo siempre lo sacaremos a 16 o a 8 bits, ya que son los bits que admite x264 de entrada. En caso de tratar de importar un vídeo a 10 bits, lo convertirá a 16 bits y de nuevo a 10 bits (o a 8, según los bits que hayamos especificado). De esa manera, evitamos conversiones innecesarias.
Descale
Hay una gran cantidad de series que están animadas a resoluciones inferiores, pero que fueron reescaladas a una resolución mayor. En la mayoría de los casos, esto no supondrá mejoras en el vídeo, e incluso hará que se vea peor, por lo que preferiremos devolver el vídeo a su resolución original. ¿Y cómo averiguamos su resolución original? Pues para ello usaremos getnative, que instalaremos mediante pip:
py -m pip install getnative
Ahora, con una captura que hayamos hecho de un fotograma claro con el menor desenfoque posible y sin efectos (o muchos efectos), ejecutamos el siguiente comando, donde %1% es la ruta a la imagen (preferiblemente podemos crear un .bat y arrastar la imagen en él) y --output-dir donde guardará los resultados.
Probará con varios kernels y estimará cuál es la resolución nativa. Dentro del terminal aparecen estas resoluciones, pero preferiblemente iremos a donde ha guardado las gráficas y las revisaremos.
Claramente señala que es 720p, que es la resolución nativa de Sword Art Online, con la cual he probado. Ahora, quedaría probar con distintos kernels y comprobar por cuenta propia cuál se ve mejor. Sin embargo, comprobemos ahora una serie que esté animada a 1080p o a una resolución superior a 900p (o simplemente un mal fotograma de una que sí lo esté).
Aquí podemos observar claramente que no se puede ni debe desescalar. En caso de que tengamos que hacerlo, importaremos la función desde fvsfunc y la usaremos:
from fvsfunc import Despline36M #la “M” ayuda con elementos que sí están en 1080p, como créditos, creando una máscara y escalándolos mediante Spline36
#Descale
descale = Despline36M(videod, 1280, 720)
En ocasiones tendremos que cambiar la resolución del vídeo, como en el caso anterior. Para ello, principalmente usaremos core.resize.[kernel]. Además, la función de resize también nos puede servir para transferir espacios de color y el formato, entre otras cosas. También disponemos de escaladores basados en redes neuronales, que son una buena opción al hacer upscale, como nnedi3_rpow2.
downscale = core.resize.Spline36(video, 1280, 720)
upscale = nnedi3_rpow2(descale, nns=4, qual=2, pscrn=1).resize.Spline64(1920, 1080)
dtl_mask = core.resize.Spline16(mask, format=vs.GRAY16) #cambiar el formato a GRAY16
switch_colorspace = core.resize.Spline16(dvd, transfer_in_s=”709”, matrix_in_s="709") #transferir el espacio de color a 709
Masking
Es muy importante crear máscaras, pues algunos filtros resultan muy destructivos y pueden cargarse los detalles. Con las máscaras buscamos evitar que eso ocurra en la medida de lo posible. Existen muchas máscaras, y también se pueden crear manualmente.
from dhh import mask as dehalo_mask
dh_mask = dehalo_mask(aa, smooth=True, dha=True)
smooth=True: habilita una pequeña protección extra para las líneas.
dha=True: habilita la protección de líneas adyacentes para scripts como Dehalo_alpha.
lvsfunc.mask.detail_mask
Es una máscara para detalle, a usar cuando se hace denoise/deband.
from lvsfunc import mask as lvfmask
deband_mask = lvfmask.detail_mask(video, rad=1, brz_a=0.025, brz_b=0.039)
deband_mask = lvfmask.detail_mask_neo(masked_dehalo, detail_brz=1000, lines_brz=2750) #variante que trata de conservar el mayor detalle posible
brz_a/detail_brz: binarización del detalle.
brz_b/lines_brz: binarización de bordes.
retinex_edgemask
Otra máscara de detalle, pero con más precisión en escenas con poco brillo.
from kagefunc import retinex_edgemask
dtl_mask = retinex_edgemask(video)
MaskedMerge
Lo usaremos para juntar dos vídeos mediante una máscara. El primer valor será el vídeo filtrado, el segundo el vídeo antes de ese filtro (o ese filtro pero más suave) y lo último la máscara.
Este suele ser el punto más complicado, pues conseguir un buen equilibrio entre conservar detalle e intentar que el aliasing “desaparezca” es muy tedioso. La función preferida para esto es xaa, aunque hay quienes crean la suya propia. La descargaremos de aquí.
from xaa import *
aa = xaa(video, mode=”di3 nnedi3cl”, mask=1, nns=4, mthr=8)
mode:
AA: sr (single rate), dr (double rate) o di (doubled image).
Pasadas: el número de pasadas que realizará (de 1 a 9).
Tipo: el plugin de antialiasing a utilizar (SangNom, znedi3, nnedi3cl, eedi3, eedi2).
mask: 0 (procesa el fotograma al completo), 1 (procesa solo los bordes) o 2 (procesa todo menos los bordes).
nns: valores mayores suponen mayor calidad (de 0 a 4).
mthr: el umbral de la máscara de detalle. Cuando mask es 1, valores menores resultan en más bordes procesados, y cuando es 2, menos bordes excluidos.
edge_cleaner (sirve para limpiar los bordes, como el nombre indica):
hot: aplica “repair” de rgtools.
smode: crea una máscara de detalle.
Deringing
from havsfunc import HQDeringmod
dering = HQDeringmod(video, mthr=24)
mthr: umbral de la máscara de detalle. Valores menores implican un procesamiento más agresivo y más ringing siendo interpretado como borde, lo que impide que sea procesado.
Denoise
Las funciones más normales a usar son BM3D y KNLMeansCL, empleadas normalmente juntas (BM3D para el plano Y y KNLMeansCL para los planos UV).
from lvsfunc import mask as lvfmask
from vsutil import get_y
from mvsfunc import BM3D
from muvsfunc import MergeChroma
from vardefunc import noise, decsiz
#Denoise
d_mask = lvfmask.detail_mask(video, sigma=2, rad=1, brz_a=0.026, brz_b=0.0023)
luma = get_y(dehaloed) #extraemos el plano Y
denoise_Y = BM3D(luma, radius1=1, profile1='fast', sigma=[2.5,0.0,0.0]) #aplicamos denoise a Y
denoise_UV = core.knlm.KNLMeansCL(dehaloed, d=2, a=3, h=0.4, device_type='gpu', device_id=0, channels="UV") #aplicamos denoise a los planos UV
denoise = MergeChroma(denoise_Y, denoise_UV) #juntamos el plano Y con los planos UV
denoised = core.std.MaskedMerge(denoise, dehaloed, d_mask)
BM3D:
radius1: radio temporal para la estimación básica (0 para espacial y 1-16 para espacio-temporal).
profile1: el perfil a utilizar
fast (rápido)
lc (baja complejidad)
np (normal)
high (alto)
vn (mucho ruido)
sigma: la intensidad del filtro ([Y, U, V]).
KNLMeansCL:
d: el número de fotogramas pasados y futuros que puede usar como referencia.
a: el radio de búsqueda (0=1 píxel, 1=9 píxeles, etc.).
h: la intensidad del filtro.
device_type: el dispositivo a usar con OpenCL (accelerator, cpu, gpu o auto).
device_id: 0 para seleccional el primer dispositivo correspondiente a device_type (o 1 para el segundo si, por ejemplo, se tienen dos GPU).
channels: los planos a procesar (auto, YUV, Y, UV o RGB) (las gráficas de AMD solo trabajan con los planos UV).
decsiz
Una función para aumentar la compresibilidad difuminando el ruido invisible que se encuentre por encima de max_in manteniéndolo por debajo de min_in.
El desentrelazado y el detelecine son algo muy extenso. No hay una solución mágica para todo; hay que jugar mucho e investigar para poder desentrelazar correctamente el vídeo. En el siguiente script, tuve que dividir el vídeo en tres partes (episodio, ending y avance) y aplicar un método distino a cada una para luego volver a unirlas.
