Tutorial - Using FFMPEG for DNxHD/DNxHR encoding, resizing, and batch encoding

Before I begin, I'd like to acknowledge Jon Hall, whose recently deceased web page taught me how to set up FFMPEG in my system path. Also, a shoutout to /u/kichigai on the Reddit /r/editors subreddit for his excellent FFMPEG for editors FAQ:

https://www.reddit.com/r/editors/wiki/ffmpeg

If you want a comprehensive look at FFMPEG for a bunch of editing tasks, the above link is the way to go. If you want a video tutorial for a comprehensive FFMPEG setup, check out my tutorial for setting up FFMPEG 32-bit (along with an alternate install method for AVISynth+).

Or, you could try setting up both the 32-bit and 64-bit versions of FFMPEG (along with AVISynth+) at the same time.


BIG DISCLAIMER: This process may not work, may crash, or do other things to your system. Virus scanning all files is strongly encouraged, but not a 100% guarantee of safety.

You have been warned. 

Also, this tutorial is for Windows 10. Most of the steps work for other OSes, but I won't cover the differences here.



Regardless, I'm going to assume for the rest of this post that you already have FFMPEG installed.

First, let's start with a quick review of an FFMPEG command. Note that the line below doesn't actually run as written; this is just to show you the basic structure of the command:

ffmpeg -i "inputvideo.mp4" -c:v videocodec -c:a audiocodec "outputvideofile.mp4"

Simple enough, right? -i for input, -c:v for video codec, -c:a for audio codec, and then the name of the output file. There's a bunch of other options you can put in amongst this, but basically, this is the way the command is structured.


DNxHD, DNxHR, ProRes and Cineform are all what are known as "intermediate codecs". This means that they're designed to be used to transcode footage from other sources into a form that's easy for video editing programs to work with while maintaining quality. So, unlike most h.264 implimentations, they focus on low CPU usage, retaining as much detail as possible,  and an ability to be re-compressed several times without significant loss in quality. They have larger bitrates than consumer video codecs, but they still represent a significant space savings over fully uncompressed video.

DNxHD and DNxHR are Avid's intermediate codecs, designed to work well with Avid Media Composer, and as competition for ProRes. They have roughly equivalent quality to ProRes, but, like Media Composer, are organized in a more complicated manner.

DNxHD

DNxHD is the first variant of Avid's intermediate codec, and focuses (as the name suggests) on high-definition resolutions. It works great, but has an incredibly unintuitive naming system for different quality levels and resolutions based on the overall bitrate of the video. If you really want to take a look at the full list, check out this Wikipedia page:

https://en.wikipedia.org/wiki/List_of_Avid_DNxHD_resolutions

In FFMPEG, you need to set the bitrate properly in order for the built-in DNxHD encoder to work. Here's an example command using a 1280x720 h.264 .mp4 file running at 29.97fps:

ffmpeg -i "inputvideo.mp4" -c:v dnxhd -b:v 110M -pix_fmt yuv422p -c:a pcm_s16le "outputvideo.mxf"

Using the list of resolutions, we find that is the correct bitrate to output an 8-bit 422 chroma subsampled 720p video at 29.97fps is 110 megabits, which is denoted by that "110M" setting in the command.

Unfortunately, the official list of bitrates isn't exact. For example, looking at the list, you might assume that if you wanted to do 10-bit instead of 8-bit, you would think that you just had to change the colorspace to yuv422p10le (like we do for ProRes) and keep the bitrate the same. However, that will give you an error. Luckily, DNxHD errors in FFMPEG will list the correct range of supported bitrates. Let's take a look (cropped to relevant section and cleaned up a bit for readability):

Frame size: 1280x720p; bitrate: 90Mbps; pixel format: yuv422p10
Frame size: 1280x720p; bitrate: 180Mbps; pixel format: yuv422p10
Frame size: 1280x720p; bitrate: 220Mbps; pixel format: yuv422p10
Frame size: 1280x720p; bitrate: 90Mbps; pixel format: yuv422p
Frame size: 1280x720p; bitrate: 110Mbps; pixel format: yuv422p
Frame size: 1280x720p; bitrate: 180Mbps; pixel format: yuv422p
Frame size: 1280x720p; bitrate: 220Mbps; pixel format: yuv422p
Frame size: 1280x720p; bitrate: 60Mbps; pixel format: yuv422p
Frame size: 1280x720p; bitrate: 75Mbps; pixel format: yuv422p
Frame size: 1280x720p; bitrate: 120Mbps; pixel format: yuv422p
Frame size: 1280x720p; bitrate: 145Mbps; pixel format: yuv422p

Unfortunately, this list doesn't display framerates, but you'll find that these bitrates work for any framerate within the same frame size and pixel format. In this case, the answer for 10-bit 720p/29.97fps is 180M. So, the command for a 10-bit output would look like this:

ffmpeg -i "inputvideo.mp4" -c:v dnxhd -b:v 180M -pix_fmt yuv422p10le -c:a pcm_s16le "outputvideo.mxf"

Just for reference, here's the complete list that FFMPEG spits out:

Frame size: 1920x1080p; bitrate: 175Mbps; pixel format: yuv422p10
Frame size: 1920x1080p; bitrate: 185Mbps; pixel format: yuv422p10
Frame size: 1920x1080p; bitrate: 365Mbps; pixel format: yuv422p10
Frame size: 1920x1080p; bitrate: 440Mbps; pixel format: yuv422p10
Frame size: 1920x1080p; bitrate: 115Mbps; pixel format: yuv422p
Frame size: 1920x1080p; bitrate: 120Mbps; pixel format: yuv422p
Frame size: 1920x1080p; bitrate: 145Mbps; pixel format: yuv422p
Frame size: 1920x1080p; bitrate: 240Mbps; pixel format: yuv422p
Frame size: 1920x1080p; bitrate: 290Mbps; pixel format: yuv422p
Frame size: 1920x1080p; bitrate: 175Mbps; pixel format: yuv422p
Frame size: 1920x1080p; bitrate: 185Mbps; pixel format: yuv422p
Frame size: 1920x1080p; bitrate: 220Mbps; pixel format: yuv422p
Frame size: 1920x1080p; bitrate: 365Mbps; pixel format: yuv422p
Frame size: 1920x1080p; bitrate: 440Mbps; pixel format: yuv422p
Frame size: 1920x1080i; bitrate: 185Mbps; pixel format: yuv422p10
Frame size: 1920x1080i; bitrate: 220Mbps; pixel format: yuv422p10
Frame size: 1920x1080i; bitrate: 120Mbps; pixel format: yuv422p
Frame size: 1920x1080i; bitrate: 145Mbps; pixel format: yuv422p
Frame size: 1920x1080i; bitrate: 185Mbps; pixel format: yuv422p
Frame size: 1920x1080i; bitrate: 220Mbps; pixel format: yuv422p
Frame size: 1440x1080i; bitrate: 120Mbps; pixel format: yuv422p
Frame size: 1440x1080i; bitrate: 145Mbps; pixel format: yuv422p
Frame size: 1280x720p; bitrate: 90Mbps; pixel format: yuv422p10
Frame size: 1280x720p; bitrate: 180Mbps; pixel format: yuv422p10
Frame size: 1280x720p; bitrate: 220Mbps; pixel format: yuv422p10
Frame size: 1280x720p; bitrate: 90Mbps; pixel format: yuv422p
Frame size: 1280x720p; bitrate: 110Mbps; pixel format: yuv422p
Frame size: 1280x720p; bitrate: 180Mbps; pixel format: yuv422p
Frame size: 1280x720p; bitrate: 220Mbps; pixel format: yuv422p
Frame size: 1280x720p; bitrate: 60Mbps; pixel format: yuv422p
Frame size: 1280x720p; bitrate: 75Mbps; pixel format: yuv422p
Frame size: 1280x720p; bitrate: 120Mbps; pixel format: yuv422p
Frame size: 1280x720p; bitrate: 145Mbps; pixel format: yuv422p
Frame size: 1920x1080p; bitrate: 36Mbps; pixel format: yuv422p
Frame size: 1920x1080p; bitrate: 45Mbps; pixel format: yuv422p
Frame size: 1920x1080p; bitrate: 75Mbps; pixel format: yuv422p
Frame size: 1920x1080p; bitrate: 90Mbps; pixel format: yuv422p
Frame size: 1920x1080p; bitrate: 350Mbps; pixel format: yuv444p10, gbrp10
Frame size: 1920x1080p; bitrate: 390Mbps; pixel format: yuv444p10, gbrp10
Frame size: 1920x1080p; bitrate: 440Mbps; pixel format: yuv444p10, gbrp10
Frame size: 1920x1080p; bitrate: 730Mbps; pixel format: yuv444p10, gbrp10
Frame size: 1920x1080p; bitrate: 880Mbps; pixel format: yuv444p10, gbrp10
Frame size: 960x720p; bitrate: 42Mbps; pixel format: yuv422p
Frame size: 960x720p; bitrate: 60Mbps; pixel format: yuv422p
Frame size: 960x720p; bitrate: 75Mbps; pixel format: yuv422p
Frame size: 960x720p; bitrate: 115Mbps; pixel format: yuv422p
Frame size: 1440x1080p; bitrate: 63Mbps; pixel format: yuv422p
Frame size: 1440x1080p; bitrate: 84Mbps; pixel format: yuv422p
Frame size: 1440x1080p; bitrate: 100Mbps; pixel format: yuv422p
Frame size: 1440x1080p; bitrate: 110Mbps; pixel format: yuv422p
Frame size: 1440x1080i; bitrate: 80Mbps; pixel format: yuv422p
Frame size: 1440x1080i; bitrate: 90Mbps; pixel format: yuv422p
Frame size: 1440x1080i; bitrate: 100Mbps; pixel format: yuv422p
Frame size: 1440x1080i; bitrate: 110Mbps; pixel format: yuv422p

You'll notice some 10-bit 444 color profiles in the 1920x1080p section. Don't use those unless you're coming from a 444 source, or you're wasting hard drive space.

DNxHR

So what about DNxHR? This is the more modern variant of DNxHD that supports a wider range of resolutions and color options. More importantly, it's way simpler to work with.

There's no need to specify bitrate, it will automatically use the correct one based on your input file. Unfortunately, most HR codec variants are only 8-bit, and will give an error if you try to convert to a different bit depth. The options for DNxHR are:

LB (roughly equivalent to ProRes Proxy)
SQ (roughly equivalent to ProRes LT)
HQ (roughly equivalent to ProRes 422)
HQX (roughly equivalent to ProRes 422HQ)
444 (you guessed it, roughly equivalent to ProRes 444)

Both the 444 and HQX variants use 10-bit color in HD or less, and either 10 or 12-bit color at 2K/UHD/4k resolutions. LB through HQX will always use 422 chroma subsampling, 444 will always use, well, 444 chroma subsampling. Still Confusing? You bet.

What's worse is that FFMPEG won't actually encode to 12-bit DNxHR HQX/444 or ProRes 4444XQ, it only supports 10-bit color depth.

That all said, here's a command that will give the same video quality as the first DNxHD command above, but using DNxHR:

ffmpeg -i "inputvideo.mp4" -c:v dnxhd  -profile:v dnxhr_hq -pix_fmt yuv422p -c:a pcm_s16le "outputvideo.mxf"

Notice how the codec variant is specified at the end of the profile option with an underscore before it.

If you wanted to transcode to HQX 10bit from a file with a different bitdepth/colorspace, you would do something like:

ffmpeg -i "inputvideo.mp4" -c:v dnxhd -profile:v dnxhr_hqx -pix_fmt yuv422p10le -c:a pcm_s16le "outputvideo.mxf"

To go to 10-bit 444, you would need to give it a 2K or larger resolution file and do:

ffmpeg -i "inputvideo.mp4" -c:v dnxhd -profile:v dnxhr_444 -pix_fmt rgb24 -c:a pcm_s16le "outputvideo.mxf"

As before, you generally don't want to use 444 unless you're coming from a 444 colorspace file, or a raw capture format that FFMPEG can understand. Otherwise, it's a waste of storage space, and is much slower to encode.

Oh, and if you're wondering how the FFMPEG DNxHD/HR encoder compares to the equivalent presets in Adobe Media Encoder, know that it's very close, but just slightly softer.

Tutorial - Installing 64-bit and 32-bit AVISynth+, QTGMC, and FFMPEG side by side

Hey folks - just wanted to let you know that this tutorial is now officially outdated.  I'm leaving it up here are for up historical interest, but here's a link to a post that I will maintain from this point forward with the current instructions for setting up AVISynth and QTGMC:

https://macilatthefront.blogspot.com/2021/01/deinterlacing-with-avisynth-and-qtgmc.html

============================================

So, it turns out I made a mistake. I assumed that QTGMC still didn't work properly in 64-bit AVISynth, even though it had been over a year since I looked into it.

Not only does it work, it actually gives a 10%-20% speed boost during rendering.

However, there is one particular hitch that holds it back a bit: AvsPMod 64-bit throws up error messages when you use the video preview function. It's not a deal-breaker, but it's annoying. Hopefully, a newer version will come out soon. In the meantime, in the interest of both correcting my error and of finally putting the setup tutorial videos to rest, I'm going to show how to install and run the 32 and 64-bit versions of AVISynth+, QTGMC and FFMPEG side by side.


BIG DISCLAIMER: This process may not work, may crash, or do other things to your system. Always check your files before submitting/uploading them.

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.

You have been warned. 

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 tutorial:

Also, I will be rushing through some of the initial steps for 32-bit AVISynth+, so if you'd like a little more depth, check out my original tutorial first, or check out my video version of that tutorial:

BIG DISCLAIMER: This process may not work, may crash, or do other things to your system. Virus scanning all files is strongly encouraged, but not a 100% guarantee of safety.

You have been warned. 

If you're on a deadline (and using Premiere Pro, After Effects, or Final Cut Pro) probably your best best is to use a paid plugin like FieldsKit. And no, they aren't paying me to say that.

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.





First of all, AVISynth+ installs both the 32-bit and 64-bit versions by default. You can grab it from here:

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

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

FFMPEGSource

11/6/2018 Update: looks like Jiangmin antivirus is currently flagging FFMpegSource with a warning on VirusTotal. Given that no other antivirus engines have spotted anything, I'm cautiously calling this a false positive, especially because one of the top search results for Jiangmin on Google is a post about the problems with reporting false positives to them.

QTGMC

Don't forget to get all the "Core Plugins", along with 32-bit FFTW3 library as well.


If you need to sharpen the image, I recommend LimitedSharpen (Technically "LimitedSharpenFaster")

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. Be sure to grab both the 32-bit and 64-bit versions.

FFMPEG

Update: since Zeranoe has shut down, I will be recommending compiling 32-bit FFMPEG from source using https://github.com/m-ab-s/media-autobuild_suite . Since this tutorial is getting a little long in the tooth any ways, I'll just leave this here as a placeholder until I create a newer and better version. You can get the 64-bit version here: https://www.gyan.dev/ffmpeg/builds/ffmpeg-git-essentials.zip 

7-zip

If you don't have 7-zip already installed, you won't be able to open many of the downloaded archives. The version you get here doesn't matter, so maybe just do the 64-bit one.

After virus scanning everything, install:

7-zip (if needed)
AVISynth+

Just follow the default options in both cases. Then, go to the 32-bit plugins directory for AVISynth+. On my system, this is:

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

Extract all .dll and .avsi files to the plugins directory from all plugins EXCEPT the fftw-3*.dll archive. If there's a choice between an x86 and an x64 version, use the x86 version. If there's a choice between AVX, AVX2 and a version without either, you'll need to know what instruction sets your processor supports. CPU-Z can tell you this if you're not sure.

Once that's done, do the same with the 64-bit versions of the plugins, except copy those to the "plugins64+" folder.

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.

Extract the 32-bit AvsPMod archive to wherever you want to run it from, and then extract the 64-bit version to a different directory. If you want to associate .avs files with AvsPMod, I would generally recommend doing so with the 32-bit version, but if you work primarily in 64-bit, then you should probably use that version.

Now, for the tricky part: setting up both the 32 and 64-bit versions of FFMPEG to run from any directory on your computer. We're going to do this with batch files. Also, kudos to Jon Hall's tutorial blog post on FFMPEG setup (currently defunct) for showing me basically how to do this.

First, open the 32-bit FFMPEG archive, then open the long-named folder within.

Create a folder somewhere on your system called "ffmpeg32". Personally, I put it in Program Files (x86).

Copy the "bin" and other folders from the opened FFMPEG archive to your ffmpeg32 folder.

Create a new text file, then rename it to "ffmpeg32.bat".

Right-click on the batch file and select "edit".

Write some version of the following into the notepad window:

@ECHO OFF
"C:\Program Files (x86)\ffmpeg32\bin\ffmpeg.exe" %*

Adjust the path as needed depending on where you installed 32-bit FFMPEG. Save, close batch file. Keep the explorer window showing the contents of your ffmpeg32 folder open.

Do the above steps for the 64-bit version of FFMPEG, except change the folder name to "ffmpeg64" and the batch file name to "ffmpeg64.bat". In the batch file, put some version of the following:

@ECHO OFF
"C:\Program Files\ffmpeg64\bin\ffmpeg.exe" %*

As you can see, I put ffmpeg64 in Program Files, but again, you can put it wherever you want.

Save, and close the batch file. Keep the explorer window showing the contents of your ffmpeg64 folder open.

Now, to add both versions of FFMPEG to your system path:

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 your ffmpeg32.bat file is. 
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. 
9.  Repeat steps 6-8, but use the location of your ffmpeg64.bat file.
10. Click OK on all the windows you opened to get here.

To make sure everything worked, open a command prompt (or Powershell, whatever your preference), then type ffmpeg32. If a long list of options is shown after a moment, cool. Do the same with ffmpeg64. If neither shows an error message like "command not found", you should be good to go.

Now, whenever you make your .bat file to run ffmpeg, you can specify whether you want to run the 32-bit version of both FFMPEG and AVISynth by calling ffmpeg32, like so:

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

If you want to run the 64-bit versions of FFMPEG and AVISynth, just call ffmpeg64 instead, like so:

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

PS: FFMPEG 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 (on Reddit's /r/editors subreddit) said that FFMPEG ProRes files won't pass QC with them.

Tutorial - Alternate Setup for FFMPEG, Alternate Install for AVISynth+

Hey folks - just wanted to let you know that this tutorial is now officially outdated.  I'm leaving it up here are for up historical interest, but here's a link to a post that I will maintain from this point forward with the current instructions for setting up AVISynth and QTGMC:

https://macilatthefront.blogspot.com/2021/01/deinterlacing-with-avisynth-and-qtgmc.html

============================================

There are a few setup options that I didn't cover in my last tutorial that I do on my own system to make my life easier when dealing with AVISynth and FFMPEG.

I like to set up FFMPEG to run on any folder on my system, as opposed to having to drop the ffmpeg.exe binary in the folder every time. I also like using the Univsersal AVISynth installer, which allows me to easily install/uninstall different versions of AVISynth, and is just generally cleaner than the official AVISynth+ installer.

DISCLAIMER: 

This process may not work, may crash, or do other things to your system. I check for viruses before using any software, but malicious hackers have been known to break into developer accounts and insert code into previously benign programs, and even regular programs can have bugs.

This is a post accompanying a YouTube tutorial. Video is here:

First, let's set up FFMPEG. I basically already covered this in my now-archived original method for setting up QTGMC, but here's a recap: 

1. Download and virusscan the latest nightly 32-bit static build of FFMPEG. 
   
   Update: since Zeranoe has shut down, I will be recommending compiling 32-bit FFMPEG from source using https://github.com/m-ab-s/media-autobuild_suite . Since this tutorial is getting a little long in the tooth any ways, I'll just leave this here as a placeholder until I create a newer and better version. 
   
   
2. Open the downloaded FFMPEG archive. Open the long-named folder within. 
3. Create a new FFMPEG folder somewhere on your main drive. 
4. Copy all the files in the opened archive folder to your new FFMPEG folder. 
5. Press the Windows and R keys or go to the start menu and type "run" and click on the run option. 
6. Type "control sysdm.cpl,,3". Click "Run". 
7. Click on "Environment Variables". 
8. Select "Path" under "System variables" and click "Edit". 
9. Go back to your open folder where ffmpeg.exe is located. Select and copy the folder's path address from the address bar towards the top of the window. 
10. 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. 

When that's done, you can now run FFMPEG from any directory on your computer, and your .bat files that call FFMPEG will do the same.


Now, for the Universal AVISynth Installer (which I will refer to as the UAI for the rest of this post).

1. Grab the UAI archive file from here. Virus scan it. 
2. Open the file. You'll notice there's a folder inside called "AVISynthRepository". 
3. Open another window with the location where you want the UAI to go. Copy the AVISynthRepository folder over to that location. 
4. Close the archive window. Open up the folder from where you just copied it to. 
5. Right-click on the setavs.bat and select "Edit". This will open the .bat file in Notepad. 
6. Look for the line that says ":set AVS_SRC_DIR=%~dp0". Remove the colon so it now reads: "set AVS_SRC_DIR=%~dp0". Save and close Notepad. 
7. Right-click on the .bat file and select "Run as administrator". Say yes to the UAC prompt. 
8. Type 6, hit enter. 
9. Open up the AVSPLUS_x86 folder, then the plugins folder. 
10. Copy over all your desired AVISynth plugins (aka filters). 
11. Set up any additional system .dll files as necessary.

To uninstall:

1. Right-click on the .bat file and select "Run as administrator".
2. Say yes to the UAC prompt. 
3. Type 8 to uninstall any 32-bit versions of AVISynth.
4. Type 9 to uninstall any 64-bit version. 
5. Hit enter. Type y, hit enter. 

Please note that you can install 64-bit AVISynth+ either instead of or alongside the 32-bit version. Its filters would then go in the plugins folder inside the AVSPLUS_x64 folder. To preview a script with 64-bit filters, you'll need the 64-bit version of AVSPmod. To render using 64-bit AVISynth, you'll need to use the 64-bit version of FFMPEG. You can follow the above setup instructions for FFMPEG I've described above, or go to this post to see how to set up both the 32 and 64-bit versions at the same time and use either at will.



Bonus unnecessary info:

If you need to do step 11 of the setup process a lot, you can copy the files over to the directory of whatever version of AVISynth you're running (in the case of the above tutorial, AVSPLUS_x86), then add entries to the .bat file to have them copied over and uninstalled as part of the script. To do so, edit the .bat file.

For example, if I wanted to add the FFTW3 library files to the install, I would change:

) else (

echo copying %avs% files to "%WINDIR%\SysWow64"...

echo copy /y "%AVS_SRC_DIR%\%avs%\avisynth.dll" "%WINDIR%\SysWow64"

copy /y "%AVS_SRC_DIR%\%avs%\avisynth.dll" "%WINDIR%\SysWow64"

copy /y "%AVS_SRC_DIR%\%avs%\devil.dll" "%WINDIR%\SysWow64"

so it becomes:

) else (

echo copying %avs% files to "%WINDIR%\SysWow64"...

echo copy /y "%AVS_SRC_DIR%\%avs%\avisynth.dll" "%WINDIR%\SysWow64"

copy /y "%AVS_SRC_DIR%\%avs%\avisynth.dll" "%WINDIR%\SysWow64"

copy /y "%AVS_SRC_DIR%\%avs%\devil.dll" "%WINDIR%\SysWow64"

copy /y "%AVS_SRC_DIR%\%avs%\FFTW3.dll" "%WINDIR%\SysWow64"

copy /y "%AVS_SRC_DIR%\%avs%\libfftw3f-3.dll" "%WINDIR%\SysWow64"

To allow the installer to uninstall those files, I would change:

) else (

echo removing %avs% files from "%WINDIR%\SysWow64"...

del "%WINDIR%\SysWow64\avisynth.dll"

del "%WINDIR%\SysWow64\devil.dll"

so it becomes:

) else (

echo removing %avs% files from "%WINDIR%\SysWow64"...

del "%WINDIR%\SysWow64\avisynth.dll"

del "%WINDIR%\SysWow64\devil.dll"

del "%WINDIR%\SysWow64\libfftw3f-3.dll"

del "%WINDIR%\SysWow64\FFTW3.dll"

Tutorial - Deinterlacing and upscaling with 32-bit QTGMC revisited

Hey folks - just wanted to let you know that this tutorial is now officially outdated.  I'm leaving it up here are for up historical interest, but here's a link to a post that I will maintain from this point forward with the current instructions for setting up AVISynth and QTGMC:

https://macilatthefront.blogspot.com/2021/01/deinterlacing-with-avisynth-and-qtgmc.html

================================================

After more than a year and a lot more experience with my SD to HD workflow, I’ve made a few changes. That means it’s time for an update.

Some of the larger changes include switching to AVISynth+ instead of standard AVISynth plus AVISynth MT, dropping the “source match” and “lossless” presets from QTGMC, and updating a whole mess of plug-ins. In total, these changes result in better speed, stability, and image quality.

BIG DISCLAIMER: This process may not work, may crash, or do other things to your system. I've had an issue with intermittent audio dropouts in the resulting files, but it seems to only happen with Quicktime ProRes files from a certain source. Always check your files before submitting/uploading them.

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.

You have been warned. 

If you're on a deadline (and using Premiere Pro, After Effects, or Final Cut Pro) probably your best best is to use a paid plugin like FieldsKit. And no, they aren't paying me to say that.

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 a basic QTGMC deinterlacing workflow:

And here's a video about cropping and upscaling:

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

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

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

FFMPEGSource

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. Also, don't bother with the "10-bit hack version", as we won't be working in 10-bit color.

11/6/2018 Update: looks like Jiangmin antivirus is currently flagging FFMpegSource with a warning on VirusTotal. Given that no other antivirus engines have spotted anything, I'm cautiously calling this a false positive, especially because one of the top search results for Jiangmin on Google is a post about the problems with reporting false positives to them.

QTGMC

The deinterlacing plugin of choice. Requires a whole host of additional plugins, of which you will be using the 32-bit versions (if there's a choice). For most uses, however, only the "Core Plugins and scripts" are necessary. Thaks to one anonymous commenter, I should mention that if you're trying to import YUY2 colorspace video (some pro video codecs use this) without converting, you'll also need the AnimeITVC plugin.

Update: the 64-bit version of QTGMC and related programs are now stable, and slightly faster. You can find info on how to install those versions here:

https://macilatthefront.blogspot.com/2018/10/64-bit-avisynth-and-qtgmc-update-and.html

For the SmDegrain link, go to the page and click on the tiny "download" link next to the "raw" link. When you save the file to your computer, rename the .txt extension to .avsi.

If you decide to grab the optional plugins, then for the AnimeITVC pastebin link, select the text of the link and copy it, then right-click on the link and do "Save Page As", select "All Files" in the Save As drop-down box, paste the name of the file, delete any spaces from the front of the filename, then save the file. Most people won't need this plugin, thankfully.

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

If you need to sharpen the image, I recommend LimitedSharpen (Technically "LimitedSharpenFaster"). Get the x86 version in order for it to work within a script using 32-bit QTGMC.

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 32-bit version for this tutorial.

FFMPEG

Update: since Zeranoe has shut down, I will be recommending compiling 32-bit FFMPEG from source using https://github.com/m-ab-s/media-autobuild_suite . Since this tutorial is getting a little long in the tooth any ways, I'll just leave this here as a placeholder until I create a newer and better version. 


7-zip

If you don't have 7-zip already installed, you won't be able to open many of the downloaded archives. The version you get here doesn't matter, so maybe just do the 64-bit one.

After virus scanning everything, install:

7-zip
AVISynth+

Just follow the default options in both cases. Then, go to the plugins directory for AVISynth+. On my system, the default installer creates a plugin folder at

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

Extract all .dll and .avsi files to the plugins directory from all plugins EXCEPT the fftw-3*.dll archive. If there's a choice between x86 and x64, use the x86 version. 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 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 is seems pointlessly tedious.

Extract the AvsPMod archive to wherever you want to run it from.

Finally, open the ffmpeg archive, 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.

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. Alternatively, you can just create a new text file and chance the .txt extension to .avs.

Right-click on the .avs script, choose "Open With", then "Choose Another App", then check "Always use this app to open .avs files", then scroll down the list of apps until you see "More Apps". Click on that, scroll some more until you see "Look for another app on this PC". Click on that, navigate to where you extracted AvsPmod, select avspmod.exe and click OK. Your .avs scripts will now automatically open in AvsPMod when you double-click on them.

In a few moments, you should now see your blank script open in AvsPmod.

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

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

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


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, but your mileage may vary. If you experience any random rendering freezes (not overall system freezes), then lower this number first.

Also, a quick note here: Amazon and some other streaming services prefer 640x480 over 720x540 for SD content. I use the latter because I consider the resulting file a new "master" file that can be used to create future derivative versions, but if you're going to send the file directly to a distributor or service, read/ask for their deliverables spec to see what resolution and framerate they want.

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

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

Anyways, here's what to add if you want to upscale 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 crop command doesn'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)

If your initial video has noticeable compression artifacts, you might want to do BilinearResize instead of Spline64Resize to avoid accentuating said artifacts. If it's clean and you want to sharpen even more, LimitedSharpenFaster does a a good job of this.

    LimitedSharpenFaster()

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.

Loading this script in AvsPmod will let you preview your results, and change to your preference. To preview your settings, click anywhere on the playback bar at the bottom of the window. The first time you do this, FFmpegSource will index your file, so be patient. When you're done, don't forget to save your work.

Create a new text file in the same directory 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"

If you need to convert to a different video format, search for options and further instructions on the FFMPEG Wiki.

PS: FFMPEG 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.

Tutorial - Using ShotCut as a ProRes transcoder

After the complexity of my previous tutorials, I thought I'd do something simpler this time, just in case there are some of you who aren't a fan of the complex AVISynth-FFMPEG workflow. It just uses one program, and a minimum of steps.

The program in question is ShotCut, a free, open-source editing program for Windows, MacOS and Linux. Like a lot of other open-source video editing apps, it uses the MLT Engine for timeline playback/editing, and FFMPEG for export. Unlike most of those apps, the Windows port is pretty stable, even with heavily compressed h.264 footage.

ShotCut is a fairly simple program, but it does have enough features that it can be used as a decent replacement for Windows Movie Maker or any of the slew of $15-$50 editing programs that flood the internet. It'll do multi-track editing, text, some basic color correction, and even supports some video output cards/devices like the Blackmagic Intensity Pro. If you're interested in learning how to do that, The ShotCut site has a tutorials page that's fairly comprehensive. For the purposes of this tutorial, I'm just treating ShotCut as a transcoding program.

BIG DISCLAIMER: 

This process may not work, may crash, or do other things to your system. I check for viruses before using any software, but malicious hackers have been known to break into developer accounts and insert code into previously benign programs.

If you are working on a professional production, the results may or may not be acceptable, especially if you're trying to send out a ProRes master to a TV station. Their QC department may reject ProRes files that haven't come from an official, licensed-by-Apple encoding app.

You have been warned. 

First, download ShotCut. I personally think the installer is the way to go, but if you want more control over were it installs everything, then you can grab the "portable" version.

Next, virus scan the file using VirusTotal or a major anti-virus/malware scanning program.

Then, install ShotCut. This is pretty easy, basically just click "next" a few times, then "finish". If you went with the portable version, extract the files into your location of choice.

Once ShotCut is installed, run it. You'll see a fairly simple interface with a few buttons at the top. At the moment, it's just showing the Source panel, and that's all we'll need to get started. Drag your video file of choice onto the blank area, and it will load and start playback. Pause it with the spacebar.

Click on the Export button, which will bring up the Export panel. Make sure that the resolution and framerate settings match your video file, then scroll the list of codecs on the left to get to "Intermediate-ProRes" and select it. If you want to change the subtype of ProRes, click on the Other panel and change the "vprofile=" number to your preference. If you need a refresher from the FFMPEG tutorial:

0 = ProRes Proxy
1 = ProRes LT
2 = ProRes 422
3 = ProRes 422HQ

If you change the codec to "Intermediate-ProRes-Kostoya", then you can also do:

4 = ProRes 444

Once you're happy with the settings, hit the Export button, name your file and save. Rendering will start, and once it's done, you should be good to go.

Best of all, because you didn't add anything to a timeline, you won't get a prompt to save your work when closing ShotCut.

The caveats to this process are that the encoder is slow - I only get about the equivalent of one core's performance, which is far slower than command-line FFMPEG. Not sure why that is, although I suspect it may have something to do with a bottleneck between the MLT engine and FFMPEG.

Also, deinterlacing is performed using YADIF, so don't expect the kind of high-res interpolation that AVISynth+QTGMC can provide, and don't expect it to frame-double. It's fine for quick and dirty conversions, but for pro work, you might want to consider using either the AVISynth+QTGMC method or Premiere Pro or Final Cut Pro X with the FieldsKit plugin installed.

Oh, and don't try to deinterlace and upscale. In my experience, it causes a chroma/colorspace shift. Upscaling progressive video should be fine, but check before using the exported video just in case.

UPDATE: I found the problem with upscaling, and it's a bug in FFMPEG. Solutions to it and other issues are covered in this post.

You can actually encode a number of different video files, but I don't recommend it. To do so, click on the Playlist button to give you a Project bin-like place to drop multiple files. Drag your files over, then switch to the Export panel. In the "From" drop-down, select "Each Playlist Item", then proceed as if you're working with a single file.

There are some significant downsides to encoding multiple files at once. You need to have the exact same resolution and framerate settings for all the files in the playlist, or the files that don't match the preset will be converted to those settings. It also doesn't automatically carry over the filenames from the original files, and will only let you enter a single filename for the exported videos with a "-1", "-2", etc appended to the end.

Tutorial - Converting DVDs to editable video files - Option 1

UPDATE: Due to an increase in VirusTotal virus detections on more recent versions of MakeMKV, I'm recommending proceeding with caution when installing it. It might just be false positives, but if you're working on a major project, you might consider other methods for ripping DVDs.

After my last tutorial, I decided to focus on improving my antiquated DVD-ProRes workflow.

Thankfully, newer software can make this process a lot simpler.

A program called MakeMKV works as a sort of all-in-one DVD/Blu-Ray extracting program, and unlike most similar programs, the resulting file is not only all in a single file, but is not recompressed. You get an .mkv wrapper around the video and audio that you choose to extract, and that's about it.

From there, you can use the FFmpegSource filter in AVISynth to load the file, and then apply any additional processing you need. If MakeMKV detects your footage as being 24p, then it will include that metadata in its .mkv, so you shouldn't have to go through the IVTC process. If it detects it as 60i, then you can use QTGMC and it should work... however, the preview window in AVSPmod can be a little glitchy when using FFmpegSource, and scrubbing back and forth may display hitches not present in the rendered end result.

One additional note: FFmpegSource needs to index the file before loading it, so don't worry if it takes a long time to load initially. This index is dumped into an .ffindex file in the same folder as your video file, which will load automatically in the future.

I should also mention that this process doesn't work on all DVDs. Some will have audio sync issues, and need an alternate (and more complicated) workflow with its own benefits and tradeoffs that I'll outline in a future post.


BIG DISCLAIMERS: 

This process may not work, may crash, or do other things to your system. I check for viruses before using any software, but malicious hackers have been known to break into developer accounts and insert code into benign programs.

You should always obtain the written permission of the copyright owner of the content before decrypting their DVD. Failure to do so may result in fines, lawsuits and/or jail time depending on your country's laws.

You have been warned. 

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.

UPDATE: I have a new version of the AVISynth and FFMPEG portion of this tutorial that is more stable, faster, and even potentially higher quality. Please check that out first if you're setting up those programs for the first time.

Here's the video version of this tutorial:

And here's where you go to get the software:

MakeMKV

AVISynth (You will need both the 32-bit "Official" build and the 32-bit "Unofficial" multi-threaded build)

FFmpegSource

If you're going to be dealing with 60i footage, then you'll probably want to deinterlace with QTGMC. If you need to know how to do this, check out my previous blog post.

QTGMC (Get the QTGMC download, then get both the "required" and "optional" filters as listed on the page. If there's a choice, get the 32-bit [x86] version of filters.)

LimitedSharpen (Technically LimitedSharpenFaster. Optional. Get the x86 version in order for it to work within a script using QTGMC. )

FFMPEG Windows Binaries (Get the current 32-bit static version)

AvsPmod

Setup:

1. Install MakeMKV.
2. Run the main AVISynth installer. 
3. Put the AVISynth filters you downloaded (.dlls and .avsi files) in the AVISynth Plugins directory. Make sure to use the 32-bit (x86) versions of any filters if there is a choice. Make sure you're using version 2.2.7 (or later) of MaskTools2.
4. Copy the multithreaded build of avisynth.dll to your system folder (Usually C:/Windows/SysWow64/) and replace the existing file.
5. Copy the libfftw3f-3.dll file your system folder.
6. Extract FFMPEG and AvsPmod to their own folders. Keep the folder with the ffmpeg.exe binary open.
7. Set up FFMPEG to run from any directory on your PC by adding it to your PATH variable:
1. Press the Windows and R keys.
2. Type "control sysdm.cpl,,3". Click "Run".
3. Click on "Environment Variables".
4. Select "Path" under "System variables" and click "Edit".
5. Go back to your open folder where ffmpeg.exe is located. Select and copy the folder's path address from the address bar towards the top of the window.
6. 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.

Process:

Open MakeMKV.

Put a DVD in your optical drive. Open the DVD in MakeMKV.

Note: I've run into a DVD sent by a client that had some odd authoring, which prevented me from opening it successfully in MakeMKV. I ended up using my older method to process it, but there's now an option that gets around the problem in the last two betas of MakeMKV. Before clicking on the giant drive icon, check the "Open DVD Manually" box, then when you get a list of the disk contents, type each of the titles you want to load in the text box, separated by a space between them. Hit OK and those titles should now open up properly. Also, you might need to decrease the minimum length of a detected title in MakeMKV's preferences.

Select the Titles and Audio tracks that you want to copy over. Select the output directory. Click on the Save to MKV button.

When done, close MakeMKV and go to the directory you just saved the .mkv file to.

In the same directory as your .mkv file, make an .avs script with the settings listed below. Change the filename, source filter, and crop settings as necessary.

Here's my boilerplate .avs script settings:

SetMTMode (5, 10)
FFmpegSource2("videofile.mkv", atrack=1)

If you're using 4:3 video, then a pixel aspect ratio conversion is necessary (unless you'll be outputting back to DVD...in which case, ugh):

BilinearResize(720,540)

And here's what to add if you want to upscale to 720p HD:

BilinearResize(1280,720)

You can also use Lanczos4Resize or Spline64Resize on the last resize step if you need some overall sharpening. I'll also sometimes use LimitedSharpenFaster at the end for a little extra punch.

LimitedSharpenFaster()

Please keep in mind that DVD video tends to have lots of compression artifacts, and sharpening can accentuate them.

Working on this script in AvsPmod will let you preview your results, and change them to your preference. When you're done, don't forget to save your work.

Create a new text file in the same directory 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 -c:a pcm_s16le "output.mov"

Change where necessary. The quotes around the filenames in the FFMPEG command allow you to enter path addresses and filenames with spaces in them.

You might notice i'm using "prores" instead of "prores_ks" for the video codec setting. Since DVDs are already very heavily compressed, the difference in visual quality between the two encoders isn't enough to justify the massive difference in speed. If you're really keen on getting every last little detail, then "-c:v prores_ks -profile:v 3 -qscale:v 5" will provide it at the cost of a much larger filesize and a 2-5x longer rendering time. Also, the resulting file is nonstandard, so (I have been told) it might be bounced by the QC department of some TV stations.

Tutorial - An (outdated) SD interlaced to HD progressive Conversion Tutorial, or A Long-delayed Video

Hey folks - just wanted to let you know that this tutorial is now officially outdated.  I'm leaving it up here are for up historical interest, but here's a link to a post that I will maintain from this point forward with the current instructions for setting up AVISynth and QTGMC:

https://macilatthefront.blogspot.com/2021/01/deinterlacing-with-avisynth-and-qtgmc.html

============================================

After all the time (see here and here) I've put into getting the AVISynth+QTGMC+FFMPEG deinterlacing workflow working properly on my system, I figured it was about time for a video tutorial. In my spare time, I've been trying to record one.


It's taken a lot longer than I thought.

Partly, this was due to finding new tricks/plugins that improved the process. Partly, it was due to finding unexpected bugs.

However, the main delay came from me not just wanting to do a "do this, then this' tutorial where you come away with no context whatsoever about what's actually happening. I want people who watch the video to get a good idea of what AVISynth is, and what FFMPEG brings to the process.

So, I'd start recording a tutorial, then get caught up in a tangent. An hour and a half later, I still haven't finished the video.

Plus, I make mistakes. There's a lot of material to cover, and I found myself leaving out crucial points (or ones that clear up confusing areas). I could have tried writing out a script, or just patching over my mistakes. However, it turned out that just repeating the actions so many times that you can practically do them in your sleep eventually got me to the right place. I still had some audio issues to address in post, but my overall presentation quality is much improved from earlier attempts.

Here's a written description of the process, including links:

Deinterlacing HD footage with FFMPEG (Outdated)

Hey there folks - this post is pretty old at this point, and many options for deinterlacing have changed. Check out this latest post where I compare a few of the options:

https://macilatthefront.blogspot.com/2021/05/which-deinterlacing-algorithm-is-best.html

I've kept this post up mainly for archival value.

After my last post, I played around with bunch of different settings, and discovered that plain old FFMPEG can do decent deinterlacing. One of the reasons I looked into this is that QTGMC (my AVISynth deinterlacing plugin of choice) is ridiculously slow and prone to crashing when processing HD footage.

The problem with FFMPEG is that its documentation is enormous, and while it sometimes includes clear examples to show you how to use certain features, other times it's simply assumed that you're technically savvy enough to know what they're talking about. For example, trying to figure out the best method for deinterlacing involved me doing Google searches for each of the various methods. Normally, something like that would give results pretty quickly, but most of the substantive discussions were from at least five to nine (!) years ago or related to programs that use FFMPEG as a back-end engine, rather than as a standalone app. Even after all that, it wasn't immediately obvious which method would be superior, so I decided to run a few tests.

Method 1: kerndeint - a relatively simple deinterlacing method that automatically halves the framerate and is roughly on par with the old After Effects / Premiere Pro deinterlacer.

Method 2: w3fdif - Developed by the BBC, this is much closer to what I was looking for. Unfortunately it was originally designed for interlaced standard definition PAL content, and as such somehow does not have a mechanism for selecting Top Field First field order. It did successfully deinterlace the footage, but ended up looking herky-jerky as a result of the field order mismatch.

Method 3: nnedi - The method that QTGMC was designed to incorporate/replace. In theory, it does many of the same things, but to say that trying to figure out the options was confusing is an understatement.

Method 4: bwdif - To quote the FFMPEG documentation: “Motion adaptive deinterlacing based on yadif with the use of w3fdif and cubic interpolation algorithms”. This turned out to be the perfect solution. The default settings automatically detect field order (if it's set in the file's metadata) and do not introduce weird image artifacts, but still give decent deinterlacing. Oh, and it runs significantly faster than AVISynth+QTGMC. Like, 6-8 times as fast.

Now, there are some downsides to bwdif. QTGMC can introduce some ghosting artifacts (including misaligned chroma artifacts), but it can also pull more detail out of the original image. This makes bwdif a sub-par solution for SD interlaced to HD progressive upconversion. FFMPEG also doesn't have the (relatively) easy-to-read syntax of an AVISynth script, and definitely lacks the versatility of the insane range of plugins available for the latter.

As always, here’s an example of the command-line options so you can run this process on your system. Note that you have to use -vf before naming the filter in quotes:

ffmpeg -i "input_video.avi" -vf "bwdif" -c:v libx264 -preset slow -crf 18 -pix_fmt yuv420p -c:a aac -b:a 320k "output_video.mp4" 

This is what I used to deinterlace a 60i HD file and re-encode it for YouTube. For ProRes encoding, see my previous post.

The Odyssey of trying to upscale interlaced SD to HD without losing quality: Part 2

UPDATE: I have a new version of this tutorial up that is more stable, faster, and even potentially higher quality. Please check that out first. This post is kept up only for archival purposes.

You might want to read the first post in this series, because I'm not going to explain interlacing or what the various programs do again.

Since Part 1, I've discovered a few things:

VapourSynth currently requires the same plugins as AVISynth in order to run QTGMC, with the same stability issues and limitations. I'm actually trying to learn Python at the moment anyways, though, so I might revisit it again in the future and see if someone has ported the process natively in a way that supports multithreading without hacks.

Setting the topmost SetMTMode in my AVISynth script to (5, 10) versus (5, 12) appears to have solved my remaining stability issues. I'll be posting my full script down below.

I discovered AvsPmod, a program that loads AVISynth scripts with syntax highlighting and video preview. It makes adjusting scripts a heck of a lot easier. Because of AvsPmod, I don't need to use VirtualDub to check my work anymore.

I also discovered that I don't need VirtualDub to render the AVISynth scripts, because FFMPEG can load them directly. That means I can convert .avs scripts directly to any format that FFMPEG supports, including ProRes. This is awesome, because I can write .bat files that include all the settings I want for a particular codec/container/etc. All I have to do is change the input and output file names and double-click the .bat file. Also, while ProRes is awesome, I don't actually need to use an intermediate codec - I can render straight to a YouTube-friendly H.264 .mp4 file if I want without the (admittedly minor) quality loss of the extra step.

According to a few TV editors I asked, FFMPEG should probably not be used to render a ProRes deliverable for broadcast TV. Apparently, the implementation of ProRes is not recognized by Apple, and might be rejected by QC because of differences in embedded metadata. Not a problem for my current work, but if I did need to generate a file for broadcast, I would probably want to get a cheap Mac Mini or a month-long subscription to Scratch to make "official" ProRes deliverables. Incidentally, if I could afford to get a permanent license for Scratch, I would do it. Even with its oddball interface, it's still far and away the most responsive grading/compositing program I've ever used.

BIG DISCLAIMER: This process may not work, may crash, or do other things to your system. 

You have been warned. 

If you're on a deadline (and using Premiere Pro, After Effects, or Final Cut Pro) probably your best best is to use a paid plugin like FieldsKit.

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

SetMTMode (5, 10)
QTSource ("videofile.mov", audio= 1)
ConvertToYV12()
SetMTMode(2)
AssumeTFF()
QTGMC(preset="Slower, SourceMatch=3, Lossless=2, EdiThreads=1)
Distributor()
BilinearResize(720,540)
Crop(0,36,0,-36)
Spline64Resize(1280,720)

I've also found an awesome conservative sharpening filter that can be added at the end for a little extra punch:

LimitedSharpenFaster()

So, where do you go to get all this goodness? Here's some web links:

AVISynth (You will need both the 32-bit Official Build and the 32-bit Unofficial Build)

AVISynth source filters (Get the source filter for the format/codec you want to load. In the above script, I use QTInput.)

QTGMC (Get the "Plugin Package for multithreading".)

LimitedSharpen (Optional, note that it requires RGTools to run. Get the x86 version of the latter in order for it to work within a script using QTGMC. )

FFMPEG Windows Binaries (Get the 32-bit static version)

AvsPmod

Install AVISynth. Put the AVISynth filters in the AVISynth Plugins directory, copy the multithreaded build of avisynth.dll to your system folder and replace the existing file. Copy a couple of system .dlls from the QTGMC package to your system folder. Extract FFMPEG and AvsPmod to their own folders. Set up FFMPEG to run from any directory on your PC by adding it to your PATH variable:

http://jonhall.info/how_to/setup_and_use_ffmpeg_on_windows  (skip to where it says "Windows Vista and Windows 7 users:")

In the same directory as your video file that you want to process, make an .avs script with the settings I listed above, changing the filename, source filter, and crop settings as necessary. Loading this script in AvsPmod will let you preview your results, and change to your preference. When you're done, don't forget to save your work.

Make a .bat file with 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_ks -profile:v 3 -qscale:v 9 -pix_fmt yuv422p10le "output.mov"

Change where necessary. The quotes around the filenames allow you to enter filenames with spaces in them.

I'll post a video soon with a full tutorial and more examples.

The Odyssey of trying to upscale interlaced SD to HD without losing quality: Part 1

UPDATE: I have a new version of this tutorial up that is more stable, faster, and even potentially higher quality. Please check that out first. This post is kept up only for archival purposes, or if you're stuck on the old AVISynth. The old video tutorial referenced below has become very outdated.

In the past, I did some work involving upscaling a letterboxed standard definition (SD) show to HD for online streaming video. As it turned out, the built-in After Effects and Premiere Pro resizing tools are not the best for this sort of scenario.

The reason why the otherwise fabulous tools fall short is how they deal with interlacing.

Interlacing is a technique started in the early days of television that allows for the appearance of 60fps motion with the bandwidth of a 30fps signal. This is achieved by using "fields", which are only half the resolution of a full progressive frame. However, the image data in each field is displayed every other horizontal line on one field, then the next field does the same but displays where the blank lines were in the first field. Because the two fields are interlaced together, the eye and brain of the viewer combine them together, giving you roughly the appearance of 60 frames per second (fps) video. Because of the reduction in signal bandwidth, interlaced video has been used by TV broadcasts ever since (yup, even in HD). For a slightly clearer example, here's a section of two fields combined together with a fast-moving object as the subject (In motion, these combing artifacts are usually not as noticeable):

Once we moved into the age of digital video editing, interlacing made everything more complicated. Since digital video devices didn't want to show individual jagged-looking fields, they combined (or deinterlaced) them into discrete frames, then based timecode standards around 30 frames per second (technically 29.97 fps for color NTSC video) rather than 60 fields per second (technically 59.94 fps). In order to work with broadcast video devices and timecode, computer editing/compositing/etc. devices and programs had to follow the same standards, but still be able to output either progressive or interlaced video at the end.

The bottom line is this: in order to upscale (most) SD video, it first needs to be deinterlaced.

I'm greatly oversimplifying, but deinterlacing is commonly done in one of three ways:

1. Double the lines in each field to fill in the gaps, then treat each of the line-doubled fields as individual frames. With this method, you end up with less overall resolution, but it's quick and easy. In the old days, they used to make "line doubler" devices that would do this sort of thing for high-end TVs and such. Depending on the algorithm, the process might also "decimate" the framerate to 30fps in order to avoid twitchy artifacts from constantly switching between "upper" and "lower" fields.

2. Combine every 2 fields together into a single frame via an image processing algorithm like Yadif. This gives you better frame resolution, but still decimates the framerate to 30fps and can look like a Photoshop "artistic" filter. This might be a good thing; it gives a slightly more "filmic" look and saves on video filesize. After Effects uses a somewhat similar process if you check the "Preserve Edges" checkbox in the Interpret Footage right-click menu of a clip. A better way (in my opinion) involves using VirtualDub to perform the deinterlacing and upscaling. This is the workflow I've used in the past.

3. Use complex algorithms to look at detail from several fields at a time to create interpolated frames at 60fps. This retains both the full detail and the full motion of the original video, but... while consumer TVs do an okay job with this, in the pro editing world it's either been done by very expensive dedicated hardware devices (like the Teranex) or moderately-to-somewhat-pricey software plugins (like FieldsKit or Tachyon) that still require a fair amount of fiddling to get working properly. It can also result in minor-to-moderate "ghosting" artifacts. To be fair, proper frame interpolation is not a trivial process, and the above solutions do a great job.

I assumed option 3 was basically out of my reach - the best "double framerate" deinterlace option in VirtualDub can use Yadif, but has the issues of a 60fps line doubler conversion, and my budget hasn't allowed me to purchase any of the commercial solutions.

So, I gave up for a while. Then, a new project came along from the same client for upscaling some more SD footage. Since I already use AVISynth scripts to load Quicktime files into Virtualdub and I've seen some great inverse telecine (aka ITVC, which is a process of removing redundant frames from 24p video that has been transferred to 60i video) plugins, I decided to check out deinterlace filters for AVISynth again. That's when I found out about QTGMC, an AVISynth plugin that does pretty much everything I want it to, and it's free.

Unfortunately, it has some drawbacks.

First, let me tell you about AVISynth and VirtualDub. Both of these programs were developed as open-source video processing tools in the early 2000's.

VirtualDub is kind of like a video swiss army knife - it uses built-in filters to do everything from resizing a video to replacing audio, sharpening, and even some visual effects. The downside with VirtualDub is that by default it only loads and saves files in an .AVI container, which significantly limits the number of codecs that it supports. There have been plugins developed that allow it to load a number of other container formats, but the plugins don't always work properly or continue to be supported as new codecs are released. However, if you combine VirtualDub with AVISynth, you can read almost any video codec that's ever been released.

AVISynth is probably the oddest video tool I've ever used. It's not a standalone program per se, and it has no interface. It's a scripting language that gives instructions on how to process video using a frameserver. This means you have to write a text file with a list of instructions, then load that text file into a separate program that can that can communicate with AVISynth's frameserver. VirtualDub is one such program. AVISynth's syntax can be confusing, arcane, and not terribly user-friendly. However, it can do all the video processing tasks of VirtualDub and more, and do so before the video is displayed in VirtualDub. It also has a truly staggering number of plugins developed for it, and some of them rival commercial programs in their functionality.

Now, back to QTGMC. QTGMC is a plugin that uses other AVISynth plugins to perform frame interpolation and deinterlacing. I will not attempt to explain the details, suffice to say it has a huge amount of variables and settings... but it works. It really, really works. You can use the combination of AVISynth with QTGMC plus VirtualDub to turn SD interlaced footage into 60fps HD footage.

Unfortunately, there are a few problems. Remember when I mentioned when the tools were originally developed? By default, neither VirtualDub nor AVISynth are multithreaded, which means they don't take avantage of modern multi-core processors. They're also 32-bit apps. There are technically 64-bit versions of VirtualDub and AVISynth, but they lack the plugin support of the 32-bit versions. The attempt to "fork" AVISynth for proper 64-bit support (known as AVISynth+) doesn't appear to support multithreading natively, either.

Now, there is a replacement library for AVISynth that enables multithreading support, in fact QTGMC basically requires it to perform properly. It's not, however, what you would call stable. AVISynth is prone to crashing or just stop rendering if you've set something it doesn't like, and those settings may be different depending on your hardware, the versions of the plugins you're using, etc. etc. etc.

Currently, I'm having trouble getting QTGMC to render beyond about 15mins of footage. I got to that point by gradually lowering the number after "EdiThreads" from 6 to 1. will keep playing with settings to see if there's a magic combination that will work.

I should mention that there is one other option: a new ground-up rewrite of AVISynth called VapourSynth. It's 64-bit native and supports multithreading "out of the box". It also uses an entirely different scripting syntax because it's both written in and uses Python. It can now load AVISynth plugins, but you still have to learn a whole new scripting language to use them.

Stay tuned for part 2, where I reveal the results of my AVISynth experimentation and see if I'm going to be willing to try VapourSynth or not.

Grading Workflow update 7-30-2013

Since my last entry, I've upgraded to the "CC" editions of all my Adobe apps... except for Encore CS6. CC has no new version of Encore, nor is it installed by default. Thankfully, I caught this issue before uninstalling Encore (I've found out subsequently that you can install it again, but you have to re-enable the CS6 version of Premiere Pro in Adobe CC).

Unfortunately, one additional wrinkle of the new CC Premiere Pro is that my old copy of Cineform NEO no longer works with it. This is not a total loss, however, because after trying my previous color grading workflow and finding that it simply took too much time to render the individual clips for a long-form project, I've decided to take an entirely new approach.

The new version of Premiere Pro has SpeedGrade's Lumetri Deep Color engine built in, and as a result, you can create "looks" in Speedgrade that can be imported into Premiere Pro and used as filters (Sort of like Magic Bullet Quick Looks). It would be awesome if you could actually adjust these looks in Premiere Pro, but I'll take what I can get.

So, my current workflow is:

1. Do a "Send to Adobe Speedgrade" of each of the sequences in my project
2. Grade those sequences in Speedgrade.
3. Save the grades as individual "looks".
4. Transfer the look files to a looks sub-folder in my project's main footage folder. If you're on Windows, Speedgrade's custom look files are stored in: C:\Users\Owner\AppData\Roaming\Adobe\SpeedGrade\7.0\settings\looks  (I highly recommend creating a desktop shortcut to the folder so you can get back to it easily).
5. Apply the looks individually to the respective clips.

If you don't have a bunch of hard drive space to work with, you can just do the "Send to Adobe Speedgrade" for one sequence at a time, but it's handy to have the Speedgrade sequences available if you need to adjust one or more of the looks.

The only issue I've run into so far is on the project's sizzler reel, where rendering to DVD occasionally will produce a twitchy white bar on the right side of some of the clips with the "looks" applied to them. I'm still trying to track down the issue, but thankfully, there's an easy solution - render out to a full-res format (I use Uncompressed 10-bit YUV Quicktime) first, and then use that .mov to render/encode the DVD files in Adobe Media Encoder.