QTGMC EZDenoise Help Needed

[VideoFanatic]

I was wondering if there's a way to get EZDenoise to work on interlaced TV sources such as sporting events? The video source is interlaced and I want to encode to interlaced.

[jagabo]

You can deinterlace with QTGMC then re-interlace with SeparateFields().SelectEvery(4,0,3).Weave(). Or you can try SeparateFields().QTGMC((InputType=1, EZDenoise=2).Weave().

<edit>
The latter doesn't work very well. QTGMC tries to fix the bobbing and ends up creating aliasing artifacts at edges.
</edit>

[lordsmurf]

Certain filters I use are interlaced-domain only. So I've sometimes taken progressive source, used the filter, then re-deinterlaced it. Some self-proclaim purists may poo-poo this, but it's hard to argue the results. (And I highly doubt that they could do better.)

I'm curious what your issue is.

[johnmeyer]

I've kept this "advice" in a "how to" file for many years. Perhaps it will help:

"If you want to process interlaced video (thus leaving it interlaced), you should remember the following issue. When using only a spatial smoother, it is sufficient to use:

SeparateFields()
Filter(...)
Weave()

But when using a spatio-temporal smoother (or just a temporal smoother), this produces incorrect results. The reason is that the temporal smoothing occurs over two fields from the same frame (this happens for half the number of frames). To avoid this, you should put them in different clips:

SeparateFields()
even = SelectEven(last).Filter(...)
odd = SelectOdd(last).Filter(...)
Interleave(even, odd)
Weave()
"

So temporal filtering on an interlaced clip is ok if you put the fields in different clips i.e. using selecteven and selectodd.

The second, more complicated code, is what you need to use with any temporal denoiser. I assume the denoiser you are talking about (I've never heard of it) is temporal. So, you would use the second set of code and replace "Filter()" with the name of your filter.

The idea of this code is that you create two clips, each one from matching points in space (i.e., all top fields as one clip, and all bottom fields in the second clip). You then do two deparate denoising steps, each on half the fields, and then recombine them together back into the original interlaced clip. Since there is no deinterlacing, there are no artifacts introduced by the deinterlacing process (no matter how good, deinterlacing always degrades your video).

Some can (and do) argue that this approach is not as "accurate" as deinterlacing to 2x the frame rate, denoising, and then doing a selecteven and selectodd and reinterlacing. I've never seen any testing to see whether the increased "accuracy" you would get by having the interpolated resolution from the QTGMC-style deinterlacing would offset the artifacts introduced by the deinterlacing itself. It is an interesting question, both theoretically and practically, and is above my pay grade to answer.

Bottom line, for me, is to KISS (Keep It Simple Stupid) and use the second set of code listed above.

[jagabo]

I thought about mentioning that method but I've never really liked it. First, it treats scan lines that are not next to each other as if they are. Second, it treats fields that are not temporally adjacent as if they are. Both of those, especially the first, create problems with QTGMC. Maybe using the SourceMatch and Lossless options will help.

[manono]

It looks to me like it's bobbed before anything else is done, so using EZDenoise (or any of the included denoisers specifically) shouldn't be a problem. From the QTGMC doc:

The core algorithm is this:
0. Bob the source clip. Temporally smooth the bob to remove shimmer then analyse its motion
1. More accurately interpolate the source clip (e.g. NNEDI3). Use the motion analysis from previous step to temporally smooth this interpolate with motion compensation. This removes shimmer whilst retaining detail. Resharpen the result to counteract any blurring
2. A final light temporal smooth to clean the result

[ajk]

For strictly temporary deinterlacing I usually use

Bob(0.0, 1.0)

This is the "lossless" version of bob(), i.e. it fills in the missing field with interpolated data while keeping the original field intact. It has been a nice and fast method if you just need to do a bit of denoising or something but the intention is to keep the format ultimately unchanged.

QTGMC() has a lossless mode that works the same way, except of course it interpolates the missing lines in a more advanced fashion.