The application ‘ffmpeg’ consist of three executables and 5 libraries. All the sources can be downloaded using the following svn command:

Ø      svn checkout svn://svn.ffmpeg.org/ffmpeg/trunk ffmpeg

 Required patch

One version which I tried ( download: svn checkout svn://svn.ffmpeg.org/ffmpeg/trunk ffmpeg –r 17944)

has a known problem with the sources. If you try to build the code, then you will get a compile time error:

 libswscale/swscale.c:488: error: ‘PIX_FMT_YUV420PLE’ undeclared

The solution is solved by copying the contents of the libswscale directory from .   http://www.ffmpeg.org/releases/ffmpeg-0.5.tar.bz2    (see http://www.ffmpeg.org/download.html)

Please Note, only the libswscale directory should be copied over the top of the existing files.

Build Instructions

Following instructions will help you build ffmpeg under a Linux system assuming that the tar ball from the download is copied to <install_directory>:

 Ø      cd  <install_directory>

 Ø      cd tar xvfz  ffmpeg.tar.gz   #Extract the tar ball to your local directory. You will find a directory tree under the name ffmpeg installed. All the required sources are installed within this tree provided that you are not enabling any additional third party libraries.

 Ø      cd ffmpeg

 Ø      ./configure –help <cr> # to show all the options available to rebuild ffmpeg. For a reference build with gcc there is no need to provide any parameters to configure. However if you would like to enable any third party libraries like ‘libfaad’, ‘libx264’ etc. then you need to add --enable-libfaad --enable-libx264 etc. as parameters to configure. If this is required make sure that you have these sources available on your development environment and that the third party libraries are rebuilt with the selected compiler / compiler options.

 Ø      ./configure <parameters as below>

 Ø      make <cr> #recommended sequence is ‘make clean’ followed by ‘make’. The rebuild will take several minutes (depending on your development environment). Two versions of each executable are produced: ex. ‘ffmpeg’ and ‘ffmpeg_g’. The ‘*_g’ contains the executable with debug information while the ‘*’ is the stripped version. In addition ‘ffplay, ffplay_g, ffserver and ffserver_g’ are produced as executables and libavutil, libavcodec, libavformat, libavdevice and libswscale are rebuilt.

 Icc build:

Depending on what version of icc you are using different configure parameters may be necessary.

 Using icc v10.1.xxx:

 Ø      ./configure cc=icc --extra-cflags=”-xL –O3” --extra-libs=-lsvml <cr> # Without linking in the extra library (libsvml.so) you get several references unresolved.

 Using icc v11.0.xxx:

 Ø      ./configure cc=icc –extra-cflags=”-xSSE3_ATOM –O3” –extra-libs=-lsvml <cr> #  The option –xSSE3_ATOM do require that you run the code on a processor which does support the ‘movbe’ instruction. If you would like to test the code on a processor not supporting the ‘movbe’ instruction you can add the option ‘-minstruction=nomovbe’ in the extra-cflag part of the command line above.
Ø      Make sure that the LD (linker) options do not contain ‘–march=generic’ in the config.mak file. This option causes an error from the compiler.

Using icc v11.1.xxx:

Ø      To avoid a run time erratum following source change is needed:   Open file ./libavcodec/x86/dsputil_mmx.c and on line #2944 insert // before || __ICC > 1100. The line is highlighted below.

Ø      After the change it will look like: #if ARCH_X86_64 || ! ( __ICC) // || __ICC > 1100

Ø      ./configure cc=icc –extra-cflags=”-xSSE3_ATOM –O3” <cr> # This simple configure does work but you get better performance if you also add the ‘--extra-lib=-lsvml’. Additional compiler switches can be used to improve the performance – for example ‘-no-prec-div’, ‘-vec-‘. As the no-prec-div has an effect on the fp calculations please refer to the compiler documentation before it is used. In addition the ‘-xSSE3_ATOM’ switch are no longer requiring a processor with ‘movbe’ support.

 Cross compilation.

It is standard practice to build the library and executables on a development machine and then copy the resultant files to the MOBLIN target.  You can use the option --enable–cross-compile in this case.

Once you have completed the configure stage you can just run the ‘make clean’ followed by ‘make’. You could expect additional warnings produced.

Building ffmpeg with third party libraries:

The application can support 21 different external 3^rd party libraries. Each of those are selected in the configure process by adding the option ‘--enable-<library-name>’.

Below is an example of using some of the different external libraries available:

 Ø      ./configure <other options as above> --enable-libfaac --enable-libfaad --enable-libmp3lame --enable-libtheora --enable-libx264 --enable-libxvid 

The invocation above assumes that you will be using 6 external 3^rd party libraries:

 - libfaac       # for example you can download ‘faac-1.28.tar.gz’ or later version from the web.

 - libfaad       # for example you can download ‘faad2-2.7.tar.gz’ or later version from the web.

 - libmp3lame # for example you can download ‘lame-398-2.tar.gz’ or later version from the web.

 - libtheora    # for example you can download ‘libtheora-1.0.tar.tar’ or later version from the web. Please note that you can not use ICC v 10.1 to rebuild this library due to a compiler issue. This has been fixed with 11.1 version of the compiler.

 - libx264      # for example you can download ‘x264-snapshot-20090117-2245.tar.bz2’ or later version from the web.

 - libxvid      # for example you can download ‘xvidcore-1.2.1.tar.gz’ or later version from the web.

Introduction

Build environment

The build instructions below are based on the assumption that the build environment is a Fedora10 installation. 

A copy of the installation disks can be found here. http://fedoraproject.org/get-fedora

It is important that the GCC tools are installed when the Fedora installation is installed.

Cross-development

The clutter libraries  and test environment  are first built on a Fedora installation, and then the resultant executables and libraries can then be copied over to a MOBLIN2 platform.

Virtualisation

The steps below can be undertaken on a virtual machine, the only restriction being that not all virtual machines support video acceleration  

The tests

There are a number of tests that can be used to benchmark the clutter library. The benchmark performance is measured by how many Frames Per Second (FPS) are achieved.

Building the Clutter Libraries

Downloading the sources

The sources for the clutter library can be obtained by using the following command.

In a development directory of your choosing download the sources

   git clone git://git.clutter-project.org/clutter

   git clone git://git.clutter-project.org/clutter-box2d

Progress for each download should be reported similar the following:

$ git clone git://git.clutter-project.org/clutter

Initialized empty Git repository in /home/intel/dv/clutter/clutter/.git/
remote: Counting objects: 25225, done.
remote: Compressing objects: 100% (10261/10261), done.
remote: Total 25225 (delta 20575), reused 18319 (delta 14944)
Receiving objects: 100% (25225/25225), 6.99 MiB | 104 KiB/s, done.
Resolving deltas: 100% (20575/20575), done.

Building the Sources

Directory structure should look similar to this:

             <dev-dir>/clutter/
            <dev-dir>/clutter-box2d

In each of these sub directories build the libraries as follows:

Choosing which compiler

Building with GCC

For our installation, we'll use the environment variable  $PREFIX custom directory so as not to override any existing installation

     export PREFIX=/opt/custom/gcc
    ./autogen.sh --prefix=$PREFIX

Building with ICC

To build the library with the Intel compiler use the following commands

    export CC=icc
    export CXX=icc

   export PREFIX=/opt/custom/icc
  ./autogen.sh --prefix=$PREFIX

Continuing the build

When autogen has completed you should get a message similar to the display below 

  
                                  Clutter    0.9.7
                         ====================
                                  prefix:   /opt/custom/gcc
                                Flavour:   glx/gl
                                 XInput:   no
                          GL headers:   GL/gl.h
                    Image backend:   gdk-pixbuf
                       Target library:   libclutter-glx-0.9.la
               Clutter debug level:   yes
                 COGL debug level:   minimum
                      Compiler flags:   -Wall -Wshadow -Wcast-align -Wno-uninitialized -Wno-strict-aliasing -Wempty-body -Wformat-security -Winit-self
        Build API documentation:   no
  Build manual documentation:   no
         Build introspection data:   auto

Now build the source by calling make

The progress of the make will be reported, the last few lines looking similar to this:

   Making all in tools
     CC    disable-npots.o
     LINK  libdisable-npots-static.la
     LINK  libdisable-npots.la
   Making all in po

Installing the new library

To install the new library call:

make install

Note, depending on the permissions of the installation directory (set with the $PREFIX variable in the previous steps) you may need to do this as root.

Building the tests

The test directory has a number of tests. The README describes the tests as follows 

"The conform/ tests should be non-interactive unit-tests that verify a single feature is behaving as documented. See conform/ADDING_NEW_TESTS for more details.

 The micro-bench/ tests should be focused performance test, ideally testing a single metric. Please never forget that these tests are synthetic and if you are using them then you understand what metric is being tested. They probably don't reflect any real world application loads and the intention is that you use these tests once you have already determined the crux of your problem and need focused feedback that your changes are indeed improving matters. There is no exit status requirements for these tests, but they should give clear feedback as to their performance. If the frame rate is the feedback metric, then the test should forcibly enable FPS debugging.

 The interactive/ tests are any tests who's  status can not be determined without a user looking at some visual output, or providing some manual input etc. This covers most of the original Clutter tests. Ideally some of these tests will be migrated into the conformance/ directory so they can be used in automated nightly tests."

To build the tests, from the top level of the test directory do: 

    make

The build will report:

    Making all in data
    Making all in conform
    Making all in interactive
    Making all in micro-bench
    Making all in tools

Running the tests

Having built the tests, each test can be run from the command line.

Automatic running of  tests.

Many of the tests do not run to completion, but keep running,  The script in the appendix below gives an example of how the tests can be automatically called and killed after a predefined time.

Appendix 1 -  Script to drive test cases

#!/usr/bin/perl
# list of tests TODO: EDIT THESE TO YOUR REQUIREMENTS
@Tests=("test-actors", "test-behave", "test-clip","test-cogl-offscreen","test-cogl-primitives","test-cogl-tex-convert","test-cogl-tex-foreign","test-cogl-tex-getset","test-cogl-tex-polygontest","test-cogl-tex-tile","test-depth","test-layout","test-multistage","test-pixmap","test-project","test-random-text","test-rotate","test-scale","test-script","test-sharder","test-text","test-texture-quality","test-textures","test-threads","test-unproject","test-viewport");

#@Tests=("test-actors", "test-behave");
@Results=();

# for each test run it for 10 seconds
my $Timeout = 10;
## chdir interactive;
my $bStarted = 0;

foreach my $Test (@Tests)
{
    # print "executing $Test\n ";
    eval {
        local $SIG{ALRM} = sub { die "alarm\n" }; # NB: \n required
        alarm $Timeout;
        # system("./$Test --clutter-show-fps > res.$Test.txt");

        # mark end of prev test
        push @Results, "END" if $bStarted;
        push @Results, "TEST:$Test\n-----------------------\n";
        $bStarted = 1;
        open (RUN,"./$Test --clutter-show-fps &|");
        while(<RUN>)
        {
            push @Results, $_;
        }
        alarm 0;
    };
    if ($@)
    {
        die unless $@ eq "alarm\n"; # propagate unexpected errors
        # timed out
        system("killall -9 lt-test-interactive");
     }
}
# mark the end of the last test
push @Results, "END" if $bStarted;

# process the results
my $NumTests = 0;
my $Total = 0;
my $Max = 0;
my $Min = 9999;
my $TestName="";

print "\nName Min Max NumTests Average\n";
foreach my $Line (@Results)
{
    if($Line=~/^TEST:(.*)/)
    {
        # print "IN TEST $Line";
        $TestName= $1;
        chomp $TestName;
        $NumTests = 0;
        $Total = 0;
        $Max = 0;
        $Min = 9999;
    }

    if($Line=~/END/)
    {
        # print "IN END :$Line";
        $Average = 0;
        $Average = $Total/$NumTests if $NumTests > 0;
        print "$TestName $Min $Max $NumTests $Average\n";
    }

    if($Line=~/\*\*\* FPS: (.*) \*\*\*/)
    {
        # print "IN FPS: $Line";
        $NumTests++;
        $Total = $Total + $1;
        $Max = $1 if $1 > $Max;
        $Min = $1 if $1 < $Min;
    }
}

print "exiting ..\n";
 

 Appendix 2 - Essential notes on installing Fedora  

When installing Fedora you must install the Software Development tools.

Whether you intend to do most of your development on a live Moblin* image running inside a KVM* virtual machine ore whether you intend to do your development in a protected jailroot/chroot environment, there are tools components that should be installed on your development host system and should be independent of your Moblin* based Intel(R) Atom(TM) Processor target.

It is recommended to register for the Intel(R) Application Software Development Tool Suite for Intel(R) Atom(TM) Processor or the Intel(R) Embedded Software Development Tool Suite for Intel(R) Atom(TM) Processor at http://software.intel.com/en-us/intel-compilers/ and download it at https://registrationcenter.intel.com. It is also recommended to install at least the Intel(R) VTune(TM) Performance Analyzer and the Intel(R) Debugger following the steps outlined in the product installation guide Install_All.htm. This will take care of installing the host components to take advantage of the Intel(R) Application Software Development Tool Suite's performance analysis, tuning and debug capabilities.

To install the Intel(R) C++ Compiler and the Intel(R) Integrated Performance Primitives into the Moblin* Image Creator jailroot environment and prepare the Moblin* Image Creator produced target image to also include the Intel(R) Application Debugger debug agent (Idbserver) and the Intel(R) VTune(TM) Analyzer Sampling Collector (SEP) please follow the steps below:

1. Go to http://www.moblin.org and download Moblin* Image Creator 2. Detailed Moblin* Image Creator documentation can be found at http://moblin.org/documentation/moblin-image-creator-2/using-moblin-image-creator and the Moblin* Image Creator itself can be downloaded at  http://git.moblin.org/cgit.cgi/moblin-image-creator-2 .
2. Follow the instructions you find at moblin.org for installing the Moblin* Image Creator.
3. Go to http://software.intel.com/en-us/articles/moblin-integration-software-development-tool-suite-atom/ and download the two scripts netbook-core-developer_JAILROOT.ks and netbook-core-developer_TARGET.ks .
4. To create a KVM* image or a Live-CD of the target Moblin* system, please use netbook-core-developer_TARGET.ks:
    

   > moblin-image-creator -c <path_to_ks>/netbook-core-developer_TARGET.ks -f raw --cache=/tmp/mycache

   The image created will contain The Intel(R) Application Debugger Idbserver and the Intel(R) VTune(TM) Analyzer Sampling Collector for target system located as a tarball in the /tmp directory. TheParameter '-f raw' of the moblin-image-creator command instructs the Moblin* Image Creator to create an image which can be loaded into a KVM* virtual machine. For more information on Moblin* Image Creator usage please consult moblin.org.

5. To create an image with the Intel(R) C++ Compiler & the Intel(R) Integrated Performanced Primitives that you can then use to do builds in a protected jailroot/chroot environment before creating the target image please use netbook-core-developer_JAILROOT.ks:
    

   > moblin-image-creator -c <path_to_ks>/netbook-core-developer_JAILROOT.ks -f loop --cache=/tmp/mycache

   The image will contain the Intel(R) C++ Compiler and the Intel(R) IPP at /opt/intel/Compiler. The command parameter '-f loop' of moblin-image-creator tells it to create a loop image. You can mount this image and then chroot into it for your protected builds using the following commands:
     

   > mount -o loop moblin-netbook-core-developer_JAIROOT.img /mnt/loop
    > chroot /mnt/loop su

6. To additionally install the Intel(R) VTune(TM) Analyzer Sampling Collector (SEP) you would download it directly from http://downloads.moblinzone.com/development-tool-suite-2/rpm/vtune91_target.tar.gz and unpack it and install it in the Moblin* environment. Please be advised that using SEP is only supported on real Intel(R) Atom(TM) Processor based hardware and not on OS images running under KVM*. 

    

Advanced

If you would like to modify the kickstart script templates provided with the Moblin* Image Creator yourself, below is a short outline of the changes we apply to the template scripts provided with the Moblin* Image Creator to enable our integration. The example kickstart scripts for the Moblin* Image Creator can be found in the /usr/share/mic2 after you installed it.

To enable integration of the Intel(R) Software Development Tool Suite you would do the following:

1. add a repository entry for the Intel(R) Software Development Tool Suite  to the header of ks file:  
      

   > repo --name=intel-tools --baseurl=http://downloads.moblinzone.com/development-tool-suite-2

2. add packages which you want to install into Moblin image in %packages section of the ks file.
   There are 4 groups of Intel packages which you may want to install:
   

     @Compiler
     @IPP
     @Application Debugger
     @Server agent for Application Debugger

Each of these groups contains a set of rpm files related to the corresponding products.
  

@Compiler contains the Intel(R) C++ Compiler for applications runninng on IA-32
  @IPP containsthe Intel(R) IPP for Intel(R) Atom(TM) Processor
  @Application Debuggers contains the Intel(R) Application Debugger 2.0 for Intel(R) Atom(TM) Processor
  @Server agent for Application Debugger conntains the Intel(R) Debugger Remote Server (idbserver) 

    
Each group of packages contains the information about its dependencies which will be automatically resolved during the installation.

Host Install 

It is recommended to register for the Intel(R) Application Software Development Tool Suite for Intel(R) Atom(TM) Processor or the Intel(R) Embedded Software Development Tool Suite for Intel(R) Atom(TM) Processor at http://software.intel.com/en-us/intel-compilers/ and download it at https://registrationcenter.intel.com. It is also recommended to install at least the Intel(R) VTune(TM) Performance Analyzer and the Intel(R) Debugger following the steps outlined in the product installation guide Install_All.htm. This will take care of installing the host components to take advantage of the Intel(R) Debugger and Intel(R) VTune(RM) Perfromance Analyzers debuging and performance optimization tuning capabilities.

If you wanted to you could however also do the host component install using the kickstart script approach of Moblin Image Creator 2. This is however not the recommended approach.
To the any kickstart script of your choice you would add  the '%post --nochroot' section shown below for copying of the Intel(R) VTune(TM) Performance Analyzer and the Application Debugger to the host machine and VTune sampling collector for embedded systems (SEP-embedded) to the target image.

%post --nochroot

# Copying vtune_for_targets to the target image (set your proxy here if needed)
echo "Downloading required additional packages..."
export http_proxy=http://proxy.jf.intel.com:911
test -s /tmp/vtune91_target.tar.gz || wget http://downloads.moblinzone.com/development-tool-suite-2/rpm/vtune91_target.tar.gz -O /tmp/vtune91_target.tar.gz
cp /tmp/vtune91_target.tar.gz $INSTALL_ROOT/tmp/vtune91_target.tar.gz

# copying VTune for host to the user's host machine
test -d /tmp/intel-tools || mkdir -p /tmp/intel-tools
test -s /tmp/intel-tools/l_vt_pu_9.1.021.tar.gz || wget http://downloads.moblinzone.com/development-tool-suite-2/l_vt_pu_9.1.021.tar.gz -O /tmp/intel-tools/l_vt_pu_9.1.021.tar.gz

# copying Application Debugger to the user's host machine
test -d /tmp/intel-tools/idb || mkdir -p /tmp/intel-tools/idb
wget http://downloads.moblinzone.com/development-tool-suite-2/rpm/intel-mid_idb20006-2.0.006-001.i486.rpm -O /tmp/intel-tools/idb/intel-mid_idb20006-2.0.006-001.i486.rpm
wget http://downloads.moblinzone.com/development-tool-suite-2/rpm/intel-mid_idb-kernel20006-2.0.006-001.i486.rpm -O /tmp/intel-tools/idb/intel-mid_idb-kernel20006-2.0.006-001.i486.rpm
wget http://downloads.moblinzone.com/development-tool-suite-2/rpm/intel-mid_idb-eclipse20006-2.0.006-001.i486.rpm -O /tmp/intel-tools/idb/intel-mid_idb-eclipse20006-2.0.006-001.i486.rpm

# Installing App Debugger (if needed, please remove the comments)
# TODO: write some lines, so that add installation for non-rpm systems (like Ubuntu 8.10)
#echo "Installing an Application Debugger..."
#type -P rpm &>/dev/null
#if [ $? -eq 0 ]; then
# rpm -U --force --nodeps /tmp/intel-tools/idb/intel-mid_idb20006-2.0.006-001.i486.rpm
# rpm -U --force --nodeps /tmp/intel-tools/idb/intel-mid_idb-kernel20006-2.0.006-001.i486.rpm
# rpm -U --force --nodeps /tmp/intel-tools/idb/intel-mid_idb-eclipse20006-2.0.006-001.i486.rpm
#fi

%end