Frames interpolation ?

[lisztfr9]

Hi all,

There was a frame interpolation script or program which could replace, if i recall until 5-7 frames ?

For the moment i can only remember Badframes, and MvTools, but there was another one...

(Btw i think that badframes could be used for jerky videos, when just 1 frame is displaced)

Thanks, L

[Jenyok]

Wait a moment.
Include 10 continious frames restored.
.
Would be 8 parts.
Part 1
.

#
# Constants
#
ColorWhite = $FFFFFF
#
isDebug = false
#isDebug = true



LoadPlugin("C:\PROGRAM FILES\AVISYNTH 2.5\PLUGINS\MVTOOLS-V2_5_11_3\mvtools2.dll")





AVISource("Programma_A_Part1_01.avi")



ConvertToYUY2()


# Для отладки фильтров часть 1
# Only for debbuging part 1
#
SourceView = (isDebug == true) ? last.AddBorders(0, 0, 8, 0, Color=ColorWhite) : last



Audio=GetChannel(last, 1, 2)
KillAudio()


# Чтобы восстановить испорченные кадры интерполяцией c MFlowInter
# Restore bad frames with MFlowInter
#
#
# function MSuper(clip, int "hpad", int "vpad", int "pel", int "levels", bool "chroma", \
# int "sharp", int "rfilter", clip "pelclip", bool "isse", bool "planar")
#
super = MSuper(last, \
hpad = 4, \
vpad = 4, \
pel = 2, \
levels = 0, \
chroma = true, \
sharp = 0, \
rfilter = 4, \
isse = true, \
planar = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
backward_vectors1 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = true, \
lambda = 0, \
chroma = true, \
delta = 2, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
forward_vectors1 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = false, \
lambda = 0, \
chroma = true, \
delta = 2, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
backward_vectors2 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = true, \
lambda = 0, \
chroma = true, \
delta = 3, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
forward_vectors2 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = false, \
lambda = 0, \
chroma = true, \
delta = 3, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
backward_vectors3 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = true, \
lambda = 0, \
chroma = true, \
delta = 4, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
forward_vectors3 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = false, \
lambda = 0, \
chroma = true, \
delta = 4, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

[Jenyok]

Would be 8 parts.
Part 2
.

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
backward_vectors4 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = true, \
lambda = 0, \
chroma = true, \
delta = 5, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
forward_vectors4 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = false, \
lambda = 0, \
chroma = true, \
delta = 5, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
backward_vectors5 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = true, \
lambda = 0, \
chroma = true, \
delta = 6, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
forward_vectors5 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = false, \
lambda = 0, \
chroma = true, \
delta = 6, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
backward_vectors6 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = true, \
lambda = 0, \
chroma = true, \
delta = 7, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
forward_vectors6 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = false, \
lambda = 0, \
chroma = true, \
delta = 7, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

[Jenyok]

Would be 8 parts.
Part 3
.

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
backward_vectors7 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = true, \
lambda = 0, \
chroma = true, \
delta = 8, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
forward_vectors7 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = false, \
lambda = 0, \
chroma = true, \
delta = 8, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
backward_vectors8 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = true, \
lambda = 0, \
chroma = true, \
delta = 9, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
forward_vectors8 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = false, \
lambda = 0, \
chroma = true, \
delta = 9, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
backward_vectors9 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = true, \
lambda = 0, \
chroma = true, \
delta = 10, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
forward_vectors9 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = false, \
lambda = 0, \
chroma = true, \
delta = 10, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

[Jenyok]

Would be 8 parts.
Part 4
.

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
backward_vectors10 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = true, \
lambda = 0, \
chroma = true, \
delta = 11, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
forward_vectors10 = MAnalyse(super, \
blksize = 8, \
blksizeV = 8, \
levels = 0, \
search = 4, \
searchparam = 2, \
pelsearch = 2, \
isb = false, \
lambda = 0, \
chroma = true, \
delta = 11, \
truemotion = true, \
lsad = 1200, \
plevel = 0, \
global = true, \
pnew = 50, \
pzero = 50, \
pglobal = 0, \
overlap = 0, \
overlapV = 0, \
dct = 0, \
divide = 0, \
sadx264 = 0, \
badSAD = 10000, \
badrange = 24, \
isse = true, \
meander = true, \
temporal = false, \
trymany = false)


# function MFlowInter(clip source, clip super, clip mvbw, clip mvfw, float "time", float "mL", bool "blend", \
# int "thSCD1", int "thSCD2", bool "isse", bool "planar")
#
global interOne = MFlowInter(last, \
super, \
backward_vectors1, \
forward_vectors1, \
time = 50, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interPair1 = MFlowInter(last, \
super, \
backward_vectors2, \
forward_vectors2, \
time = 33.3, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interPair2 = MFlowInter(last, \
super, \
backward_vectors2, \
forward_vectors2, \
time = 66.7, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interThree1 = MFlowInter(last, \
super, \
backward_vectors3, \
forward_vectors3, \
time = 25, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interThree2 = MFlowInter(last, \
super, \
backward_vectors3, \
forward_vectors3, \
time = 50, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interThree3 = MFlowInter(last, \
super, \
backward_vectors3, \
forward_vectors3, \
time = 75, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interFour1 = MFlowInter(last, \
super, \
backward_vectors4, \
forward_vectors4, \
time = 20, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interFour2 = MFlowInter(last, \
super, \
backward_vectors4, \
forward_vectors4, \
time = 40, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interFour3 = MFlowInter(last, \
super, \
backward_vectors4, \
forward_vectors4, \
time = 60, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interFour4 = MFlowInter(last, \
super, \
backward_vectors4, \
forward_vectors4, \
time = 80, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interFive1 = MFlowInter(last, \
super, \
backward_vectors5, \
forward_vectors5, \
time = 16.66, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interFive2 = MFlowInter(last, \
super, \
backward_vectors5, \
forward_vectors5, \
time = 33.32, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interFive3 = MFlowInter(last, \
super, \
backward_vectors5, \
forward_vectors5, \
time = 49.98, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interFive4 = MFlowInter(last, \
super, \
backward_vectors5, \
forward_vectors5, \
time = 66.64, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interFive5 = MFlowInter(last, \
super, \
backward_vectors5, \
forward_vectors5, \
time = 83.34, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

[Jenyok]

Would be 8 parts.
Part 5
.

global interSix1 = MFlowInter(last, \
super, \
backward_vectors6, \
forward_vectors6, \
time = 14.29, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interSix2 = MFlowInter(last, \
super, \
backward_vectors6, \
forward_vectors6, \
time = 28.58, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interSix3 = MFlowInter(last, \
super, \
backward_vectors6, \
forward_vectors6, \
time = 42.87, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interSix4 = MFlowInter(last, \
super, \
backward_vectors6, \
forward_vectors6, \
time = 57.16, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interSix5 = MFlowInter(last, \
super, \
backward_vectors6, \
forward_vectors6, \
time = 71.45, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interSix6 = MFlowInter(last, \
super, \
backward_vectors6, \
forward_vectors6, \
time = 85.71, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interSeven1 = MFlowInter(last, \
super, \
backward_vectors7, \
forward_vectors7, \
time = 12.5, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interSeven2 = MFlowInter(last, \
super, \
backward_vectors7, \
forward_vectors7, \
time = 25, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interSeven3 = MFlowInter(last, \
super, \
backward_vectors7, \
forward_vectors7, \
time = 37.5, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interSeven4 = MFlowInter(last, \
super, \
backward_vectors7, \
forward_vectors7, \
time = 50, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interSeven5 = MFlowInter(last, \
super, \
backward_vectors7, \
forward_vectors7, \
time = 62.5, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interSeven6 = MFlowInter(last, \
super, \
backward_vectors7, \
forward_vectors7, \
time = 75, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interSeven7 = MFlowInter(last, \
super, \
backward_vectors7, \
forward_vectors7, \
time = 87.5, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interEight1 = MFlowInter(last, \
super, \
backward_vectors8, \
forward_vectors8, \
time = 11.11, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interEight2 = MFlowInter(last, \
super, \
backward_vectors8, \
forward_vectors8, \
time = 22.22, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interEight3 = MFlowInter(last, \
super, \
backward_vectors8, \
forward_vectors8, \
time = 33.33, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interEight4 = MFlowInter(last, \
super, \
backward_vectors8, \
forward_vectors8, \
time = 44.44, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interEight5 = MFlowInter(last, \
super, \
backward_vectors8, \
forward_vectors8, \
time = 55.55, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interEight6 = MFlowInter(last, \
super, \
backward_vectors8, \
forward_vectors8, \
time = 66.66, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interEight7 = MFlowInter(last, \
super, \
backward_vectors8, \
forward_vectors8, \
time = 77.77, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interEight8 = MFlowInter(last, \
super, \
backward_vectors8, \
forward_vectors8, \
time = 88.89, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

[Jenyok]

Would be 8 parts.
Part 6
.

global interNine1 = MFlowInter(last, \
super, \
backward_vectors9, \
forward_vectors9, \
time = 10, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interNine2 = MFlowInter(last, \
super, \
backward_vectors9, \
forward_vectors9, \
time = 20, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interNine3 = MFlowInter(last, \
super, \
backward_vectors9, \
forward_vectors9, \
time = 30, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interNine4 = MFlowInter(last, \
super, \
backward_vectors9, \
forward_vectors9, \
time = 40, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interNine5 = MFlowInter(last, \
super, \
backward_vectors9, \
forward_vectors9, \
time = 50, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interNine6 = MFlowInter(last, \
super, \
backward_vectors9, \
forward_vectors9, \
time = 60, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interNine7 = MFlowInter(last, \
super, \
backward_vectors9, \
forward_vectors9, \
time = 70, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interNine8 = MFlowInter(last, \
super, \
backward_vectors9, \
forward_vectors9, \
time = 80, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interNine9 = MFlowInter(last, \
super, \
backward_vectors9, \
forward_vectors9, \
time = 90, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interTen1 = MFlowInter(last, \
super, \
backward_vectors10, \
forward_vectors10, \
time = 9.09, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interTen2 = MFlowInter(last, \
super, \
backward_vectors10, \
forward_vectors10, \
time = 18.18, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interTen3 = MFlowInter(last, \
super, \
backward_vectors10, \
forward_vectors10, \
time = 27.27, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interTen4 = MFlowInter(last, \
super, \
backward_vectors10, \
forward_vectors10, \
time = 36.36, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interTen5 = MFlowInter(last, \
super, \
backward_vectors10, \
forward_vectors10, \
time = 45.45, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interTen6 = MFlowInter(last, \
super, \
backward_vectors10, \
forward_vectors10, \
time = 54.54, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interTen7 = MFlowInter(last, \
super, \
backward_vectors10, \
forward_vectors10, \
time = 63.63, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interTen8 = MFlowInter(last, \
super, \
backward_vectors10, \
forward_vectors10, \
time = 72.72, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interTen9 = MFlowInter(last, \
super, \
backward_vectors10, \
forward_vectors10, \
time = 81.81, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

global interTen10 = MFlowInter(last, \
super, \
backward_vectors10, \
forward_vectors10, \
time = 90.91, \
mL = 70, \
blend = true, \
thSCD1 = 1500, \
thSCD2 = 130, \
isse = true, \
planar = false) # mL = 70

[Jenyok]

Would be 8 parts.
Part 7
.

function OneFrame(clip clp, int N)
{
# N is number of the frame in Source that needs replacing.
# Frame N will be replaced.

clp.trim(0, N - 1) ++ interOne.trim(N - 1, -1) ++ clp.trim(N + 1, 0)
}

function OneBackFrame(clip clp, int N)
{
# N is number of the frame in Source that needs replacing.
# Frame N will be replaced.

clp.trim(0, N - 1) ++ interOne.trim(N + 1, -1) ++ clp.trim(N + 1, 0)
}

function PairFrames(clip clp, int N)
{
# N is number of the first frame in Source that needs replacing.
# Frames N and N + 1 (O) will be replaced.

clp.trim(0, N - 1) ++ interPair1.trim(N - 1, -1) ++ interPair2.trim(N - 1, -1) ++ clp.trim(N + 2, 0)
}

function PairBackFrames(clip clp, int N)
{
# N is number of the first frame in Source that needs replacing.
# Frames N - 2 and N - 1 (O) will be replaced.

clp.trim(0, N - 3) ++ interPair1.trim(N, -1) ++ interPair2.trim(N, -1) ++ clp.trim(N, 0)
}

function ThreeFrames(clip clp, int N)
{
# N is number of the first frame in Source that needs replacing.
# Frames N and N + 1 and N + 2 (O) will be replaced.

clp.trim(0, N - 1) ++ interThree1.trim(N - 1, -1) ++ interThree2.trim(N - 1, -1) ++ \
interThree3.trim(N - 1, -1) ++ clp.trim(N + 3, 0)
}

function ThreeBackFrames(clip clp, int N)
{
# N is number of the last frame in Source that needs replacing.
# Frames N - 3 and N - 2 and N - 1 (O) will be replaced.

clp.trim(0, N - 4) ++ interThree1.trim(N, -1) ++ interThree2.trim(N, -1) ++ \
interThree3.trim(N, -1) ++ clp.trim(N, 0)
}

function FourFrames(clip clp, int N)
{
# N is number of the first frame in Source that needs replacing.
# Frames N and N + 1 and N + 2 and N + 3 (O) will be replaced.

clp.trim(0, N - 1) ++ interFour1.trim(N - 1, -1) ++ interFour2.trim(N - 1, -1) ++ \
interFour3.trim(N - 1, -1) ++ interFour4.trim(N - 1, -1) ++ clp.trim(N + 4, 0)
}

function FourBackFrames(clip clp, int N)
{
# N is number of the last frame in Source that needs replacing.
# Frames N - 4 and N - 3 and N - 2 and N - 1 (O) will be replaced.

clp.trim(0, N - 5) ++ interFour1.trim(N, -1) ++ interFour2.trim(N, -1) ++ \
interFour3.trim(N, -1) ++ interFour4.trim(N, -1) ++ clp.trim(N, 0)
}

function FiveFrames(clip clp, int N)
{
# N is number of the first frame in Source that needs replacing.
# Frames N and N + 1 and N + 2 and N + 3 and N + 4 (O) will be replaced.

clp.trim(0, N - 1) ++ interFive1.trim(N - 1, -1) ++ interFive2.trim(N - 1, -1) ++ \
interFive3.trim(N - 1, -1) ++ interFive4.trim(N - 1, -1) ++ interFive5.trim(N - 1, -1) ++ \
clp.trim(N + 5, 0)
}

function FiveBackFrames(clip clp, int N)
{
# N is number of the last frame in Source that needs replacing.
# Frames N - 5 and N - 4 and N - 3 and N - 2 and N - 1 (O) will be replaced.

clp.trim(0, N - 6) ++ interFive1.trim(N, -1) ++ interFive2.trim(N, -1) ++ \
interFive3.trim(N, -1) ++ interFive4.trim(N, -1) ++ interFive5.trim(N, -1) ++ \
clp.trim(N, 0)
}

function SixFrames(clip clp, int N)
{
# N is number of the first frame in Source that needs replacing.
# Frames N and N + 1 and N + 2 and N + 3 and N + 4 and N + 5 (O) will be replaced.

clp.trim(0, N - 1) ++ interSix1.trim(N - 1, -1) ++ interSix2.trim(N - 1, -1) ++ \
interSix3.trim(N - 1, -1) ++ interSix4.trim(N - 1, -1) ++ interSix5.trim(N - 1, -1) ++ \
interSix6.trim(N - 1, -1) ++ clp.trim(N + 6, 0)
}

function SixBackFrames(clip clp, int N)
{
# N is number of the last frame in Source that needs replacing.
# Frames N - 6 and N - 5 and N - 4 and N - 3 and N - 2 and N - 1 (O) will be replaced.

clp.trim(0, N - 7) ++ interSix1.trim(N, -1) ++ interSix2.trim(N, -1) ++ \
interSix3.trim(N, -1) ++ interSix4.trim(N, -1) ++ interSix5.trim(N, -1) ++ \
interSix6.trim(N, -1) ++ clp.trim(N, 0)
}

function SevenFrames(clip clp, int N)
{
# N is number of the first frame in Source that needs replacing.
# Frames N and N + 1 and N + 2 and N + 3 and N + 4 and N + 5 and N + 6 (O) will be replaced.

clp.trim(0, N - 1) ++ interSeven1.trim(N - 1, -1) ++ interSeven2.trim(N - 1, -1) ++ \
interSeven3.trim(N - 1, -1) ++ interSeven4.trim(N - 1, -1) ++ interSeven5.trim(N - 1, -1) ++ \
interSeven6.trim(N - 1, -1) ++ interSeven7.trim(N - 1, -1) ++ clp.trim(N + 7, 0)
}

function SevenBackFrames(clip clp, int N)
{
# N is number of the last frame in Source that needs replacing.
# Frames N - 7 and N - 6 and N - 5 and N - 4 and N - 3 and N - 2 and N - 1 (O) will be replaced.

clp.trim(0, N - 8) ++ interSeven1.trim(N, -1) ++ interSeven2.trim(N, -1) ++ \
interSeven3.trim(N, -1) ++ interSeven4.trim(N, -1) ++ interSeven5.trim(N, -1) ++ \
interSeven6.trim(N, -1) ++ interSeven7.trim(N, -1) ++ clp.trim(N, 0)
}

function EightFrames(clip clp, int N)
{
# N is number of the first frame in Source that needs replacing.
# Frames N and N + 1 and N + 2 and N + 3 and N + 4 and N + 5 and N + 6
# and N + 7 (O) will be replaced.

clp.trim(0, N - 1) ++ interEight1.trim(N - 1, -1) ++ interEight2.trim(N - 1, -1) ++ \
interEight3.trim(N - 1, -1) ++ interEight4.trim(N - 1, -1) ++ interEight5.trim(N - 1, -1) ++ \
interEight6.trim(N - 1, -1) ++ interEight7.trim(N - 1, -1) ++ interEight8.trim(N - 1, -1) ++ \
clp.trim(N + 8, 0)
}

function EightBackFrames(clip clp, int N)
{
# N is number of the last frame in Source that needs replacing.
# Frames N - 8 and N - 7 and N - 6 and N - 5 and N - 4 and N - 3 and N - 2
# and N - 1 (O) will be replaced.

clp.trim(0, N - 9) ++ interEight1.trim(N, -1) ++ interEight2.trim(N, -1) ++ \
interEight3.trim(N, -1) ++ interEight4.trim(N, -1) ++ interEight5.trim(N, -1) ++ \
interEight6.trim(N, -1) ++ interEight7.trim(N, -1) ++ interEight8.trim(N, -1) ++ \
clp.trim(N, 0)
}

function NineFrames(clip clp, int N)
{
# N is number of the first frame in Source that needs replacing.
# Frames N and N + 1 and N + 2 and N + 3 and N + 4 and N + 5 and N + 6
# and N + 7 and N + 8 (O) will be replaced.

clp.trim(0, N - 1) ++ interNine1.trim(N - 1, -1) ++ interNine2.trim(N - 1, -1) ++ \
interNine3.trim(N - 1, -1) ++ interNine4.trim(N - 1, -1) ++ interNine5.trim(N - 1, -1) ++ \
interNine6.trim(N - 1, -1) ++ interNine7.trim(N - 1, -1) ++ interNine8.trim(N - 1, -1) ++ \
interNine9.trim(N - 1, -1) ++ clp.trim(N + 9, 0)
}

function NineBackFrames(clip clp, int N)
{
# N is number of the last frame in Source that needs replacing.
# Frames N - 9 and N - 8 and N - 7 and N - 6 and N - 5 and N - 4 and N - 3
# and N - 2 and N - 1 (O) will be replaced.

clp.trim(0, N - 10) ++ interNine1.trim(N, -1) ++ interNine2.trim(N, -1) ++ \
interNine3.trim(N, -1) ++ interNine4.trim(N, -1) ++ interNine5.trim(N, -1) ++ \
interNine6.trim(N, -1) ++ interNine7.trim(N, -1) ++ interNine8.trim(N, -1) ++ \
interNine9.trim(N, -1) ++ clp.trim(N, 0)
}

function TenFrames(clip clp, int N)
{
# N is number of the first frame in Source that needs replacing.
# Frames N and N + 1 and N + 2 and N + 3 and N + 4 and N + 5 and N + 6
# and N + 7 and N + 8 and N + 9 (O) will be replaced.

clp.trim(0, N - 1) ++ interTen1.trim(N - 1, -1) ++ interTen2.trim(N - 1, -1) ++ \
interTen3.trim(N - 1, -1) ++ interTen4.trim(N - 1, -1) ++ interTen5.trim(N - 1, -1) ++ \
interTen6.trim(N - 1, -1) ++ interTen7.trim(N - 1, -1) ++ interTen8.trim(N - 1, -1) ++ \
interTen9.trim(N - 1, -1) ++ interTen10.trim(N - 1, -1) ++ clp.trim(N + 10, 0)
}

function TenBackFrames(clip clp, int N)
{
# N is number of the last frame in Source that needs replacing.
# Frames N - 10 and N - 9 and N - 8 and N - 7 and N - 6 and N - 5 and N - 4
# and N - 3 and N - 2 and N - 1 (O) will be replaced.

clp.trim(0, N - 11) ++ interTen1.trim(N, -1) ++ interTen2.trim(N, -1) ++ \
interTen3.trim(N, -1) ++ interTen4.trim(N, -1) ++ interTen5.trim(N, -1) ++ \
interTen6.trim(N, -1) ++ interTen7.trim(N, -1) ++ interTen8.trim(N, -1) ++ \
interTen9.trim(N, -1) ++ interTen10.trim(N, -1) ++ clp.trim(N, 0)
}

[Jenyok]

Would be 8 parts.
Part 8
.

# Плохие кадры
# Bad frames
#
PairFrames(30 +25)
OneFrame(61)
OneFrame(74)
OneFrame(79)
OneFrame(82)
PairFrames(86)
OneFrame(67 +25) #92
OneFrame(64 +25) #89
OneFrame(97)
OneFrame(99)
OneFrame(101)
OneFrame(103)
OneFrame(105)
OneFrame(107)
PairFrames(87 +25) #112
PairFrames(96 +25) #121
OneFrame(126)
OneFrame(129)
PairFrames(131)
PairFrames(109 +25) #134
OneFrame(136)
FiveFrames(113 +25) #138
OneFrame(146)
OneFrame(150)
OneFrame(152)
PairFrames(129 +25) #154
PairFrames(135 +25) #160
PairFrames(165)
OneFrame(178)
OneFrame(183)
PairFrames(161 +25) #186
ThreeFrames(195)
OneFrame(201)
PairFrames(179 +25) #204
PairFrames(208)
PairFrames(186 +25) #211
OneFrame(213)
FourFrames(216)
OneFrame(229)
PairFrames(233)
PairFrames(237)
OneFrame(240)
ThreeFrames(230 +25) #255
PairFrames(237 +25) #262
OneFrame(267)
PairFrames(269)
OneFrame(276)
OneFrame(283)
OneFrame(287)
OneFrame(289)
OneFrame(291)
OneFrame(294)
OneFrame(309)
OneFrame(313)
OneFrame(326)
ThreeFrames(306 +25) #331
FiveFrames(318 +25) #343
OneFrame(358)
OneFrame(364)
OneFrame(373)
OneFrame(377)
ThreeFrames(386 +25) #411
OneFrame(415)
OneFrame(417)
OneFrame(427)
PairFrames(436)
OneFrame(439)
#FourFrames(429 +25)
ThreeFrames(429 +25) #454
OneFrame(466)
PairFrames(447 +25) #472
OneFrame(474)
OneFrame(476)
OneFrame(478)
OneFrame(490)
OneFrame(492)
ThreeFrames(478 +25) #503
OneFrame(509)
PairFrames(512)
OneFrame(518)
OneFrame(526)
OneFrame(548)
OneFrame(552)
OneFrame(566)
OneFrame(548 +25) #573
OneFrame(569)
PairFrames(591 +25)
OneFrame(610)
ThreeFrames(595 +25) #620
OneFrame(700)
OneFrame(718)
ThreeFrames(700 +25)
PairFrames(733)
PairFrames(711 +25)
PairFrames(734 +25)
PairFrames(743 +25)
OneFrame(790)
ThreeFrames(774 +25)
OneFrame(804)
OneFrame(812)
OneFrame(841)
ThreeFrames(853)
ThreeFrames(835 +25)
PairFrames(840 +25)
#PairFrames(855 +25)
OneFrame(856 +25)
FourFrames(906 +25) #931
OneFrame(939)
OneFrame(917 +25) #942
OneFrame(961)
OneFrame(988)
OneFrame(1027 +25) #1052
OneFrame(1056)
#OneFrame(1032 +25)
#ThreeFrames(1034 +25)
PairFrames(1088)
ThreeFrames(1067 +25)
PairFrames(1097 +25)
OneFrame(1108)
OneFrame(1157)
PairFrames(1160)
PairFrames(1149 +25)
OneFrame(1176)
ThreeFrames(1158 +25)
ThreeFrames(1163 +25)
OneFrame(1179 +25)
PairFrames(1199 +25)
#FourFrames(1206 +25)
OneFrame(1231)
OneFrame(1233)
OneFrame(1283 +25)
OneFrame(1332 +25)
OneFrame(1362)
OneFrame(1351 +25)
OneFrame(1369 +25)
OneFrame(1410)
OneFrame(1419 +25)
OneFrame(1463)
PairFrames(1452 +25)
#OneFrame(1488)
OneFrame(1473 +25)
FourFrames(1502)
#ThreeFrames(1477 +25)
OneFrame(1504 +25)
OneFrame(1556)
OneFrame(1576)
ThreeFrames(1585)
#PairFrames(1561 +25)
PairFrames(1571 +25)
PairFrames(1602 +25)
ThreeFrames(1613 +25)
OneFrame(1649 +25)
OneBackFrame(1659 +25)
OneFrame(1700 +25)
OneBackFrame(1758 +25)
ThreeFrames(1767 +25)
OneFrame(1823 +25)
OneFrame(1870)
FourFrames(1917 +25)
PairFrames(2042 +25)
PairFrames(2048 +25)
ThreeFrames(2057 +25)
PairFrames(2079 +25)
ThreeFrames(2094 +25)
#PairFrames(2174)
OneFrame(2271 +25)
OneFrame(2401)
PairFrames(2654 +25)
#FourFrames(2677 +25)
SixFrames(2677 +25)
PairFrames(2693 +25)

#PairFrames(2696 +25) #2721
#OneFrame(2698 +25) #2723
OneFrame(2722)

OneFrame(2721 +25)
OneFrame(2828)
FiveFrames(2841 +25)
PairFrames(2861 +25)
OneFrame(2896 +25)
OneFrame(2950)
ThreeFrames(2957 +25)
OneFrame(2995 +25)
PairFrames(3078 +25)
#SixFrames(3206 +25)
SevenFrames(3206 +25)
OneFrame(3214 +25)
PairFrames(3230 +25)
OneFrame(3261 +25)

#EightFrames(3312 +25)
#TenFrames(3312 +25)

SevenFrames(3311 +25) #3336
OneFrame(3321 +25) #6646

OneFrame(3339 +25)
OneFrame(3399 +25)
OneFrame(3445 +25)
OneFrame(3596 +25)
PairFrames(3658 +25)
PairFrames(3660 +25)
OneFrame(3671 +25)
OneFrame(3689 +25)
OneFrame(3707 +25)
OneFrame(3727 +25)
OneFrame(3797 +25)
OneFrame(3854 +25)
PairFrames(3881 +25)
PairFrames(3963 +25)
OneFrame(4020 +25)
OneFrame(4023 +25)
OneFrame(4213 +25)
FourFrames(4283 +25)
PairFrames(5969 +25)
PairFrames(5972 +25)


AudioDub(last, Audio)



# Для отладки фильтров часть 2
# Only for debbuging part 2
#
(isDebug == true) ? StackHorizontal(SourceView, last) : last

[lisztfr9]

I ended up dropping a lot of frames... a huge list.

I must say that Avisynth is remarkable bug free, for all the junk i wrote, Avsp never crashs. And it does the code.

I could need a function for dropping/interpolating all bad frames, for example all with too much noise.

The only thing i can't tweak is Descratch...

[cobo]

Morph.avsi
# http://forum.doom9.org/showthread.php?t=161154
# morph by Mug Funky
# usage: if you have, say, frames 21 and 22 bad, then use "morph(20,23)"
# edit1: increased default thscd1 from 255 to 800 and blksize from 16 to 32 to improve accuracy
# edit2: increased searchparam from default 2 to 16 and changed search from default 4 to 3 to improve accuracy - http://forum.doom9.org/showthread.php?t=165338

function morph (clip c, int in, int "out", int "blksize")
{

Function fill_loop(string s, int stop, int count)
{
return (stop == 0) ? s : string("tofill.mflowinter(morph_spr,fill_vb,fill_vf,time=" + string(100*(count - stop)/float(count))) + ",thscd1=800,thscd2=255).selectevery(tofill.framecount(),0)," + fill_loop(s,stop-1,count)
#return (stop == 0) ? s : string("tofill.mflowinter(morph_spr,fill_vb,fill_vf,time=" + string(100*(count - stop)/float(count))) + ",thscd1=255,thscd2=255).selectevery(tofill.framecount(),0)," + fill_loop(s,stop-1,count)
}

out=default(out, 0)
#blksize=default(blksize,16)
blksize=default(blksize,32)

d=c.trim(in,out)# in-1?

numframes=d.framecount-2
tofill=d.selectevery(c.framecount(),0,c.framecount()-1)
global morph_spr=tofill.msuper()
#fill_vf=morph_spr.manalyse(truemotion=true,blksize=blksize,isb=false,overlap=blksize/2)
#fill_vb=morph_spr.manalyse(truemotion=true,blksize=blksize,isb=true,overlap=blksize/2)
fill_vf=morph_spr.manalyse(truemotion=true,blksize=blksize,isb=false,search=3,searchparam=16,overlap=blksize/2)
fill_vb=morph_spr.manalyse(truemotion=true,blksize=blksize,isb=true,search=3,searchparam=16,overlap=blksize/2)
filled=eval("interleave(" + fill_loop("" ,d.framecount()-1,d.framecount()-1) + "tofill.selectevery(tofill.framecount(),tofill.framecount())).assumefps(c.framerate())")
c.trim(0,-(in+1))++filled.trim(1,numframes)++c.trim(out,0)
}

[lisztfr9]

Thanks, i will give it a try tomorrow !

[Jenyok]

Morph.avsi
# http://forum.doom9.org/showthread.php?t=161154
# morph by Mug Funky
# usage: if you have, say, frames 21 and 22 bad, then use "morph(20,23)"
# edit1: increased default thscd1 from 255 to 800 and blksize from 16 to 32 to improve accuracy
# edit2: increased searchparam from default 2 to 16 and changed search from default 4 to 3 to improve accuracy - http://forum.doom9.org/showthread.php?t=165338

function morph (clip c, int in, int "out", int "blksize")
{

Function fill_loop(string s, int stop, int count)
{
return (stop == 0) ? s : string("tofill.mflowinter(morph_spr,fill_vb,fill_vf,time=" + string(100*(count - stop)/float(count))) + ",thscd1=800,thscd2=255).selectevery(tofill.framecount(),0)," + fill_loop(s,stop-1,count)
#return (stop == 0) ? s : string("tofill.mflowinter(morph_spr,fill_vb,fill_vf,time=" + string(100*(count - stop)/float(count))) + ",thscd1=255,thscd2=255).selectevery(tofill.framecount(),0)," + fill_loop(s,stop-1,count)
}

out=default(out, 0)
#blksize=default(blksize,16)
blksize=default(blksize,32)

d=c.trim(in,out)# in-1?

numframes=d.framecount-2
tofill=d.selectevery(c.framecount(),0,c.framecount()-1)
global morph_spr=tofill.msuper()
#fill_vf=morph_spr.manalyse(truemotion=true,blksize=blksize,isb=false,overlap=blksize/2)
#fill_vb=morph_spr.manalyse(truemotion=true,blksize=blksize,isb=true,overlap=blksize/2)
fill_vf=morph_spr.manalyse(truemotion=true,blksize=blksize,isb=false,search=3,searchparam=16,overlap=blksize/2)
fill_vb=morph_spr.manalyse(truemotion=true,blksize=blksize,isb=true,search=3,searchparam=16,overlap=blksize/2)
filled=eval("interleave(" + fill_loop("" ,d.framecount()-1,d.framecount()-1) + "tofill.selectevery(tofill.framecount(),tofill.framecount())).assumefps(c.framerate())")
c.trim(0,-(in+1))++filled.trim(1,numframes)++c.trim(out,0)
}
.
It is very strange, maybe...

[Jenyok]

There are some changes to morph() function.
.

#
# morph() function...
#
# Usage:
# if you say frames 21, 22, 23, 24 and 25 are bad, then use "morph(20, 26)"
#
function morph(clip clp, int FrameIn, int "FrameOut")
{
# Constants
# MSuper()
#
hpad = 8 # Maybe 4, 8, 16, 32, !!! Change this constant for best tuning !!!
vpad = 8 # Maybe 4, 8, 16, 32, !!! Change this constant for best tuning !!!
pel = 2 # default=2
sharp = 2 # default=2 !!!
rfilter = 4 # default=2
chroma = true # default=true
isse = true # default=true
planar = false # default=false
levels = 0 # default=0

# Constants
# MAnalyse()
#
blkh = 32 # Maybe 4, 8, 16, 32, !!! Change this constant for best tuning !!!
blkv = 32 # Maybe 4, 8, 16, 32, !!! Change this constant for best tuning !!!
overlap = 4 # Maybe 2, 4, 8, 16, !!! maybe blkh/2 or litle !!! Change this constant for best tuning !!!
overlapV = 4 # Maybe 2, 4, 8, 16, !!! maybe blkv/2 or litle !!! Change this constant for best tuning !!!
search = 3 # default=4 !!! DO NOT CHANGE =3
searchparam = 1 # default=2 !!! DO NOT CHANGE =1
dct = 5 # default=0
plevel = 2 # default=0
badsad = 10000 # default=10000
badrange = (-24) # default=24
divide = 0 # default=0
sadx264 = 0 # default=0
truemotion = true # default=true

lambda = (truemotion == false) ? 0 : (1000 * blkh * blkv / 64) # default=0 truemotion=false, default=1000*blksize*blksizeV/64 truemotion=true
lsad = (truemotion == false) ? 400 : 1200 # default=400 truemotion=false, default=1200 truemotion=true
pnew = (truemotion == false) ? 0 : 50 # default=0 truemotion=false, default=50 truemotion=true
pzero = pnew # default pzero=pnew

# Constants
# MRecalculate()
#
blkhR = 8 # Maybe 4, 8, 16, 32, !!! Change this constant for best tuning !!!
blkvR = 8 # Maybe 4, 8, 16, 32, !!! Change this constant for best tuning !!!
overlapR = 4 # Maybe 2, 4, 8, 16, !!! maybe blkhR/2 or litle !!! Change this constant for best tuning !!!
overlapVR = 4 # Maybe 2, 4, 8, 16, !!! maybe blkvR/2 or litle !!! Change this constant for best tuning !!!
searchR = 3 # default=4
searchparamR = 1 # default=2
thSAD = 400 # default=200 !!! DO NOT CHANGE =400

lambdaR = (truemotion == false) ? 0 : (1000 * blkhR * blkvR / 64) # default=0 truemotion=false, default=1000*blksize*blksizeV/64 truemotion=true

# Constants
# MFlowInter()
#
thSCD1 = 800 # default=400 !!! DO NOT CHANGE =800
thSCD2 = 255 # default=130
ml = 70 # default=100
blend = true # default=true


# Defaults
#
FrameOut = Default(FrameOut, 0)


# Local Fill_Loop() function...
#
function Fill_Loop(string s, int stop, int count, int ml, int thSCD1, int thSCD2, bool isse, bool planar, bool blend)
{
return ((stop == 0) ? \
s : String("MFlowInter(tofill, morph_spr, fill_vb, fill_vf" + \
", time=" + String(100.0 * Float(count - stop) / Float(count))) + \
", ml=" + String(ml) + \
", thSCD1=" + String(thSCD1) + \
", thSCD2=" + String(thSCD2) + \
", isse=" + String(isse) + \
", planar=" + String(planar) + \
", blend=" + String(blend) + \
").SelectEvery(tofill.FrameCount(), 0)," + \
Fill_Loop(s, stop-1, count, ml, thSCD1, thSCD2, isse, planar, blend))
}


# Here is code of function...
#
d = clp.Trim(FrameIn, FrameOut) # in - 1 ?
tofill = d.SelectEvery(clp.FrameCount(), 0, clp.FrameCount()-1)

# function MSuper(clip, int "hpad", int "vpad", int "pel", int "levels", bool "chroma", \
# int "sharp", int "rfilter", clip "pelclip", bool "isse", bool "planar")
#
morph_spr = MSuper(tofill, \
hpad = hpad, \
vpad = vpad, \
pel = pel, \
chroma = chroma, \
sharp = sharp, \
rfilter = rfilter, \
isse = isse, \
planar = planar, \
levels = levels)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
fill_vb = MAnalyse(morph_spr, \
delta = 1, \
isb = true, \
blksize = blkh, \
blksizeV = blkv, \
overlap = overlap, \
overlapV = overlapV, \
search = search, \
searchparam = searchparam, \
pelsearch = pel, \
lambda = lambda, \
chroma = chroma, \
truemotion = truemotion, \
lsad = lsad, \
dct = dct, \
plevel = plevel, \
pnew = pnew, \
pzero = pzero, \
divide = divide, \
sadx264 = sadx264, \
badSAD = badsad, \
badrange = badrange, \
isse = isse, \
levels = levels, \
global = true, \
pglobal = 0, \
meander = true, \
temporal = false, \
trymany = false)

# function MAnalyse(clip super, int "blksize", int "blksizeV", int "level", int "search", int "searchparam", \
# int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", \
# int "lsad", int "plevel", bool "global", int "pnew", int "pzero", int "pglobal", int "overlap", \
# int "overlapV", string "outfile", int "dct", int "divide", int "sadx264", int "badSAD", \
# int "badrange", bool "isse", int "full", bool "meander", bool "temporal")
#
fill_vf = MAnalyse(morph_spr, \
delta = 1, \
isb = false, \
blksize = blkh, \
blksizeV = blkv, \
overlap = overlap, \
overlapV = overlapV, \
search = search, \
searchparam = searchparam, \
pelsearch = pel, \
lambda = lambda, \
chroma = chroma, \
truemotion = truemotion, \
lsad = lsad, \
dct = dct, \
plevel = plevel, \
pnew = pnew, \
pzero = pzero, \
divide = divide, \
sadx264 = sadx264, \
badSAD = badsad, \
badrange = badrange, \
isse = isse, \
levels = levels, \
global = true, \
pglobal = 0, \
meander = true, \
temporal = false, \
trymany = false)

# MRecalculate(clip super, clip vectors, int "thSAD", int "smooth", int "blksize", int "blksizeV", \
# int "search", int "searchparam", int "lambda", bool "chroma", bool "truemotion", \
# int "pnew", int "overlap", int "overlapV", string "outfile", int "dct", int "divide", \
# int "sadx264", bool "isse")
#
fill_vb = MRecalculate(morph_spr, \
fill_vb, \
blksize = blkhR, \
blksizeV = blkvR, \
overlap = overlapR, \
overlapV = overlapVR, \
search = searchR, \
searchparam = searchparamR, \
lambda = lambdaR, \
dct = dct, \
truemotion = truemotion, \
thSAD = thSAD, \
isse = isse, \
chroma = chroma, \
pnew = pnew, \
divide = divide, \
sadx264 = sadx264, \
smooth = 1)

# MRecalculate(clip super, clip vectors, int "thSAD", int "smooth", int "blksize", int "blksizeV", \
# int "search", int "searchparam", int "lambda", bool "chroma", bool "truemotion", \
# int "pnew", int "overlap", int "overlapV", string "outfile", int "dct", int "divide", \
# int "sadx264", bool "isse")
#
fill_vf = MRecalculate(morph_spr, \
fill_vf, \
blksize = blkhR, \
blksizeV = blkvR, \
overlap = overlapR, \
overlapV = overlapVR, \
search = searchR, \
searchparam = searchparamR, \
lambda = lambdaR, \
dct = dct, \
truemotion = truemotion, \
thSAD = thSAD, \
isse = isse, \
chroma = chroma, \
pnew = pnew, \
divide = divide, \
sadx264 = sadx264, \
smooth = 1)

filled = Eval("Interleave(" + \
Fill_Loop("", d.FrameCount()-1, d.FrameCount()-1, ml, thSCD1, thSCD2, isse, planar, blend) + \
"tofill.SelectEvery(tofill.FrameCount(), tofill.FrameCount())).AssumeFps(clp.Framerate())")

return (clp.Trim(0, (-1 * (FrameIn + 1))) ++ filled.Trim(1, d.FrameCount - 2) ++ clp.Trim(FrameOut, 0))
}