function HalfWink(clip c, int "ml"){
ml = Default(ml, 100)
c
#e e e
# o o o
#The clip is made of even/odd frames and the simplest way to reduce
#framerate would be to just take the even frames. But some clips have
#blinking that alternates frame to frame. That could make a "transparent"
#object solid or disappear entirely.
#E e E
# o I o o
#This function takes every other even frame and a frame interpolated
#from the odd frames. There are even times when it is appropriate to
#use some of the skipped even frame.
e0=selectevery(4,0)
e2=selectevery(4,2)
OddBlend=selectodd.convertfps(c).selectevery(4,1)
interleave(e0,overlay(OddBlend,e2,mask=BlinkMask(c,ml=ml)))
}
function BlinkMask(clip c, int "ml"){
ml = Default(ml, 100)
c.ConvertToYv12.colorYUV(autogain=true)
#oo is the part of the odd frame that is moving.
#If it isn't moving it doesn't need to be replaced.
OddMoving=selectodd.mt_motion(thT=255).selectodd
#Use mvtools to detect motion.
#If the object is blinking it will show crazy high motion since it doesn't
#exist frame to frame.
super=MSuper()
fvec =MAnalyse(super, isb=false, truemotion=false)
bvec =MAnalyse(super, isb=true , truemotion=false)
fmask=Mmask(last,fvec,kind=1,ml=ml).mt_binarize
bmask=Mmask(last,bvec,kind=1,ml=ml).mt_binarize
#mask is the part of the even frame that IS moving in both the forward and
#backwards direction. If it isn't moving in BOTH directions then it isn't
#blinking and we CAN!!! use it.
#f f f f
# b b b b
masks=interleave(fmask,bmask)
#f b f b f b f b
tf=mt_logic(masks.selectevery(2,1),masks.selectevery(2,2),mode="or").mt_expand.mt_expand
#f(bf)(bf)(bf)(bf)(b
Blinking=mt_logic(tf.selectevery(4,1),tf.selectevery(4,2),mode="and")
# >2<
NotBlinking=Blinking.mt_invert
mt_logic(OddMoving,NotBlinking,mode="and").mt_expand.mt_expand
} o = AVISource("t:\roadrunner_fast_and_flickering_section_noaudio.avi")
return stackvertical( stackhorizontal(o.selecteven, o.selectodd), \
stackhorizontal( halfwink(o), halfwink(o.deleteframe(0)) ))
What is the arm-pumping? Part of the running animation?
Edit: the fine-tuning from Vit produces a result without any visible artifacts when played back at Youtube, here is the Roadrunner clip with the code from nanoglyth and vit
FFVideoSource("sm.avi")
ConvertToRGB32
HalfWink(debug=true)
function HalfWink(clip c, bool "debug"){
debug=default(debug,false)
#The clip is made of even/odd frames and the simplest way to reduce
#framerate would be to just take the even frames. But some clips have
#blinking/shaking that alternates frame to frame. That could make a
#"transparent" object solid or disappear entirely. Or lock a shaking
#scene in a single position.
#e e e
# o^o o
#Every other even frame is taken as is. The other even frame is used
#as much as it can be. A mask is made of the blinking and the shaking.
#Those parts of the frame are simply replaced with data from one of the
#odd frames. NO BLENDING!!!
e0=c.selectevery(4,0)
o1=c.selectevery(4,1)
e2=c.selectevery(4,2)
o3=c.selectevery(4,3)
e2fix=overlay(e2,o1,mask=BlinkShake(c))
DebugMask=stackvertical(\
stackhorizontal(o1,e2,o3),\
stackhorizontal(Shaking(c,debug=true),e2fix,Blinking(c,debug=true)))
return debug ? DebugMask : interleave(e0,e2fix)
}
function BlinkShake(clip c){
return mt_logic(Blinking(c),Shaking(c),mode="or")
}
function Shaking(clip c, bool "debug"){
debug=default(debug,false)
c=c.ConvertToYv12 #.colorYUV(autogain=true)
#Shaking is the background moving at a regular rate.
#E e E
# o ^ o o
move=c.mt_motion
oe=move.selectevery(4,2)
eo=move.selectevery(4,3)
oo=c.selectodd.mt_motion.selectodd
#Motion will be seen between oe AND eo, AND NOT oo
Shaking=mt_logic(mt_logic(oe,eo,mode="and"),oo.mt_invert,mode="and")
DebugMask=mergeRGB(oe,eo,oo.mt_invert)
return debug ? DebugMask : Shaking
}
function Blinking(clip c, bool "debug"){
debug=default(debug,false)
c=c.ConvertToYv12 #.colorYUV(autogain=true)
#Blinking is an object that appears/disappears from the scene.
#If the object is blinking it will show crazy high motion since it doesn't
#exist frame to frame. Use mvtools to detect motion.
#Look for motion to and from. The vectors aren't symetric because it is
#easier to match the background than an object.
#The motion must be forward AND backward or it isn't a one-frame blink.
super=MSuper(c)
fvec =MAnalyse(super, isb=false, truemotion=false)
bvec =MAnalyse(super, isb=true , truemotion=false)
fmask=Mmask(c,fvec,kind=1).mt_binarize
bmask=Mmask(c,bvec,kind=1).mt_binarize
#f f f f
# b b b b
#f b f b f b f b
#f(bf)(bf)(bf)(bf)(b
# >2<
masks=interleave(fmask,bmask)
To=masks.selectevery(2,1)
From=masks.selectevery(2,2)
ToFrom=mt_logic(To,From,mode="or")
tfForward=ToFrom.selectevery(4,1)
tfBackward=ToFrom.selectevery(4,2)
Blinking=mt_logic(tfForward,tfBackward,mode="and")
DebugMask=mergeRGB(tfForward,tfBackward,blankclip(tfForward))
return debug ? DebugMask : Blinking
}
So, we can see in the odd to odd transition there are pixel changes, but only complex motion in the platform.
function momix(clip c){
#E e E
# o ^ o o
o1=c.selectevery(4,1)
e2=c.selectevery(4,2)
o3=c.selectevery(4,3)
move=c.moveit
oddMove=c.selectodd.moveit
#e e e
# o^o o
oe=move.selectevery(4,1)
eo=move.selectevery(4,2)
oo=oddMove.selecteven
return stackvertical(\
stackhorizontal(oe, e2, eo),\
stackhorizontal(o1, oo, o3))
}
function moveIt(clip c,int "ml"){
ml=default(ml,100)
c=c.ConvertToYv12 #.colorYUV(autogain=true)
super=MSuper(c)
fvec =MAnalyse(super, isb=false, truemotion=false)
bvec =MAnalyse(super, isb=true , truemotion=false)
fmask=Mmask(c,fvec,kind=1,ml=ml).mt_binarize
bmask=Mmask(c,bvec,kind=1,ml=ml).mt_binarize
To=fmask.trim(1,0)
From=bmask
move=c.mt_motion(thT=255).trim(1,0)
return mergeRGB(to,move,from)
}Poor motion matches are caused by objects appearing or disappearing or by objects changing their shape, look or color radically from one frame to the next.
clip = AVIsource("allinone-noaudio.avi").deleteframe(0)
function split(clip c, bool horizontal, string layername, int hlevel) {
c1 = subtitle(c.selectrangeevery(2400,1200), layername + " off", x=hlevel*20, y=hlevel*20 )
c2 = subtitle(c.trim(1200,0).selectrangeevery(2400,1200), layername + " on" , x=hlevel*20, y=hlevel*20)
return horizontal ? stackhorizontal(c1, c2) : stackvertical(c1, c2)
}
return clip.split(true, "sprites", 4).split(true,"bg4", 3).split(true,"bg3",2).split(false,"bg2",1).split(false,"bg1",0)
Does it actually help to have all layers separated from each other?
ConvertToRGB32
PointResize(Width * 2, Height * 2)
interleave(selectevery(4,0),halfwink)
function halfwink(clip c){
c=c.convertToYuy2(matrix="PC.601")
inter=c.selectodd.separatefields.trim(1,0).weave
deinter=inter.qtgmc.selectevery(4,1)
return deinter.ConvertToRGB32( matrix="PC.601" )
}clip_a=FFVideoSource("sm/sm.avi")
clip_b=ffvideosource("sm/1-sf2ceua-unaltered.mp4")
clip_c=directshowsource("sm/roadrunner_fast_and_flickering_section_noaudio.avi")
clip_d=ffvideosource("sm/#2223 - cpadolf's SNES Super Metroid ''any%, glitched''.avi")
clip_b
assumefps(60)
PointResize(Width * 2, Height * 2)
convertToyv12
i2=smoothOverlay(selectevery(4,1),halfwink,motionMask)
interleave(selectevery(4,0),i2)
#PointResize(Width / 2, Height / 2)
function smoothOverlay(clip a, clip b, clip mask){
step1=overlay(a,b,mask=mask.mt_expand.mt_expand,opacity=.5)
return overlay(step1,b,mask=mask)
}
function motionMask(clip c){
pc=c.mt_motion(thT=255)
oepc=pc.selectevery(4,2)
eopc=pc.selectevery(4,3)
oopc=c.selectodd.mt_motion(thT=255).selectevery(2,1)
mask=mt_logic(oepc, eopc, mode="or")
return mt_logic(mask, oopc, mode="or")
}
function halfwink(clip c){
inter=c.convertToyuy2.selectodd.separatefields.trim(1,0).weave
deinter=inter.qtgmc.selectevery(4,1)
return deinter.convertToyv12
}#interleave(selectevery(4,0),selectevery(4,3))Edit: I think I understand now: It's my avatar, isn't it? It makes me look angry.
Another strange thing: viewing this one in different screen sizes causes changes to the flicker frequency...
Would it be possible to tell the emulator to make all the blinking sprites be visible on the even frames? (or blink at a on-on-off-off cadence?)
clip_c
assumefps(60)
converttorgb32
e0=selectevery(4,0)
o1=selectevery(4,1)
e2=selectevery(4,2)
o3=selectevery(4,3)
mask=ng_mask(o1,e2,o3)
i2 = layer(o1,o3.mask(mask))
interleave(e0,i2)
function ng_mask(clip a, clip b, clip c){
a=a.converttoyv24
b=b.converttoyv24
c=c.converttoyv24
dd=dad(a,b,c)
y=dd.converttoy8
u=dd.uToY8
v=dd.vToY8
uv=mt_lutxy(u,v,"x y + 2 /")
mask=mt_lutxy(y,uv,"x y + 256 > 255 0 ?")
return mask.converttorgb32
}
function dad(clip a, clip b, clip c){
ab=ab_dif(a,b)
bc=ab_dif(b,c)
return mt_lutxy(ab,bc,"x y - 2 / 128 +") #(x-y)/2 +128
}
function ab_dif(clip a, clip b){
return mt_lutxy(a,b,expr="x y - abs")
}