Saving Your Analog Data from Oblivion

Transferring VHS tapes, audio cassettes, and other analog home media formats to a digital format, such as Ogg or Matroska, can be a complex and expensive process with archival-grade conversions. In this article, I show you a simple and inexpensive method for digitizing your VHS tapes that is perfect for personal use.

Shopping List

To convert a VHS tape to a digital format, you need two pieces of equipment: a playback device for the original medium and a capture device to read the playback device's output. In addition, you need transcoding software to process the data that the capture device retrieves from the playback device. For a list of what I used in this project, see the "Software and Hardware Requirements" box.

For the playback device, you can find a used VCR for less than EUR100 online ($100-$200+ for NTSC/PAL/multisystem). Keep in mind that your chosen playback device must match the color encoding system of the VHS tapes you intend to transfer. Trying to play a PAL VHS on an NTSC device won't work (see the box "PAL vs. NTSC").

For a capture device, I use a USBTV007 EasyCAP (Figure 1), which is inexpensive (less than EUR15/may be difficult to find in the US), performs captures of acceptable quality, and has Linux support. Keep in mind that "EasyCAP" is not a commercial brand name; it is a popular term used by Chinese manufacturers to designate cheap, simple USB capture cards. Finding a specific EasyCAP model can be challenging, since manufacturers usually don't provide the full specification list in their product description or similar use cases. See the box "The Other EasyCAP."

Figure 1: This EasyCAP device works as a cost-effective capture device.

You will also need an SCART to RCA adaptor (Figure 2), which may be purchased for less than EUR10 ($8). The SCART connector is plugged into the VCR output, and the RCA plugs into the EasyCAP connectors. Most RCA connectors are correctly color coded (Table 2).

Figure 2: This SCART to RCA adaptor has an extra pin for audio input, which I won't be using.

In addition, I used a laptop with an i5-2467M CPU for my tests, but you can use a computer with less horsepower. A dual-core CPU of 2.5OGHz for each core is the minimum requirement. However, tests showed that the procedures described in this article will result in a barely acceptable loss of frames in the encoding when using this weak of a CPU. Using a drive with a high write speed is also advisable, since the VHS will be transferred and saved to the filesystem in real time.

In terms of software, I used GStreamer with the Ugly plugin for the capture (see the "Why GStreamer?" box) and FFmpeg to transcode. FFmpeg requires x264 and libdfk-aac support. Finally, the SoX sound processing utility is used to clean up the transferred media's audio.

Hardware Detection

First, power up your computer and connect all the hardware as previously described. Then, make sure your operating system properly identifies the capture device.

The USBTV007 EasyCAP will show up as two different capture devices: one for audio and one for video. This model does not work with the PulseAudio sound server, so you might need to tell PulseAudio to ignore the device so that ALSA can manage it instead. To do this, use the graphical tool pavucontrol: Move to the Configuration tab and select the Off profile for USBTV007. If you prefer to work from the command line, then enter,

pactl set-card-profile $card_number off

where $card_number is the identifier of your EasyCAP device for PulseAudio. If you don't know what it is, you can find out by typing:

pactl list cards | grep -E 'device.product.name|device.string'

To list your currently detected audio inputs, enter the command:

arecord -l

This will display the working capture devices detected by ALSA.

Video inputs will show up as files named /dev/video* (e.g., /dev/video0, /dev/video1, etc.). If you have more than one video input – for example, you have a webcam in addition to an EasyCAP – and you are not sure which one is which, you can extract information from each device with the v4l2-ctl command. The following command will display some known properties of /dev/video0:

v4l2-ctl --device=/dev/video0 --list-inputs

The Capture Process

Once everything is connected and detected, it is time to capture the video. To do this, insert a VHS tape into the VCR and play it, and then turn on your capture software, which takes the VCR's output and dumps it into a file on the fly.

The raw video and audio stream can take up a lot of storage, probably more than 100GB, which is why most people prefer encoding that stream into something more manageable as it is captured. Because the computer is capturing the raw VCR output in real time, your encoder must be both fast and CPU-friendly, so as not to affect the data capture negatively. If you try to use an encoding configuration that is too hard on the CPU, it will not have enough time to process each piece of incoming data before the next one arrives, which will result in lost frames and data loss.

Listing 1 performs a lossless capture of the analog input. While not very practical, Listing 1 is provided as a reference. Notice that the buffers are set to zero in order to avoid problems during the real-time video capture. The pixel format, YUY2, is set to the format that the EasyCAP feeds to the computer. Audio is captured in a lossless format at a sampling rate of 48KHz in stereo. The output is dumped to a Matroska file. Listing 1 is tuned for PAL devices (if you are using NTSC, see the "PAL vs. NTSC" box.)

gst-launch-1.0 -q v4l2src device="$videodevice" do-timestamp=true norm="PAL" pixel-aspect-ratio=1
    ! video/x-raw,format=YUY2,framerate=25/1,width=720,height=576
    ! queue max-size-buffers=0 max-size-time=0 max-size-bytes=0
    ! mux.
  alsasrc device="$alsadevice" do-timestamp=true
    ! audio/x-raw,format=S16LE,rate=48000,channels=2
    ! queue
  max-size-buffers=0 max-size-time=0 max-size-bytes=0
    ! mux. matroskamux name=mux
    ! queue max-size-buffers=0 max-size-time=0 max-size-bytes=0
    ! filesink location=vhs.mkv

In Listing 1, replace "$videodevice" with a video input device (e.g., /dev/video1). The "$alsadevice" (in the alsasrc device line) describes an audio input such as hw:1,0 or hw:2,0. The ALSA audio inputs are always named in a "hw:$card,$device" format.

Listing 2 performs lossy compression while carrying the analog stream's capture, resulting in a smaller file. It is configured to capture video for 1 hour and 40 minutes, but you can stop the recording by pressing q at any time.

ffmpeg -loglevel 32 -t 01:40:00
       -i <( gst-launch-1.0 -q v4l2src device="$videodevice1"
             do-timestamp=true norm="PAL" pixel-aspect-ratio=1
             ! video/x-raw,format=YUY2,framerate=25/1,width=720,height=576
             ! queue max-size-buffers=0 max-size-time=0 max-size-bytes=0
             ! mux.
            alsasrc device="$alsadevice" do-timestamp=true
             ! audio/x-raw,format=S16LE,rate=48000,channels=2
             ! queue max-size-buffers=0 max-size-time=0 max-size-bytes=0
             ! mux.
            matroskamux name=mux
             ! queue max-size-buffers=0 max-size-time=0 max-size-bytes=0
             ! fdsink fd=1
           )
       -c:v libx264 -preset ultrafast -x264opts crf=18:keyint=50:min-keyint=5
       -pix_fmt yuyv422 -c:a flac
       -f matroska file:vhs.mkv

Listing 2 offers a good trade-off. GStreamer captures the VHS output and pipes it to FFmpeg for transcoding (see Table 3). It will encode the raw stream without a noticeable loss of quality and will diminish the output file size by a factor of ten. Because it is CPU-friendly, it allows the capture of the analog data without frame loss. The resulting file is, however, still too big for most users. It is also likely to suffer from audio and video noise, since old analog data is susceptible to acquiring defects because of the media's age. Therefore, the captured video will require postprocessing.

Audio Cleanup

When you capture the audio of a VHS tape with the process outlined here, it is likely to be noticeably noisy. In addition to the noise contained in the VHS and generated by the VCR (see the box titled "Removing Audio Noise from Old VHS Tapes" ), the capture card also produces its own noise. Especially true when using cheap capture devices, the capture card will always introduce a barely audible buzzing sound to the resulting recording.

To mitigate the noise introduced by the capture card, you can use SoX. First, capture an audio segment that only contains the noise introduced by the capture card. With your EasyCAP connected to the VCR when it is not generating any sound output (e.g., when the tape is paused), capture a few seconds of an audio segment as follows:

gst-launch-1.0 -q alsasrc device=$alsadevice ! wavenc ! fdsink | sox -t wav - -n trim 0 1 noiseprof noiseprofile

This will create a file named noiseprofile that contains a description of the noise introduced by EasyCAP. This profile can be used for reducing the noise in the audio you capture.

Now, the tape's digitized audio can be extracted from its file and cleaned with:

ffmpeg -i vhs.mkv -acodec pcm_s16le -vn vhs_tmpaud.wav
sox vhs_tmpaud.wav vhs_tmpaud-clean.wav noisered general_noise.prof 0.21

A clean version of the audio will be recorded to vhs_tmpaud-clean.wav. The last value of the sox command above defines the denoiser's aggressiveness. Higher values mean more noise reduction, but at the expense of sound fidelity. Denoising is a destructive procedure that may wipe information away. Values that are too high will cause audible sound artifacts that are in fact worse than the original noise. Values between 0.21 and 0.31 are reasonable.

Finally, the audio is muxed back with the video stream. In this example, a video-only stream is extracted from vhs.mkv and stored in vhs_video_only.mkv. Then this video stream is combined with the clean version of the audio just generated, and the whole file is stored as vhs_whole.mkv:

ffmpeg -i vhs.mkv -vcodec copy -an vhs_video_only.mkv
ffmpeg -i vhs_video_only.mkv -i vhs_tmpaud-clean.wav -map 0:v -map 1:a -c:v copy -c:a copy vhs_whole.mkv

The Transcoding Process

You now have a video file with clean audio that uses about 15GB of disk space. This file may be transcoded into some more practical format using any encoder, such as HandBrake or MEncoder. However, I used FFmpeg in my example, because it is easily available and well documented.

For the excess video usually found at the beginning and end of a recording, trim it out with the following command:

ffmpeg -i vhs_whole.mkv -acodec copy -vcodec copy -ss $start_position -to $end_position vhs_trim.mkv

Start and end positions are values in the form hours:minutes:seconds, such as 01:30:50.

Listing 3 transcodes the captured video file and the cleaned audio file into vhs_final.mkv.

ffmpeg -i vhs_trim.mkv
       -vf "crop=(iw-10):(ih-14):3:0,pad=iw+10:ih+14:(ow-iw)/2:(oh-ih)/2,hqdn3d=2:1:2:3"
       -c:v libx264 -flags +ilme+ildct -profile:v high -tune:v animation
       -preset veryslow -crf 26 -c:a libfdk_aac -b:a 224k -f matroska vhs_final.mkv

The second line in Listing 3 is a set of video filters that are applied to the encoding; crop removes the overscan at the picture's borders, and pad replaces it with simple black bands. hqdn3d is a video denoiser (see the "Removing Video Noise" box).

Figure 3: Before (top) and after (bottom) the application of an aggressive denoiser.

The veryslow H.264 preset ensures that the best quality-to-size ratio is obtained at the expense of encoding time (for other presets, see Table 4). The ilme and ildct flags ensure that interlacing information is preserved. The tune:v option serves to adjust the H.264 encoder to the content type being transcoded; I used animation in Listing 3 (for other tune options, see Table 5). libfdk_aac encodes the sound into Advance Audio Coding (AAC) at 224Kbps. (See also the "Patent-Encumbered Codecs" box.)

The profile:v switch selects an encoding profile. Files encoded with a high profile setting will be playable by most modern multimedia appliances. The baseline profile may be used in order to ensure compatibility with older appliances, at the expense of compression efficency. [5]

Wrapping Up

The last thing you need to do is provide (optional) metadata to the file. Listing 4 shows an example metadata.xml file. Matroska metadata is not well documented, but if you want to delve deeper, see some examples online [7].

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE Tags SYSTEM "matroskatags.dtd">
<Tags>
  <!-- movie -->
  <Tag>
    <Targets>
      <TargetTypeValue>50</TargetTypeValue>
    </Targets>
    <Simple>
      <Name>TITLE</Name>
      <String>Happy Rottweiler</String>
    </Simple>
    <Simple>
      <Name>DIRECTOR</Name>
      <String>Rubén Llorente</String>
    </Simple>
    <Simple>
      <Name>DATE_RELEASED</Name>
      <String>1992</String>
    </Simple>
    <Simple>
      <Name>ORIGINAL_MEDIA_TYPE</Name>
      <String>VHS</String>
    </Simple>
  </Tag>
</Tags>

The final step is to merge the metadata with the Matroska file, as follows:

mkvpropedit "vhs_final.mkv" --edit info --set "title=Happy Rottweiler" -t global:metadata.xml --edit track:a1 --set "language=spa" --set "flag-default=1"

This command sets the file's title Happy Rottweiler, merges the metadata file metadata.xml with the vhs_final.mkv file, and sets the audio track number 1 language value to Spanish. The only audio track is set as the default audio track.

Conclusion

Saving your old VHS tapes or audio cassettes is quite easy with minimal hardware expenses. Although video and audio encoding and analog to digital conversion is surrounded by a lot of black magic, this article should provide a starting point to converting your old VHS tapes for personal use.

You can easily use the procedure presented here to save audio cassettes just by capturing and encoding the audio by selecting a suitable codec, such as Ogg, FLAC, or Opus, and a suitable container. Matroska does the trick (in fact, files with the mka extension are Matroska files with audio-only content), but its use for this purpose is not widespread.

If the steps presented here look too cumbersome to perform manually, you can always use the LinuxTV's V4L capturing script [8] to automate the process.