2.1.1 Introduction to Transcoding

One of the basic tasks you can perform on an audio track in FFmpeg is to convert it into another format. This process known as Transcoding, is the direct digital-to-digital conversion of one stream encoding to another, whether video or audio. Transcoding is usually done in cases where a target device – media player such as iPod, iPAD, DVD players or a software application, does not support the format or has limited storage capacity that requires a condensed file size. Transcoding can also be used to convert an incompatible or obsolete format to a better-supported format.

Transcoding is generally a “lossy process” – a data encoding method which compresses data by discarding (losing) some of it to minimize the amount of data that need to be stored in a file; however, transcoding can also be “lossless” if the input is losslessly compressed and the output is either losslessly compressed or stored in a uncompressed state. Although compression can reduce file size considerably, repeatedly performing transcoding on a single file using lossy compression can create a ‘generation loss’ – a reduction in the quality of the audio when copying, which would cause further reduction in quality on making a copy of the copy. So you need to keep this in mind while repeatedly transcoding between various formats.

Although I could not show you here the difference between an original and lossy audio compression (due to the limitation of the media of course), the following shows an example of a lossy compression in an image. The original JPG image is on the left and a lossy image of the same after repeated compression is shown on the right. As we lose precious information forever during compression, we cannot get back the original image using the compressed image.

2.1.2 Audio compression

Audio compression is a form of data compression designed to reduce the transmission bandwidth and storage requirement of a digital audio stream. Audio compression algorithms are implemented in software as audio codec’s, – which is a software program or library capable of encoding/decoding a digital audio stream.

Audio compression is either lossy or lossless as discussed earlier. Lossless audio compression produces a version of digital audio that can be decoded to an exact digital duplicate of the original audio stream. This is in contrast to the irreversible changes upon playback from lossy compression techniques such as Vorbis and MP3.

The whole idea behind audio compression in FFmpeg is to lower the audio bitrate (96kbps, 128kbps, 192 kbps etc.), this effectively also reduces the fidelity or quality of the audio. So you want to keep in mind that, a high bitrate audio file confirms a better sound quality, so by lowering its bitrate you are actually degrading the quality.
For normal computer use, the 128kbs rate produces a quality equal to that of an audio CD. But in the case of an MP3 use, it is necessary to use a 256kbs bitrate to reach an identical result to that of the CD quality sound.

2.1.3 Getting your audio file ready

Now that we have gone through a short introduction to compression, we will now work on the process of transcoding audio files.

To run the example commands in this section, you will need an audio file in a .wav or an .mp3 format. You can get hold of a wav file by ripping an audio track from a music CD or downloading an mp3 file from the Internet. Call the resulting file ‘myaudio.mp3’. For this section I used the ‘Solo Piano 7’ Opening file from http://www.archive.org/details/solo-piano-7.

Next, we will get ffmpeg to identify the file. This will tell us the various details of the audio file. The simple way to get this information is to just tell ffmpeg to use it for input. For this we need to use the –i option. Enter the following command at your prompt.

ffmpeg  -i  myaudio.mp3

The exact output on my PC is shown below; which may differ from yours depending on the version of ffmpeg you are using.

D:\ffmpeg>ffmpeg -i myaudio.mp3
ffmpeg version N-31100-g9251942, Copyright (c) 2000-2011 the FFmpeg developers
Input #0, mp3, from ‘myaudio.mp3′:
Metadata:
album : solo piano 7
artist : Torley
album_artist : Torley
composer : Torley
genre : Piano
track : 001/176
title : 001 – Openings
date : 2008
Duration: 00:01:39.50, start: 0.000000, bitrate: 193 kb/s
Stream #0.0: Audio: mp3, 44100 Hz, stereo, s16, 192 kb/s
At least one output file must be specified

There is a lot of information we can gather from the output – the track is
1 minute 39.50 seconds long, the bitrate is 193kb/s, the audio is encoded in mp3 format at 44100Hz (44.1KHz) and has two channels (stereo). All this information will come in handy during a transcoding process.

2.1.4 Transcoding to a different format

Let us now convert the downloaded file to a simple wav format. Notice that we have not specified any format option or flag, just the complete output filename. FFmpeg automatically guesses which encoders to use by noticing the format of the input and output files, this can be a big help if you keep forgetting the option name or are just being lazy. If you are not going to specify the encoder format, make sure you mention the full filename, along with the appropriate format extension.

ffmpeg  -i  myaudio.mp3  myaudio.wav

The output of the command is shown below.

ffmpeg version N-31100-g9251942, Copyright (c) 2000-2011 the FFmpeg developers
Input #0, mp3, from ‘myaudio.mp3′:
Metadata:
album : solo piano 7
artist : Torley
album_artist : Torley
composer : Torley
genre : Piano
track : 001/176
title : 001 – Openings
date : 2008
Duration: 00:01:39.50, start: 0.000000, bitrate: 193 kb/s
Stream #0.0: Audio: mp3, 44100 Hz, stereo, s16, 192 kb/s
File ‘myaudio.wav’ already exists. Overwrite ? [y/N] y
Output #0, wav, to ‘myaudio.wav’:
Metadata:
album : solo piano 7
artist : Torley
album_artist : Torley
composer : Torley
genre : Piano
track : 001/176
title : 001 – Openings
date : 2008
encoder : Lavf53.4.0
Stream #0.0: Audio: pcm_s16le, 44100 Hz, stereo, s16, 1411 kb/s
Stream mapping:
Stream #0.0 -> #0.0
Press [q] to stop, [?] for help
size= 17141kB time=00:01:39.50 bitrate=1411.2kbits/s
video:0kB audio:17141kB global headers:0kB muxing overhead 0.000251%

Notice how large the resulting wav file is (17 Mb) as compared to the original mp3 format (2.1 Mb). This being for the reason that the wav file is not compressed like its mp3 counterpart. Incidentally, the audio format of the wav is Pulse-code modulation (PCM), technically PCM signed 16 bit little-endian format.

As you can see from the screenshot above the output of an ffmpeg command is quite large, so from here on I’ll just specify the command and do away with the output screen unless it is required for explanation.

2.1.5 Changing the bitrate of the audio

As we learned in Chapter 1, bitrates control the file size and the quality of an audio or video stream. Lowering the bitrate will result not only in a reduced file size but also diminish the quality of the final output. This can be required if you have a high quality audio recording and need to lower the quality for a reduced file size to stream over the Web. For example the following command will set the bitrate of the mp3 file to 64kb/s. This uses the –ab option to the job.

-ab

ffmpeg  -i  myaudio.mp3  -ab 64k  out.mp3

The higher the value the better is the audio quality. This is one of the important factors responsible for the audio quality. But that doesn’t mean you can make a poor audio file sound better by increasing its bitrate. The resultant file will just be of bigger size.

Another example – to transcode an mp3 file to an AAC format, with a bitrate of 128K, we can use the following.

ffmpeg  -i  myaudio.mp3  -ab 128k  myaudio.aac

As we saw earlier the original audio track has 2 channels (stereo). Many times it is not necessary to have 2 channels, like in a speech recording, where its really doesn’t matter.. In such cases you can further reduce the file size by setting the audio channels to mono or ‘1’. For output streams it is set by default to the number of input audio channels.

-ac

ffmpeg  -i  myaudio.mp3  -ac 1 out.mp3

Note that once you convert a stereo channel to a mono, you cannot convert it back to a stereo channel audio. That information is lost forever. The same thing happens with bitrates. Once you reduce a bitrate of an audio file, you cannot just increase the bitrate back again to get the original quality. That information is already gone. So as a precaution, never work with your original media files. Make a copy of the original and work with the copy.

The other important audio option is –acodec. This option lets you choose the type of audio codec you want to use. e.g. if you are using ffmpeg on a mp3 file, then it will need the audio codec libmp3lame. You can specify it using -acodec libmp3lame. Although, by default, ffmpeg takes care of the codecs you need (by guessing it from the output file format) but if you need anything different, then go for this option. FFmpeg uses a default encoder for each audio stream, using the output file extension to guess the encoder to use. This option lets you force FFmpeg to use a specific audio encoder rather than the default. The following for example will extract the audio stream from a .flv video and save it as an .mp3 file using the libmp3lame encoder.

-acodec

ffmpeg  -i  myvideo.flv   -acodec  libmp3lame  myaudio.mp3

Sometime you FFmpeg may be unable to correctly decode the input file, giving the error something like the following.

Error while decoding stream #0.0

In such cases you can force FFmpeg to use a particular decoder to decode the input file. The following example will force FFmpeg to use the mp3 codec toe decode the input file audio.

ffmpeg  -acodec  libmp3lame  -i  myvideo.flv    myaudio.mp3

Note that the –acodec option comes before the –i option when we want the codec to apply to the input stream and comes after the –i option when we want the codec to apply to the output stream. To see what codecs are available on your system, issue the following command.

ffmpeg  -codecs

Sometimes you may want to completely disable the audio recording for which we can use the –an option. This can be used to strip out an audio stream from a video file. When you use this option, all the other audio related attributes are cancelled out, which is fine, as they would not matter without the audio. So for example you are want to disable the audio from a video file and only copy the video stream, you can use the following.

ffmpeg  -i  myvideo.flv  -an out.flv

Another important option is –ar, the audio sampling frequency. This lets you set the maximum sampling frequency of the audio stream. Audio sampling was discussed in Chapter 1. You can use the option to reduce the sampling frequency to a lower value to reduce file storage or Internet bandwidth capacity. The default value is set at 44100Hz. The value is given in Hz. So the following will resample the input audio to 11025Hz with a single channel (mono).

-ar

ffmpeg  -i  myaudio.mp3  -ar 11025  -ac 1 myaudio.mp3

Note that once you have reduced the sampling frequency some of the audio data is lost. You cannot again resample it to a higher value and expect increase in the audio quality.

2.1.6 Audio grabbing

Until now we have looked into how to transform existing audio stream into other formats. FFmpeg can also grab audio from external devices such as a microphone. This can be useful if you need to record from your desktop microphone or create a screencast. Note that the following command will not work on a Windows machine. You need to have a Linux machine to correctly grab the mic audio. Enter the following command at your Linux prompt.

ffmpeg  -f oss  -i  /dev/dsp  ./audio.wav

This will start recording the input audio from the mic to the ‘audio.wav’ file. Once started you will need to press ‘q’ to stop the recording. We will now look into the various options given above.
The option –f denotes the format to be used for the input stream. There are various formats FFmpeg supports; you can find the complete list by issuing the following command.

ffmpeg  -formats

Here we are using the ‘oss’ format, which stands for Open Sound System input device. The Open Sound System (OSS) is an interface for making and capturing sound in Unix or Unix-like operating systems. In the Linux kernel, there have historically been two uniform sound APIs. One is OSS; the other is ALSA (Advanced Linux Sound Architecture). ALSA is available for Linux only.

The device ‘/dev/dsp’ is the default audio input device in the Linux system. It’s connected to the main speakers and the primary recording source such as a microphone. The system administrator can set /dev/dsp to be a symbolic link to the desired default device.

The ‘audio.wav’ file is where the recorded audio will be saved.
Another example – the following will record the mic audio to the file ‘rec.flac’ in the current directory, this is a flac format file.

ffmpeg  -f alsa  -ar 48000  -i front  ./rec.flac

2.2 Some popular audio formats

.AAC Advanced Audio Coding File – declared the new audio-file standard in 1997, designed to replace its predecessor, MP3. It provides better quality at lower bit rates, and its Apple’s standard iTunes and iPod audio format.

.AIF(F) Audio Interchange File Format – developed by Electronic Arts and Apple back in the ’80s. AIFF files contain uncompressed audio, resulting in large file sizes.

.m4a Apple Lossless – This file format uses lossless compressions for digital music.

.MP3 MPEG Layer 3 – the most popular digital-audio music format, designed by a team of European engineers in 1991 to conserve the quality of a song while storing it in a small, compact file.

.OGG Ogg Vorbis – one of the most popular license-free, open-source audio-compression formats. It’s efficient for streaming and compression because it creates smaller files than MP3 while maintaining audio quality.

.RA(M) Real Audio Media – developed by RealNetworks in 1995. It has a wide variety of uses, from videos to music, but is mainly used for streaming audio such as that from Internet radio stations.

.WAV Windows WAVE – IBM and Microsoft-developed format popular audio format among PC computer users; it can hold both compressed and uncompressed audio.

.WMA Windows Media Audio - designed by Microsoft to be an MP3 competitor, but with the introduction of iTunes and iPods, it’s fallen far behind MP3 in popularity.

2.3 Audio processing recipes

MP3 to AAC High Quality Stereo

ffmpeg -i in.mp3  -acodec aac -ac 2 -ar 48000 -ab 192k out.aac

MP3 to AAC High Quality 5.1

ffmpeg -i in.mp3  -acodec aac -ac 6 -ar 48000 -ab 448k out.aac

Convert to low quality mp3 to preserve storage

ffmpeg  -i in.mp3 -ab 64K out.mp3

MP3 to Vorbis OGG (can be played in HTML 5)

ffmpeg  -i in.mp3 -acodec vorbis -aq 50 out.ogg

In the next post in the series we will look into various video processing tasks.

Subscribe now to get the next post update.

1.1.1 What is FFmpeg?

FFmpeg is a command-line tool for *nix and Windows systems that, in its simplest form, provide a facility to decode and an encode media files. With the proliferation of video on the Internet and in our daily lives, users need the ability to transcode (convert) audio and video files from one format to another. For example, a user might have downloaded a video from YouTube and need to convent it to a format playable on an iPod or other media device.

Besides this obvious use, FFmpeg is also capable of a few other fundamental manipulations on the audio and video data. These manipulations include changing the sample rate of the audio and advancing or delaying it with respect to the video, reducing the size of the media file. They also include changing the frame rate of the resulting video, cropping it, resizing it, placing bars left and right and/or top and bottom in order to pad it when necessary, or changing the aspect ratio of the picture. Furthermore, ffmpeg allows importing audio and video from different sources such as a microphone.

The main components of FFmpeg are libavcodec, an audio/video codec library, libavformat, an audio/video container mux/demux library, and the ffmpeg command line program for passing various transcoding options to the main program.

The FFmpeg project was started by Fabrice Bellard, and has been maintained by Michael Niedermayer since 2004. The name of the project comes from the MPEG video standards group, together with “FF” for “fast forward”. On March 13, 2011 a group of FFmpeg developers decided to fork the project under the name Libav (http://libav.org/) due to some project management related issues.

FFmpeg is used by many open source and proprietary projects, including ffmpeg2theora, VLC, MPlayer, HandBrake, Blender, Google Chrome, and various others.

1.1.2 Components of FFmpeg

FFmpeg is made of the following main components.

Programs
ffmpeg – a command line tool to convert multimedia files between formats.
ffserver – a multimedia streaming server for live broadcasts.
ffplay – a simple media player based on SDL and the FFmpeg libraries.
ffprobe – a simple multimedia stream analyzer.

Libraries
libavutil – a library containing functions for simplifying programming, including random number generators, data structures, mathematics routines, core multimedia utilities, and much more.
libavcodec – a library containing decoders and encoders for audio/video codecs.
libavformat – a library containing demuxers and muxers for multimedia container formats.
libavdevice – a library containing input and output devices for grabbing from and rendering to many common multimedia input/output software frameworks, including Video4Linux, Video4Linux2, VfW, and ALSA.
libavfilter – a library containing media filters.
libswscale – a library performing highly optimized image scaling and color space/pixel format conversion operations.

In this posts we will primarily focus on the ffmpeg program, the other programs like ffserver are used for video broadcasts and is outside the scope of this posts. Among the libraries, the most notable parts of FFmpeg are libavcodec, an audio/video codec library, and libavformat, an audio/video container mux and demux library

1.1.3 Compression

To be honest, trying to shoehorn the complete details of audio and video in a paragraph or two is plainly ridiculous, as the topic is rather complex. But since this is a beginner’s guide, a few basic overviews will be enough to get you started using ffmpeg properly.

If you are working with audio and video, you are well aware that these files take an inordinate space for storage. You cannot easily work with these files if they were not compressed beforehand. Assuming an NTSC standard video format; a raw (uncompressed) video at 720×480 pixels, 30 frames per second and 24-bit RGB color, would take about 1,036,800 bytes (1 Mb) per frame. That’s almost 30MB per second, or over 200GB for a 2-hour movie. And that’s just the video. Audio stream also takes additional storage. Something needs to be done so that the movie can be stored on a consumer-grade medium such as a DVD. The data needs to be compressed beforehand.

Conventional, lossless compression algorithms such as ZIP, which everyone uses on a regular basis, don’t reduce the size of the data enough, so we need to look into lossy compression for further size reduction. Lossy compression works by discarding some data in the media which results in smaller file sizes. So now you might be thinking what data the compression algorithm discards. Well in general the algorithm does not discard any random data, which would be a disaster. The compression algorithm discards data only if it thinks that the data is redundant. For example in movie frames many times not much changes between successive frames; if the compression software discards some of these frames the viewer will hardly notice any difference, but the storage requirement of those frames have been saved.

Lossy compression is commonly used to compress multimedia data such as audio, video and still images. The only negative aspect of lossy compression is that as some data is removed during compression which can reduce the fidelity of the output.
The algorithms that allow us to encode and decode the data, whether by using lossy or lossless technique are called codecs. Several codecs are enclosed in the libavcodec library supplied with ffmpeg, which enables you to work with a wide variety of video and audio formats.

Once the audio and video streams have been encoded by their respective codecs, this encoded data needs to be put together into a single file. This file is called the ‘container’. A graphic of the process is shown below.

1.1.4 Bitrates

A movie is made-up of two main components, Audio and Video. Both “components” produce a separate stream of data that must be decoded by your DVD-player or some program so we can see and hear the video properly.

The bitrate of a movie is the key to the quality of the audio and video of that movie. Also, particular formats specify the bitrate or the maximum bitrate to be used. Bitrate is a measurement of the number of bits that are transmitted over a set length of time. Your overall bitrate is a combination of your video stream and audio stream in your file with the majority coming from your video stream. Bitrate denotes the average number of bits that one second of audio or video data will take up in your compressed bit stream. The overall bitrate of your movie is a combination of your video stream and audio stream in your file with the majority coming from your video stream.

A bit rate is usually measured in some multiple of bits per second – for example, kilobits, or thousands of bits per second (Kbps – for example, kilobits, or thousands of bits per second (Kbps).

Bitrates come in two versions – VBR (Variable Bit Rate encoding) or CBR (Constant Bit Rate encoding). VBR allows a higher bitrate (and therefore more storage space) to be allocated to the more complex segments of media files while less space is allocated to less complex segments. The average of these rates can be calculated to produce an average bitrate for the file. VBR allows you to set a maximum and minimum bitrate. The compression algorithm then tries to efficiently compress the data reducing to the minimum bitrate when there is little or no motion on screen and increasing to the maximum defined rate when the motion is prevalent. This helps to give you a smaller overall file size without compromising the quality of the video.

CBR is used when a predictable flat bit rate is needed. Although the flat bitrate throughout the entire file comes at the price of efficiency for the codec; usually resulting in a larger file, but smoother playback. CBR is useful for streaming multimedia content on limited capacity channels since it is the maximum bit rate that matters, not the average, so CBR would be used to take advantage of all of the capacity. CBR would not be the optimal choice for storage as it would not allocate enough data for complex sections (resulting in degraded quality) while wasting data on simple sections.

Depending on your video you might want to use a VBR for a streaming playback if the sudden spikes do not exceed your target user’s connection speed. For example if there is only one high motion scene in a video, you will be wasting considerable bandwidth on a CBR throughout the entire file and may better serve your user’s need by using a VBR. Either way try experimenting with the two settings to find what works best for your video.

Briefly, a bitrate specifies how many kilobits the file may use per second of audio. The following shows the quality for various standard audio bitrates.

1.1.5 Audio Sampling Frequency

The audio sampling frequency is the number of times per second audio is sampled and stored – CD audio is sampled at 44.1 KHz, which means when the sound is converted from analog to digital, 44100 samples per second are taken of the audio signal. The higher the sampling rate the audio has, the wider the frequency range it provides. In other words, higher is better quality. Your lows will be lower; your highs will be higher. For example the following image shows an analog signal on the left converted to a digital representation using two different sampling rates. As you can see the higher sampling will lead to an even more exact reproduction of the original signal.

The sample rate can be thought of as how often or how much the sound is described. CD quality audio has 44,100 of these measurements a second. That’s why it’s called 44.1 kilohertz (khz).

So what is the relationship between bitrate and sampling frequency? Bitrate simply specifies the number of bits per second that are used to encode the audio stream. The uncompressed bitrate for CD audio is 16 bits x 44100 samples x 2 channels = 1411200bps, or approximately 1411kbps. When audio is stored in an uncompressed format, the bitrate is a linear function of the sample rate; i.e. doubling the sample rate doubles the bitrate.

With uncompressed audio, there is a direct relationship between the sample rate and the bitrate. A 44.1kHz 16-bit stereo signal takes 1411.2 kbps, or approximately 10.4Mb per minute to record. A 44.1kHz 16-bit mono file would take half of this, as would a 44.1kHz 8-bit stereo file or a 22.05kHz 16-bit stereo file.

But now formats like Ogg Vorbis and MP3, compress audio by making calculated guesses about the sounds humans aren’t likely to hear and then discard these sound samples. As part of this process, such formats allow us to make some of the decisions by deciding how much to throw away, or to put it more simply, how much data to use to represent the original sound. So, using our 44.1kHz stereo sample, we can choose to use as little as 48kbps or as much as approx 500kbps to store this sound. At 500kbps, more of the original sound fidelity is preserved than at 48kbps.

Calculating values

An audio file’s bit rate can be easily calculated when given sufficient information.
Bit rate = (sampling rate) x (bit depth) x (number of channels)

e.g., a recording with a 44.1 kHz sampling rate, a 16 bit depth, and 2 channels:
44100 x 16 x 2 = 1411200 bits per second, or 1411.2 kbit/s

The file size of an audio recording can also be calculated using a similar formula:
File Size (Bytes) = (sampling rate) x (bit depth) x (total channels) x (seconds) / 8

e.g. a 70 minutes long CD quality recording will take up 740MB:
44100 x 16 x 2 x 4200 / 8 = 740880000 Bytes

Some standard sampling frequencies with their applications is given below.

1.1.6 Frame rate

The frame rate is how many unique consecutive images are displayed per second in the video to give the illusion of movement; each image thus is called a ‘frame’. The human brain perceives a smooth continuous motion if shown around 24 frames per second. If the frames are less than this magic number, you will see a jerky motion rather than a smooth one. Most video creators use this frame rate.

This is not a standard of course, if your video is a screen cast you can get to frame rates as low as 5fps. Television standards such as PAL (common in Europe and some parts of Asia) uses 25fps, while NTSC standard (used in the US and Japan) uses 29.97fps. Generally you should never exceed the frame rate of the source video. Obviously, the best results will be achieved if the frame rate is kept the same as your original source.

1.1.7 Containers

A container file is used to identify and combine different data types. Simpler container formats can contain different types of audio formats, while more advanced container formats can support multiple audio and video streams, subtitles and meta-data — along with the synchronization information needed to play back the various streams together. In most cases, the file header and most of the metadata are specified by the container format. For example, container formats exist for optimized, low-quality, internet video streaming which differs from high-quality DVD streaming requirements.

The video file formats we’re familiar with, such as Quicktime movies (.mov), .avi are media container formats. Some container formats just contain audio, like WAV file fro Windows, MP3 music files or AIFF files for Macs. Others contain audio and video, such as ASF files for Windows, which contain audio compressed with the WAV codec and video compressed with the WMV codec. There are dozens of these container formats. If you’re uploading a video to an online site, check to see what formats the site supports. Sometimes this can be confusing because the list of accepted formats may have both compression formats like MPEG-4 and container formats like .mov listed.

1.2 Installing FFmpeg

FFmpeg is developed under GNU/Linux, but it can be compiled under most operating systems, including Mac OS X, Microsoft Windows, AmigaOS. In most of the Linux distros, you can directly install ffmpeg using their respective package managers. But in case you are looking for installing the latest version or want to customize the installation, you might need direct installation from the source code too, but as it is an involved and tricky procedure, I’m not discussing it here.

Installing FFmpeg on Ubuntu
Run the following command in the terminal to install FFmpeg.

$ sudo apt-get install ffmpeg

Installing FFmpeg on Fedora
FFmpeg can be directly installed from the repos using the following command.

$ su -c 'yum install ffmpeg'

Installing FFmpeg on CentOS
FFmpeg can be directly installed from the repos using the following command.

$ yum install ffmpeg ffmpeg-devel

Installing FFmpeg on Windows
By far the easiest way to start using FFmpeg is to get a precompiled binary. Zeranoe.com has pre-built binaries for windows, which makes it easier to install ffmpeg. So if you are using Windows you can get up and running FFmpeg in no time. Go ahead and grab the binaries from the below link.
http://ffmpeg.zeranoe.com/builds/

Once installed use the following command to get the ffmpeg version and the versions of the codecs installed.

C:\ffmpeg>ffmpeg  -version

On my Windows machine it returns the following; of course this may be different on your system, depending on the version of FFmpeg installed:

ffmpeg version N-31100-g9251942, Copyright (c) 2000-2011 the FFmpeg developers
built on Jun 30 2011 21:17:59 with gcc 4.5.3
libavutil 51. 11. 0 / 51. 11. 0
libavcodec 53. 7. 0 / 53. 7. 0
libavformat 53. 4. 0 / 53. 4. 0
libavdevice 53. 2. 0 / 53. 2. 0
libavfilter 2. 24. 0 / 2. 24. 0
libswscale 2. 0. 0 / 2. 0. 0
libpostproc 51. 2. 0 / 51. 2. 0
ffmpeg N-31100-g9251942
libavutil 51. 11. 0 / 51. 11. 0
libavcodec 53. 7. 0 / 53. 7. 0
libavformat 53. 4. 0 / 53. 4. 0
libavdevice 53. 2. 0 / 53. 2. 0
libavfilter 2. 24. 0 / 2. 24. 0
libswscale 2. 0. 0 / 2. 0. 0
libpostproc 51. 2. 0 / 51. 2. 0

1.2.2 FFmpeg Command syntax

Adhering to the UNIX culture, FFmpeg relies on a plethora of command-line options to do its work. The generic syntax of an FFmpeg command is shown below.

ffmpeg [[infile options]['-i' infile]]...{[outfile options] outfile}...

Each section of the command is explained below.

ffmpeg – The first is the FFmpeg executable file name.

infile option – This is where you put options for your input video or audio file. This tells FFmpeg to apply any options give here to the input file before processing starts. This section is not as widely used as the ‘outfile options’.

-i infile – This is the actual video or audio file you use for processing, and also the directory of where it is located.
e.g /home/george/media/myvideo.flv. You will always need to include the `-i` option before your file name.

outfile options – This is where you will put the various options that are required which you want to be applied to the video or audio you will be creating.

outfile – The name of the output file you want to create, and also the directory path if it not the same as your input file directory.
e.g is /home/george/media/out.flv

Now that we have FFmpeg installed, in the next post we will learn about audio processing.

Subscribe now to get the next post update.

In part 1 of this tutorial you have seen how to write a simple web test using Selenium. In this part we will see how to use the test generated using the IDE with Selenium RC and PHPUnit.

In this part we will use Delicious as our test target. I’ve already created a small Selenium test that you can use. You can download the HTML source from here.

Starting up.
Restart the Selenium IDE. In the source tab replace the default HTML with the one from the above file. Set the Base URL to http://delicious.com/. After doing this your IDE should like below.

If you are on a slow internet connection than it may help to slow the test speed.

So what exactly does this test do? Simple:

1. First it opens the delicious home page
2. Then it searches by the keyword ‘selenium’
3. Reads the total number of bookmarks from the results page as shown below

Now this may not look like a test for you , but it is just an exercise in using Selenium, you will surely apply it to a good test case. Onwards…

Before running this test make sure that you are logged out of Delicious.
Now run the selenium IDE test. After the test is successfully completed this is what you should see in the log pane.

Is that all?
If this was all there was I wouldn’t be really writing this post. The interesting part comes now – running the same test from PHP. From the file menu select ‘Export Test Case As…’ and as we are using PHP, select ‘PHP – Selenium RC’. Save the file by the name ‘Example.php’.

This is what we will get in the ‘Example.php’ file.

<?php
 
require_once 'PHPUnit/Extensions/SeleniumTestCase.php';
 
class Example extends PHPUnit_Extensions_SeleniumTestCase
{
  function setUp()
  {
    $this->setBrowser("*chrome");
    $this->setBrowserUrl("http://delicious.com/");
  }
 
  function testMyTestCase()
  {
    $this->open("/");
    $this->type("homepage-searchinput", "selenium");
    $this->click("homepage-searchsubmit");
    $this->waitForPageToLoad("30000");
    $this->getText("xpath=/html/body[@id='index']/div
                         [@id='doc3']/div[@id='bd']/div
                         [@id='yui-main']/div[@id='content']/h3/div/em");
  }
}
?>

A short notice.
Before we proceed a few points to consider. Make sure that the file name and the class name are the same, here ‘Example’. Say if you change the class name to ‘Delicious’ make sure that you also change the file name to ‘Delicious.php’.

What the code basically does is it initializes the browser to ‘chrome’ (you can set the browser to your preference by changing to ‘*iexplore’ or ‘*firefox’); sets the baseurl to ‘http://delicious.com/’ and runs the test.

Whats the complex looking line!?
Everything may look fine to you except maybe the last line – ‘$this->getText…’. The function ‘getText’ returns the text found at the element specified in the expression. The complex looking line is an xpath expression to the results element:

You don’t have to rake your brains to find an xpath to an element. An easy way is to use the XPather Firefox addon to get the xpath of any element on a page. After you download and install the addon, restart Firefox, right-click on any element and from the context menu select ‘Show in XPather’. XPather retrieves the xpath to the specified element, which you can than use in your test code.

Note: This site uses ‘delicious’ as an example, so even some minor changes made by them to their site will render the xpath invalid, throwing an ‘element not found’ error in selenium. If this happens please notify me or you can find the new xpath using the Xpather plugin.

Downloading and installing Selenium RC
Selenium RC is a Java based command line server that starts browsers and runs commands you pass from your tests.

1. First make sure you have a Java runtime installed on your machine.
2. Download Selenium RC from here.
3. After extracting the files from the archive copy the ‘selenium-server.jar’ file to any directory you feel appropriate. I copied it to my PHP installations bin directory.
4. Start the Selenium RC server from the command-line by issuing the following command:

java -jar selenium-server.jar

This will start the server on port 4444.
5. Now the server is ready to accept test commands from your PHP script. Make sure you keep this server running till you finish testing.

Installing PHPUnit
1. An easy way to install PHPUnit is to use the PEAR installer. The PEAR channel (pear.phpunit.de) is used to distribute PHPUnit so make sure that it is registered with your local PEAR environment:

pear channel-discover pear.phpunit.de

After the channel is registered install PHPUnit:

pear install phpunit/PHPUnit

Actual testing
Now that PHPUnit is installed and the Selenium RC server is up and running, its time to run our test we saved before in our ‘Example.php’ file. Type the following on your command-line:

phpunit Example

This will start the test. The PHPUnit Selenium driver will execute each test command from your file and send it to the Selenium server, which does the job of launching the appropriate browser, opening web pages, and performing various specified actions; and closing the browser after the test completes.

Now the above test does basically nothing important. So we will add some simple conditional statements to the code.

.
.
    $bookmarks = $this->getText("xpath=/html/body[@id='index']/div
                       [@id='doc3']/div[@id='bd']/div
                       [@id='yui-main']/div[@id='content']/h3/div/em");
 
    echo ($bookmarks > 3000)? "On the top" : "Still not there";
  }
}
 
?>

This is what PHPUnit has to say about the above test.

Or we can use an assertion as below, deliberately rigged to fail the test:

.
.
    $bookmarks = $this->getText("xpath=/html/body[@id='index']/div
                       [@id='doc3']/div[@id='bd']/div
                       [@id='yui-main']/div[@id='content']/h3/div/em");
 
    $this->assertGreaterThan(33000, $bookmarks);
 
 
 
 
 
    }
}
 
?>

Now PHPUnit will shout failure:

You can look at more functions to implement in your tests here and here.

This concludes the second part of the tutorial.

Its always nice to see some working code first, before getting into the details. So here goes.

require_once 'Pager/Pager.php';
/* We will bypass the database connection code ... */
$sqlQuery = "SOME SQL QUERY";
$result = mysql_query($sqlQuery);
$totalRows = mysql_num_rows($result);
 
$pager_options = array(
'mode'       => 'Sliding',
'perPage'    => 10,
'delta'      => 4,
'totalItems' => $totalRows,
);
$pager = Pager::factory($pager_options);
echo $pager->links;

The above code will return the following pagination links.

1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 » [10]

Assuming the page where the above code is included is named ‘dataPage.php’; the pager links will have a url like follows:

dataPage.php?pageID=n

where n is the page number.

You can see how easy it is using the Pager class. All the link building is handled by the class. Now lets go into the details.

1. Installation

If you are installing using the Pear installer, enter the following at the command prompt to install Pager.

c:\pear install Pager

Or else you can just download the module from here and then copy it to your Pear includes directory, which will probably be ‘c:\your php installation directory\Pear’.

2. A simple example

In the following example we will create a pagination for a ‘logs’ table.

/* Include the Pear::Pager file */
require_once ('Pager/Pager.php');
 
/* Replace this with your database details */
$connection = mysql_connect("localhost", username, password);
mysql_select_db(database name, $connection);
 
/* First we need to get the total rows in the table */
$result=mysql_query("SELECT count(*) AS total FROM logs", $connection);
$row = mysql_fetch_array($result);
 
/* Total number of rows in the logs table */
$totalItems = $row['total'];
 
/* Set some options for the Pager */
$pager_options = array(
'mode'       => 'Sliding',   // Sliding or Jumping mode. See below.
'perPage'    => 10,   // Total rows to show per page
'delta'      => 4,   // See below
'totalItems' => $totalItems,
);
 
/* Initialize the Pager class with the above options */
$pager = Pager::factory($pager_options);
 
/* Display the links */
echo $pager->links;
 
/* The following code will retreive the result using the pager options */
 
/* The function below will get the page offsets to be used with
the database query. For e.g if we are on the third page then the
$from variable will have the value of '21' (we are showing 10 items per 
page, remember) and the $to variable will have the value of '30'.
*/
list($from, $to) = $pager->getOffsetByPageId();
/* The MySQL 'LIMIT' clause index starts from '0', 
    so decrease the $from by 1 */
$from = $from - 1;
 
/* The number of rows to get per query */
$perPage = $pager_options['perPage'];
 
$result = mysql_query("SELECT * FROM alogs LIMIT $from , $perPage",
$connection);
 
while($row = mysql_fetch_array($result))
{
/* Do something with the query results */
}

In the Pager class there are two modes to display the pagination: Sliding & Jumping.

With Pager in “Sliding” mode the pagination links change smoothly, and the current page is always shown at the center of the “window” (except for the start and end pages). When in Sliding mode the delta option implies how many links to show on the left and right of the current page link.
For e.g with a delta set to ’3′ the links are displayed as shown below, page 10 being the current page:

[1] « 7 | 8 | 9 | 10 | 11 | 12 | 13 » [13]

With delta option set to ’4′ the links are shown as below. As you can see there are four links to the left and right of the current page.

[1] « 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 » [13]

With the Pager in “Jumping” mode and delta set to ’4′ the Pager always shows the same 4 page links while you are on one of these pages.
For e.g with a delta set to ’4′ the links are displayed as shown below, page 5 being the current page:

[1] << Back 5 6 7 8  Next >> [13]

If you are on page ’9′ the links displayed are as below:

[1] << Back 9 10 11 12  Next >> [13]

3. More options

You can also change the default separator to any character or image you like.

$pager_options = array(
'mode'       => 'Sliding',
'perPage'    => 10,
'delta'      => 4,
'separator' => ',',
'totalItems' => $totalItems,
);

This will output the following:
[1] « 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 » [13]

If you would like to add images to the ‘next’ and ‘previous’ links, use the following options:

$pager_options = array(
'mode'       => 'Sliding',
'perPage'    => 10,
'delta'      => 4,
'nextImg'    => '<img src="next.png"  />',
'prevImg'    => '<img src="prev.png"  />',
'totalItems' => $totalItems,
);

Which will display the links as shown below:

The default number of spaces before each separator is three. To change the number of spaces use the ‘spacesBeforeSeparator’ option. For e.g:

.
.
'spacesBeforeSeparator' => 1,
.

4. Styling

You can style the links by putting them in a div tag and applying a css. A example css and its output is shown below.

Add a div tag:

.
.
echo '<div class="pager">';
echo $pager->links;
echo '</div>';

Apply CSS:

.pager {
    font-family: Arial;
    font-size: 14px;
}
 
.pager a {
    font-family: Arial;
    font-size: 14px;
    text-decoration: none;
    width: 17px;
    height: 17px;
    border: 1px solid #000;
    background-color: #0C74BA;
    text-align: center;
    color: #fff;
}
 
.pager a:hover {
    background-color: #c0c0c0;
}

The output:

That’s it. There are many other options you can use with the Pager class, the details which you can find in the Pager documentation.

Selenium IDE is an integrated development environment for performing Selenium tests.  Selenium tests can be written as HTML tables or coded in various languages like C#, PHP, Perl, Python and can be run directly in most modern browsers.The IDE can help you to record, edit and debug tests. Currently the IDE is only available for Firefox (as if we developers will use any other) as a addon.

Here is a possible scenario for using Selenium. Imagine you have created a HTML form with about twenty fields and you have to repeatedly test the form. Filling the form every time can quickly become tedious. With Selenium you can automate the whole process and run the test as required. In this part we will see how to create a simple test in Selenium. So let’s get started.

STEP 1 – installation :

You can download Selenium IDE from this locations.
http://selenium-ide.openqa.org/download.jsp
https://addons.mozilla.org/en-US/firefox/addon/2079
Once the addon is installed make sure you do not forget to restart Firefox.

STEP 2 – running a simple test :

a. Start Selenium IDE  in Firefox: Tools->Selenium IDE. You will see the following popup.

b. Click on the red record button on the right.
c. Browse to Google.com and enter ‘selenium’ in the search box and click enter.
d. Click on the first result, which is that of selenium.openqa.org.
e. Stop the recording by clicking on the record button.

You should see something like below. If you click on the ‘ Source’ tab you can see the test html generated by selenium.

The ‘table’ tab shows the commands recorded by Selenium.

f. Open a new tab in Firefox and click on the Selenium IDE’s play button to run the recorded test.

The IDE should play your recorded test. After the test is complete you should have landed on the selenium page (http://selenium.openqa.org/). The IDE after the test run is shown below. In the ‘Log section’ you can see the various events run by the test. In the table tab you can see that all the rows are green, which means that the test ran successfully.

Now lets add a small assertion to the above test.

a. Click on the blank line below after the last ‘clickAndWait’ command and insert ‘assertTextPresent’ command from the drop down box as shown below. You should see something like this.

This test checks to see if the text ‘Selenium News’ is present in the last rendered page. Run the test again and you should see that the test has run successfully. No try replacing the text with something that is not present on the page, take for example ‘elvis’ and run the test again. Now the test fails and you should get the screen below.

You have just completed your first test run. And it was so simple.

‘assertTextPresent’ is one of the hundreds of commands available for your testing needs. Just browse throught the command drop down to get a feel of what you can you get.

In the next part we will see more advanced features of Selenium.