Convolution3d(preset="vhsBQ") Problem

geht bei mir auch nur in der YV12-Version. Halte ich aber für kein sonderliches Problem, da in der Avisynth-Doku die Presets alle aufgelistet sind; ich persönlich passe die Werte sowieso von Hand an und verwende am liebsten die Version, die in meiner Filterkette am wenigsten Farbraumkonvertierungen (also im Idealfalle gar keine) erfordert.

Wenn man die Farben vorher entrauscht (wie ich das tue) und Convolution3D nur als "Zwischenfilter" nutzt (ich persönlich schiebe in vielen Fällen den PeachSmoother mit ebenfalls reduzierten Default-Parametern nach, dürfte aber Geschmackssache sein), sollte man die Werte (vor allem Chroma) sowieso etwas reduzieren. Ich nehm lieber 2 abgeschwächte als einen starken Filter, gibt für meinen Geschmack die besten Ergebnisse (gerade mit Temporalen Filtern sollte man sowieso vorsichtig sein).

Uiiiii, da gibts doch mittlerweile richtig leckerere Deinoiser. Schaue mal auf
http://www.removegrain.de.tf, lade dir die PlugIns (je nach CPU, welche du hast) und nutze diese Funktion (lecker!!):

function LRemoveDust(clip input, int _mode, int "limit")
{
limit=default(limit,4)
repmode = 2
clensed = Clense(input)
rep=Repair(clensed, input, mode=repmode)
rg = RemoveGrain(rep, mode=_mode)
rd=TemporalRepair(rg, rep)
return LimitChange(rd, input, limit, limitU=255)
}

Wenn du LRemoveDust(4,2) oder bei leichterem Rauschen (4,1) nimmst, wirst du merken wie flott das geht.

@ Didée (falls er hier vorbeischaut)
Wenn die Funktion auf YV12 native Sources losgeht, ist das Script sehr langsam.
NUR ... wenn ich vorher ein "sinnloses" ConverttoYUY2().ConverttoYV12() setzte wird sie richtig flott! Scheint mir als hätte das was mit einer Memory-Chroma-Allocation zu tun (oder wie ich das immer deuten soll, Uops).

Mpeg2Source("HohlMirDiePickelchenAusDemGesicht.d2v")
LRemoveDust(4,2)

= Laangsam

Mpeg2Source("HohlMirDiePickelchenAusDemGesicht.d2v")
ConverttoYUY2().ConverttoYV12() # Ja, richtig gelesen
LRemoveDust(4,2)

= Wrrrrrum

Avisynth Version: 2.56 (Jan.6.2005)

Ich gehe davon aus, dass dieses Problem bereits im englischen Board diskutiert wird? Und wie sieht's mit der Verwendung einer älteren AviSynth-Version aus? Oder mit etwas größerem "SetMemoryMax"?

Ich werde da mal nachsehen. War die letzten Monate ein wenig inaktiv und müsste mich durch den Thread was durcharbeiten.

incredible: uii, da hab ich ja wieder was zum spielen ich werd's mal testen!

acrowley: mein Verfahren ist nicht unbedingt das Optimum - die Einstellung des Peach und des Convolution3D ist SEHR stark von der Quelle abhängig. Mein Ziel war es generell, mit einer Kombination aus cnr2, undot, deen und Convolution3D die Grundwerte zu stabilisieren, daß ich einen relativ szenenunabhängigen Analysewert für Noiselevel und Baseline (Parameter "readout=TRUE") im PeachSmoother bekomme und diese dann für den eigentlichen Encode fest vorgebe. Dabei achte ich darauf, daß Convolution3D keinesfalls irgendwelche Ghosts erzeugt. Generell gehe ich nach meinen eigenen Augen vor, die Werte schwanken zwischen 6 und 64 bei den Convolution3D-Parametern, also wirklich stark Quellabhängig.
Aber hier tut sich ja was neues auf, damit muß ich erstmal spielen, vielleicht ist das ja viel besser als meine (im Vergleich eher schlichte) Bearbeitung. Ich bin mal neugierig

@ incredible:

Nö, kann ich nicht bestätigen. LRemoveDust ist bei mir, mit oder ohne hin-und-her-Konvertierung, "gleich schnell".
Wenn's bei Dir so ist, kann's natürlich viele Ursachen haben ... Quelle könnte als YCbr-Dingsbums statt YV12 angeliefert werden; es könnte mit den [neuen] DLL-Versionen von kassandro zusammenhängen, bzw. noch so'ne SSE2-Geschichte sein (ich verwende, gezwungenermaßen, nur die normalen SSE-Varianten), und/oder mit den Video-Dimensionen zu tun haben ... usw. usf. etc. pp.
Wenn's also für Dich funktioniert: prima, und den Trick im Auge behalten.

@ acrowley

Zitat

OK ,RemoveGrain ,die oberste Funktionskette, was bewirkt die ?

Und..
Mpeg2Source("HohlMirDiePickelchenAusDemGesicht.d2v")
LRemoveDust(4,2)

Wäre quasi das "simple" Nutzen mit einfachen Thresholds Parametern

Tja, wie beschreiben? Ich versuch's mal ...

Convolution3D ist "dumm", und macht einfach nur "Breitmatschen". Es findet keine Unterscheidung statt "dieses könnte Detail, jenes könnte Rauschen sein".

C3D arbeitet ganz stur nach seinen Thresholds. Nachteil des Prinzips:

kleine Thresholds --> wenig Schaden, aber nur effektiv bei geringem Rauschen. Bei starkem Rauschen läuft C3D "unten durch", und das Rauschen "oben drüber" bleibt einfach stehen.

große Thresholds --> C3D "greift" auch bei starkem Rauschen, aber das gesamt-Bild wird zwangsweise breitgematscht, weil auch sehr viel Detail innerhalb der Thresholds zu liegen kommt.

RemoveGrain & Derivate machen: "Begrenzung von Ausreissern", d.h. jene einzel-Pixel mit den "extremsten" Werten werden auf den nächstgeringeren Wert zurückgestuft, der innerhalb der 3x3(x3) Umgebung vorhanden ist.

RemoveGrain() selbst arbeitet rein spatial, d.h. begrenzt nur innerhalb eines Frames die Pixel mit den extremsten Werten, innerhalb einer 3x3 Umgebung eines jeden Pixels.
Clense() arbeitet rein temporal, d.h. jedes Pixel wird so begrenzt, dass es innerhalb des Wertebereiches [VorgängerPixel,NachfolgerPixel] liegt.
Bei Repair() wird's schon schwieriger zu erklären - ist eigentlich ähnlich wie RemoveGrain, nur dass die "Überprüfung auf Extremität" mit einem zweiten Clip (statt dem Original-Clip) durchgeführt wird. Hier dient es dazu, die krassen Änderungen/Zerstörungen (!) von Clense() wieder zu reparieren.

RemoveDust() insgesamt ist so was wie ne "spatio-temporale Verzwickung", wogegen C3D eher ein "spatio-temporaler Vorschlaghammer" ist.

Jedenfalls, das "besondere" an RemoveDust ist, dass eben keine Thresholds verwendet werden. Das zugrunde liegende Prinzip greift sowohl bei schwachem, als auch bei starkem Bildrauschen.

Letztlich ist RemoveDust aber immer noch viel zu agressiv, im Hinblick auf Detailverlust. Deswegen hab ich RemoveDust einfach mal probehalber einen Limiter verpasst, so dass am Ende kein Pixel um mehr als "limit" geändert werden darf. PixieDust ist da ja schon vor langem mit gutem Beispiel vorangegangen. Und siehe da ...

Am Ende kann man für die meisten Quellen eine ordentliche und vor allem sehr schnelle Rausch-Verminderung erreichen. Man passt einfach in dem Aufruf "LRemoveDust(4,limit)" den Wert für "limit" so an (Probieren & Augenmaß), dass er zum Niveau des Rauschens in der jeweiligen Quelle passt.
LRemoveDust(4,4) wäre bereits geeignet für ziemlich starkes Rauschen von TV-Caps. Für DVB-Grabs verwende ich fast immer limit=1 oder 2.

edit:

Oha. Aus dem SSE2-Kram halte ich mich raus. Hab selber nen 1800er Athleten, begnüge mich daher mit den (int-)SSE-Varianten, und hab funktionell keinerlei Probleme...

Haaalt, langsam.

Letzteres ist der Funktions-Aufruf. Ersteres ist die Funktion selbst.

Sprich, in "LRemoveDust(4,limit)" ist clense, repair & alles andere schon drin ...

Das ist aber eigentlich die Grundlage einer jeden Programmiersprache, die Unterprogramme / Routinen / Funktionen erlaubt:

1.: Funktionsdeklaration - es wird definiert, wie eine Funktion heißen soll, welche Parameter (die Variablen in der Klammer) sie enthalten soll, und was sie im Allgemeinen mit den Parametern tun soll, die übergeben werden können; diese Deklaration befindet sich häufig "außerhalb" des Haupt-Programmes, im Falle von AviSynth gern in eigenen Dateien (oft mit der Dateiendung ".avsi"), die per "Import"-Befehl eingebunden werden können - dadurch wird die Deklaration einfach "wiederverwendbar"

2.: Funktionsaufruf - hier wird eine vorher allgemein deklarierte Funktion nun mit speziellen Werten in den Parametern aufgerufen; die Parameter nehmen den übergebenen Wert an, und die Funktion wird konkret ausgeführt

Bedenke: Wenn AviSynth die vollständige Deklaration der Funktion nicht bekannt ist, kann sie nicht aufgerufen werden!

Du würdest als Junggeselle sicher auch kein Drei-Gänge-Menü kochen können, wenn dir niemand ein Kochbuch gibt...

Entweder die DLL in's Plugins-Verzeichnis; oder zusätzlich den Befehl

LoadPlugin("Verzeichnis\Datei.dll")

in das Skript, dann wird die nötige DLL auch sicher verwendet.
__

Und noch eins: "Stürzt immer ab" hilft uns nicht weiter. Eigentlich wäre zumindest interessant, ob eine Fehlermeldung dabei kommt, und welche. Dabei sind natürlich AviSynth-Meldungen im Detail interessanter, und Schutzverletzungen weniger.

Soweit ich weiss habe ich die RemovegrainS.dll, also die "S" Varianten.
Ich besitze einen Athlon XP1800+ 1,5Gh auf 2,5Ghz hoch getaktet.

Das mit dem ConerttoYUY2().ConverttoYV12() ist ja vom Speed her ne gute Lösung, aber dadurch wird die ganze ChromaInformation einmal hochgeblasen (200%Vertikal) und wieder zurückgestaucht (50%Vertikal) das gibt leckere Minderungen via Interpolation.

Habe auch mal ein einzelnes ConverttoYV12() nach der mpeg2source() Line versucht (falls da was komisches geliefert wird, dann würde das ja Sinn machen, naja), aber neeeee der will das Chroma wohl gerne mal hin und her gerissen haben *lach

"einfach abstürzen" gibt's nicht häufig. Eventuell, wenn im Plugins-Verzeichnis vielleicht Plugins liegen, die für AviSynth 2.0x gedacht sind, obwohl du AviSynth 2.5x installiert hast. In dem Fall: Plugins-Verzeichnis komplett leerräumen, die Plugins in ein anderes Verzeichnis hinterlegen, und nur diejenigen Plugins explizit mit der Funktion "LoadPlugin" laden, wie wirklich gebraucht werden.

Welche DLL eine bestimmte Funktion bietet, kannst du wohl relativ einfach herausfinden, indem du die Windows-Dateisuche verwendest, um in dem Verzeichnis mit den Plugins alle Dateien *.dll zu suchen, und dabei in den Dateien nach dem Namen der gewünschten Funktion suchen zu lassen (das kann man ja als zusätzlichen Suchtext angeben).

function LRemoveDust(clip input, int _mode, int "limit")
{
limit=default(limit,4)
repmode = 2
clensed = Clense(input)
rep=Repair(clensed, input, mode=repmode)
rg = RemoveGrain(rep, mode=_mode)
rd=TemporalRepair(rg, rep)
return LimitChange(rd, input, limit, limitU=255)
}

alleine tut gar nichts. Damit ist die Funktion nur deklariert, wurde aber noch nie aufgerufen. Du musst zuerst die Funktion deklarieren u. anschl. aufrunfen. Das gesamte Script sieht dann z.B. so aus:

# Pfade anpassen u. ggf. je nach CPU 
 # die SSE2 bzw. SSE3 Versionen der DLLs verwenden
 loadplugin("d:\programme\avisynth\plugins25\ssetools.dll")
 loadplugin("d:\programme\avisynth\plugins25\removegrain.dll")
 loadplugin("d:\programme\avisynth\plugins25\repair.dll")


function LRemoveDust(clip input, int _mode, int "limit")
 {
 limit=default(limit,4)
 repmode = 2
 clensed = Clense(input)
 rep=Repair(clensed, input, mode=repmode)
 rg = RemoveGrain(rep, mode=_mode)
 rd=TemporalRepair(rg, rep)
 return LimitChange(rd, input, limit, limitU=255)
 }


converttoyv12() # falls erf.
avisource("test.avi")
LRemoveDust(4,2)