Adaptive LimitFilter mod (VS)

def AdaptiveLimitFilter(flt, src, mask, thr1=None, thr2=None, thrc=None, elast1=3, elast2=3, elastc=3, mthr1=None, mthr2=None, da1=0, da2=0, lo=None, hi=None):
    core=vs.core
    """
    thrN are the threshold settings when mask<=mthr1 / mask>=mthr2
    da means "dark-adapt", and changes thrN based on hi/lo (pixel luma level),
    positive values for daN raise thrN, so to preserve dark areas you'll want to give it a negative value

    thr1 = thr1+da1 if src<=lo else thr1 if src>=hi else linear interpolate from thr1+da1 to thr1
    thr2 = thr2+da2 if src<=lo else thr2 if src>=hi else linear interpolate from thr2+da2 to thr1

    thr   = thr1 if mask<=mthr1 else thr2 if mask<=mthr2 else linear interpolate from thr1 to thr2
    elast = elast1 if mask<=mthr1 else elast2 if mask<=mthr2 else linear interpolate from elast1 to elast2

    these thr and elast values, adapted per-pixel, are then used the same way as in the mvsfunc LimitFilter

    ### Default values, written as "parameter = 16-bit value(8 bit value)" ###
    thr1 = 128 (0.5) - for 8-bit mask clip: 85.333 (0.333)
    thr2 = 64 (0.25)
    thrc = 128 (0.5) - for 8-bit mask clip: 85.333 (0.333)
    elast1 = 3
    elast2 = 3
    elastc = 3
    mthr1 = 256 (1)
    mthr2 = 512 (2)
    da1 = 0
    da2 = 0
    lo = 4096 (16), or black in limited range
    hi = 15309 (60), or 1/5th of limited range

    ### Usage example: limit 16 bit clip with 8 bit mask ###
    import debandshit as db #https://pastebin.com/NGFBhCCn

    last = 8_bit_input_clip

    thr1 = 0.4
    thr2 = 0.2
    thrc = 0.3
    da1 = -0.1
    da2 = -0.05

    flt = db.f3kdb(last, range=16, y=80, cb=30, depth=16)
    src - fvf.Depth(last, 16)

    mask = db.rangemask(last, 2, 2)
    out_mask = mask.std.Binarize([3,2,2]).rgvs.RemoveGrain([22]*3).rgvs.RemoveGrain([11]*3)

    out = AdaptiveLimitFilter(flt, src, mask, thr1=thr1*256, thr2=thr2*256, thrc=thrc*256, da1=da1*256, da2=da2*256)
    out = out.std.MaskedMerge(src, out_mask)
    """

    f = src.format
    bits = f.bits_per_sample
    isINT = f.sample_type==vs.INTEGER
    brange = 1 << (bits - 1)
    wht_lim = 219 << (bits - 8) if isINT else 1
    blk_lim = 16 << (bits - 8) if isINT else 0

    mf = mask.format
    mbits = mf.bits_per_sample
    mrange = 1 << mbits if mf.sample_type==vs.INTEGER else 1

    thr1 = ( (brange/3 if mbits==8 else brange/2) if isINT else 1/219/3 ) if thr1 is None else thr1
    thr2 = ( brange/4 if isINT else 1/219/4 ) if thr2 is None else thr2
    thrc = ( (brange/3 if mbits==8 else brange/2) if isINT else 1/224/3 ) if thrc is None else thrc
    mthr1 = mrange/256 if mthr1 is None else mthr1
    mthr2 = mrange/128 if mthr2 is None else mthr2
    lo = blk_lim if lo is None else lo
    hi = blk_lim + (wht_lim/5) if hi is None else hi

    diff = ' x y - '

    thr1str = ' y {lo} <= {thr1a} y {hi} >= {thr1} y {lo} - {lr} / {tr} * {thr1a} + ? ? '.format(thr1a=thr1+da1, thr1=thr1, lr=hi-lo, tr=da1*-1, lo=lo, hi=hi)
    thr2str = ' y {lo} <= {thr2a} y {hi} >= {thr2} y {lo} - {lr} / {tr} * {thr2a} + ? ? '.format(thr2a=thr2+da2, thr2=thr2, lr=hi-lo, tr=da2*-1, lo=lo, hi=hi)
    thrstr  = ' '+str(thr1)+' ' if thr1==thr2 and da1==0 and da2==0 else ' z {mthr1} <= {thr1} z {mthr2} >= {thr2} z {mthr1} - {mr} / {tr} * {thr1} + ? ? '.format(mthr1=mthr1, mthr2=mthr2, thr1=thr1, thr2=thr2, mr=mthr2-mthr1, tr=thr2-thr1) if da1==0 and da2==0 else ' z {} <= '.format(mthr1)+thr1str+' z {} >= '.format(mthr2)+thr2str+' z {mthr1} - {mr} / {tr} * '.format(mthr1=mthr1, mr=mthr2-mthr1, tr=thr2-thr1)+thr1str+' + ? ? '
    elaststr = ' '+str(elast1)+' ' if elast1==elast2 else ' z {mthr1} <= {elast1} z {mthr2} >= {elast2} z {mthr1} - {mr} / {er} * {elast1} + ? ? '.format(mthr1=mthr1, mthr2=mthr2, elast1=elast1, elast2=elast2, mr=mthr2-mthr1, er=elast2-elast1)
    alphastr = elaststr+' 1 <= 0 1 '+elaststr+' 1 - '+thrstr+' * /  ? '
    betastr = elaststr+thrstr+' * '
    sexpr = alphastr+diff+' * '+betastr+diff+' abs - * y + ' if elast1>1 or elast2>1 else thrstr+diff+diff+' abs / * y + '
    expr = diff+' abs '+thrstr+' <= x '+diff+' abs '+betastr+' >= y '+sexpr+' ? ? '

    thrcstr  =  ' '+str(thrc)+' '
    elastcstr = ' '+str(elastc)+' '
    alphastrc = ' {} '.format(1/((elastc-1)*thrc))
    betastrc = ' {} '.format(elastc*thrc)
    sexprc = alphastrc+diff+' * '+betastrc+diff+' abs - * y + ' if elastc>1 else thrcstr+diff+diff+' abs / * y + '
    exprc = diff+' abs '+thrcstr+' <= x '+diff+' abs '+betastrc+' >= y '+sexprc+' ? ? '

    return core.std.Expr([flt, src, mask], expr if f.color_family==vs.GRAY else [expr,exprc,exprc])