Build linphone-sdk and flexisip on Yocto

This pages describes how to build linphone-sdk and/or Flexisip on Yocto, on any hardware platform.
This is not a Yocto tutorial, and therefore this requires a little bit of first-hand Yocto experience.
A few leads and links are given for the installation of packages on the target machine, however it is mainly out of this wiki page's scope.

This setup has been tested with Yocto Sumo and Yocto Thud.

Set up your build system

Before jumping into building anything for your platform, you must ensure your host build system is correctly setup with the appropriate tools.

Install required packages

Install the required packages for the host development system. The Yocto Project documentation has a list of everything needed for each host type (Ubuntu, CentOS, etc.) as well as the matching install commands for them here :

Get the Yocto build system for your platform

The Yocto project Complete documentation set covers this in details, and is available on their official website here : Yocto Documentation Website. The Yocto Project Quick Start guide is particularly helpful for the execution of the following steps.

The main steps to setup the adequate Yocto build environment and layers for your platform are as follows:

  • Get Bitbake and the OpenEmbedded components (known as Poky)
    • poky
    • openembedded-core
    • meta-openembedded
  • Check out the corresponding distribution version for each repository
  • Initialize the build environment to setup Bitbake
source oe-init-build-env
  • Add the openembedded layers to the bblayers configuration file

Add the Linphone recipe

In order to build linphone-sdk and its dependencies with Yocto, the following steps must be completed :

  • Get the linphone-sdk recipes.
  • Add the layer to the bblayers configuration file
  • Add linphone-sdk to the image build
  • Add the commercial license to the white flags list (needed by a linphone dependency) 

There are a few optional additional steps described here:

  • Change the packaging options
  • Disable video support
  • Select the number of CPU cores used for the build
  • Add networking packages
  • Save disk space during builds
  • Add an ssh server

Get Linphone recipes

Clone the Linphone layers repository on the same level as the other metadata. In this example, all the metadata layers are cloned into a "sources" directory under poky/.

The yocto-sumo branch provides the linphone-sdk for yocto-sumon

git clone -b yocto-sumo

Your metadata directory should now look like this:

[matthieu@linux-3 sources]$ ls
meta-bc   meta-openembedded   openembedded-core

[matthieu@linux-3 meta-bc]$ ls
classes   conf   recipes-bc

[matthieu@linux-3 recipes-bc]$ ls
flexisip   linphone-sdk

[matthieu@linux-3 linphone-sdk]$ ls

This repository also contains the bitbake recipes for Flexisip (SIP proxy server).

Add the linphone recipe to the layers

In the bblayers.conf file, under build/conf/ add the following line:


The file should be similar to this:


BSPDIR := "${@os.path.abspath(os.path.dirname(d.getVar('FILE', True)) + '/../..')}"

  ${BSPDIR}/meta \
  ${BSPDIR}/meta-yocto \
  ${BSPDIR}/meta-yocto-bsp \
  ${BSPDIR}/sources/openembedded-core/meta \
  ${BSPDIR}/sources/meta-openembedded/meta-oe \
  ${BSPDIR}/sources/meta-openembedded/meta-multimedia \
  ${BSPDIR}/sources/meta-openembedded/meta-networking \
  ${BSPDIR}/sources/meta-openembedded/meta-python \
  ${BSPDIR}/sources/meta-bc \

Add linphone to the image build

Once Linphone is built you can add it to the final image in local.conf using the following lines:

IMAGE_INSTALL_append = " linphone-sdk"

Choose linphone-sdk version

Linphone-sdk can be built by Yocto as a stable version  or as HEAD of master branch, which sets the latest git revision for all submodules automatically. By default the stable version mode is selected but if you want to use the master/HEAD mode you need to add the following line in local.conf:


If you aim to build linphone-sdk specify version, you need to set both branch name and commit it using LINPHONE_SDK_REV and LINPHONE_SDK_BRANCH

LINPHONE_SDK_REV = "cdc0d522dca3a52c083a90d08790891392513ba9"

Add the commercial license to the white flags list

The following step is relative to license issues, please be careful if you intend to build a commercial product. The following .bbappend files for libav and ffmpeg disable their GPL license respectively. Their use depends on the Yocto version you are using (Fido uses libav, Morty uses ffmpeg),

This is useful for libav, otherwise the linphone build will fail. In the local.conf file under build/conf/, add the following lines :


Since Yocto Krogoth, libav has been replaced by ffmpeg. In order to ignore the .bbappend file concerning libav the following line is necessary for a Yocto Morty build:

BBMASK += "/path/to/poky/sources/meta-bc/linphone/libav/libav_%.bbappend"

The following steps are optional but can be very useful if you want to customize your build

Change the packaging option

In the file local.conf, under build/conf/, make sure the PACKAGE_CLASSES is set to package_ipk:

PACKAGE_CLASSES ?= "package_ipk"

Add liblinphone_tester or flexisip

If you want to add liblinphone_tester and/or flexisip to the final image you can add the following line in local.conf:

IMAGE_INSTALL_append = " flexisip"

Disable the video options

If you don't need video support, add the following line in local.conf:

DISTRO_FEATURES_remove = "x11 wayland"

In the recipe file under /meta-bc/recipes-bc/linphone/linphone, remove the video with the following line :

PACKAGECONFIG ??= "sqlite zlib video ${@bb.utils.contains('DISTRO_FEATURES', 'x11', 'x11', '', d)}"

Or add a linphone_%.bbappend file containing the following:

PACKAGECONFIG_remove = "video"

Do not disable the video options if you intend to use liblinphone_tester on the final image. If you want to use liblinphoner_tester without having a video output, you might need to build glew and add it to the image using the following line:

IMAGE_INSTALL_append = " glew"

Select number of CPU cores used for the build

In the local.conf file under build/conf/, add the following line:


X being the number of threads that you want to use (twice the number of CPU cores)

Add networking packages if necessary

If you want to add networking packages to the core images, for example you can add the following lines to local.conf:

CORE_IMAGE_EXTRA_INSTALL += "init-ifupdown"

Save disk space during builds

You can save disk space during build by adding the following line to local.conf:

INHERIT += "rm_work"

Add ssh server if necessary

If you want to add an ssh server to the core images, you can modify the following line to local.conf:

EXTRA_IMAGE_FEATURES = "debug-tweaks ssh-server-openssh"

Build linphone-sdk, flexisip and the final image

Linphone-sdk and Flexisip must be built first before integrating them to the final image.

Build Linphone-sdk

Now that you're environment is all set up, run the following commands to build the linphone-sdk and/or the Flexisip packages:

bitbake linphone-sdk
bitbake flexisip

Build the final image

Then you can build the image you want using the following example command, which will use the configuration you specified in local.conf:

bitbake core-image-minimal

By default the machine architecture for which Yocto builds the image is qemux86 but you can choose to build for any available emulated or hardware machine by specifying it in the local.conf file under the "Machine Selection" section.

Build for Wandboard Solo Freescale i.MX6 Cortex-A9

Example of a build for a specific hardware board with an ARMv7 architecture, which can help understand how to build for your own hardware.

In order to successfully build Linphone for the Wandboard Solo, the following steps must be followed:

  • Get the Wandboard specific layers of metadata
  • Add these layers to bblayers.conf
  • Change target machine to "wandboard"
  • Accept Freescale EULA
  • Clean and re-build the image
  • Unzip wic.gz and flash the image on sd card
  • Start liblinphone_tester and linphone-daemon

Get the Wandboard specific layers of metadata

In order to support this specific architecture, you need to clone and checkout the corresponding branch of three layers of metadata :

  • meta-freescale
  • meta-freescale-distro
  • meta-freescale-3rdparty

Add these layers to bblayers.conf

You can now add the layers to the bblayers.conf configuration file under /build/conf/, which should now be similar to this:


BSPDIR := "${@os.path.abspath(os.path.dirname(d.getVar('FILE', True)) + '/../..')}"

  ${BSPDIR}/meta \
  ${BSPDIR}/meta-yocto \
  ${BSPDIR}/meta-yocto-bsp \
  ${BSPDIR}/sources/openembedded-core/meta \
  ${BSPDIR}/sources/meta-openembedded/meta-oe \
  ${BSPDIR}/sources/meta-openembedded/meta-multimedia \
  ${BSPDIR}/sources/meta-openembedded/meta-networking \
  ${BSPDIR}/sources/meta-openembedded/meta-python \
  ${BSPDIR}/sources/meta-freescale \
  ${BSPDIR}/sources/meta-freescale-distro \
  ${BSPDIR}/sources/meta-freescale-3rdparty \
  ${BSPDIR}/sources/meta-bc \

Change target machine to "wandboard"

In order to use the wandboard layers of metadata for the build you need to change to target machine in local.conf:

MACHINE = "wandboard"

Accept Freescale EULA

To accept the Freescale EULA you can add the following line to local.conf:


Clean and re-build the image

Before building the Wandboard version of your image you may need to clean the linphone and image targets:

bitbake -c cleanall core-image-minimal
bitbake -c cleanall linphone-sdk

Then you can build the Wandboard image with bitbake:

bitbake -f linphone-sdk
bitbake -f core-image-minimal

Unzip wic.gz and flash the image on sd card

If your Wandboard build is successful, you can find the final images in /build/tmp/deploy/images/wandboard/. To retreive the .wic image you need to unzip the .wic.gz file with the following command:

gunzip -f core-image-minimal-wandboard.wic.gz

Then you can flash it on an sd card with the dd command. In this example the sd card device is called /dev/sdb.

The following step is critical, be sure to target the correct device before executing the "dd" command. The "lsblk" command is very useful to determine to correct device.

sudo dd if=core-image-minimal-wandboard.wic of=/dev/sdb bs=1024

Using linphone-sdk and flexisip binaries

Start linphone or flexisip binaries

All installed files from linphone and flexisip can be found in the directory /opt/belledonne-communications/

You can find and launch any executable present in /opt/belledonne-communications/bin/

For example /opt/belledonne-communications/bin/liblinphone_tester or /opt/belledonne-communications/bin/flexisip

Link against liblinphone in your own recipe

Since the installation prefix of linphone libraries is not the default system one, compiling and linking against these libraries can be tricky.

Here is an example recipe of a test program linking against liblinphone:

‚ÄčDESCRIPTION = "Example compilation of yocto program based on linphone"                                                                                                                                                                                                         

PR = "r0"                                                                                                                                                                                                                                                                      
LICENSE = "CLOSED"                                                                                                                                                                                                                                                             
S = "${WORKDIR}"                                                                                                                                                                                                                                                               

DEPENDS = "linphone-sdk"                                                                                                                                                                                                                                                       

LINPHONE_INSTALL_PATH = "/opt/belledonne-communications"                                                                                                                                                                                                                       

do_compile() {                                                                                                                                                                                                                                                                 
             ${CC} ${CFLAGS} ${LDFLAGS} -I ${STAGING_DIR_HOST}${LINPHONE_INSTALL_PATH}/include -c test.c -o test.o                                                                                                                                                                      
             ${CC} ${CFLAGS} ${LDFLAGS} -L${STAGING_DIR_HOST}${LINPHONE_INSTALL_PATH}/lib -llinphone -Wl,-rpath-link=${STAGING_DIR_HOST}${LINPHONE_INSTALL_PATH}/lib test.o -o test                                                                                                              

do_install() {                                                                                                                                                                                                                                                                 
   install -m 0755 -d ${D}${bindir}                                                                                                                                                                                                                                           
   install -m 0755 ${S}/test ${D}${bindir}                                                                                                                                                                                                                               

The STAGING_DIR_HOST points to the recipe-sysroot folder of your recipe which should contain all linphone-sdk related files (because the recipe DEPENDS on linphone-sdk).

The important option here is `-Wl,-rpath-link` which will make the compiler check for libraries at link time in the given directory.

Previous yocto versions and linphone recipes

Using cmake 3 with Fido

You don't need this step if you are using Yocto Morty

Yocto Fido uses cmake version 2.8.12. However, the linphone recipes require cmake version 3 and higher to be compiled.

Fortunately, a patch has been done to allow porting cmake 3.2.2 to Fido , the commit is here from . The following file contains the patch based on this commit cmake_upgrade_to_3.2.2.patch

If you put the file under the openembedded-core directory, starting the patch from the same directory, the command would be:

git apply cmake_ugrade_to_3.2.2.patch