You can get the binary build (3 way universal binary with PowerPC, i386 and x86_64 architectures) here:

enhAacPlusEnc for Mac OS X Leopard, Binary build with 3 architectures.

Xcode project (3.2 or newer) can be downloaded here:

enhAacPlusEnc Xcode project (3.2 or newer)

For more info visit the original post here.

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

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.