Joining Multiple Videos Into a Single File

*!!!* This tutorial is a work in progress *!!!*

In dealing with digital video, concatenating or joining generally refers to taking multiple files and placing them together sequentially in a single container (e.g. .avi, .mp4, .flv, etc.) without re-encoding. It is preferable to use this method when re-encoding is not necessary as it is much faster and there is no quality/data loss.

Two of the most common issues that I have faced with joining video is audio sync and frame corruption problems. In this tutorial I will demonstrate some of the different free/open source software methods that I prefer to use when joining various video types. Each video type is different and not every method works well for them.

Important Note: All files being joined must have been encoded using the same method. Because the video is not being re-encoded the result will be corrupted or joining will fail altogether.

Some things that will cause video incompatibility:

Scan Type: Progressive, top frame first interlacement, and bottom frame first interlacement are not compatible with each other and will guarantee frame corruption.

Framerate: The speed at which frames are displayed during playback must match. It may be possible to change the framerate of all files without re-encoding with some programs.

Resolution: All video files must have the same width and height.

Aspect Ratio: Most programs will use the aspect ratio of the initial video unless otherwise specified. If the trailing videos do not use the same it will likely result in them looking “stretched” or “squeezed”.

Bitrate: Videos using different bitrates may end up corrupted.

Pixel Format / Color Space: This one has been a real pain for me. I didn’t realize until recently just how many different color spaces are available for video encoding. Some codecs support many different color spaces while others only a few or maybe even one. A few common color spaces are RGB, YUV4:4:4, YUV4:2:2, and YUV4:2:0.

Audio Format and Encoding: The audio will be a factor as well. Codec, bitrate, frequency, and channel count should all be taken into account.

GUI (Graphical User Interface) Methods:

Avidemux:

http://avidemux.sourceforge.net/

Avidemux is a versatile in-line video editor and its primary functions are joining, muxing, and encoding. It supports almost any video and audio type (not perfectly unfortunately) and is built on top of the FFmpeg libraries. It is free open source software and released under the GNU General Public License (GPL).

It does a good job of joining MPEG-2 videos as long as indexing is enabled. Older versions have an option in the preferences menu that allow it to be disabled while newer versions seem to have omitted it, making indexing mandatory.

Open the first .mpg in Avidemux. It will begin indexing and create an .idx2 file in the same directory.

Next go to the menu bar and select “File” -> “Append”. This will append another file at the end of the previous. If the two MPEGs are not compatible with each other the appending will mostly likely fail. Older versions had an option to automatically append all filenames that followed a numbered sequence (e.g. video001.mpg, video002.mpg, video003.mpg, …) and was located in the same directory. However, this often cause audio sync issues on my system. So my recommendation is to add each file independently, though it is more tedious. If you chose to append the files all at once but want to go back and redo it you will need to delete or rename the .idx/.idx2 file that was created first.

After you have added all the files that you want go to the left side of the application window and make sure that under both Video Output and Audio Output “Copy” is selected. Otherwise the video and/or audio will be re-encoded. Finally, at the bottom left corner, choose the container that you would like to use. If you are creating an MPEG-2 file for use on a DVD you will probably want to use the MPEG PS format. The Matroska (.mkv) container should hold MPEG-2 data without any problems as well.

Finally press the save button (or go to “File” -> “Save”). A dialog will pop up and ask you where you want to save your video. Be sure to put the extension at the end of the filename (.mpg/.mpeg/.m2v) as Avidemux will not do this automatically. Then press “Save”.

Note: Avidemux has a setting that splits MPEG files when they reach a certain size. This is problematic if your goal is a single video file. To change the setting go to the menu bar and select “Edit” -> “Preferences”. Under the “Output” tab go to the option called “Split MPEG files every (MB):” and raise the value above the size of your output video then press “OK”.

Works well for:

• MPEG-2 / VOB / DVD

Available for:

• Apple OS X
• Microsoft Windows
• Unix-like

MKVToolNix (MKVMerge GUI):

http://www.bunkus.org/videotools/mkvtoolnix/

** No instructions yet.

Works well for:

• MPEG-4 Part 10 / AVC / BluRay

Available for:

• Apple OS X
• Microsoft Windows
• Unix-like

VirtualDub:

http://virtualdub.org/

** No instructions yet.

Works well for:

Available for:

• Microsoft Windows

CLI (Command Line Interface) Methods:

Cat Command:

http://www.gnu.org/software/coreutils/

The cat command (also available for Windows) is supposed to work similarly to the Windows copy command. In my experience it doesn’t work as well. To use it invoke “cat” followed by a list of input files. By default cat outputs to standard-out. So to make it output to a file add a “>” followed by the name of the output video:

cat <in video 1> <in video 2> … > <out video>

Works well for:

Available for:

• Apple OS X
• Microsoft Windows
• Unix-like

Copy Command:

This method seems to work flawlessly for MPEG-2 but does not work at all for H.264/MP4. To concatenate files with the copy command the binary switch /b must be added. Next add the name of the output file followed by a list of input files separated by a “+”:

copy /b out_vid.mpg in_vid1.mpg + in_vid2.mpg + in_vid3.mpg ...

Works well for:

• MPEG-2 / VOB / DVD

Available for:

• Microsoft Windows

MKVToolNix (mkvmerge):

http://www.bunkus.org/videotools/mkvtoolnix/

The following is a Windows Batch file that will concatenate all the files in the current working directory. Copy and paste it into a text document. Save it with the .bat file extension (I have it named as concatvids.bat) and place it in a directory on the system PATH (C:\Windows). Then open a command prompt and change to the directory where your videos are located. Type the filename that you gave the batch file followed by the desired name for your new video: concatvids “../video_out” (file extension not needed).

@echo off
setlocal EnableDelayedExpansion

if "%~1" == "" (
    echo Not enough arguments.
    exit /b 1
)

set filename=%~1.mkv
set filelist=

for %%a in (*) do (
    set filelist=!filelist! "%%~a" +
)

mkvmerge -o "%filename%" %filelist%

On Unix-like systems (and OS X I think) this is even simpler. Open a terminal, navigate to the directory containing your videos and execute the following command:

mkvmerge -o "../video_out.mkv" $( for x in $(ls); do echo "$x + "; done )

This is a bash/sh script that will do the same as the above batch file:

#! /bin/bash

if [ "$#" -lt "1" ]
then
    echo Not enough arguments.
    exit 1
fi

filename=${1}.mkv

mkvmerge -o ${filename} $( for x in $(ls); do echo "$x + "; done )

Works well for:

• MPEG-4 Part 10 / AVC / BluRay

Available for:

• Apple OS X
• Microsoft Windows
• Unix-like

MPEG-4 Part 2 / DivX / Xvid:

No info yet.

Advertisements

Recording the Screen of the Windows Desktop Using FFmpeg

For a tutorial on how to record an X11 desktop (Linux/Unix/BSD) with FFmpeg see:
https://antumdeluge.wordpress.com/2013/08/24/recording-the-screen-of-an-x11-unixlinuxbsd-desktop/

Setting Up:

The first thing that you will need to do (after you have FFmpeg installed) if you want to record your Windows® desktop is to install a DirectShow filter/driver that is designed specifically for this purpose. I can recommend two filters: UScreenCapture and Screen Capture Recorder. There are subtle differences between the two. By default:

• Unless explicitly declared Screen Capture Recorder will process 30 frames per second by default while UScreenCapture will only do 10. In FFmpeg it is necessary to declare FPS (-r option) before the input (-i option) in order to correctly process the desired frame rate. If you have trouble getting UScreenCapture to use a higher frame rate check this tutorial.
• UScreenCapture is free proprietary software. It is part of the Unreal Media Server. Screen Capture Recorder is open source software (contact author about license details).

Now you can use FFmpeg to display your available DirectShow capture sources: From a command line type “ffmpeg -list_devices true -f dshow -i dummy”. At the end of the output you will see a number of devices listed under “DirectShow video devices” and “DirectShow audio devices”.

Image 1-1: DirectShow capture sources listed by FFmpeg

Using FFmpeg to Record:

Some options that you may want to consider:

• Real-Time Buffer: If you have problems with buffer overflow and/or skipped frames you may want to set the real-time buffer option. Example: -rtbufsize 1500M
• Video Quality: If you do not want to lose any video quality two good encoder options are the huffyuv video codec or libx264 with the “-crf 0” or “-qp 0” options. Example: -crf 0 -vcodec libx264.
• Audio Quality: For lossless audio compression use the pcm_s16le audio codec. This is the most commonly used PCM/WAV format (signed 16-bit little endian). You can also use the flac codec, but in my experience pcm is less buggy. It is probably also a good idea to record with a single audio channel (mono) since most likely you will be recording from a single audio input (microphone). This will reduce the size of the output file. If you want to use a frequency other than the default (generally 44,100 Hz) you can specify the audio rate option. Example: -acodec pcm_s16le -ac 1 -ar 44100

Recording:

Use the ffmpeg command and optionally set the real-time buffer:

ffmpeg -rtbufsize 1500M

Set the format to “dshow”.

ffmpeg -rtbufsize 1500M -f dshow

To avoid a few frame rate problems if want something other than the default it is a good idea to set it before declaring the video input:

ffmpeg -rtbufsize 1500M -f dshow -r 30

Now choose the video input source. This should be typed exactly (letter casing does not matter on Windows® systems) as displayed in the list of DirectShow devices (Image 1-1):

ffmpeg -rtbufsize 1500M -f dshow -r 30 -i video=”UScreenCapture”

If you want to capture audio as well add a colon (:) and set the audio input source. Just like the video capture source this should be typed exactly as displayed in the list of DirectShow devices. Note from the picture above that on my system there is no closing brace in the microphone name:

ffmpeg -rtbufsize 1500M -f dshow -r 30 -i video=”UScreenCapture”:audio=”Microphone (Realtek AC’97 Audio”

Specify the video and audio encoders. It is not important which comes first (Note that -vcodec and -acodec can be substituted by -c:v and -c:a respectively).

Video: Remember to use “-crf 0” or “-qp 0” if you want lossless compression with libx264 (Note: crf stands for “Constant Rate Factor” and qp I believe stands for “Quantization Parameter”). According to the FFmpeg documentation qp is recommended over crf but I am unsure of the difference. If you want more information on crf vs qp this document may be helpful. Note: I am not sure if it is important when this option is declared:

ffmpeg -rtbufsize 1500M -f dshow -r 30 -i video=”UScreenCapture”:audio=”Microphone (Realtek AC’97 Audio” -crf 0 -vcodec libx264

A nice feature of the huffyuv format is that it uses all I-frames. This makes editing the video much more simple in some cases. It allows cropping of the video at any frame without the need for re-encoding. There is also a way use I-frames only with libx264 by setting the keyframe interval to 1 using the option x264opts. However, this may result in a greater chance of buffer overflow:

ffmpeg -rtbufsize 1500M -f dshow -r 30 -i video=”UScreenCapture”:audio=”Microphone (Realtek AC’97 Audio” -crf 0 -vcodec libx264 -x264opts keyint=1

For other supporting encoders you can force I-frames only by adding “-force_key_frames expr:1” after the video codec:

-vcodec libxvid -force_key_frames expr:1

See here for a list of lossless video encoders that FFmpeg can use.

Audio:

ffmpeg -rtbufsize 1500M -f dshow -r 30 -i video=”UScreenCapture”:audio=”Microphone (Realtek AC’97 Audio” -crf 0 -vcodec libx264 -acodec pcm_s16le -ac 1 -ar 44100

Notes On Encoding AAC Audio:

FFmpeg has a few different AAC encoders: aac, libvo_aacenc, libfaac, and libfdk_aac. However, the official build only supplies aac and libvo_aacenc. If you want to use one of the other encoders you will either have to compile FFmpeg yourself or find an unofficial download that includes them. libfdk_aac is considered to be the best and libvo_aacenc the worst. libvo_aacenc is more limited than the other encoders as it can only use constant bitrate (CBR). aac can use variable bitrate (VBR) but the encoder is disabled by default. You must add “-strict experimental” or “-strict -2” to the command line to use it:

-strict experimental -acodec aac

If you want to output VBR with aac use the audio quantizer switch (-q:a or -qscale:a) which receives a floating point value. The audio bitrate switch (-ab or -b:a) will create a reference bitrate for the quantizer. By default it is 128k and a quantizer value of about 1.1 will place the average bitrate (ABR) close to that. The following examples demonstrate how the quantizer’s value is affected by the reference bitrate:

-strict experimental -acodec aac -q:a 0.47 (ABR will be about 64k)

-strict experimental -acodec aac -q:a 1.1 (ABR will be about 128k)

-strict experimental -acodec aac -q:a 0.47 -b:a 256k (ABR will be about 113k)

-strict experimental -acodec aac -q:a 1.1 -b:a 256k (ABR will be about 212k)

Choosing a Video Container Format (e.g. File Extension):

Finally specify the output filename and container (e.g. .avi, .mp4, .mkv, etc.). Note: Some container formats will not work correctly with certain codecs:

ffmpeg -rtbufsize 1500M -f dshow -r 30 -i video=”UScreenCapture”:audio=”Microphone (Realtek AC’97 Audio” -crf 0 -vcodec libx264 -acodec pcm_s16le -ac 1 -ar 44100 “out video.avi”

Troubleshooting:

In my experience I have had problems with buffer overflow, frame rate and audio synchronization on different systems. This may be due to higher screen resolutions or limited resources. If you are having similar problems some of these suggestions might help:

Audio and Video Out of Sync:

Set Async to Match Video Frame Rate:

This option seems to work the best for me to fix audio sync problems. Use -async and set its value to the same as the desired video frame rate:

-r 30 -vcodec libx264 -crf 0 -acodec pcm_s16le -ac 1 -ar 44100 -async 30

Setting Pixel Format:

Adding the pixel format option before the video and audio codecs may help with audio synchronization issues. Screen Capture Recorder and UScreenCapture both seem to process frames in rgb24 by default:

-crf 0 -pix_format rgb24 -vcodec libx264 -acodec …

Buffer Overflow:

Windows Resolution and Themes:

It may be possible to avoid buffer overflow by disabling any desktop themes that use transparency (e.g. Aero) or reducing the display resolution. This will free up some system resources.

Limiting I-frames:

Intra frames, a.k.a. key frames or I-frames, are larger than other types. Some encoders output in key frames only which requires a larger load on the encoder. If the encoder allows it, reducing the amount encoded into the video will probably greatly help. You can use the -x264opts switch to change the I-frames interval with the libx264 encoder:

-vcodec libx264 -x264opts keyint=100:min-keyint=80

Otherwise you can use the -force_key_frames expr:expr switch. But this is much more complicated.

Using HuffYUV FFmpeg Variant:

If you are having problems with the huffyuv encoder you can alternatively try the FFmpeg variant ffvhuff. This, however, will probably not solve problems with buffer overflow.

Using MPEG4 Encoder (Xvid):

If you are having trouble solving problems with any lossless encoders then I recommend trying to encode into the Xvid (MPEG-4 Part 2 ASP) format using the mpeg4 encoder. Unfortunately there will be some quality loss because the pixel format will be downscaled to yuv420p. Quality loss can be minimized by setting the video quantizer value (-q:v or -qscale:v) to “0”:

-vcodec mpeg4 -vtag xvid -q:v 0

Re-Processing Output Video to Correct Audio Synchronization:

If you are unable to prevent audio synchronization problems then as a last resort you can try running the output video file through some other video software which can re-sync. Below are some software options and the steps to do this.

VirtualDub:

So far this is the only solution I have found for reprocessing the video. I am currently checking out Mencoder to see if it is possible.

1. Start VirtualDub and the output video file.
2. In the menu bar: Select “Video” then “Direct stream copy”. Also Make sure that “Direct stream copy” is selected under “Audio”. This copies the video and audio streams without the need to re-encode.
3. Again under “Video” select “Frame Rate”.
4. Under “Source rate adjustment” select “Change so video and audio durations match” and press “OK”.
5. If you want the output frame rate to be the same as input: Under “Frame rate conversion” select “Convert to fps:” and input the source frame rate in the adjacent field. (Note: You may need to do this step separately after you synchronize the audio)
6. Go back to the menu bar and select “File” -> “Save as AVI”. Choose a file name and press “Save”.

Problems with this method: Depending on the change in frame rate the resulting video could end up “choppy”.

Re-encoding Video with FFmpeg or Mencoder:

In my testing I have been able to resync audio by simply re-encoding the video. This leads me to believe that though scanning the files shows that the video is encoded at 30fps it is actually not:

ffmpeg -i video_in.avi -vcodec libx264 -crf 0 -acodec copy video_out.avi

mencoder -ovc x264 -x264encopts crf=0 -oac copy -o video_out.avi video_in.avi

Increase Frame Rate of UScreenCapture

UScreenCapture is a desktop recording/screencasting driver for the Microsoft Windows® operating system. It is a free component of the Unreal Media Server. It can be used with software that records video from DirectShow devices such as CamStudio or FFmpeg.

By default UScreenCapture records at a low 10 frames per second which will result in a “choppy” video. If you have trouble recording at a higher frame rate you can add the following registry key to change the default:

HKEY_LOCAL_MACHINE\SOFTWARE\UNREAL\Live\UScreenCapture

Under that key add a new DWORD value called “FrameRate” and set it to the frame rate of your choice.

Optionally you can download a .reg file that I have prepared that will set the default frame rate to 30fps. You can download it from here. It is located in the zip filed called “DirectShow Capture with FFmpeg”. Just double click the file called “UScreenCapture_30fps.reg” to add it to the registry. If you have any problems try extracting it from the zip file first.

This is a list of options that can be set in the registry:

DWORD: MonitorNum
DWORD: Left
DWORD: Right
DWORD: Top
DWORD: Bottom
DWORD: FrameRate
DWORD: ShowCursor
DWORD: CaptureLayeredWindows

MonitorNum – is monitor to capture. Two monitors are supported. Value of 0 means capture from both monitors.
Left – is the x-coordinate of the upper left corner of the region to capture in pixels.
Right – is the x-coordinate of the lower right corner of the region to capture in pixels.
Top – is the y-coordinate of the upper left corner of the region to capture in pixels.
Bottom – is the y-coordinate of the lower right corner of the region to capture in pixels.
FrameRate – the valid range is 1 to 30.
ShowCursor – 1 to capture cursor, 0 not to capture.
CaptureLayeredWindows – 1 to capture layered windows, 0 not to capture.

If you would like more information on editing the registry there are a lot of good tutorials on YouTube and Dailymotion.

Fixing A Broken AVI Video Using Free Sofware

Recording the Screen of an X11 (Unix/Linux/BSD) Desktop Using FFmpeg

For a tutorial on how to record a Microsoft Windows desktop see: Recording the Screen of the Windows Desktop Using FFmpeg

(The text portion of this tutorial is incomplete. But below you will find a complete video tutorial & shell script.)

Contents:

• Text Tutorial
  • Format
  • Frame Rate
  • Finding Screen Resolution
  • Choosing Input Devices
    • Video
    • Audio
  • Setting Codecs
    • Video
    • Audio
  • Setting Output Filename
• Video Tutorial
• Shell Script

---

↑ Text Tutorial:

↑ Format:

For FFmpeg to record an X11/X.org screen session, it must have been compiled with the –enable-x11grab. You can check if it is listed in the build parameters like this:

$ ffmpeg -help 2>&1 | grep x11grab

To capture an X11 session, add -f x11grab to the FFmpeg line:

$ ffmpeg -f x11grab

↑ Frame Rate:

Frame rate is set with the -r option. To use input frame rate, set the option before setting the input devices. For output frame rate, set it after.

$ ffmpeg -f x11grab -r 30

You can use a fraction to declare accurate decimal values. For example, for the NTSC standard of 29.976 fps, you could explicitly declare that decimal value or use 30000/1001:

$ ffmpeg -f x11grab -r 30000/1001

Some common frame rates are:

• 30 fps
• 29.976 fps (30000/1001) NTSC
• 25 fps PAL
• 23.976 fps (24000/1001) Film standard

For more common frame rates, see this Wikipedia article.

↑ Finding Screen Resolution:

FFmpeg cannot discern the screen dimensions itself. So, a second tool will be needed for this. xdpyinfo is the standard tool for X11 servers. If it is not already installed on your system, you may find it in one of these packages:

• Archlinux: xorg-xdpyinfo
• Debian/Ubuntu: x11-utils
• Fedora: xorg-x11-utils
• FreeBSD: xdpyinfo
• OpenSuse: xdpyinfo

To see the dimensions of the first display you can use this command:

$ echo $(xdpyinfo | grep dimensions | cut -d " " -f7)

Now add it to the FFmpeg line using the -s option:

$ ffmpeg -f x11grab -r 30000/1001 -s $(xdpyinfo | grep dimensions | cut -d " " -f7)

Another option is xrandr.

• Archlinux: xorg-xrandr
• Debian/Ubuntu: x11-xserver-utils
• Fedora: xorg-x11-server-utils
• FreeBSD: xrandr
• OpenSuse: xrandr

(Instructions for xrandr to come)

↑ Choosing Input Devices:

↑ Video:

↑ Audio:

↑ Setting Codecs:

↑ Video:

↑ Audio:

↑ Setting Output Filename:

---

↑ Video Tutorial:

---

↑ Shell script for recording X11 desktop:

#!/usr/bin/env bash
 # Script for recording the screen in an X11 window system
 #
 # This script is public domain (CC0). You may distribute, modify, share in any way.

# Screen/Window dimensions and position

set -e

RES=$(xdpyinfo | grep dimensions | cut -d " " -f7)
 XPOS=0
 YPOS=0

# Video codec to use
 VCODEC="mpeg4 -vtag xvid"
 VARGS=""

# Audio codec to use
 ACODEC="libmp3lame -ac 1 -ab 128k -ar 44100"
 AARGS=""

# Output filename
 OFILE="screen-capture_$(date +%Y-%m-%d_%R.%S$(date +%N | cut -b1)).avi"

if [ $# -gt 0 ] ; then :
 # Show help/usage and exit
 if [ $1 == "help" ] || [ $1 == "-h" ] || [ $1 == "--help" ] ; then :
 echo -e " USAGE:"
 echo -e "\trecord-desktop [res=value] [xpos=value] [ypos=value] [vcodec=value] \\"
 echo -e "\t [vargs=value] [acodec=value] [aargs=value] [ofile=value]"
 echo -e "\trecord-desktop [-h|--help|help]"
 echo -e "\n ARGUMENTS:"
 echo -e "\thelp\tShow this help message.\n"
 echo -e "\tres\tDimensions to record (e.g. 1280x720)."
 echo -e "\t\t[automatically detected]\n"
 echo -e "\txpos\tHorixontal axis of upper-left corner"
 echo -e "\t\tof recording area. [$XPOS]\n"
 echo -e "\typox\tVertical axis of upper-left corner of"
 echo -e "\t\trecording area. [$YPOS]\n"
 echo -e "\tvcodec\tVideo codec to pass to ffmpeg."
 echo -e "\t\t[$VCODEC]\n"
 echo -e "\tvargs\tVideo codec arguments to pass to"
 echo -e "\t\tffmpeg. [$VARGS]\n"
 echo -e "\tacodec\tAudio codec to pass to ffmpeg."
 echo -e "\t\t[$ACODEC] (audio not yet implemented)\n"
 echo -e "\taargs\tAudio codec arguments to pass to"
 echo -e "\t\tffmpeg. [$AARGS]\n"
 echo -e "\tofile\tOutput file name."
 echo -e "\t\t[screen-capture_--_:..avi]"
 exit 0
 fi
 # Get argument keys and values
 for arg in $@ ; do :
 case "$arg" in
 *"="* ) :
 KEY=${arg%"="*}
 VAL=${arg#*"="}
 if [ "$KEY" == "res" ] ; then :
 RES=$VAL
 elif [ "$KEY" == "xpos" ] ; then :
 XPOS=$VAL
 elif [ "$KEY" == "ypos" ] ; then :
 YPOS=$VAL
 elif [ "$KEY" == "vcodec" ] ; then :
 VCODEC=$VAL
 elif [ "$KEY" == "vargs" ] ; then :
 VARGS=$VAL
 elif [ "$KEY" == "acodec" ] ; then :
 ACODEC=$VAL
 elif [ "$KEY" == "aargs" ] ; then :
 AARGS=$VAL
 elif [ "$KEY" == "ofile" ] ; then :
 OFILE=$VAL
 else
 echo "Invalid argument: $KEY"
 exit 1
 fi;;
 * ) :
 echo "Argument \"$arg\" not of type \"key=value\"."
 exit 1;;
 esac
 done
 fi

echo "Recording desktop..."
 ffmpeg -f x11grab -r 30 -s $RES -i :0.0+$XPOS,$YPOS -sameq \
 -vcodec $VCODEC $VARGS -acodec $ACODEC $AARGS \
 $OFILE