[не удалять] Обработка и пересжатие видео [архив №1]

function Deblock_QED ( clip clp, int "quant1", int "quant2",
\                     int "aOff1", int "bOff1", int "aOff2", int "bOff2", int "uv", bool "usegrid", bool "fixmod" )
{
quant1 = default( quant1, 20 )
quant2 = default( quant2, 40 )
aOff1  = default( aOff1, quant1/2 )  #  I've no clue if these are clever values or not!
bOff1  = default( bOff1, quant1/4 )  #  So:
aOff2  = default( aOff2, quant1/4 )  #  Also try all these 4 values @ 0 (zero),
bOff2  = default( bOff2, quant1/8 )  #  and quant1=30, quant2=40~45 instead.
uv     = default( uv,      3 )       #  u=3 -> use proposed method for chroma deblocking
                                     #  u=2 -> no chroma deblocking at all (fastest method)
ox     = clp.width()                 #  u=1|-1 -> directly use chroma debl. from the normal|strong deblock()
oy     = clp.height()
usegrid=default(usegrid,false)
fixmod=default(fixmod,true)
# With avisynth scripting, there is no information available about the position of the  currently
# processed pixel ... there simply is no such thing like an "actual" processed pixel.
# So first I've to build up a grid covering the transitions between all 8x8 blocks,
# and make some LUTmania with it later. Yes, this is cumbersome.
Assert(clp.isyv12(),"Deblock_QED: Requires YV12.")
o=clp
clp=clp.makemod(8)
Assert(clp.width() % 8 == 0 && clp.height() % 8 == 0,"Deblock_QED: Requires mod8 video.")
block=clp.grid().trim(1,1).loop(framecount(clp))
# create normal deblocking (for block borders) and strong deblocking (for block interiour)
normal   = clp.deblock(quant=quant1,aOffset=aOff1,bOffset=bOff1)
strong   = clp.deblock(quant=quant2,aOffset=aOff2,bOffset=bOff2)
# build difference maps of both
normalD  = mt_makediff(clp,normal,chroma=uv>2?"process":"ignore")
strongD  = mt_makediff(clp,strong,chroma=uv>2?"process":"ignore")
# separate border values of the difference maps, and set the interiours to '128'
strongD2 = mt_lutxy(StrongD,block,expr="y 255 == x 128 ?",U=uv,V=uv)
normalD2 = mt_lutxy(normalD,block,expr="y 255 == x 128 ?",U=uv,V=uv)
# interpolate the border values over the whole block: DCTFilter can do it. (Kiss to Tom Barry!)
# (Note: this is not fully accurate, but a reasonable approximation.)
strongD3 = strongD2.mt_lut(expr="x 128 - 1.01 * 128 +",U=uv,V=uv).dctfilter(1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0)# .yv12lut("x 128 - 2 / 128 +")
# apply compensation from "normal" deblocking to the borders of the full-block-compensations calculated
# from "strong" deblocking ...
strongD4 = mt_lutxy(strongD3,normalD2,expr="y 128 == x y ?",U=uv,V=uv)
# ... and apply it.
deblocked= mt_makediff(clp,strongD4,chroma=uv>2?"process":"ignore")
# simple decisions how to treat chroma
deblocked = (uv<0) ? deblocked.mergechroma(strong) : uv<2 ? deblocked.mergechroma(normal) : deblocked
deblocked.crop(0,0,o.width,o.height)
return( last )
}
function Grid(clip clp) {
block = blankclip(clp,width=6*4,height=6*4,color=$000000).addborders(4,4,4,4,color=$FFFFFF)
block = stackhorizontal( block,block,block,block)
block = stackvertical(   block,block,block,block) .pointresize(32,32) .mt_binarize(upper=false)
block = stackhorizontal( block,block,block,block,block,block,block,block)
block = stackvertical(   block,block,block,block,block,block)
block = stackhorizontal( block,block,block)
block = stackvertical(   block,block,block)
block = stackhorizontal( block,block,block)
block = stackvertical( block,block)
#return clp.subtitle(string(block.width)+"x"+string(block.height))
block = block .crop(0,0,ox,oy)
block = (uv!=3) ? block
\    : YtoUV(block.crop(0,0,ox/2,oy/2),block.crop(0,0,ox/2,oy/2),block)
return block
}
function makemod(clip c,int "xmod",int "ymod",bool "mirror",bool "crop") {
xmod=default(xmod,16)
ymod=default(ymod,xmod)
mirror=default(mirror,false)
crop=default(crop,false)
ox=c.width
oy=c.height
w=c.isrgb32() || c.isrgb24() ? 1 : 2
right=c.crop(ox-w,0,w,0)
right=right.stackhorizontal(right,right,right)
right=xmod>w*4 ? right.stackhorizontal(right,right,right) : right
vx=ox % xmod==0 ? c : stackhorizontal(c,right.crop(0,0,xmod-(ox % xmod),0))
bottom=vx.crop(0,oy-w,0,w)
bottom=bottom.stackvertical(bottom,bottom,bottom)
bottom=ymod>w*4 ? bottom.stackvertical(bottom,bottom,bottom) : bottom
vy=oy % ymod==0 ? vx : stackvertical(vx,bottom.crop(0,0,0,ymod-(oy % ymod)))
cropped = c.crop(0,0,int(c.width/xmod)*xmod,int(c.height/ymod)*ymod)
return crop == true ? cropped : vy
}
#loadplugin(avsplugins+"dctfilter.dll")
#loadplugin(avsplugins+"grid.dll")