HTPC, aiuto per la guida di ffdshow

[thefunkydonkey]

Grazie per il suggerimento. Infatti il resize lo faccio con Avisynth dopo avere eseguito in multithread denoise e LSF. Avevo provato a posporre il LSF dopo il resize ma era davvero oneroso anche se devo dire c'era un bel guadagno ma per questo si vedano le pagine precedenti, non voglio risollevare un polverone

[Tony359]

Grazie Stealth!!!!

Ho letto tutto adesso, appena ho mezza giornata comincio a smanettare!

La versione di Ffdshow indicata è sempre quella più gettonata? Non avevo quel link e ne ho scaricata una "più recente" ma a quanto ho capito il progetto ffdshow originale non è più sviluppato o cosa?

Ciao
Antonio

[rs232]

ho da farvi una domanda
uso un proc. 6600 d.c. e usando la config. facendo fare tutto ad avisint oltre al valore ss di 1.0 non riesco ad aumentare perchè si impalla tutto
dite che sono al limite, come posso fare per aumentere?
devo dire che il risultato ottenuto gia cosi' è fantastico
ciao

[sebi]

Usi il filtro HQdn3d(2)?
Il resize lo fai prima o dopo LimitedSharpenFaster?

[davestas]

Ragazzi una domanda:ma le release prese da video ntsc come appunto puo' essere un telefilm americano, o una partita di sport americano tipo nba trasmessi proprio su canali americani ed ovviamente registrati da li, è normale che abbiano una fluidità minore rispetto al formato PAL vedendola su tv pilotato dal pc, è che quando la si sposta la camera per esempio durante la partita di nba la visuale RALLENTA ?
Grazie della risposta


Cmq io ho scaricato Dscaler, ho eseguito tutti i consigli per settare ffdshow(tra cui adaptiveNoise espressamente indicato per i divx da tv) come da thread in evidenza, tranne settaggi Avisinth che non ho installato, ho visto che si è creata uan schifezza e ho cdisattivato tutto e regolato solo la gamma.
Solo che appunto ho sto problema quando guardo per esempio un torrent di una aprtita di NBA registrata in America.

[rs232]

Usi il filtro HQdn3d(2)?
Il resize lo fai prima o dopo LimitedSharpenFaster?

in ordine uso
hqdn3d
resize
lsf
dovrebbe essere giusto, no?

[sebi]

hqdn3d
resize
lsf
dovrebbe essere giusto, no?

Probabilmente non esiste un "giusto", vi sono in giro varie discussioni in merito e diciamo 2 scuole di pensiero.

Quello che è certo è che con il resize prima di LSF metti il processore alla frusta, soprattutto se vuoi utilizzare anche il supersampling. Io ci ero riuscito utilizzando l'EVR in XP...ne veniva fuori una distribuzione di carico più equa sui 2 processori e riuscivo anche a farci stare dentro un SS>1.0.

Però con l'EVR in XP c'erano sempre dei "piccoli" problemi in agguato.

Da circa un mese uso con soddisfazione seesaw al posto del LSF con il VMR9: non posso che consigliartelo, se ne parla abbondantemente su AVSforum e purtroppo poco sul nostro forum e devo dire che, negli ultimi tempi, ho provato a inserire dentro l'istruzione operativa hqdn3d al posto dei parametri di denoise è il risultato è notevole (sto smanettando per arginare qualche "scalettatura" di troppo che comunque c'era anche con LSF).

Ps. io ho un dual core 6400

[animale81]

Scusate io ho seguito il post di stealth82 ma utilizzando ffdshow video con un dvd risulta tutto più appannato..... molto più brutto che con i codec nvidia.....

[Armando73]

@Sebi

Mi hai incuriosito sul discorso del seesaw. Vorrei farti qualche domanda:
1 per usarlo è necessario scaricare qualche dll da inserire nella cartella
plug-in dell'Avisynth? se si quali, dove si trovano e dove vanno inserite.
2 Potresti indicarmi lo script che utilizzi tu così parto da un qualcosa di
già funzionante.

Il mio pc monta un intel e4400 overcloccato a 2800 pensi che sia abbastanza potente per poter utilizzare il seesaw? mi sembra di aver capito che sia più avido di risorse rispetto al LSF.

ciao

[sebi]

@Sebi

Mi hai incuriosito sul discorso del seesaw. Vorrei farti qualche domanda:
1 per usarlo è necessario scaricare qualche dll da inserire nella cartella
plug-in dell'Avisynth?

Si

2 Potresti indicarmi lo script che utilizzi tu così parto da un qualcosa di
già funzionante.

Adesso non sono sul PC di casa. In giornata o massimo domani posterò il necessario, compresi i plugins.

mi sembra di aver capito che sia più avido di risorse rispetto al LSF.

Non mi è parso.

ho seguito il post di stealth82 ma utilizzando ffdshow video con un dvd risulta tutto più appannato..... molto più brutto che con i codec nvidia

Sbagli qualcosa

[Armando73]

grazie mille

[animale81]

Si sicuramente sbaglio qualcosa..... ma anche su un dvd i filtri di ffdshow hanno un effetto migliorativo?
Altra cosa: oltre ai filtri spiegati da stealth82 dove posso trovare un Doc che spiega anche gli altri?
Thanks

[rs232]

non trovo nessuna dll col nome seesaw mi potreste aiutare nelle ricerca
conoscete il link per scaricarla
ciao

[spinmar]

Innanzitutto non esiste nessuna dll ma seesaw è uno script (.avsi).
Ti consiglio di andare al seguente link:

http://www.avsforum.com/avs-vb/showthread.php?t=719041

scaricarti il dvd package (primo link) che contiene tutto quello che ti serve.
Quindi segui le istruzioni del primo post scegliendo una configurazione consona al tuo hw.
Ciao

[sebi]

Innanzitutto non esiste nessuna dll ma seesaw è uno script (.avsi)

Seesaw è uno script che per funzionare ha bisogno delle librerie.


Questa è la lista completa dei plugins necessari per seesaw (e anche LSF):

LimitedSharpenFaster.avsi
SeeSaw.avsi (rename the seesaw extension to .avsi)
Soothe.avsi

MT.dll
MaskTools.dll
mt_masktools.dll

RepairSSE2.dll and RemoveGrainSSE2.dll oppure RepairSSE3 and RemoveGrainSSE3.dll

ColorMatrix.dll
TDeint.dll
Fluxsmooth.dll

Qui c'è il pacchetto completo per l'elaborazione dei DVD che pesa circa 17 mb.

In alternativa su AVSForum come già scritto si possono trovare i link ai singoli files, con l'eccezione dei 2 script SeeSaw.avsi e Soothe.avsi che allego:

#  SeeSaw v0.3e (02 Jan 2006)
#
#  (Full Name: "Denoiser-and-Sharpener-are-riding-the-SeeSaw" )
#
#  This function provides a (simple) implementation of the "crystality sharpen" principle.
#  In conjunction with a user-specified denoised clip, the aim is to enhance
#  weak detail, hopefully without oversharpening or creating jaggies on strong
#  detail, and produce a result that is temporally stable without detail shimmering, 
#  while keeping everything within reasonable bitrate requirements.
#  This is done by intermixing source, denoised source and a modified sharpening process,
#  in a seesaw-like manner.
#
#  This version is considered alpha.  
#
#  Usage:
#
#  a = TheNoisySource
#  b = a.YourPreferredDenoising()
#  SeeSaw( a, b, [parameters] )
#
#  You're very much encouraged to feed your own custom denoised clip into SeeSaw.
#  If the "denoised" clip parameter is omitted, a simple "spatial pressdown" filter is used.
#
#
#  Fiddled together by Didée, for your pleasure.
#


# =======  Main function  =======

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 : mt_lutxy(clp,clp.removegrain(4,-1),"x "+NRL+" + y < x "+NRL+" + x "+NRL+" - y > x "+NRL+" - y ? ?",chroma="copy first")

NRdiff = mt_makediff(clp,denoised,chroma="process")
tame   = mt_lutxy(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.mt_merge(tame,tame.prewitt(multiplier=1.0).mt_expand().removegrain(20))

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

SootheSS(last,tame,sootheT,sootheS)
sharpdiff= mt_makediff(tame,last)

(NRlimit==0) ? clp : \
mt_lutxy(clp,NRdiff, "y 128 "+NRL+" + > x "+NRL+" - y 128 "+NRL+" - < x "+NRL+" + x y 128 - - ? ?",chroma="process")

Slimit>=0 ? mt_lutxy(last,sharpdiff,"y 128 "+SLIM+" + > x "+SLIM+" - y 128 "+SLIM+" - < x "+SLIM+" + x y 128 - - ? ?",chroma="copy first")
 \        : mt_lutxy(last,sharpdiff,"y 128 == x x y 128 - abs 1 "+SlIM+" / ^ y 128 - y 128 - abs / * - ?",chroma="copy first")

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 ^ +"

mt_lutxy( 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+" / + ?",chroma="copy first")
return( last )
}


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

function SootheSS(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))

mt_makediff(orig,sharp)

(sootheS==0) ? last
 \           : mt_lutxy( 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 ? ?", chroma="ignore")
 
(sootheT==0) ? last
 \           : mt_lutxy( 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 ? ?", chroma="ignore")

(sootheT > -1) ? last 
 \             : mt_lutxy( 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 ? ?",chroma="ignore")

mt_makediff(orig,last)
# 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)}

da copiare nel blocco note e salvare come seesaw.avsi

function Soothe(clip sharp, clip orig, int "keep")
{
Assert(sharp.width == orig.width && sharp.height == orig.height,
 \  "Soothe: clip dimentions must match!")
keep  = default(keep, 24)
keep  = (keep>100) ? 100 : (keep<0) ? 0 : keep
KP    = string(keep)
diff  = mt_makediff(orig,sharp)
diff2 = diff.temporalsoften(1,255,0,32,2)
diff3 = mt_lutxy(diff,diff2,  "x 128 - y 128 - * 0 < x 128 - 100 / "  + KP 
 \                           + " * 128 + x 128 - abs y 128 - abs > x " + KP 
 \                           + " * y 100 " + KP + " - * + 100 / x ? ?")
return( mt_makediff(orig,diff3,chroma="copy first") )
}

da copiare nel blocco note e salvare come Soothe.avsi

Le opzioni di personalizzazione sono evidentemente innumerevoli poichè i parametri che entrano in gioco sono molti di più che non in LSF.