Come compilare FFmpeg per Raspberry Pi (Raspbian)

Se hai familiarità con una piccola cosa chiamata ​Raspberry Pi (un computer da scheda singola di dimensioni di carta di credito, chiamato breve RPi) e devi compilare il tuo codice sorgente FFmpeg per essere in grado di eseguirlo su ​Raspbian (un sistema operativo basato su Debian Linux ottimizzato per l'hardware Raspberry Pi), allora questo tutorial potrebbe aiutarti.

Siate consapevoli, però, che Raspberry Pi non ha un hardware molto potente (ha un sistema Broadcom On a Chip (SoC), che include processore ARM da 700 MHz, con possibile overclocking fino a 1 GHz, VideoCoreGPU IV e di solito viene fornito con 256/512 MB di memoria RAM), quindi probabilmente non sarai in grado di eseguire alcun tipo di codificatore su di esso, ma puoi usarlo come un lettore multimediale 1080 molto economico.

Compilare direttamente su RPi (in esecuzione su Raspbian) è possibile e alcune persone lo fanno in quel modo, ma dal momento che il suo hardware è molto limitato, questo non è raccomandato per nulla di così grande come FFmpeg (mi ci sono volute 9 ore per compilare il FFmpeg di base in questo modo, senza alcuna libreria aggiuntiva). Fortunatamente, ci sono altri modi per compilare le cose per RPi. Uno di questi è ​l'emulazione di Raspberry Pi sulla macchina utilizzando QEMU (emulatore). Un altro modo (descritto in questo documento) è la compilazione incrociata, il che significa che si compila tutto sulla macchina desktop, utilizzando il proprio sistema operativo, producendo binari per il Raspbian.

(TODO: La tabella di confronto di diversi modi per compilare FFmpeg per Raspbian)

FFmpeg di compilazione incrociata per

Descriveremo qui il metodo per compilare FFmpeg incrociato per Raspbian. In primo luogo, prepareremo il nostro ambiente di costruzione. Quindi mostreremo come compilare librerie aggiuntive comuni che FFmpeg potrebbe utilizzare (ad esempio libx264). E finalmente mostreremo come compilare l'ultima (e più grande) versione di FFmpeg che funzionerà su Raspbian.

Preparare l'ambiente

Per compilare con successo le cose, abbiamo bisogno di qualcosa chiamato (un insieme di strumenti di programmazione che vengono utilizzati per creare un altro programma per computer). Serve una toolchain che possa produrre binari, specifici per l’architettura ARM e la stessa Raspbian. Ora, ci sono un sacco di catene di strumenti già creati per Raspbian e se ti piace accelerare le cose, potresti semplicemente andare a trovarne uno e installarlo, ma tieni presente che qualsiasi toolchain che scarichi, potrebbe non essere ottimizzato sia per il tuo sistema operativo che per Raspbian. Se compili la tua toolchain, puoi essere sicuro che sarai in grado di utilizzare tutte le ottimizzazioni disponibili che il tuo sistema operativo e il tuo supporto Raspbian.

Il ​crosstool-ng è uno strumento utilizzato per creare una toolchain personalizzata. Lo useremo per creare la nostra toolchain che possiamo utilizzare per compilare tutto ciò che vogliamo per il Raspbian. Quindi, prepariamo tutto per costruire prima la nostra catena di attrezzi.

Building the crosstool-ng

The following section is mostly inspired by ​How to build a cross compiler for your Raspberry Pi.

First, ​download crosstool-ng, extract the archive and compile the source code. We recommend you to use something like this:

./configure --prefix=/opt/cross
make
sudo make install
export PATH=$PATH:/opt/cross/bin

which will install all the crosstool-ng needed files into the "/opt/cross" directory and add it to the current PATH environment variable.

If something goes wrong, check your "build.log" file to get a clue on what went wrong. I've had some trouble because of some missing system packages, which I installed using:

apt-get install texinfo pkg-config

Although, the error complained about "makeinfo", it appears that, in Debian, this package is named "texinfo". Also consider installing texi2html package.

Building the toolchain

Ora che abbiamo costruito crosstool-ng, possiamo costruire la nostra catena di attrezzi RPi.

In primo luogo, creare una directory che crosstool-ng utilizzerà come terreno di staging. Questa directory conterrà la configurazione della tua toolchain, i file scaricati e i risultati della build di intermediazione. Questo non è dove la tua toolchain finale finirà e occupa molto spazio (ad esempio /home/user/ctng). Entra in quella directory ed esegui "ct-ng menuconfig":

mkdir /home/user/ctng
cd /home/user/ctng
ct-ng menuconfig

The menu should show up and you should set up things as instructed by the following walkthrough (checkboxes are selected using the SPACEBAR key and text fields can be edited pressing the ENTER/RETURN key on your keyboard, once you select it with your cursor keys):

• Paths and misc options
  • (Important) Enable "Try features marked as EXPERIMENTAL"
  • (Optional) Change "Prefix directory" (for example, you can put "/opt/cross/x-tools/${CT_TARGET}" there)
• Target options
  • (Important) Change "Target architecture" to "arm"
  • (Important) Leave "Endianness" set to "Little endian"
  • (Important) Leave "Bitness" set to "32-bit"
• Toolchain options
  • (Nothing to do here, the defaults are fine)
• Operating system
  • (Important) Change "Target OS" to "linux"
• Binary utilities
  • (Optional) Change "binutils version" to "2.21.1a" or whichever is the latest that isn't marked as experimental
• C compiler
  • (Optional) Enable "Show Linaro versions (EXPERIMENTAL)". In the "gcc version" field, choose the "linaro-4.6-2012.04 (EXPERIMENTAL) compiler". You're free to choose a different one but this one works well. We do recommend the Linaro versions over the vanilla ones for the RPi
  • (Optional) Enable "C++" under the group "*** Additional supported languages: ***" if you need g++ tool also built for your RPi toolchain

Now, exit the configuration tool, save your changes and run:

costruzione ct-ng

This will take some time and when it finishes, you should have an ARM compiler, in the "Prefix directory" that you chose above - "/opt/cross/x-tools/${CT_TARGET}", ready to build anything for your RPi. One final step is to add that directory to your PATH:

export PATH=$PATH:/opt/cross/x-tools/arm-unknown-linux-gnueabi/bin

It also might help to export one more important environment variable CCPREFIX:

export CCPREFIX="/opt/cross/x-tools/arm-unknown-linux-gnueabi/bin/arm-unknown-linux-gnueabi-"

Quick test of the toolchain

Let's make a quick sanity check of our ARM compiler:

$ braccio-sconosciuto-linux-gnueabi-gcc --versione
braccio-sconosciuto-linux-gnueabi-gcc (crosstool-NG 1.15.2) 4.6.4 20120402 (prerelease)
Copyright (C) 2011 Free Software Foundation, Inc.
Questo è il software libero; vedere la fonte per copiare le condizioni.  Non c'è nessun
garanzia; nemmeno per COMMERCIABILITÀ o FITNESS PER UNO SCOPO PARTICOLARE.

$ gatto > test.c
#include <stdio.h>
int main() { printf("Ciao, mondo! \n"); ritorno 0; }
^D

$ braccio-sconosciuto-linux-gnueabi-gcc -o test test.c

Copia il binario "test" nel tuo RPi ed eseguilo. Dovrebbe mostrare un familiare "Ciao, mondo!" testo.

Compilazione di librerie aggiuntive necessarie per FFmpeg

This section will describe how to compile some common libraries that are usually used by FFmpeg, like libx264 or libaacplus, etc.

Compilazione di libaacplus

cd /my/path/where/i/keep/my/source/code
wget http://217.20.164.161/~tipok/aacplus/libaacplus-2.0.2.tar.gz
tar -xzf libaacplus-2.0.2.tar.gz
cd libaacplus-2.0.2
./autogen.sh --con-parametro-espansione-string-replace-capable-shell=/bin/bash --host=arm-unknown-linux-gnueabi --enable-static --prefix=/my/path/were/i/keep/built/arm/stuff
fare
fare installazione

Dopo aver terminato, tutte le librerie e i binari saranno installati in "/my/path/were/i/keep/built/arm/stuff", quindi se stai compilando alcune librerie come dipendenze per altre cose, molto probabilmente farai riferimento a questa directory in seguito utilizzando:

cd /my/path/where/i/keep/my/source/code
cd my_other_biblioteca
CFLAGS="-I/my/path/were/i/keep/built/arm/stuff/include" LDFLAGS="-L/my/path/were/i/keep/built/arm/stuff/libs" ./configure ... --prefix=...
fare
fare installazione

In questo modo stai dicendo al compilatore dove sono le dipendenze, che hai anche compilato per RPi, che si trova, al fine di compilare con successo anche quella "altra libreria".

Compilazione di libx264

cd /my/path/where/i/keep/my/source/code
git clone git://git.videolan.org/x264
cd x264
./configure --host=arm-unknown-linux-gnueabi --enable-static --cross-prefix=${CCPREFIX} --prefix=/my/path/were/i/keep/built/arm/stuff --extra-cflags='-march=armv6' --extra-ldflags='-march=armv6'
fare
fare installazione

Si noti che usiamo la variabile d'ambiente CCPREFIX qui, per specificare il prefisso di tutti gli strumenti in una toolchain, da utilizzare per questa build (istruisce la shell a non chiamare cc, gcc, g++ e altri strumenti standard, ma piuttosto a chiamare /opt/cross/cross/x-tools/arm-unknown-linux-gnueabi/bin/arm-unknown-linux-gnueabi-cc, /opt/

Compilazione della biblioteca ALSA

cd /my/path/where/i/keep/my/source/code
leggi http://mirrors.zerg.biz/alsa/lib/alsa-lib-1.0.25.tar.bz2
catrame xjf alsa-lib-1.0.25.tar.bz2
cd alsa-lib-1.0.25/
./configure --host=arm-unknown-linux-gnueabi --prefix=/my/path/were/i/keep/built/arm/stuff
fare
fare installazione

Compilazione di Fmpeg

Questa parte è la stessa per tutti gli esempi successivi:

cd /my/path/where/i/keep/my/source/code
git clone git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg

Base FFmpeg, senza librerie aggiuntive

./configure --enable-cross-compile --cross-prefix=${CCPREFIX} --arch=armel --target-os=linux --prefix=/my/path/were/i/keep/built/arm/stuff
fare
fare installazione

FFmpeg con libaacplus, libx264 e alsa-lib

./configure --enable-cross-compile --cross-prefix=${CCPREFIX} --arch=armel --target-os=linux --prefix=/my/path/were/i/keep/built/arm/stuff --enable-gpl --enable-libx264 --enable-nonfree --enable-libacplus --extra-cflags="-I/my/
fare
fare installazione

Inoltre, se alcune biblioteche dipendono da pkg-config, molto probabilmente sarai in grado di risolverlo usando la variabile d'ambiente PKG_CONFIG_PATH, come questo:

pkg_config=$(che pkg-config) PKG_CONFIG_PATH=/my/path/were/i/keep/built/arm/stuff/lib/pkgconfig ./configure ...

più

Conclusione

Dopo aver costruito il tuo FFmpeg per RPi, copia ffmpeg, ffplaye ffserverbinari da "/my/path/were/i/keep/built/arm/stuff/bin/" al vostro Raspberry Pi e provarlo per vedere come funziona :)

Una nota importante, che potrebbe farti risparmiare giorni di mal di testa è che RPi è un hardware molto ottimizzato, che consuma pochissima potenza e fornisce anche pochissima potenza alle sue porte USB, quindi se hai intenzione di collegare qualsiasi disco USB esterno, fotocamere, dongle USB wireless / audio / ecc, tieni presente di collegare tutte queste periferiche USB attraverso un hub USB autoalimentato, che può fornire abbastanza potenza per i dispositivi per funzionare correttamente, quindi il tuo RPi

Buona fortuna per tutto questo.