deint.vpy

import vapoursynth as vs
import functools
from havsfunc import QTGMC

core = vs.core
resize = core.resize
std = core.std

def loadfieldsfm(filename):
    fmap = {}
    arr = []
    with open(filename, 'r') as f:
        for line in f:
            parts = line.split()
            arr.append(parts)
    last_frame = 0
    last_fields = [0]
    last_cycle = 1
    for e in sorted(arr, key=lambda e: e[0]):
        frame = int(e[0])
        fields = [int(f) for f in e[1:]]
        cycle = len(fields)
        for i in range(last_frame, frame):
            field = (i - last_frame) % last_cycle
            fmap[i] = last_fields[field]
        fmap[frame] = fields[0]
        last_frame = frame + 1
        last_fields = fields
        last_cycle = cycle
    return fmap

def deinterlace(v, fmap):
    dec = std.FrameEval(v, functools.partial(decimate, v=v, fmap=fmap))
    ref = core.nnedi3cl.NNEDI3CL(dec, 1, nns=4, qual=1)
    return core.tdm.TDeintMod(dec, 1, edeint=ref)

def decimate(n, v, fmap):
    cycle = 5
    skip = fmap[n] if n in fmap else 0
    frames = []
    for i in range(cycle):
        if i != skip:
            frames.append(i)
    v = std.SeparateFields(v, True)
    v = std.SelectEvery(v, cycle, frames)
    v = std.DoubleWeave(v, True)
    v = std.SelectEvery(v, 2, skip % 2)
    #v = core.text.Text(v, '{} {}'.format(skip, n))
    return v

inp = core.d2v.Source(d2v)
fmap = loadfieldsfm(mapfile)
deint = deinterlace(inp, fmap)
deint = std.AssumeFPS(deint, fpsnum=24000, fpsden=1001)
deint = QTGMC(deint, InputType=1)
deint.set_output()