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.

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.

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 !