Thanks, Boulder. Think I'll back off that idea ("You'll lose all existing data on those two drives though.").

Finally upgraded my dual core with GeForce 7600GT and bought full version of Fraps (now enhanced for dual core). Capturing aquarium (Dream Aquarium) screensaver at 29.97fps at 1280x1024 - smooth.

Intend to make DVD. Tried Phil's:
http://www.kvcd.net/forum/viewtopic.php?t=7223. Results are pretty blurred.

Have attached jpg of original avi capture. The actual frames are clearer. Need some ideas to try.

http://www.digitalfaq.com/archives/error.gif

Why filter at all as there is no noise? I would just resize and encode, possibly do light deblocking (the blue areas look as if they had some blocking).

How should I deblock? I did notice the blue areas.

With BlindPP(CPU=4,quant=x), raising the value x till the result satisfies you. Another option is to use Deblock_QED (leave the settings at default):
You'll need the latest MaskTools v2 alpha, DCTFilter and Deblock.

http://manao4.free.fr/
http://avisynth.org.ru/mvtools/deblock.html

Important : deblock before any resizing!

Tested with:

AVISource("E:\cap\04.avi",false)
converttoyv12()
LanczosResize(704,480,0,0,1184,1024)
Deblock_QED_MT2()
ConverttoRGB24()

Cleared up the "blue" area. FInal is not as sharp as the original, but pretty good.

Thanks :D

Move the deblocking before resizing, it's very important. The sharp block edges will not be there after resizing so deblocking is not efficient.

This working pretty good, but one capture could be better. Any suggestions? I have attached a jpg frame from the avi source and a bmp frame from the encoded mpg. (A bmp frame from the source AVI is almost 4MB - but about perfect!

AVISource("E:\cap\m01.avi")

converttoyv12()
Deblock_QED_MT2()

LanczosResize(656,480,2,0,1276,1024)
AddBorders(32,0,32,0)
#FadeOut(150)
ConverttoRGB24()

http://www.digitalfaq.com/archives/error.gif

http://www.digitalfaq.com/archives/error.gif

What do you mean the mpeg file doesn't look fine? The original file is super-sharp (if not oversharp) and that's always a problem for the encoder. Try using Spline36Resize instead of Lanczos. If you need more sharpness, there's SeeSaw.

And another point : if you encode to MPEG2, ditch TMPGEnc and use HC instead. You can avoid that one (actually two) extra colorspace conversion and HC provides better quality anyway.

Boulder,
Which of the following should I use? :?:

[v2.56]
Spline36Resize (clip, int target_width, int target_height) [v2.56]
Spline36Resize (clip, int target_width, int target_height, float "src_left", float "src_top", float "src_width", float "src_height")

What will my resize line look like? :?:

Do I need to use clip=a+b (I'm joining Fraps avi files)? :?:

Could you recommend some parameters for seesaw? :?:

SeeSaw(a,b, NRlimit=3, NRlimit2=4, Sstr=1.5, Slimit=5, Spower=5, Sdamplo=6, Szp=16)

Lots of questions and my low skills level. :?
I certainly appreciate your advice so far. The results are outstanding. :!:

Just put Spline36Resize instead of LanczosResize. The parameters are exactly the same.

What comes to SeeSaw, first try with the default values, just use SeeSaw(). All the fine tuning depends on your source and you must choose what you like and dislike.

Use a++b to keep the a/v sync.

:D Thanks as usual, Boulder, and:

a++b instead of a+b? New to me, shows how little I know. :oops:

Just downloaded HCenc. Want to try it out!

So many settings. Can't find detailed instructions. :?:

Delivered with the encoder itself, in a PDF document.

:oops: My extractor failed to extract this (and other) files. Will extract with another program.

:D Thanks. There are so many settings that I really need something!

Having read the PDF, need to know anything I should change from defaults. Am encoding NTSC DVD's.

Like
"constant Quantization"
"autogop"
"matrix"

Constant quant should be disabled.

If you are unsure of the settings, just load the avs file in HC and click the "make DVD compliant" button. Then set the average and maximum bitrates according to your wishes and choose the quant matrix you wish to use.

Why ?
I encode this way. This is the only "1pass quality"-like mode provided by HC. Are you using it only in 2-pass VBR ?

Thats is Autogop that should be disable IMHO.

I don't like to use a lot of time predicting a correct quant so I'm using 2-pass as the rate control is very good. AutoGOP is useful especially with high-motion video. Most of the time the GOP is the maximum length even with autoGOP.

Trying to use seesaw(). Can't find yv12lutxy()

AVISource("E:\cap\m01.avi")

converttoyv12()
Deblock_QED_MT2()

Spline36Resize(656,480,2,0,1276,1024)
Seesaw()

#AddBorders(32,0,32,0)
#FadeOut(150)
ConverttoRGB24()


function Deblock_QED_MT2 ( clip clp, int "quant1", int "quant2",
\ int "aOff1", int "bOff1", int "aOff2", int "bOff2", int "uv" )
{
quant1 = default( quant1, 20 )
quant2 = default( quant2, 24 )

aOff1 = default( aOff1, 2 ) # I've no clue if these are clever values or not!
bOff1 = default( bOff1, 4 ) # So:
aOff2 = default( aOff2, 4 ) # Also try all these 4 values @ 0 (zero),
bOff2 = default( bOff2, 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()

# 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.

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)
block = block.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=bOf f1)
strong = clp.deblock(quant=quant2,aOffset=aOff2,bOffset=bOf f2)

# build difference maps of both
normalD = mt_makediff(clp,normal,chroma=uv>2?"process":"igno re")
strongD = mt_makediff(clp,strong,chroma=uv>2?"process":"igno re")

# 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":"ig nore")

# simple decisions how to treat chroma
deblocked = (uv<0) ? deblocked.mergechroma(strong) : uv<2 ? deblocked.mergechroma(normal) : deblocked

deblocked
return( last )
}

function SeeSaw( clip clp, clip "denoised",
\ int "NRlimit",int "NRlimit2",
\ float "Sstr", int "Slimit", float "Spower", float "SdampLo", float "SdampHi", float "Szp",
\ float "bias", int "Smode", int "sootheT", int "sootheS", float "ssx", float "ssy")
{
ssx = default( ssx, 1.0 ) # supersampling factor x / SeeSaw doesn't require supersampling urgently.
ssy = default( ssy, ssx ) # supersampling factor y / if at all, small values ~1.25 seem to be enough.
NRlimit = default( NRlimit, 2 ) # absolute limit for pixel change by denoising
NRlimit2 = default( NRlimit2, NRlimit+1) # limit for intermediate denoising
Sstr = default( Sstr, 1.5 ) # Sharpening strength (don't touch this too much)
Slimit = default( Slimit, NRlimit+2 ) # positive: absolute limit for pixel change by sharpening
# negative: pixel's sharpening difference is reduced to diff=pow(diff,1/abs(limit))
Spower = default( Spower, 4 ) # exponent for modified sharpener
Szp = default( Szp, 16+2 ) # zero point - below: overdrive sharpening - above: reduced sharpening
SdampLo = default( SdampLo, Spower+1 ) # reduces overdrive sharpening for very small changes
SdampHi = default( SdampHi, 24 ) # further reduces sharpening for big sharpening changes. Try 15~30. "0" disables.
bias = default( bias, 49 ) # bias towards detail ( >= 50 ) , or towards calm result ( < 50 )
Smode = default( Smode, ssx<1.35 ? 11 : ssx<1.51 ? 20 : 19 )
sootheT = default( sootheT, 49 ) # 0=minimum, 100=maximum soothing of sharpener's temporal instableness.
# (-100 .. -1 : will chain 2 instances of temporal soothing.)
sootheS = default( sootheS, 0 ) # 0=minimum, 100=maximum smoothing of sharpener's spatial effect.

Szp = Szp / pow(Sstr, 1.0/4.0) / pow( (ssx+ssy)/2.0, 1.0/2.0 )
SdampLo = SdampLo / pow(Sstr, 1.0/4.0) / pow( (ssx+ssy)/2.0, 1.0/2.0 )

ox=clp.width
oy=clp.height
xss = m4(ox*ssx)
yss = m4(oy*ssy)
NRL = string( NRlimit )
NRL2 = string( NRlimit2 )
NRLL = string( int(round( NRlimit2 * 100.0/bias - 1.0 )) )
SLIM = string( abs(Slimit) )
BIAS1 = string( bias )
BIAS2 = string( 100-bias )
#ZRP = string( abs(Szp) )
#PWR = string( abs(Spower) )
#DMP = string( SdampLo )

denoised = defined(denoised) ? denoised : yv12lutxy(clp,clp.removegrain(4,-1),"x "+NRL+" + y < x "+NRL+" + x "+NRL+" - y > x "+NRL+" - y ? ?",U=2,V=2)

NRdiff = yv12lutxy(clp,denoised,"x y - 128 +","x y - 128 +","x y - 128 +",U=3,V=3)
tame = yv12lutxy(clp,denoised,"x "+NRLL+" + y < x "+NRL2+" + x "+NRLL+" - y > x "+NRL2+" - x "+BIAS1+" * y "+BIAS2+" * + 100 / ? ?")
head = tame.sharpen2(Sstr,Spower,Szp,SdampLo,SdampHi,4)
# head = head.maskedmerge(tame,tame.prewitt(multiplier=1.0) .expand().removegrain(20))

(ssx==1.0 && ssy==1.0) ? repair(tame.sharpen2(Sstr,Spower,Szp,SdampLo,Sdamp Hi,Smode),head,1,-1,-1)
\ : repair(tame.lanczosresize(xss,yss).sharpen2(Sstr,S power,Szp,SdampLo,SdampHi,Smode),head.bicubicresiz e(xss,yss,-.2,.6),1,-1,-1).lanczosresize(ox,oy)

Soothe(last,tame,sootheT,sootheS)
sharpdiff= yv12lutxy(tame,last,"x y - 128 +",U=1,V=1)

(NRlimit==0) ? clp : \
yv12lutxy(clp,NRdiff,"y 128 "+NRL+" + > x "+NRL+" - y 128 "+NRL+" - < x "+NRL+" + x y 128 - - ? ?",
\ "y 128 "+NRL+" + > x "+NRL+" - y 128 "+NRL+" - < x "+NRL+" + x y 128 - - ? ?",
\ "y 128 "+NRL+" + > x "+NRL+" - y 128 "+NRL+" - < x "+NRL+" + x y 128 - - ? ?",U=3,V=3)

Slimit>=0 ? yv12lutxy(last,sharpdiff,"y 128 "+SLIM+" + > x "+SLIM+" - y 128 "+SLIM+" - < x "+SLIM+" + x y 128 - - ? ?",U=2,V=2)
\ : yv12lutxy(last,sharpdiff,"y 128 = x x y 128 - abs 1 "+SlIM+" / ^ y 128 - y 128 - abs / * - ?",U=2,V=2)

return( last )
}


# ======= Modified sharpening function =======

function sharpen2(clip clp, float strength, int power, float zp, float lodmp, float hidmp, int rgmode)
{
STR = string( strength )
PWR = string( 1.0/float(power) )
ZRP = string( ZP )
DMP = string( lodmp )
HDMP = (hidmp==0) ? "1" : "1 x y - abs "+string(hidmp)+" / 4 ^ +"

yv12lutxy( clp, clp.RemoveGrain(rgmode,-1,-1), \
"x y = x x x y - abs "+ZRP+" / "+PWR+" ^ "+ZRP+" * "+STR+" * x y - 2 ^ x y - 2 ^ "+DMP+" + / * x y - x y - abs / * "+HDMP+" / + ?",U=2,V=2)
return( last )
}


# ======= Soothe() function to stabilze sharpening =======

function Soothe(clip sharp, clip orig, int "sootheT", int "sootheS")
{
sootheT = default(sootheT, 25 )
sootheS = default(sootheS, 0 )
sootheT = (sootheT > 100) ? 100 : (sootheT < -100) ? -100 : sootheT
sootheS = (sootheS > 100) ? 100 : (sootheS < 0) ? 0 : sootheS
ST = string( 100 - abs(sootheT))
SSPT = string( 100 - abs(sootheS))

yv12lutxy(orig,sharp,"x y - 128 +","x y - 128 +","x y - 128 +", U=1,V=1)

(sootheS==0) ? last
\ : yv12lutxy( last, last.removegrain(20,-1,-1),
\ "x 128 - y 128 - * 0 < x 128 - 100 / "+SSPT+" * 128 + x 128 - abs y 128 - abs > x "+SSPT+" * y 100 "+SSPT+" - * + 100 / x ? ?", U=1,V=1)

(sootheT==0) ? last
\ : yv12lutxy( last, last.temporalsoften(1,255,0,32,2),
\ "x 128 - y 128 - * 0 < x 128 - 100 / "+ST+" * 128 + x 128 - abs y 128 - abs > x "+ST+" * y 100 "+ST+" - * + 100 / x ? ?", U=1,V=1)

(sootheT > -1) ? last
\ : yv12lutxy( last, last.temporalsoften(1,255,0,32,2),
\ "x 128 - y 128 - * 0 < x 128 - 100 / "+ST+" * 128 + x 128 - abs y 128 - abs > x "+ST+" * y 100 "+ST+" - * + 100 / x ? ?", U=1,V=1)

yv12lutxy(orig,last,"x y 128 - -","x y 128 - -","x y 128 - -",U=1,V=1)
# mergechroma(sharp) # not needed in SeeSaw
return( last )
}


# ======= MOD4-and-atleast-16 helper function =======

function m4(float x) {x<16?16:int(round(x/4.0)*4)}