Deinterlacing with AVISynth and QTGMC - Updated occasionally

Welcome to the new home of my QTGMC deinterlacing tutorial. This post will be updated periodically as new changes happen and new info comes out, or until a better option comes along.

Changes since last post/video:

• I've switched to an entirely 64-bit workflow
• QTGMC has some new requirements
• I've dropped FFMPEG as the recommended rendering program in favor of VirtualDub2
• AVISynth Info Tool is now the recommended way to check and make sure that you've installed AVISynth correctly.

BIG DISCLAIMER: This process may not work, may crash, or may do other things to your system. Virus scan everything you download. It's not a 100% guarantee that you'll avoid getting a malware infection, but it's a lot better than not checking at all.

If you're doing professional work, always watch any files you create using this process before submitting/uploading them to check for audio and/or video glitches.

Follow this tutorial at your own risk. 

Also, this tutorial is for Windows 10. Most of the steps work for previous versions of Windows, but may require slight modifications. Users of MacOS and other OSes should look elsewhere.

Here's the video version of the setup and basic QTGMC deinterlacing workflow:

Setup

7-zip (optional)

If you don't have 7-zip already installed, you won't be able to open many of the downloaded archives. The stable, 64-bit version should be fine.

Next, we're going to need to get AVISynth+. You can grab it from here:

https://github.com/AviSynth/AviSynthPlus/releases

If you don't already have the MSVC 2019 Redistributable installed, grab the version ending with "vcredist".

Then, we'll need to get all the filters (plugins) needed:

FFMPEGSource

Note: Version 2.40 has been shown to corrupt video frames. Please either use a different version, or use LSMASHSource as linked below.

This is what will allow AVISynth+ to load our video files. Works with almost any container/codec combination, but read the "Known Issues" section for things to look out for (hint: don't use interlaced h.264 video with it).

Note: If you do need to work with interlaced h.264 video, try LSMASHSource instead. It requires two commands rather than one to work (technically three if you count AudioDub(video, audio) to combine the two together), but can support some non-standard formats. Thanks to neonfrog for the heads up.

QTGMC

The deinterlacing plugin of choice. Requires a whole host of additional plugins, of which you will be using the 64-bit versions (if an option is given). For most uses, only the "Core Plugins and scripts" are necessary.

For the "Zs_RF_Shared.avsi" link, right-click on the link and do "Save Link As", or whatever the equivalent is in your browser of choice.

DO NOT forget to download the 32-bit FFTW3 library as well. Without it, QTGMC will not run.

With all the AVISynth filters and scripts grabbed, it's time to get the supporting software:

AvsPMod

This is like an IDE for AVISynth scripts, and is pretty much essential IMO. Grab the 64-bit version for this tutorial.

AVISynth Info Tool

This allows us to detect processor features and check to see if AVISynth is properly installed.

Finally we need to grab a rendering program.  For ease of use, I now recommend VirtualDub2 - a fork of the original program used to render AVISynth scripts. 

VirtualDub2

When finished downloading, virus scan all the things.

Installing

AVISynth+ has a simple installer. I recommend installing into whatever your user folder is (for example C:\Users\Me\) rather than the default of Program Files(x86) so you don't have to deal with authentication requests every time you add a plugin. Also, I highly recommend checking the "Add AVISynth Script to New items menu" option. Otherwise, you can stick with the defaults.

Then, go to the plugins64+ directory for AVISynth+. For example, the default install creates a plugin folder at:

C:\Program Files(x86)\AVISynth+\plugins64+\

Extract all "x64" versions of the .dll and .avsi files to the plugins directory (if given a choice) from all plugins EXCEPT the fftw-3*.dll archive. If there's a choice between AVX, AVX2 and a version without AVX, you'll need to know what instruction sets your processor supports. CPU-Z  or AVISynth Info Tool can tell you this if you're not sure.

Now, open the fftw-3*.dll archive, then (as noted on the QTGMC page) extract the libfftw3f-3.dll file. Make a copy of it and rename it as "FFTW3.dll". Place the files "libfftw3f-3.dll" and "FFTW3.dll" in the SysWow64 folder. Don't ask me why you have to do this, I agree that it seems pointlessly tedious.

Please note: If you're only using AVISynth+ (not older versions of AVISynth) and only need to use QTGMC, you can skip the above step and just download/put the 64-bit version of libfftw3f-3.dll in the plugins64+ directory. Despite the error message in 32-bit AVSInfoTool, QTGMC will now work in both modes (although you can drop the 32-bit version of libfftw3f-3.dll in the plugins+ director to clear the error if you like, and to clear the Zf_RF_Shared error, you need to do the regular install method above). 

Also, if you want to be able to run QTGMC's "EZDenoise" & "Sharpness" functions, put the 64-bit version of "fft3dfilter.dll" into the plugins64+ directory.

Thanks to Spammy Family for pointing this out.

Speaking of tedious, if you want to use the "Very Slow" or "Placebo" preset for QTGMC, it looks like you need to install the 64-bit version of FFTW in your System32 directory using the same method mentioned above.

Extract the AvsPMod archive to wherever you want to run it from - again, I recommend your user folder.

Extract AVISynth Info Tool in the same way. If you like, you can install it more officially by clicking on the AVSInfoToolInstaller.exe file, but I generally just run it directly from the "AVSInfoTool_FilesOnly" folder. 

Go ahead and run it now, making sure to select the "AVISynth 64-bit" option once loaded.  If you get errors that are not about the FFTW3 library or Zs_RF_Shared.avsi (to fix those errors, install the 64-bit version of FFTW in your System32 directory using the same renaming/copying process listed above), then double-check and make sure you followed all the previous steps correctly. You might also want to take note of how many cores and logical processors you have, along with what instruction sets are supported by your CPU. 

Finally, create a folder for VirtualDub2 and extract its archive there.

Making your .avs script

Now that everything's ready, let's go to the directory with your video files and make an .avs script. Right-click anywhere in the directory, select New, then AVISynth Script and rename it however you want. If that option doesn't show up, you can just create a new text file and change the .txt extension to .avs.

Open AvsPMod, then go to the Options menu and click on "Associate .avs files with AvsPMod". You should now be able to double-click on .avs scripts and have them open directly in AvsPmod. Do so with the script you just created.

Here's my boilerplate .avs script settings for deinterlacing:

    SetFilterMTMode ("QTGMC", 2)
    FFMPEGSource2("videofile.avi", atrack=1)

    AssumeBFF()
    QTGMC(preset="Slower")
    BilinearResize(720,540)
    Prefetch(10)


The "atrack=1" option for FFMPEGSource selects the track of audio that is passed through during processing. If the default option doesn't give you audio in the results, try "atrack=-1" instead.

Please note that by default both FFMPEGSource and (certain modes of) LSMASHSource index your video file the first time you load the .avs script into either AvsPMod or your rendering program of choice. This may take a while and give the appearance of freezing the program. When it's finished, you'll see an .ffindex or .lwi file appear in the same directory as your video with the same name as your video.

Also note that LSMASH requires separate commands for video and audio along with a dub command to recombine them. for example:

a=LWLibavAudioSource(source="yourfile.m2ts", stream_index=-1, cache=true, av_sync=true, rate=0, decoder="")

v=LWLibavVideoSource("yourfile.m2ts")

AudioDubEx(v,a)

For more info, check out the wiki page here: http://avisynth.nl/index.php/LSMASHSource

If you're trying to load an .avi file, you should probably try:

AVISource("yourfile.avi", audio=true)

instead of FFMPEGSource, as AVISource has better performance and can support some edge case .avi codecs that FFMPEGSource struggles with.

AssumeBFF/TFF deals with interlaced field order.  Simple rule of thumb here: home videos are probably going to be BFF, commercially released dvds or professional video are probably going to be TFF. You'll know if you get this wrong if you preview the video and it "jumps" every other frame.

You may or may not need either

ConvertToYV12(interlaced=true)

or

ConvertToYUY2(interlaced=true)

commands before QTGMC depending on the type of video that you're feeding into FFMPEGSource2. I used to use ConvertToYV12() frequently on older versions of QTGMC that didn't support other color formats, but the current version seems to be a lot more forgiving. 

The main difference between YV12 and YUY2 has to do with chroma subsampling (which is a whole other rabbithole to go down)  but to simplify - some older AVISynth plugins only support YV12, while other support both YV12 and YUY2. If a plugin complains about your source footage not being in either color format, convert to YUY2 if you can.

It's a good idea to try previewing the script without a Convert command and see if it works first, if not then add it in. Thanks to ENunn for the suggestion about adding interlaced=true, which should reduce chroma smearing errors.

The resize I use in this case is to correct the pixel aspect ratio of the footage. I explain in more detail in the video tutorial, but basically SD video was designed to be shown on TVs that slightly vertically stretched the image (or very slightly horizontally in the case of PAL). On "square pixel" displays (pretty much every display except for analog TVs), you need to correct for this in order for the image to have the right proportions. I enlarge the image to retain some detail and create a new "master" version that I can use in different ways, but if you're trying to convert something for a major streaming service, they usually want 640x480 for SD content (and 29.97 or 25 fps rather than 59.94 or 50fps). You can do a different resize method here like Lanczos or Spline64 if you'd like to add some light sharpening.

If you want to upscale slightly to correct the pixel aspect ratio instead (like I did in the example script above), then 720x540 is correct for NTSC, and 768x576 is correct for PAL.

The Prefetch number should be set to 1 or 2 less than the number of "logical processors" in your system. To check what that is, go to Task Manager in Windows, select the Performance tab, then click on the CPU item. You'll see down below in the window an entry for the number of logical processors in your system. For some people, it will be the same as the number of physical cores, for others it might be double that if your CPU supports Hyperthreading. In my case, I have 12 logical processors, so I set Prefetch to 10.

On the other hand, EdiThreads is supposed to be set to half the number of physical cores in your system, and if so can give a mild speed boost. With the current workflow, I've been able to set it to 3 with no issues (only my 6-core system), but your mileage may vary. If you experience any random rendering freezes (not overall system freezes), then lower this number first before restarting the render. 

Update: Looks like EdiThreads can now use all cores without stability issues, so I'm removing my advice about it. If you run into render freezes, you might try adding EdiThreads=1, otherwise leave it out.

If you need to output 29.97fps (25fps for PAL) rather than 59.94fps (50fps for PAL) at this stage, then add FPSDivisor=2 to the QTGMC command like so:

    QTGMC(preset="Slower", FPSDivisor=2)

Rendering

Instead of using command-line FFMPEG, I'm now recommending VirtualDub2 for rendering out AVISynth scripts. This is mainly because VirtualDub2 is a lot easier for most people to work with and seems to be staying around.

Working with AVISynth scripts in VirtualDub2 is pretty simple - launch VirtualDub2, drag your script into the main window, then wait for the preview to appear. Set your desired compression settings under the video and audio menus. Please note: the audio menu defaults to "direct stream copy", which you should change to "full processing mode", then you can select compression afterwards.

I personally use ProRes for most conversions, but you can choose from a variety of other codecs.  I might go into details about the particular settings in a separate blog post/video. 

To export the video, go to the file menu, then select "save video".  Make sure you select the correct file type for the codecs that you're using (For example, you can put H.264 video in an .mp4, .mov, or .mkv container, but ProRes will only go in .mov or .mxf).

Watch your video before sending it out anywhere to make sure that there are no glitches.  I've gotten burned by this in the past when exporting out multiple episodes of a TV series that had random audio dropouts.

PS: VirtualDub2 doesn't generate "official" ProRes files, so if it will be the last stop in your export chain, consider using a different workflow if the file is going to a major TV channel. Some channels have reportedly (at least according to editors on Reddit's /r/editors subreddit) said that FFMPEG ProRes files won't pass QC with them.

Optional - Cropping and resizing to HD resolutions

Here's what to add if you want to upscale SD to HD with a center crop:

    Crop(0,68,0,-68)
    Spline64Resize(1280,720)

Note that the numbers in the crop command refer to left,top,right,bottom respectively, and the right and bottom numbers are negative, while the left and top numbers are positive. Don't ask me why AVISynth does this, it just does.

The above settings will give you as close to a 16x9 frame as you can get out of this resolution. Technically, 720x405 is true 16x9, but the chroma subsampling options supported by QTGMC don't like odd numbers, so 720x404 is the closest you can get.

Also, this may crop off more than you want, so feel free to play around with the settings. If you want to frame a different part of the image (like the top or bottom versus the middle), then just adjust the crop numbers accordingly by adding what you subtract from one number to the other, or vice versa. For example, to use just the top part of the frame, you would do:

    Crop(0,0,0,-136)

It has a ton of additional features listed on the wiki page, which you can play around with if the defaults don't work for you.

One other thing to note: If you notice a color or gamma shift in your upscaled image on render, try adding:

ColorMatrix(mode="rec.601->rec.709)

after the resize step.

Optional - FFMPEG

If you want to use command-line FFMPEG instead of VirtualDub2, here's some setup instructions:

Open whatever ffmpeg archive you've grabbed, navigate to the "bin" directory, and extract the ffmpeg.exe file to whatever directory your video file/files are located in.

Alternatively, you can extract the archive to somewhere on your system and then set up FFMPEG to run from any directory by adding it to your PATH variable:

1. Press the Windows and R keys.
2. Type "control sysdm.cpl,,3". 
3. Click "Run".
4. Click on "Environment Variables".
5. Select "Path" under "System variables" and click "Edit".
6. Go to where you extracted ffmpeg.exe. 
7. Select and copy the folder's path address from the address bar towards the top of the window.
8. Back in the "Edit environment variable" window, click "New" and paste in the folder path. Click OK on all the windows you opened to get here.

Create a new text file in the same directory as your video(s) and change its extension to .bat. Add the FFMPEG commands of your choice. For example, here's a command to encode an .avs script to a ProRes 422HQ Quicktime file:

    ffmpeg -i "videofile.avs" -c:v prores -profile:v 3 -pix_fmt yuv422p10le "output.mov"