Posts: 9
Threads: 4
Joined: Oct 2023
Hi,
und zwar wollte ich fragen ob es eventuell möglich wäre beim Verwenden von BWDIF fürs Deinterlacing mehr Optionen zur Verfügung zu bekommen.
Ich bin kein großer Fan von QTGMC (vorallem bei grainy sources), deswegen ist mein go-to eigentlich immer NNEDI3. Da NNEDI3 alleine aber nicht motion-adaptive ist, nutze ich es immer in Verbindung mit BWDIF als edeint (yadifmod würde natürlich auch funktionieren).
Diese Kombi ist bis heute der Hauptgrund wieso ich noch StaxRip fürs reguläre Deinterlacen verwende, Hybrid ist für mich im Großen und Ganzen aber trotzdem die erste Wahl weil es in meinen Augen userfreundlicher und "intelligent" ist.
Hybrid benutze ich eigentlich ausschließlich im VapourSynth Mode, beim Scripten (StaxRip) verwende ich aber immer noch AviSynth da ich bei den Syntaxen und Parametern von VapourSynth nicht ganz durchblicke..
Wäre es also möglich in Hybrid (VapourSynth) BWDIF mit allen (wichtigen) Parametern zu nutzen und diese auch zur Auswahl anzubieten und zusätzlich noch die Parameter für den gewählten edeint?
BWDIF - Avisynth wiki
Nnedi3/nnedi3 - Avisynth wiki
Also z.B. als edeint NNEDI3 anklicken, und dann die Optionen für den edeint angezeigt bekommen, wie z.B. nsize, qual, nns, pscrn?
Bei Yadifmod ist das ja sogar möglich, allerdings lassen sich die Parameter für NNEDI3 nicht anpassen, d.h. es werden warscheinlich die default settings vom Filter benutzt.
Höhepunkt wäre natürlich noch OpenCL Unterstützung, allerdings habe ich da keine Ahnung ob nnedi3cl überhaupt dafür geeignet ist bzw. alles kann was die "normale" Version auch kann.
Würde mich sehr darüber freuen denn dann kann ich endlich der anderen GUI den Rücken kehren.
LG
Posts: 10.933
Threads: 56
Joined: May 2017
22.10.2023, 07:53
(This post was last modified: 22.10.2023, 08:37 by Selur.)
Eigentlich kann man QTGMC durchaus kontrollieren, wie die Grain-Retention ist.
Insbesondere wenn man noch die Parameter dazu nimmt, die nicht in der GUI sind, hat man eigentlich recht gute Kontrolle,...
Hier mal die Parameter, die es gibt:
def QTGMC(
Input: vs.VideoNode,
Preset: str = 'Slower',
TR0: Optional[int] = None,
TR1: Optional[int] = None,
TR2: Optional[int] = None,
Rep0: Optional[int] = None,
Rep1: int = 0,
Rep2: Optional[int] = None,
EdiMode: Optional[str] = None,
RepChroma: bool = True,
NNSize: Optional[int] = None,
NNeurons: Optional[int] = None,
EdiQual: int = 1,
EdiMaxD: Optional[int] = None,
ChromaEdi: str = '',
EdiExt: Optional[vs.VideoNode] = None,
Sharpness: Optional[float] = None,
SMode: Optional[int] = None,
SLMode: Optional[int] = None,
SLRad: Optional[int] = None,
SOvs: int = 0,
SVThin: float = 0.0,
Sbb: Optional[int] = None,
SrchClipPP: Optional[int] = None,
SubPel: Optional[int] = None,
SubPelInterp: int = 2,
BlockSize: Optional[int] = None,
Overlap: Optional[int] = None,
Search: Optional[int] = None,
SearchParam: Optional[int] = None,
PelSearch: Optional[int] = None,
ChromaMotion: Optional[bool] = None,
TrueMotion: bool = False,
Lambda: Optional[int] = None,
LSAD: Optional[int] = None,
PNew: Optional[int] = None,
PLevel: Optional[int] = None,
GlobalMotion: bool = True,
DCT: int = 0,
ThSAD1: int = 640,
ThSAD2: int = 256,
ThSCD1: int = 180,
ThSCD2: int = 98,
SourceMatch: int = 0,
MatchPreset: Optional[str] = None,
MatchEdi: Optional[str] = None,
MatchPreset2: Optional[str] = None,
MatchEdi2: Optional[str] = None,
MatchTR2: int = 1,
MatchEnhance: float = 0.5,
Lossless: int = 0,
NoiseProcess: Optional[int] = None,
EZDenoise: Optional[float] = None,
EZKeepGrain: Optional[float] = None,
NoisePreset: str = 'Fast',
Denoiser: Optional[str] = None,
FftThreads: int = 1,
DenoiseMC: Optional[bool] = None,
NoiseTR: Optional[int] = None,
Sigma: Optional[float] = None,
ChromaNoise: bool = False,
ShowNoise: Union[bool, float] = 0.0,
GrainRestore: Optional[float] = None,
NoiseRestore: Optional[float] = None,
NoiseDeint: Optional[str] = None,
StabilizeNoise: Optional[bool] = None,
InputType: int = 0,
ProgSADMask: Optional[float] = None,
FPSDivisor: int = 1,
ShutterBlur: int = 0,
ShutterAngleSrc: float = 180.0,
ShutterAngleOut: float = 180.0,
SBlurLimit: int = 4,
Border: bool = False,
Precise: Optional[bool] = None,
Tuning: str = 'None',
ShowSettings: bool = False,
GlobalNames: str = 'QTGMC',
PrevGlobals: str = 'Replace',
ForceTR: int = 0,
Str: float = 2.0,
Amp: float = 0.0625,
FastMA: bool = False,
ESearchP: bool = False,
RefineMotion: bool = False,
TFF: Optional[bool] = None,
nnedi3_args: Mapping[str, Any] = {},
eedi3_args: Mapping[str, Any] = {},
opencl: bool = False,
device: Optional[int] = None,
) -> vs.VideoNode:
und welche direkt durch die Presets abgedeckt werden
# Very Very Super Ultra
# Preset groups: Placebo Slow Slower Slow Medium Fast Faster Fast Fast Fast Draft
TR0 = fallback(TR0, [ 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 0 ][pNum])
TR1 = fallback(TR1, [ 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1 ][pNum])
TR2X = fallback(TR2, [ 3, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0 ][pNum])
Rep0 = fallback(Rep0, [ 4, 4, 4, 4, 3, 3, 0, 0, 0, 0, 0 ][pNum])
Rep2 = fallback(Rep2, [ 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 0 ][pNum])
EdiMode = fallback(EdiMode, ['NNEDI3', 'NNEDI3', 'NNEDI3', 'NNEDI3', 'NNEDI3', 'NNEDI3', 'NNEDI3', 'NNEDI3', 'NNEDI3', 'Bwdif', 'Bob' ][pNum]).lower()
NNSize = fallback(NNSize, [ 1, 1, 1, 1, 5, 5, 4, 4, 4, 4, 4 ][pNum])
NNeurons = fallback(NNeurons, [ 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0 ][pNum])
EdiMaxD = fallback(EdiMaxD, [ 12, 10, 8, 7, 7, 6, 6, 5, 4, 4, 4 ][pNum])
SMode = fallback(SMode, [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0 ][pNum])
SLModeX = fallback(SLMode, [ 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0 ][pNum])
SLRad = fallback(SLRad, [ 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ][pNum])
Sbb = fallback(Sbb, [ 3, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 ][pNum])
SrchClipPP = fallback(SrchClipPP, [ 3, 3, 3, 3, 3, 2, 2, 2, 1, 1, 0 ][pNum])
SubPel = fallback(SubPel, [ 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1 ][pNum])
BlockSize = fallback(BlockSize, [ bs, bs, bs, bs, bs, bs, bs2, bs2, bs2, bs2, bs2 ][pNum])
bs = BlockSize
Overlap = fallback(Overlap, [ bs // 2, bs // 2, bs // 2, bs // 2, bs // 2, bs // 2, bs // 2, bs // 4, bs // 4, bs // 4, bs // 4][pNum])
Search = fallback(Search, [ 5, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0 ][pNum])
SearchParam = fallback(SearchParam, [ 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1 ][pNum])
PelSearch = fallback(PelSearch, [ 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1 ][pNum])
ChromaMotion = fallback(ChromaMotion, [ True, True, True, False, False, False, False, False, False, False, False ][pNum])
Precise = fallback(Precise, [ True, True, False, False, False, False, False, False, False, False, False ][pNum])
ProgSADMask = fallback(ProgSADMask, [ 10.0, 10.0, 10.0, 10.0, 10.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ][pNum])
Quelle: https://github.com/Selur/VapoursynthScri...avsfunc.py
QTGMC ist ja gerade ein Skript, was viele Parameter und Presets hat, damit auch ohne die Syntax voll zu verstehen brauchbar deinterlacen kann. 
Zu BWDIF:
bwdif.Bwdif(vnode clip, int field[, vnode edeint=None, int opt=0])
Quelle: https://github.com/HomeOfVapourSynthEvol...ynth-Bwdif
Quote:edeint: Allows the specification of an external clip from which to take spatial predictions instead of having Bwdif use cubic interpolation. This clip must be the same width, height, and colorspace as the input clip. If using same rate output, this clip should have the same number of frames as the input. If using double rate output, this clip should have twice as many frames as the input.
Was für Optionen sollen den zur Auswahl stehen und was für Code soll erstellt werden?
Bei YadifMode wird einfach:
edeint=core.znedi3.nnedi3(clip=clip,field=X)
edeint=core.eedi3.eedi3(clip=clip,field=X)
edeint=core.nnedi3cl.NNEDI3CL(clip=clip,field=X)
verwendet. (field=X in NNEDI3 ist nicht der gleiche field-Wert wie bei YadifMod, glaube bei BWDIF sind sie gleich)
Was znedi3 kann, kannst Du bei https://github.com/sekrit-twc/znedi3 sehen.
Was NNEDI3CL kann, kannst Du bei https://github.com/HomeOfVapourSynthEvol...h-NNEDI3CL sehen.
Was EEDI3 bzw. EEDI3CL kann, kannst Du bei https://github.com/HomeOfVapourSynthEvol...ynth-EEDI3 sehen.
in durchaus bereit in BWDIF Elemente hinzufügen, um den edeint-Parameter zu nutzen, brauch aber mehr Details, da ich selber BWDIF nicht nutze.
Wenn Du mir (!genau!) sagen kannst, was für Parameter mit welchen Werten unterstützt werden sollen und was da für Code entstehen muss, kann ich da was für schreiben.
Cu Selur
Posts: 10.933
Threads: 56
Joined: May 2017
Habe mal eine dev Version gemacht (Link habe ich Dir per PM geschickt), in der ich analog zu YadifMod auch bei BWDIF 'edeint' als Parameter hinzugefügt habe.
Wie gesagt, kann da mehr Optionen dazupacken, muss aber wissen welche mit welchen erlaubten Werten.
Zum Hinzufügen einer Option brauche ich immer:
a. Beschreibung, was die Option macht. (tool-tip-Text)
b. Eine Liste der erlaubten Werte bzw. erlaubtes Minimum und Maximum.
c. den Defaultwert.
Cu Selur
Posts: 9
Threads: 4
Joined: Oct 2023
Hey,
erstmal vielen lieben Dank für die schnelle Antwort sowie für die Bereitstellung der Dev Version.
Zu QTGMC hatte ich mal einen Thread bei videohelp erstellt ( Why is QTGMC so destructive and why do so many people still recommend it? - VideoHelp Forum), sehe auch gerade dass du da vor nem Jahr auch kommentiert hast. Werde bei Gelegenheit mal schauen ob ich dir da paar Samples zeigen kann bei denen man sieht was ich meine. Durch den Thread bin ich übrigens auch auf die Kombi BWDIF + NNEDI3 gekommen.
Kurz gesagt ist mir QTGMC für meinen Geschmack einfach zu viel des Guten, habe selbst nach stundenlangem Tuning nicht das Ergebnis erzielt auf das ich gehofft habe. Habe viele ältere DVDs von Sitcoms aus den 80ern/90ern die sehr noisy/grainy sind und egal welche Settings ich versucht habe hat dazu geführt dass sich bewegende Personen (vorallem Köpfe) die Struktur vom Grain/Noise - in dem Areal wo die Bewegung stattfand - verändert hat sodass z.B. die Köpfe wie eine Art Magnet auf das Grain/Noise wirkten. Sehr schwierig zu beschreiben, die Umrandung der Köpfe sah dann immer anders aus als die Wand dahinter, d.h. in einem bestimmten Radius wurde es geblurrt oder so.
Ich zitiere mal den Kommentar von poisondeathray bei meinem Thread:
Quote:Yes, stuck grain, blocks moving in wrong direction, temporal artifacts
Das hat mir ein wenig Hoffnung gegeben dass ich nicht der einzige war dem das aufgefallen ist.
Aber ja, QTGMC erstmal beiseite denn ich für mich hab damit sowieso schon (zum reinen Deinterlacing zumindest) eh abgeschlossen. Ist mir ehrlich gesagt viel zu viel tunen, und am Ende bin ich trotzdem nicht zufrieden. Ist mir persönlich den Aufwand und die Zeit nicht wert wenn ich stattdessen BWDIF + NNEDI3 nutzen kann und eigentlich nichts weiter einstellen muss. Klar sieht QTGMC an manchen Stellen besser aus (z.B. Anti-Aliasing) aber für meinen Geschmack greift es zu sehr in das Source Material ein (egal bei welchen Settings).
Quote:Was für Optionen sollen den zur Auswahl stehen und was für Code soll erstellt werden?
Das ist jetzt leider ein bisschen tricky. Wie gesagt, habe mich nie wirklich mit VapourSynth auseinander gesetzt. Also mein go-to "Script" für TFF in AviSynth ist einfach:
BWDIF(field=3, edeint=nnedi3(field=3, nns=4, qual=2, nsize=3))
Dann schaue ich ob ich noch mehr tunen kann, wie z.B. den preescreener oder andere nns Werte.
Bin aber gerade etwas verunsichert. Bin ich korrekt in der Annahme dass field=3 für TFF input der gebobbt wird ist? Wiki sagt " 3 = double rate (alternates each frame), starts with top" also hab ichs immer so verstanden dass 1 oder 3 = TFF und 0 oder 2 = BFF.
Habe mir mal angeschaut wie Hybrid (Dev) das VS Script erstellt und so an meine Settings angepasst:
NNEDI3CL:
# Deinterlace using Bwdif
clip = core.bwdif.Bwdif(clip=clip, field=3, edeint=core.nnedi3cl.NNEDI3CL(clip=clip,field=3,nns=4,qual=2,nsize=3)) # new fps: 50
znedi3:
# Deinterlace using Bwdif
clip = core.bwdif.Bwdif(clip=clip, field=3, edeint=core.znedi3.nnedi3(clip=clip,field=3,nns=4,qual=2,nsize=3)) # new fps: 50
Die Github Links die du gesendet hast machen ja auf mich den Eindruck dass die meisten Parameter dieselben sind wie beim "originalen" AviSynth NNEDI3, sprich field, nns, qual, nsize, etype. Einzig bei pscrn unterscheidet sich NNEDI3CL von znedi3 und dem regulären NNEDI3. Denn bei NNEDI3CL kann man den prescreener nur auf 1 (old) oder 2 (new stellen) während bei znedi3 und AVS NNEDI3 eine Auswahl von 0-4 möglich ist. Also NNEDI3CL scheint da schon etwas unterschiedlicher zu sein, wäre aber auch froh wenn "nur" znedi3 implementiert ist, denn soweit ich das jetzt gesehen habe unterscheidet sich das nicht vom klassischen AVS NNEDI3.
Um aber nochmal auf BWDIF generell zurückzukommen, passt bis dahin ja alles. Die field= values sind ja dieselben wie bei znedi3 bzw. NNEDI3CL und viel mehr gibt es ja sowieso nicht einzustellen. Deshalb ist die Dev Version eigentlich was BWDIF angeht schon ausreichend, das einzige was mir noch fehlt wären eben die Optionen für den edeint.
Wie gesagt, am wichtigsten sind für mich eben nns, qual, nsize, etype, pscrn. Field könnte man ja so einstellen dass die selbe value wie für BWDIF genommen wird, sind ja eh die selben ( aber nur bei znedi3/NNEDI3CL). Mit EEDI3 oder EEDI3CL hab ich leider noch nie zu tun gehabt, kann dazu also nichts sagen außer dass field= hier wieder genau wie bei BWDIF ist.
Quote:Wenn Du mir (!genau!) sagen kannst, was für Parameter mit welchen Werten unterstützt werden sollen und was da für Code entstehen muss, kann ich da was für schreiben.
Kann ich gerne machen, aber das meiste werde ich aus den Github Seiten kopieren, weiß jetzt nicht ob dir das so viel bringt. Vorallem bei dh= bin ich wirklich überfragt, da die default value ja false ist, es wird aber von interpolieren gesprochen. Oder ist das nur relevant für Upscaling?
Wie gesagt habe ich selber nie mit VS gescriptet, da ich da irgendwie nicht durchblicke mit z.B. clip=, da war AviSynth echt besser für Noobs wie mich 
Hätte aber auch garnichts dagegen wenn du BWDIF mit edeint Parameter nur für den AviSynth Teil implementierst.
Die Github page von BWDIF verwirrt mich auch etwas, da im Code folgendes steht:
bwdif.Bwdif(vnode clip, int field[, vnode edeint=None, int opt=0])
das Script was Hybrid ausspuckt (siehe weiter oben) hat eben nicht vnode & int field drinnen und ich bin da auch ehrlich gesagt komplett überfordert wie was wo gescriptet werden muss. Auch beim Vanilla BWDIF Script von der Hybrid Dev Version bin ich überfordert:
# Deinterlace using Bwdif
clip = core.bwdif.Bwdif(clip=clip, field=3, edeint=core.znedi3.nnedi3(clip=clip,field=3)) # new fps: 50
z.B. bei BWDIF selber wird noch mit Leerzeichen gearbeitet, sobald die Klammer aber für znedi3 aufgeht eben nicht mehr.
Posts: 10.933
Threads: 56
Joined: May 2017
vnode und int sind beschreiben welche Typen die Parameter haben, die gehören nicht in den Aufruf rein.
=>ich schau mal ob ich die Woche etwas Zeit finde um auf die nnedi3&co Parameter zu schauen.
Posts: 9
Threads: 4
Joined: Oct 2023
(22.10.2023, 17:26)Selur Wrote: vnode und int sind beschreiben welche Typen die Parameter haben, die gehören nicht in den Aufruf rein.
=>ich schau mal ob ich die Woche etwas Zeit finde um auf die nnedi3&co Parameter zu schauen.
Vielen lieben Dank! Wie gesagt ich kann das gerne nochmal alles zusammenfassen, allerdings denke ich wird die Formatierung in den jeweiligen Github Repos einfacher zu verstehen sein als wenn ich sie poste.
Mal ne ganz andere Frage: ist es irgendwie möglich einen temporären (lossless) Videostream zu generieren, wenn man 2-Pass Encoding benutzt? Ich hab z.B. bei Reencodes das Problem dass wenn ich 2-Pass Encoding nutze Hybrid die ganzen Filter usw. 2 mal rendert (1. Pass und 2. Pass), was je nach gewählten Filtern etc. ja doppelt so lange dauert. Klar könnte ich auch einfach CRF bei x264 benutzen, allerdings hab ich z.B. viele WEB-DLs die Interlacing Artefakte aufweisen und rausgefiltert werden müssen und ich zwar a) natürlich soviel Qualität wie möglich beibehalten möchte, aber auch b) nicht unnötig Bitrate verschwenden will. Was ich meistens mache ist mit Bitrate Viewer/MediaInfo die originalen Files analysiere und dann einfach 500-1000 kbit/s beim 2-Pass Encode draufpacke, bin damit eigentlich immer zufrieden gewesen. Bei CRF ist es immer so ne Art Ratespiel wenn man mit bereits sehr komprimiertem Material arbeitet.
Weiß ja nicht genau wie die Encoding Pipeline bei Hybrid funktioniert aber gibt es da zufällig eine Option die den Videostream inkl. Filter lossless rendert und solange zwischenspeichert bis der Job (und somit auch der finale Encode) fertig ist?
Also könnte natürlich auch einfach statt x264 irgendeinen Lossless Encoder nehmen (FFvHuff, FFV1, UT Video), die ganzen Filter reinpacken und damit quasi "Proxies" erstellen, und danach in Hybrid importieren und final mit x264 encoden. Allerdings habe ich da irgendwie zu sehr Schiss dass Colorspace, etc. Informationen verloren gehen und generell wüsste ich dann auch nicht für welchen Lossless Encoder ich mich entscheiden sollte. Automatisiert wär das natürlich sehr nice, ist aber eher ein Komfort Ding und eigentlich nebensächlich (nice to have).
Schönen Sonntag dir noch 
Posts: 10.933
Threads: 56
Joined: May 2017
Ich kann mal darüber nachdenken, eine Option für ein 3pass Encoding einzubauen. (wenn ich das BWDIF fertig habe)
Erster Druchlauf erzeugt lossless encode.
Zweiter Druchlauf macht x264 2pass 1st-pass
Dritter Druchlauf macht x264 2pass 2nd-pass
Kann Sinn machen, wenn das Filtering sehr langsam ist.
Quote:Klar könnte ich auch einfach CRF bei x264 benutzen, allerdings hab ich z.B. viele WEB-DLs die Interlacing Artefakte aufweisen und rausgefiltert werden müssen und ich zwar a) natürlich soviel Qualität wie möglich beibehalten möchte, aber auch b) nicht unnötig Bitrate verschwenden will.
okay.
Quote:Was ich meistens mache ist mit Bitrate Viewer/MediaInfo die originalen Files analysiere und dann einfach 500-1000 kbit/s beim 2-Pass Encode draufpacke, bin damit eigentlich immer zufrieden gewesen.
Okay,...
Quote:Weiß ja nicht genau wie die Encoding Pipeline bei Hybrid funktioniert aber gibt es da zufällig eine Option die den Videostream inkl. Filter lossless rendert und solange zwischenspeichert bis der Job (und somit auch der finale Encode) fertig ist?
Wenn man in den Jobs 'Minimize job command line' deaktiviert, sieht man die Aufrufe, die Hybrid macht.
Aktuell gibt es dafür keine Option.
Quote:Also könnte natürlich auch einfach statt x264 irgendeinen Lossless Encoder nehmen (FFvHuff, FFV1, UT Video), die ganzen Filter reinpacken und damit quasi "Proxies" erstellen, und danach in Hybrid importieren und final mit x264 encoden.
Hoffe, Du bist Dir darüber im klaren wie groß lossless Encodes sind, insbesondere bei hochauflösendem Material frisst das einiges an Platz.
=> ich denke mal darüber nach
Cu Selur
Posts: 10.933
Threads: 56
Joined: May 2017
Habe Dir mal nen Link geschickt zu ner dev Version die für NNEDI3 die Parameter 'nsize','nns' und 'etype' zur Verfügung stellt.
Denke es macht keinen Sinn die anderen Parameter da noch hinzuzufügen, da man die nicht ändern sollte.
Cu Selur
Posts: 9
Threads: 4
Joined: Oct 2023
(22.10.2023, 19:02)Selur Wrote: Habe Dir mal nen Link geschickt zu ner dev Version die für NNEDI3 die Parameter 'nsize','nns' und 'etype' zur Verfügung stellt.
Denke es macht keinen Sinn die anderen Parameter da noch hinzuzufügen, da man die nicht ändern sollte.
Cu Selur
Hey,
sorry habe eine so schnelle Antwort bzw. Dev Version garnicht erwartet Habe leider auch keine E-Mail bekommen, sonst hätte ich direkt geantwortet.. Jedenfalls ist der Downloadlink leider nicht mehr gültig und wollte fragen ob es eventuell möglich ist an einen neuen Link zu kommen?
Danke dir!
Posts: 10.933
Threads: 56
Joined: May 2017
Habe Dir einen neuen Link geschickt, der so ca. 16 Stunden noch aktiv sein sollte.
Cu Selur
|
