Even the fact that I have several workstations with professional level video capture devices, those machines are usually working doing renders or any other thing and is not that I can waste days capturing all that media there, so i decided to buy one of those EasyCap devices on eBay and give it a try.

The specifications are pretty outstanding for what it is, and specially, for the $15 price… AND it is compatible with Mac OS (by using the non-free VideoGlide app) which makes it even better.

Just some highlights:

• Complies with Universal Serial Bus Specification Rev 2.0
• Supports NTSC, PAL (B), Video format
• Video input: RCA composite or S-Video
• Audio input: Stereo audio (RCA)
• Dimension(Main Body): 8.8cm x 2.8cm x 1.8cm typical credit card size is 8.5cmx5.4cm)
• Powers by USB 
• Supports high quality video resolution for 
• NTSC: 720 x 480 @30fps
• PAL: 720 x 576 @25fps

Im still waiting for it to arrive, and i will post several video examples and personal impressions as soon as i get it.

Since I’m working on a really big project which involves a “youtube like” behavior, i though it would be cool to also create iPhone / iPod compatible streams (I’m amazed at the fact that 3% of the people coming to this site is using iPod’s or iPhone’s)… so, I did some modifications to the original script for it to generate the compatible streams.

Now, how am i dealing with this… well… let me explain you:

The iPhone specification states:

Video formats supported: H.264 video, up to 1.5 Mbps, 640 by 480 pixels, 30 frames per second, Low-Complexity version of the H.264 Baseline Profile with AAC-LC audio up to 160 Kbps, 48kHz, stereo audio in .m4v, .mp4, and .mov file formats; H.264 video, up to 2.5 Mbps, 640 by 480 pixels, 30 frames per second, Baseline Profile up to Level 3.0 with AAC-LC audio up to 160 Kbps, 48kHz, stereo audio in .m4v, .mp4, and .mov file formats; MPEG-4 video, up to 2.5 Mbps, 640 by 480 pixels, 30 frames per second, Simple Profile with AAC-LC audio up to 160 Kbps, 48kHz, stereo audio in .m4v, .mp4, and .mov file formats

This means that the high profile streams that I am generating with the MKMP4 script won’t play, simple as that. So i have 2 possible approachs:

1. I could just use a single low profile stream for the iPhone and iPod, and since the stream is H264 and low complexity AAC audio, it will just play fine on the flash players too.
2. I could have 2 different files, one for the flash players (making use of b-frames, entropy coding, and a high profile stream, which substantially improves the final video quality).

I decided to use the option 2, mostly because i want to give desktop users as much quality as possible, and i want to use the HE-AAC encoder to save some extra bandwidth that i can instead use for the video stream, so I am using 2 different files, one for desktop users, and a different one for iPhone or iPod users.

To check if the user is visiting the site with a desktop browser or a Mobile Safari version is really simple: Let’s consider a PHP based scenario.

The first thing that i had to do is to create a simple function to check the browser’s user-agent string.

function isIphone() {
$agent = $_SERVER['HTTP_USER_AGENT'];
if (stristr($agent, 'iPhone') == TRUE || stristr($agent, 'iPod') == TRUE) {
echo '<!--iPhone or iPod Touch detected-->;';
return TRUE;
} else {
echo '<!--iPhone or iPod Touch not detected-->';
return FALSE;
}
}

This function is self explanatory for anybody with basic PHP skills, basically it checks the user-agent string and returns TRUE if it contains the words “iPhone” or “iPod”.

So, then in your template you could make something like this:

if (!isIphone()) {
// Code to display the standard high profile stream goes here.
} else {
// Code to display the iPhone compatible stream goes here.
}

Pretty simple.

The updated MKMP4 script.

This is an updated version of my MKMP4 encoding script, basically, it is almost the same thing than the original one published here, with the addition of an extra -i switch that you can use if you want to create an iPhone compatible stream.

Important: FAAC encoder is a requeriment for this!

This version of the MKMP4 script uses the FAAC encoder that you can download by going here. Be sure that you have correctly compiled and installed it BEFORE trying to use this script on your desktop or server.

#! /bin/bash

# This bash script has been created by Diego Massanti
# www.massanti.com
#
# set -x # uncomment this for debugging
shopt -s nullglob # so the glob expands to nothing when there are no .mov files.

# User settings:

fileext=".mov" # Set this variable to the video file extension that you want to search for when encoding whole directories.
onlythumbs=FALSE # IF you set this to TRUE, the script will only generate thumbnails.
# End user settings
# You should not change anything below this line unless you know what you are doing.

usage()
{
cat << EOF
usage: $0 -f  [-w ] -b  [-q][-i][-k][-t][-o ]

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* h264 video with he-aac audio encoding script by Diego Massanti. *
*                 October 2008,  Made in Argentina.               *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

OPTIONS:
 -h    Show this message
 -f    Path to the file to encode < REQUIRED
 -w    Resize video to fit inside this width while keeping the aspect ratio < OPTIONAL
 -b    Desired video bitrate < REQUIRED
 -o    Output directory for compressed media < OPTIONAL (will use same as source if ommited)
 -q     Better quality encoding using 2 passes (slower) < OPTIONAL
 -k    Do not delete (keep) temporary files < OPTIONAL
EOF
}
audiobitrate=48000
platform=""
uname=`uname`
if [ $uname == "Darwin" ]; then
 ## 99% of chances that this is a Mac
 platform="Mac"
else
 platform="Linux"
fi

width=""
bitrate=
deltemp=TRUE
quality=FALSE
iphone=FALSE
poster=FALSE
filename=""
rsize=""
outdir=`pwd`
outFileName=""
itemVideoBitrate=""

while getopts ":f:w:o:b:qktvi" OPTION; do
 case $OPTION in
 w ) width=$OPTARG;;
 f ) filename=$OPTARG;;
 b ) bitrate=$OPTARG;;
 k ) deltemp=FALSE;;
 q ) quality=TRUE;;
 t ) poster=TRUE;;
 i ) iphone=TRUE;;
 o ) outdir=`cd "$OPTARG"; pwd`;;
 h ) usage;;
 \? ) usage
 exit 1;;
 * ) echo $usage
 exit 1;;
 esac
done

if [ "$1" == "" ]; then
 usage
 exit 0
fi

if [ "$filename" == "" ]; then
 echo
 echo you MUST supply a file to encode!, use the -f parameter. i.e: -f mymovie.avi
 echo
 usage
 exit 1
fi
if [ "$bitrate" == "" ]; then
 echo
 echo you MUST specify a target bitrate!, use the -b parameter. i.e: -b 512
 echo
 usage
 exit 1
fi

if [ "$width" != "" ]; then
 rsize="-vf scale=$width:-3"
 rsizemsg="fit into $width pixels wide"
else
 rsize=""
 rsizemsg="Movie is not being resized."
fi

# Check if output directory exists
if [ -d "$outdir" ]; then
 echo "Target directory set to: $outdir"

else
 echo "Error: '$outdir' does not exist!!"
 echo "Can not continue, please make sure that the specified output directory exists. Exiting..."
 exit 1
fi

# Start the magic...

showMessage() {
 echo "MKMP4 : "$1""
}

initialize() {
 if [ -d "$filename" ]; then
 $filename = `cd $filename; pwd`
 showMessage "Output directory set to: $outdir."
 showMessage "Triggering the encoder with all media files in directory: $filename."
 for file in "$filename"*$fileext; do
 if [ -f "$file" ]; then
 showMessage "Will encode file: $file"
 startEncoders "$file"

 fi
 done
 elif [ -f "$filename" ]; then
 showMessage "Triggering the encoder with source media: $filename."
 startEncoders "$filename"

 else
 # input is no file and no directory ? WTF ?
 echo "Something really weird has happened here: $filename is not valid, exiting..."
 exit 1
 fi
}

startEncoders() {
 if [ $onlythumbs == "FALSE" ]; then
 firstPass "$1"
 if [ "$quality" == "TRUE" ]; then
 secondPass "$1"
 fi
 extractAudio "$1"
 encodeAAC "$1"
 mux "$1"
 fi
 if [ $poster == "TRUE" ]; then
 createThumbnail "$1"
 fi
 if [ $deltemp == "TRUE" ]; then
 cleanTemporaryFiles "$1"
 fi
}
firstPass() {
 local iFile="${1##*/}"    # remove directory and keep only file name.
 # First, lets get some basical information about this file, as FPS.
 MOVIE_FPS=`midentify "$1" | grep FPS | cut -d = -f 2`
 MOVIE_LENGTH = `midentify "$1" | grep "ID_LENGTH" | cut -d = -f 2 | cut -d . -f 1`
 let "THUMB_SECONDS = $MOVIE_LENGTH / 2"
 # Lets print some info to stdout.
 showMessage "Encoding: $1"
 showMessage "Resizing to: $rsizemsg."
 showMessage "Total Bitrate: $bitrate kbps."
 let "caudiobitrate = $audiobitrate / 1000"
 let "itemVideoBitrate = $bitrate - $caudiobitrate"
 showMessage "Video Bitrate: $itemVideoBitrate kbps."
 showMessage "Audio Bitrate: $caudiobitrate kbps."
 showMessage "Platform: $platform."
 # Lets start the encoding for the first pass.
 showMessage "Starting video encoding pass 1..."
 if [ $iphone == "TRUE" ]; then
 mencoder "$1" -o "$outdir/${iFile%%.*}_temp.264" -demuxer lavf -passlogfile "$outdir/${iFile%%.*}"_temp.log $rsize -ssf lgb=0.2 -ovc x264 -x264encopts bitrate=$itemVideoBitrate:frameref=1:nocabac:bframes=0:b_adapt:b_pyramid:weight_b:partitions=all:me=umh:subq=6:trellis=2:brdo:threads=auto:pass=1:analyse=all -of rawvideo -nosound
 else
 mencoder "$1" -o "$outdir/${iFile%%.*}_temp.264" -demuxer lavf -passlogfile "$outdir/${iFile%%.*}"_temp.log $rsize -ssf lgb=0.2 -ovc x264 -x264encopts bitrate=$itemVideoBitrate:frameref=8:bframes=3:b_adapt:b_pyramid:weight_b:partitions=all:8x8dct:me=umh:subq=6:trellis=2:brdo:threads=auto:pass=1:analyse=all -of rawvideo -nosound
 fi
}

secondPass() {
 local iFile="${1##*/}"    # remove directory and keep only file name.
 showMessage "Starting video encoding pass 2..."
 if [ $iphone == "TRUE" ]; then
 mencoder "$1" -o "$outdir/${iFile%%.*}_temp.264" -demuxer lavf -passlogfile "$outdir/${iFile%%.*}"_temp.log $rsize -ssf lgb=0.2 -ovc x264 -x264encopts bitrate=$itemVideoBitrate:frameref=1:nocabac:bframes=0:b_adapt:b_pyramid:weight_b:partitions=all:me=umh:subq=6:trellis=2:brdo:threads=auto:pass=2:analyse=all -of rawvideo -nosound
 else
 mencoder "$1" -o "$outdir/${iFile%%.*}_temp.264" -demuxer lavf -passlogfile "$outdir/${iFile%%.*}"_temp.log $rsize -ssf lgb=0.2 -ovc x264 -x264encopts bitrate=$itemVideoBitrate:frameref=8:bframes=3:b_adapt:b_pyramid:weight_b:partitions=all:8x8dct:me=umh:subq=6:trellis=2:brdo:threads=auto:pass=2:analyse=all -of rawvideo -nosound
 fi
}

extractAudio() {
 local iFile="${1##*/}"    # remove directory and keep only file name.
 showMessage "Extracting Audio..."
 if [ $iphone == "TRUE" ]; then
 mplayer "$1" -af resample=48000:0:2,channels=2,volnorm=1:0.25,format=s16le -ao pcm:file="$outdir/${iFile%.*}_temp.wav" -vc dummy -vo null
 else
 mplayer "$1" -af resample=48000:0:2,channels=2,volnorm=1:0.25,format=s16le -ao pcm:file="$outdir/${iFile%.*}_temp.wav" -vc dummy -vo null
 fi

}

encodeAAC() {
 local iFile="${1##*/}"    # remove directory and keep only file name.
 if [ $iphone == "TRUE" ]; then
 faac "$outdir/${iFile%.*}_temp.wav" -q 100 -o "$outdir/${iFile%.*}_temp.mp4"
 else
 if [ "$platform" == "Mac" ]; then
 enhAacPlusEnc "$outdir/${iFile%.*}_temp.wav" "$outdir/${iFile%.*}_temp.aac" $audiobitrate s
 else
 neroAacEnc -br 48000 -he -if $outdir/${iFile%.*}_temp.wav -of $outdir/${iFile%.*}_temp.mp4
 fi
 fi
}

mux() {
 local iFile="${1##*/}"    # remove directory and keep only file name.
 MP4Box -add "$outdir/${iFile%.*}_temp.264#video:fps=$MOVIE_FPS" "$outdir/${iFile%.*}.m4v"
 if [ $iphone == "TRUE" ]; then
 MP4Box -add "$outdir/${iFile%.*}_temp.mp4#audio" "$outdir/${iFile%.*}.m4v"
 else
 if [ "$platform" == "Mac" ]; then
 MP4Box -add "$outdir/${iFile%.*}_temp.aac" -sbr "$outdir/${iFile%.*}.m4v"
 else
 MP4Box -add "$outdir/${iFile%.*}_temp.mp4#audio" "$outdir/${iFile%.*}.m4v"
 fi
 fi

 name=${iFile%.*}
 album="The Mac Video Archive"
 author="Apple Computer // massanti.com"
 comment="Professionally encoded by Diego Massanti"
 created="2008"
 MP4Box -inter 500 -itags album="$album":artist="$author":comment="$comment":created="$created":name="$name" -lang English "$outdir/${iFile%.*}".m4v
}

createThumbnail() {
 local iFile="${1##*/}"    # remove directory and keep only file name.
 mplayer "$1" -ss 10 -nosound $rsize -sws 7 -vo jpeg:outdir=$outdir -frames 1
 mv "$outdir/00000001.jpg" "$outdir/${iFile%.*}.jpg"
 mplayer "$1" -ss 10 -nosound -vf scale=150:-3 -sws 7 -vo jpeg:outdir=$outdir -frames 1
 mv "$outdir/00000001.jpg" "$outdir/${iFile%.*}_small.jpg"
}

cleanTemporaryFiles() {
 local iFile="${1##*/}"    # remove directory and keep only file name.
 showMessage "Removing temporary files..."
 rm "$outdir/${iFile%.*}"_temp*
}

initialize

The following example command line will encode the video stream in my_video.avi as a low profile H264 without b-frames, will encode the audio track as a Low Complexity AAC stream and will mux everything inside a M4V file which will play on the iPhone, iPod Touch, Apple TV and Quicktime / iTunes.

./mkmp4 -f my_video.avi -b 512 -w 640 -q -t -i

For a detailed explanation of all the supported command line switches, you can visit the original MKMP4 post.

Some final considerations:

• Due to the fact that I am forced to use a low complexity AAC encoder for the iPhone streams, the audio bandwidth is hardcoded at around 100kbps inside the script, that would give you an audio quality similar to the one you get with the HE-AAC encoder at 48kbps, feel free to experiment with different values for this.
• Using a low profile H264 stream gives me iPhone compatibility, but at the expense of losing some video quality, clearly, a 512kbps stream looks much better when we use b-frames and entropy coding so unless you really care about iPhone and iPod users like I do, you should use high profile streams.
• If you are visiting this page with an iPhone or iPod and want to see how all this works, feel free to visit this section of the Apple Video Archive here to see the magic happening: If you visit the page with a desktop browser, it will simply show the standard flash player, BUT when it detects you are on a Mobile Safari platform, it will automatically show you the iPhone compatible stream (click here to see how this all looks) and properly embed the quicktime player on the page.

I usually write such tools and scripts for myself or for clients, but due to the fact that it seems a lot of people is interested in the process, I’m releasing here the new version of my encoding tools for the Mac and any Linux / Unix variant.

Needed tools and applications

For all this to work, you will need the following things

• The latest GIT version of the one and only x264 encoder.
• The latest SVN version of mplayer
• The latest version of the GPAC utilities
• My build of the 3GPP HE-AAC encoder if you are on a Mac, or the Nero Digital Audio Encoder if you are on unix / linux.

Extra pre-requisites for Mac OS X

Mac OS X users need to install the Apple Developer Tools (aka XCode) in order to compile software, also, for building the x264 encoder, you will need to get and install YASM.

Now, you have to build and install all the tools, AND they have to be on any directory in your executable path. My scripts assume that all the tools are in your executable path.

Building x264

Building x264 is usually a matter of just typing:

./configure

in the source directory, and then the usual:

make

and

make install

If you happen to have any problem with the building process, usually a simple google search with the error string is all you need.

Building mplayer

The process of building mplayer is certainly similar, BUT if you plan to use the video thumbnail and poster frame generation on my scripts, you will have to get and compile the jpeg libraries (if you don’t have them already) BEFORE building mplayer, this should be also a really easy thing to do: go get the libjpeg sources from HERE, and then configure, build and install.

Now, you have to download the latest SVN version of mplayer, assuming that you have the subversion client enabled, you can get the whole source tree by typing:

svn checkout svn://svn.mplayerhq.hu/mplayer/trunk mplayer

Now, you need to enable some things at configure time for mplayer and mencoder to work nice with the scripts, so our configure line will look something like this

./configure --disable-gui --enable-png --enable-jpeg

Note: there should be no reason at all for the –enable-jpeg flag, but for some reason that I ignore, mplayer wont detect my libjpeg install if i don’t force it like that, also, the –disable-gui option is to save some compile time, since we don’t plan to use any of the GUI features on mplayer.

Now, its time to build, so type:

make

and then, if you get no errors, you are safe to type:

make install

At this point you should have a working install, but since we want to be 100% sure that you REALLY have a working install, in any terminal type this:

mencoder -ovc help

and you should get something like this (please notice the x264 part, that is fundamental for everything to work)

Available codecs:

   copy     - frame copy, without re-encoding. Doesn't work with filters.
   frameno  - special audio-only file for 3-pass encoding, see DOCS.
   raw      - uncompressed video. Use fourcc option to set format explicitly.
   lavc     - libavcodec codecs - best quality!
   vfw      - VfW DLLs, read DOCS/HTML/en/encoding-guide.html.
   qtvideo  - QuickTime DLLs, currently only SVQ1/3 are supported.
   x264     - H.264 encoding

now let’s verify the mplayer part, again, in any terminal type:

mplayer -vo help

and you should get something like this (here, notice the PNG and JPEG bits, this is fundamental if you plan to use the thumbnail and poster generation features).

Available video output drivers:
	macosx	Mac OSX Core Video
	quartz	Mac OSX (Quartz)
	xv	X11/Xv
	x11	X11 ( XImage/Shm )
	xover	General X11 driver for overlay capable video output drivers
	gl	X11 (OpenGL)
	gl2	X11 (OpenGL) - multiple textures version
	null	Null video output
	mpegpes	MPEG-PES file
	yuv4mpeg	yuv4mpeg output for mjpegtools
	png	PNG file
	jpeg	JPEG file
	tga	Targa output
	pnm	PPM/PGM/PGMYUV file
	md5sum	md5sum of each frame

Very Important!

After you compile and install mplayer, you need to copy the midentify.sh script into any directory inside your executable path, for example /usr/local/bin. This is mandatory, because the MKMP4 script will NOT be able to correctly identify the source video files without this tool. The midentify script (called midentify.sh) is located inside the TOOLS directory in the mplayer source tree.

At this point, almost everything is ready, now it is time for the next step.

Building and configuring the GPAC utilities

If you are on Linux / Unix, building the GPAC utilities is a really simple process.

Get the latest stable release from here, and then do the usual ./configure, make and make install.

For Mac OS users there is an extra step that you have to do if you want to be able to build and install the GPAC utilities without headaches, and it involves the editing of a source file in the package.

So, after you have downloaded the sources, open the file src/utils/os_net.c , line 78 reads:

#ifndef __DARWIN__

right AFTER it, add the following:

typedef unsigned long u_long;

save the file, and you can now configure, build and install the GPAC utilities (MP4Box) on Mac OS without any problem.

Installing the HE-AAC (aacPlus) audio encoder.

This is a pretty simple step, if you are on a Mac, get this encoder that i have built myself from the 3GPP sources and copy it to /usr/local/bin, and if you are on linux, get the Nero Digital Audio Encoder from HERE and again, copy it to /usr/local/bin. You can actually move the encoders to any directory that IS inside your executable path, /usr/local/bin is a good choice though .

Putting it all togheter.

At this point, you have pretty much everything you would need to encode amazing quality H264 video and aacPlus audio, the only one remaining thing is some tool to put all this togheter in an *easy to use* way, so i have created the following bash script which pretty much simplifies the whole process.

#! /bin/bash

# This bash script has been created by Diego Massanti
# www.massanti.com
#
# set -x # uncomment this for debugging
shopt -s nullglob # so the glob expands to nothing when there are no .mov files.

# User settings:

fileext=".mov" # Set this variable to the video file extension that you want to search for when encoding whole directories.

# End user settings
# You should not change anything below this line unless you know what you are doing.

usage()
{
cat << EOF
usage: $0 -f  [-w ] -b  [-q][-k][-t][-o ]

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* h264 video with he-aac audio encoding script by Diego Massanti. *
*                September 2008, Made in Argentina.               *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

OPTIONS:
   	-h	Show this message
-f	Path to the file to encode < REQUIRED
   	-w	Resize video to fit inside this width while keeping the aspect ratio < OPTIONAL
   	-b	Desired video bitrate < REQUIRED
-o	Output directory for compressed media < OPTIONAL (will use same as source if ommited)
   	-q 	Better quality encoding using 2 passes (slower) < OPTIONAL
-k	Do not delete (keep) temporary files < OPTIONAL
EOF
}
audiobitrate=48000
platform=""
uname=`uname`
if [ $uname == "Darwin" ]; then
## 99% of chances that this is a Mac
platform="Mac"
else
platform="Linux"
fi

width=""
bitrate=
deltemp=TRUE
quality=FALSE
poster=FALSE
filename=""
rsize=""
outdir=`pwd`
outFileName=""
itemVideoBitrate=""

while getopts ":f:w:o:b:qktv" OPTION; do
case $OPTION in
w ) width=$OPTARG;;
f ) filename=$OPTARG;;
b ) bitrate=$OPTARG;;
k ) deltemp=FALSE;;
q ) quality=TRUE;;
t ) poster=TRUE;;
o ) outdir=`cd "$OPTARG"; pwd`;;
h ) usage;;
\? ) usage
exit 1;;
* ) echo $usage
exit 1;;
esac
done

if [ "$1" == "" ]; then
usage
exit 0
fi

if [ "$filename" == "" ]; then
echo
echo you MUST supply a file to encode!, use the -f parameter. i.e: -f mymovie.avi
echo
usage
exit 1
fi
if [ "$bitrate" == "" ]; then
echo
echo you MUST specify a target bitrate!, use the -b parameter. i.e: -b 512
echo
usage
exit 1
fi

if [ "$width" != "" ]; then
rsize="-vf scale=$width:-3"
rsizemsg="fit into $width pixels wide"
else
rsize=""
rsizemsg="Movie is not being resized."
fi

# Check if output directory exists
if [ -d "$outdir" ]; then
echo "Target directory set to: $outdir"

else
echo "Error: '$outdir' does not exist!!"
echo "Can not continue, please make sure that the specified output directory exists. Exiting..."
exit 1
fi

# Start the magic...

showMessage() {
echo "MKMP4 : "$1""
}

initialize() {
if [ -d "$filename" ]; then
$filename = `cd $filename; pwd`
showMessage "Output directory set to: $outdir."
showMessage "Triggering the encoder with all media files in directory: $filename."
for file in "$filename"*$fileext; do
if [ -f "$file" ]; then
showMessage "Will encode file: $file"
startEncoders "$file"

fi
done
elif [ -f "$filename" ]; then
showMessage "Triggering the encoder with source media: $filename."
startEncoders "$filename"

else
# input is no file and no directory ? WTF ?
echo "Something really weird has happened here: $filename is not valid, exiting..."
exit 1
fi
}

startEncoders() {
firstPass "$1"
if [ "$quality" == "TRUE" ]; then
secondPass "$1"
fi
extractAudio "$1"
encodeAAC "$1"
mux "$1"
if [ $poster == "TRUE" ]; then
createThumbnail "$1"
fi
if [ $deltemp == "TRUE" ]; then
cleanTemporaryFiles "$1"
fi
}
firstPass() {
local iFile="${1##*/}"	# remove directory and keep only file name.
# First, lets get some basical information about this file, as FPS.
MOVIE_FPS=`midentify "$1" | grep FPS | cut -d = -f 2`
# Lets print some info to stdout.
showMessage "Encoding: $1"
showMessage "Resizing to: $rsizemsg."
showMessage "Total Bitrate: $bitrate kbps."
let "caudiobitrate = $audiobitrate / 1000"
let "itemVideoBitrate = $bitrate - $caudiobitrate"
showMessage "Video Bitrate: $itemVideoBitrate kbps."
showMessage "Audio Bitrate: $caudiobitrate kbps."
showMessage "Platform: $platform."
# Lets start the encoding for the first pass.
showMessage "Starting video encoding pass 1..."
mencoder "$1" -o "$outdir/${iFile%%.*}_temp.264" -passlogfile "$outdir/${iFile%%.*}"_temp.log $rsize -ovc x264 -x264encopts bitrate=$itemVideoBitrate:frameref=8:bframes=3:b_adapt:b_pyramid:weight_b:partitions=all:8x8dct:me=umh:subq=6:trellis=2:brdo:threads=auto:pass=1:analyse=all -of rawvideo -nosound

}

secondPass() {
local iFile="${1##*/}"	# remove directory and keep only file name.
showMessage "Starting video encoding pass 2..."
mencoder "$1" -o "$outdir/${iFile%%.*}_temp.264" -passlogfile "$outdir/${iFile%%.*}"_temp.log $rsize -ovc x264 -x264encopts bitrate=$itemVideoBitrate:frameref=8:bframes=3:b_adapt:b_pyramid:weight_b:partitions=all:8x8dct:me=umh:subq=6:trellis=2:brdo:threads=auto:pass=2:analyse=all -of rawvideo -nosound
}

extractAudio() {
local iFile="${1##*/}"	# remove directory and keep only file name.
showMessage "Extracting Audio..."
mplayer "$1" -af resample=48000:0:2,channels=2,volnorm=1:0.25,format=s16le -ao pcm:file="$outdir/${iFile%.*}_temp.wav" -vc dummy -vo null
}

encodeAAC() {
local iFile="${1##*/}"	# remove directory and keep only file name.
if [ "$platform" == "Mac" ]; then
enhAacPlusEnc "$outdir/${iFile%.*}_temp.wav" "$outdir/${iFile%.*}_temp.aac" $audiobitrate s
else
neroAacEnc -br 48000 -he -if $outdir/${iFile%.*}_temp.wav -of $outdir/${iFile%.*}_temp.mp4
fi
}

mux() {
local iFile="${1##*/}"	# remove directory and keep only file name.
MP4Box -add "$outdir/${iFile%.*}_temp.264#video:fps=$MOVIE_FPS" "$outdir/${iFile%.*}.m4v"
if [ "$platform" == "Mac" ]; then
MP4Box -add "$outdir/${iFile%.*}_temp.aac" -sbr "$outdir/${iFile%.*}.m4v"
else
MP4Box -add "$outdir/${iFile%.*}_temp.mp4#audio" "$outdir/${iFile%.*}.m4v"
fi
name=$outdir/${iFile%.*}
album="The Mac Video Archive"
author="Apple Computer // massanti.com"
comment="Professionally encoded by Diego Massanti"
created="2007"
MP4Box -inter 500 -itags album="$album":artist="$author":comment="$comment":created="$created":name="$name" -lang English "$outdir/${iFile%.*}".m4v
}

createThumbnail() {
local iFile="${1##*/}"	# remove directory and keep only file name.
mplayer "$1" -ss 10 -nosound $rsize -ssf lgb=1.0 -sws 7 -vo jpeg:outdir=$outdir -frames 1
mv "$outdir/00000001.jpg" "$outdir/${iFile%.*}.jpg"
mplayer "$1" -ss 10 -nosound -vf scale=150:-3 -ssf lgb=1.0 -sws 7 -vo jpeg:outdir=$outdir -frames 1
mv "$outdir/00000001.jpg" "$outdir/${iFile%.*}_small.jpg"
}

cleanTemporaryFiles() {
local iFile="${1##*/}"	# remove directory and keep only file name.
showMessage "Removing temporary files..."
rm "$outdir/${iFile%.*}"_temp*
}

initialize

You can also download the script by clicking here in order to keep proper code formatting. Installation is really simple, just move it to /usr/local/bin, give it execution rights (chmod +x /usr/local/bin/mkmp4) and done.

This script is really easy to use and implement, basically the script expects the following MANDATORY parameters in the command line:

• -f to specify the source media (can be a single file or a whole directory with media files)
• -b to specify the target bitrate for the final h264 encoded movie
• -w to specify the target width for the final h264 encoded movie

So for example, typing:

mkmp4 -f /path/to/some/video.avi -b 512 -w 640

will create a MP4 video file with a bitrate of 512kbps and a frame width of 640 pixels (please note that mencoder will correctly take care of the aspect ratio for the final movie and the resize will just look OK.)

Optional parameters for the MKMP4 script:

• -q turns on 2 pass encoding: This will increase the final quality (and the encoding time), but it worths the extra wait if you care about quality.
• -k to keep temporary files: The script will create several temporary files during the encoding process, if for whatever reason you want to keep that files, you should use this option.
• -o to specify a target directory: By default, the mkmp4 script will place the output video in the working directory (the directory from where you called the script), if you want to change that behavior, just use this option.
• -t to turn ON thumbnail and poster frame generation: If you use this flag, mkmp4 will create a thumbnail and a poster frame that you can then use if you plan to publish your videos on the web.

The following command line will create a 512kbps video, will set the target width to 640 pixels AND will use 2 pass encoding, will not delete temporary files, will create thumbnails and poster frames, and will place the files on the /target/directory/ directory.

mkmp4 -f /path/to/some/video.avi -b 512 -w 640 -k -q -t -o /target/directory/

Some things you need to know and FAQ’s about this script:

• By default, when the -f parameter is a directory, the script will search for any .mov file inside it, encode it, and place the final mp4 file into the directory set in the -o parameter (or the current directory if you have ommited that parameter), if you want to change that behavior, just change the value of the fileext variable inside the script to whatever file extension you want to process.
• Why are you reducing the audio level by 5db ? This is because with some old audio formats, for some reason that I really ignore, mplayer will distort the audio output. Now, if you take a closer look, you will see that right after the volume filter, im applying a normalization filter to get the audio back to 0db, so the output audio level will always be correct no matter what happens.
• Why are you forcing the audio output to be always stereo ? what if i want to encode mono material ?: Just modify the audio encoder trigger.
• The output media produced by this script is automatically interleaved and is fully compatible (and has been tested) with Flash Media Server 3 and Wowza Media Server Pro.

There are a lot of things that could be improved around here, and so far i have not tested this in any platform other than Mac OS Leopard, but so far, this should work in any Linux / Unix variant too without too much work.

If you are interested to get an idea of how the video results will look, you can take a look a The Apple Video Archive here on this site.

As usual, comments / feedback and suggestions are welcome.

As you maybe know, i have posted some months ago a really basic script to automate some of the tasks, but, what about integration with your actual website framework ? what about queue management, what about multi-server encoding environment ?

Those are all the usual questions when a potential customer calls, so i spent some days developing a complete black-box solution for this issue, using all open-source software, with the following features.

• Fully automatic video encoding queue management.
• Support for 1 to n encoding nodes with fully automatic transaction control (still in beta-testing).
• Support for the following video formats: Windows Media, Quicktime, DV, Avid DV, DivX, xVid and almost any imaginable format (any format supported by mplayer is actually 100% supported)
• Support for HE-AAC audio (Stereo near-CD quality sound at 48kbps).
• Fully automatic thumbnail generation in 3 different positions of the video stream, supported output formats are JPG, PNG and GIF.
• Fully automatic metadata injection, including all the popular “iTunes like” tags.
• Fully automatic iPod Touch / iPhone compatible stream generation.
• Support for more than 1 output format (managed from a presets file).
• Fully automatic Pixel and Display aspect ratio correction for proper video resizing and scaling.
• Possibility to select how many CPU cores to use for the encoding process (only on multicore cpu’s)

There are a several more features that I’m still developing. If you are interested and you want more details, you can contact me at: diego (at sign here) massanti.com. I don’t bite

You should consider this piece of software my “hello world” project in the Mac development arena, because, even the fact that i have pretty good skills when it comes to OO development, I’m totally new when it comes to the Mac, and I’m using this project mainly as a learning experience.

Attention: download links were moved

In order to keep things organized, the download links and general information for MediaInfo Mac were moved into this new website.

In the past few days i have been working in a full Aqua version of a linux tool called “Mediainfo”, so this is the result.
Let me introduce you to “MediaInfo Mac”.

MediaInfo Mac does just one thing: it gives you a lot of information about multimedia files, even files that QuickTime can’t read, and it does that by using a custom Universal Binary build of the linux library “libmediainfo” by Jerome Martinez as its core.
This application is obviously OpenSource and i will make all the sources available as soon as i finish cleaning the code and configuring an SVN repository on this server.
MediaInfo Mac requires any PowerPC or Intel Macintosh computer running MacOS X 10.4 “Tiger” or newer.
If you have any question or suggestion, feel free to leave your comment below .

A BIG thank you goes to Rainer Brockerhoff, (who is a true monster in the Macintosh development area), for having the patience to answer a lot of my questions, and also, to the guys at #macdev on freenode for helping me to understand a lot of things in the “Cocoa Arena”. Thank you, i really appreciate your time.

In order to keep things in organized, anything in relation with MediaInfo Mac is going to be on this new website.

IF you are any kind of software tracker, there is a feed with MediaInfo updates, and it is compatible with the AppCast definition.

Update Notice

This post has been updated with a newer and improved script and instructions, please visit the new one HERE.

It was some months ago when I wrote a tutorial about how to encode good quality h.264 video with aacPlus audio in order to use the great capabilities of the new flash player version 9.0.115 (that in case you missed it, now can play h264 video and aacPlus v2 audio).
Due to some personal convictions for my prior tutorial, i decided to use FFMPEG, and while it does the job pretty well, it has some limitations (specially in the video scaling / resizing area). So in my particular case, I had to use several php / bash scripts in order to feed the encoders with the proper resizing data, etcetera.
Well, let me introduce you to the 2nd version of my h.264 / aacPlus v2 tutorial.

This time I used Mencoder, an amazing tool that comes with the mPlayer package, and i also created what i think is a really nice bash script to make the process almost 100% smooth and simple.

These are the things you will need:

• the mPlayer package for whatever platform you’re running
• the Nero enhanced AAC audio encoder if you are on linux / unix or my build of the 3GPP HE-AAC encoder if you are on a Mac.
• the GPAC utilities
• the x264 video encoder

So let’s start. As usual, I wont dig a lot in the details about how to install or build software on linux / unix / mac, because you can find several tutorials about those matters by using google.

Building and installing the x264 encoder

In order to compile and install the x264 encoder, i recommend you to get the latest SVN version and build it yourself.
There are not any specific parameters at all for x264 other than the install path because the bash script that i will show you later assumes that you have all the tools in a directory that is inside your executable path.
So… get the latest sources for x264:
svn co svn://svn.videolan.org/x264/trunk x264
and then just run:
./configure --prefix=/usr
make
make install

After you have the x264 encoder installed, its time to get and build mPlayer.

Installing mPlayer and Mencoder

Again, get the latest sources for mPlayer:
svn checkout svn://svn.mplayerhq.hu/mplayer/trunk mplayer
and this is the configuration that you **should** use:
./configure --prefix=/usr

If you are on MacOS and you get errors when building, do this:
./configure --prefix=/usr --disable-encoder=flac --disable-encoder=cavs --disable-decoder=cavs
and then the usual…
make
make install

Very Important:

After you compile and install all the tools, you will find a directory called “TOOLS” inside the mplayer source tree, go inside it, and look for an small script called “midentify”, you MUST COPY this script to your /usr/bin directory or any other dir inside your executable path for the bash script to work. This is mandatory.

 The bash magic…

Ok, so after you have all the tools built, **AND** in your path, let me show you this simple script that i have written in order to make things really simple.

#! /bin/bash   

# This bash script has been created by Diego Massanti
# You are free and welcome to do whatever you want with it.
# www.massanti.com

usage()
{
cat < < EOF
usage: $0 -f  [-w ] -b  [-q][-k]

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* h264 video with he-aac audio encoding script by Diego Massanti. *
*                January 2008, Made in Argentina.                 *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

OPTIONS:
   	-h	Show this message
 -f	Path to the file to encode < REQUIRED
   	-w	Resize video to fit inside this width while keeping the aspect ratio < OPTIONAL
   	-b	Desired video bitrate < REQUIRED
   	-q 	Better quality encoding using 2 passes (slower) < OPTIONAL
 -k	Do not delete (keep) temporary files < OPTIONAL
EOF
}
audiobitrate=48000
platform=""
uname=`uname`
if [ $uname == "Darwin" ]; then
 ## 99% of chances that this is a Mac
 platform="Mac"
else
 platform="Linux"
fi

width=""
bitrate=
deltemp=TRUE
quality=FALSE
filename=
rsize=""

while getopts ":f:w:b:qkv" OPTION; do
  case $OPTION in
    w ) width=$OPTARG;;
 f ) filename=$OPTARG;;
    b ) bitrate=$OPTARG;;
    k ) deltemp=FALSE;;
 q )	quality=TRUE;;
    h ) usage;;
    \? ) usage
         exit 1;;
    * ) echo $usage
          exit 1;;
  esac
done

if [ "$1" == "" ]; then
 usage
 exit 0
fi

if [ "$filename" == "" ]; then
 echo
 echo you MUST supply a file to encode!, use the -f parameter. i.e: -f mymovie.avi
 echo
 usage
 exit 1
fi
if [ "$bitrate" == "" ]; then
 echo
 echo you MUST specify a target bitrate!, use the -b parameter. i.e: -b 512
 echo
 usage
 exit 1
fi

if [ "$width" != "" ]; then
 rsize="-vf scale=$width:-3"
 rsizemsg="fit into $width pixels wide"
else
 rsize=""
 rsizemsg="Movie is not being resized."
fi

MOVIE_FPS=`midentify "$filename" | grep FPS | cut -d = -f 2`
#clear
echo "*    Encoding: $filename"
echo "*    Resizing to: $rsizemsg."
echo "*    Total Bitrate: $bitrate kbps."
let "caudiobitrate = $audiobitrate / 1000"
let "bitrate = $bitrate - $caudiobitrate"
echo "*    Video Bitrate: $bitrate kbps."
echo "*    Audio Bitrate: $caudiobitrate kbps."
echo "*    Platform: $platform."

# Encoding phase starts here...
# Encoding Video...
echo "* * * Starting video encoding pass 1... * * *"
mencoder "$filename" -o "${filename%.*}_temp.264" -passlogfile "${filename%.*}"_temp.log $rsize -ovc x264 -x264encopts bitrate=$bitrate:frameref=8:bframes=3:b_adapt:b_pyramid:weight_b:partitions=all:8x8dct:me=umh:subq=6:trellis=2:brdo:threads=auto:pass=1:analyse=all -of rawvideo -nosound

if [ "$quality" == "TRUE" ]; then
echo "* * * Starting video encoding pass 2... * * *"
mencoder "$filename" -o "${filename%.*}_temp.264" -passlogfile "${filename%.*}"_temp.log $rsize -ovc x264 -x264encopts bitrate=$bitrate:frameref=8:bframes=3:b_adapt:b_pyramid:weight_b:partitions=all:8x8dct:me=umh:subq=6:trellis=2:brdo:threads=auto:pass=2:analyse=all -of rawvideo -nosound
fi

# Extracting audio to a 48khz WAV file.
echo "* * * Extracting Audio... * * *"
mplayer "$filename" -af resample=48000:0:2,volnorm=2:0.25 -ao pcm:file="${filename%.*}_temp.wav" -vc dummy -vo null

# Encoding Audio to HE-AAC plus file
echo "* * * Encoding Audio... * * *"

if [ "$platform" == "Mac" ]; then
enhAacPlusEnc "${filename%.*}_temp.wav" "${filename%.*}_temp.aac" $audiobitrate s
else
neroAacEnc -br 48000 -he -if ${filename%.*}_temp.wav -of ${filename%.*}_temp.mp4
fi

# Muxing
echo "* * * Generating final MP4 container... * * *"

MP4Box -add "${filename%.*}_temp.264#video:fps=$MOVIE_FPS" "${filename%.*}.m4v"
if [ "$platform" == "Mac" ]; then
MP4Box -add "${filename%.*}_temp.aac" "${filename%.*}.m4v"
else
MP4Box -add "${filename%.*}_temp.mp4#audio" "${filename%.*}.m4v"
fi

# MetaData and interleaving
name=${filename%.*}
album="Some Album"
author="Some Author"
comment="Some Comment"
created="2007"
MP4Box -inter 500 -itags album="$album":artist="$author":comment="$comment":created="$created":name="$name" -lang English "${filename%.*}".m4v

# Clean up temporary files...
if [ $deltemp == "TRUE" ]; then
 echo "* * * Removing temporary files... * * *"
 rm "${filename%.*}"_temp*
fi

You can also download the mkmp4 shell script in order to keep proper tabulations and code formatting.

You should save the code here into a simple text file, give it any name you want (i call mine “mkmp4″) and dont forget to chmod +x it.
Usage is really simple:
The scripts expects 2 main parameters that are mandatory:

• -f
• -b

So for example, typing ./mkmp4 -f myvideo.avi -b 512 will create a H.264 video file, with aacPlus v2 audio inside an MP4 container with a total bitrate of 512kbps and using myvideo.avi as source.
The resulting file is ready for HTTP Streaming or FlashMedia Streaming Server 3, and of course, it will also play in any video player out there capable of H.264 and aacPlus v2 decoding.
The script also accepts some other optional parameters.

• -q to use 2 pass encoding, slower, but better quality specially at low bitrates
• -w to resize the output video, for example “-w 480″ will resize the video to 480 pixels wide while keeping the correct aspect ratio.
• -k to keep temporary files
• -h to show inline help

The script will detect if you are running it on a Mac or on any kind of linux / unix variant, and use the proper audio encoder for each platform.
Also, in lines 133 to 136 in the script code, you will find some meta information variables that you can customize. That information is used by players like QuickTime, iTunes and many others in order to correctly organize the file inside a user’s media library.

Final considerations

This script can use as source, any video format supported by mPlayer, wich in other words means that almost any kind of video file can be transcoded by using this method.
If you are wondering what kind of quality / bitrate relation you will get by using this method, you are free to watch this 512kbps video stream (feel free to press the fullscreen button on the player )
When i released the first version of this tutorial 3 months ago, somebody asked how to get better quality for screencasts, and i guess the answer to that question would be something like: Framerate is not important at all, anything over 10FPS is useless for a screencast, by lowering the video framerate you get more quality at the same bandwidth, also, if you are doing a screencast, most probably you want your viewers to be able to “read” at texts, etc, so, a resolution of at least 640×480 is a must, and for bitrate, i think 512kbps with a two pass encoding process will be more than enough.

If you have any comment or suggestion you can leave a coment below. Thanks for reading !

Important

This tutorial has been updated (and improved) a lot, for the new version please follow this link.

UPDATE: I realized that when i read a tutorial about anything, in most cases, i want to first see what result im going to get so then i can decide if the tutorial is worth reading (or not), so here is a head by head comparison: 

This is an h264 file encoded by the guys at apple.com, it’s the TV Commercial for the brand new iMac: ORIGINAL VIDEO

This is the same file re-encoded using the steps on this tutorial: RE-ENCODED VIDEO

Obviouisly, there is an small quality degradation, but keep in mind that apple’s original movie is 14MB in size, while mine is 1.5MB .
You can play my MP4 video with almost any video player out there, but remember that not all video players out there support HE-AAC audio (or aacPlus) and b-frames, so if you play the file with a player like QuickTime, it is NOT going to work.
I recommend mPlayer or VLC media player to play this kind of video, and obviously, Flash Player will play the file perfectly too.

Update for Macintosh users:

I updated the bash script on this post so it can be used also by Macintosh users, so instead of using the NERO Digital AAC Encoder, Macintosh users can take advantage of the native 3GPP AAC Plus V2 encoder that i just compiled. Visit this post for more information about it.

Like a lot of people out there, i was really happy when i found the press release from Adobe, stating the addition of h.264 video support and HE-AAC Plus audio to their upcoming Flash Player versions, and also, to the upcoming Flash Media Server.
After following several “Tutorials” all over the web, i found that there was not any single one that gave me the results that i wanted; that is, good video quality, with the less possible file size, so after a lot of trial and error and after a lot of help and optimizations by the guys at the ffmpeg and x264 IRC channels, i decided to create this tutorial that will most probably help you a lot to encode good quality h264 video, with HE-AAC Plus Audio, and all this inside an MP4 container with tags and all ready to deliver to your visitors.

There are several things that you will need in order to do this:

• The latest SVN version of the x264 video codec.
• The latest SVN version of the excellent ffmpeg video encoding utility.
• The latest version of the GPAC utilies (it contains several tools to mux and work with MP4 files).
• The linux version of the Nero Digital AAC Audio Encoder
• GCC 4.1 or later installed, this is a requeriment for x264 to encode faster. It WILL work if you compile with older versions of GCC, but you will have performance issues resulting in more time needed to compress the video streams.

Some friendly bookmarks:
SVN checkout for x264:
svn checkout svn://svn.videolan.org/vlc/trunk vlc-trunk
SVN checkout for ffmpeg:
svn checkout svn://svn.mplayerhq.hu/ffmpeg/trunk ffmpeg

First of all, I’m assuming that you are running Linux, Mac-OS X or any other UNIX variant. I never tried this on windows because I am pretty sure that there are lot of really nice programs that you could buy to do the job.

Step 1: Configuring, compiling and installing all the stuff.

I am assuming that you have some basic skills with Linux / Unix / Mac OS, so i won’t really digg into the details of how to compile from sources all the tools. In most cases just taking a look at the readme file for each piece of software will tell you all you need to know, so i will just explain here some basical tips that you need to know.
After configuring, building and installing the x264 codec, this is the configure line that i used for ffmpeg in my paticular case:

./configure --enable-libx264 --enable-libfaac --enable-gpl --prefix=/usr --enable-libfaad --enable-swscaler --enable-pp

All the settings there are self-explanatory, the only thing you could need to change is the prefix to something like –prefix=/home/yourusername/ if you prefer to install the software just for your own user account.
After you have ffmpeg installed and running, we need to install two more things, the GPAC utilities and the Nero Digital AAC Audio Encoder.
Go grab the latest sources for GPAC, do the usual:

./configure && make && make install

After that you are ready to go, then go and download the latest version of the Nero encoder, and you will notice a directory called “linux” inside it, you should copy all the files there to any location in your path, usually /usr/bin (if you are installing everything as root) or /home/yourusername/bin (if you are installing just for your user account).

Step 2: Checking that everything is working as supposed.

To check that everything is ok, you should type:

ffmpeg -formats

and you will get a LONG list of supported encoders and decoders, if you have the following line, you are ready to go:

EV libx264

Step 3: Doing the video encoding (or transcoding).

So everthing looks great so far, except for one little detail, there is actually no support for any HE-AAC encoder directly from inside ffmpeg, so we will do the encode in 2 phrases, first the video, and then the audio.

From now on, i will assume that we have a video called “movie.avi” that we want to convert to a Flash Ready h264 file, so lets start encoding the video.
I am a person who likes quality, so for this example I am going to use a 2 pass encoding process.

This is the command line to perform the first pass of the video encoding:

ffmpeg -y -i movie.avi -an -pass 1 -vcodec libx264 -b 384k -flags +loop -cmp +chroma -partitions +parti4x4+partp8x8+partb8x8 -flags2 +mixed_refs -me umh -subq 5 -trellis 1 -refs 3 -bf 3 -b_strategy 1 -coder 1 -me_range 16 -g 250 -keyint_min 25 -sc_threshold 40 -i_qfactor 0.71 -bt 384k -rc_eq 'blurCplx^(1-qComp)' -qcomp 0.8 -qmin 10 -qmax 51 -qdiff 4 movie_temp.mp4

Depending on how long is your video source and how powerful is your computer, after some minutes it should finish, so it is time to make the second pass of the video encoding:

ffmpeg -y -i movie.avi -an -pass 2 -vcodec libx264 -b 384k -flags +loop -cmp +chroma -partitions +parti4x4+partp8x8+partb8x8 -flags2 +mixed_refs -me umh -subq 5 -trellis 1 -refs 3 -bf 3 -b_strategy 1 -coder 1 -me_range 16 -g 250 -keyint_min 25 -sc_threshold 40 -i_qfactor 0.71 -bt 384k -rc_eq 'blurCplx^(1-qComp)' -qcomp 0.8 -qmin 10 -qmax 51 -qdiff 4 movie_temp.mp4

This pass is gonna take more time than the first one, because the first one just analyzes the video while the 2nd pass does the actual encoding.

IF everything went as supposed, after some time you should have a new file called “movie_temp.mp4″ and you will notice that it is just your movie, but without sound…. dont alarm! we are going to make the sound part right now.

Step 4: Doing the audio encoding.

This part is pretty simple, we will use ffmpeg to create a simple wav file because the nero encoder only accepts a wav file as input, so we will do:

ffmpeg -i movie.avi -ar 48000 -ac 2 movie_temp_audio.wav

After this finishes, you will have a wav file called “movie_temp_audio.wav” that should be playable in any audio player of your choice, it basically contains the audio of your movie, so let’s transform this to a shiny HE-AAC Plus audio file.

To convert the wav audio file into an HE-AAC Plus file, we will use the Nero Encoder (neroAacEnc) and we will tell it to use our recently created wav file as source and output it to a new audio only mp4 file called “movie_temp_audio.mp4″ like this:

neroAacEnc -br 48000 -he -if movie_temp_audio.wav -of movie_temp_audio.mp4

So ok, we have at this point one MP4 file with just video, and another MP4 file with just audio, lets mux all this into our final flash ready MP4.

Step 5: Muxing everything into our final MP4 file ready for Flash broadcast.

At this point we are going to use a program called “MP4Box” that is part of the GPAC utilities that you have already installed if you followed my instructions.

First, we will command MP4Box to add ONLY the video track of our first video only MP4 into our final MP4:

MP4Box -add movie_temp.mp4#video final_movie.mp4

This will create a new MP4 file called “final_movie.mp4″, and it will add our video track inside it. Now we need to add the audio track into our final movie file, to do that we do as follows:

MP4Box -add movie_temp_audio.mp4#audio final_movie.mp4

After this step, if you open your “final_movie.mp4″ file with some video player like QuickTime, mPlayer or VLC, you should have a brand new h264 file with both video and audio, and with perfect sync between the two.
We need now to do some extra steps to optimize the file for progressive HTTP streaming so the flash player doesn’t needs to download the whole file before starting to play it, so lets interleave our file:

MP4Box -inter 500 final_movie.mp4

This line will interleave meta information to the file every 500 msec, that way, the flash player will be able to play the file as soon as it gets the first 500msec of video data.

After you are satisfied with your result, you can simply type:

rm movie_temp* -f

to get rid of all the temporal files that you created.

Obviously, this involves a LOT of steps in order to create the final file, and it is good to make them one by one so you get an idea of what are you doing…. after all, the idea is to learn…. isn’t it ?
But as you may suppose, the logical step after doing the “manual” way, is to create a bash script that is gonna do everything for us, so i give you below, an example of how this script could look:

#! /bin/bash
# ${foo%.*} to remove the extension
# FIRST PASS
echo "Starting Pass 1 ! ! !"

ffmpeg -y -i $1 -an -pass 1 -vcodec libx264 -b 384k -flags +loop -cmp +chroma -partitions +parti4x4+partp8x8+partb8x8 -flags2 +mixed_refs -me umh -subq 5 -trellis 1 -refs 3 -bf 3 -b_strategy 1 -coder 1 -me_range 16 -g 250 -keyint_min 25 -sc_threshold 40 -i_qfactor 0.71 -bt 384k -rc_eq 'blurCplx^(1-qComp)' -qcomp 0.8 -qmin 10 -qmax 51 -qdiff 4 ${1%.*}_temp.mp4

# SECOND PASS
echo "Starting pass 2 ! ! !"

ffmpeg -y -i $1 -an -pass 2 -vcodec libx264 -b 384k -flags +loop -cmp +chroma -partitions +parti4x4+partp8x8+partb8x8 -flags2 +mixed_refs -me umh -subq 5 -trellis 1 -refs 3 -bf 3 -b_strategy 1 -coder 1 -me_range 16 -g 250 -keyint_min 25 -sc_threshold 40 -i_qfactor 0.71 -bt 384k -rc_eq 'blurCplx^(1-qComp)' -qcomp 0.8 -qmin 10 -qmax 51 -qdiff 4 ${1%.*}_temp.mp4

# Exporting audio to a temporal 48k WAVE file
ffmpeg -y -i $1 -ar 48000 -ac 2 ${1%.*}_temp_audio.wav

# Encoding audio to HE-AAC V2 (aacPlus SBR + PS) -- UNCOMMENT THE FOLLOWING LINE on LINUX / UNIX with the NERO encoder
neroAacEnc -br 48000 -he -if ${1%.*}_temp_audio.wav -of ${1%.*}_temp_audio.mp4

# Encoding audio to HE-AAC V2 (aacPlus SBR + PS) -- UNCOMMENT THE FOLLOWING LINE on Mac OS X and remember to comment the LINUX one:
# enhAacPlusEnc ${1%.*}_temp_audio.wav ${1%.*}_temp_audio.aac 48000 s

#Creates final MP4 container and adds video track...
MP4Box -add "${1%.*}_temp.mp4#video" ${1%.*}_flash_ready.mp4

#Adds audio track...
# IMPORTANT: If running this script on LINUX, UNCOMMENT THIS line:
MP4Box -add "${1%.*}_temp_audio.mp4#audio" ${1%.*}_flash_ready.mp4

# IMPORTANT:if running this script on a MAC, UNCOMMENT THIS line and remember to comment the LINUX one:
#MP4Box -add "${1%.*}_temp_audio.aac" ${1%.*}_flash_ready.mp4 

#Sets MetaData...
MP4Box -lang English ${1%.*}_flash_ready.mp4

#Interleaving (For HTTP Streming... this should be removed if using FMS / RTMP )
MP4Box -inter 500 ${1%.*}_flash_ready.mp4

echo "Deleting Temporary Files..."
rm ${1%.*}_temp* *.log -f

echo "DONE!"
echo "Your file has been encoded as ${1%.*}_flash_ready.mp4"

You should make a file called, for example, mkmp4.sh and paste the script inside it, then chmod +x the file and move it to /usr/bin , after that, you should be able to run for example:

mkmp4 mymovie.avi

and the bash script will create a new file called mymovie_flash_ready.mp4 in the same directory, that assuming that you have all the needed tools in the path.

So happy encoding! if you have any questions or any problem, please post a comment here and i will try to help you as soon as i can. Please avoid to post questions about how to build / configure / compile software because i don’t really have the time to help you with that and there are a lot of tutorials for that on the web, and like i said, this tutorial assumes that you have the basic linux skills already inside your little brain.