Informações específicas da plataforma

1 Semelhante ao Unix

Algumas partes do FFmpeg não podem ser compiladas com a versão 2.15 do assembler do GNU, que algumas distribuições AMD64 ainda fornecem. Para garantir que seu compilador realmente usa a versão necessária do gas após uma atualização do binutils, execute:

$(gcc -print-prog-name=as) --version

Caso contrário, instale um compilador diferente que não tenha um caminho fixo para o gas. No pior caso, passe --disable-asm para o configure.

1.1 Configuração avançada de vinculação

Se você compilou as bibliotecas do FFmpeg de forma estática e quer usá-las para criar sua própria biblioteca compartilhada, pode ser necessário forçar o suporte a PIC (com --enable-pic durante o configure do FFmpeg) e adicionar a seguinte opção ao LDFLAGS do seu projeto:

-Wl,-Bsymbolic

Se sua plataforma de destino exigir binários independentes de posição, você deve passar a flag de vinculação correta (por exemplo, -pie) para --extra-ldexeflags.

1.2 BSD

O make do BSD não compila o FFmpeg: você precisa instalar e usar o GNU Make (gmake).

1.3 (Open)Solaris

Compilar o FFmpeg exige o GNU Make, então você precisa invocá-lo com (gmake); o Make padrão do Solaris não funciona. Ao compilar com um front-end sem suporte a c99 (gcc, o suncc genérico), adicione --extra-libs=/usr/lib/values-xpg6.o ou --extra-libs=/usr/lib/64/values-xpg6.o às opções do configure, já que a libc não é compatível com c99 por padrão. As verificações realizadas pelo configure podem gerar uma exceção que provoca a interrupção do próprio configure, devido a um bug no shell do sistema. Para contornar isso, basta invocar diretamente outro shell, como o bash:

bash ./configure

1.4 Darwin (Mac OS X, iPhone)

O toolchain fornecido com o Xcode é suficiente para compilar o código básico sem aceleração.

O Mac OS X em PowerPC ou ARM (iPhone) exige um pré-processador de https://github.com/FFmpeg/gas-preprocessor ou https://github.com/yuvi/gas-preprocessor (atualmente desatualizado) para compilar as funções de assembly otimizadas. Coloque o script Perl em algum lugar do seu PATH; o configure do FFmpeg o detectará automaticamente.

O Mac OS X em amd64 e x86 exige o nasm para compilar a maior parte das funções de assembly otimizadas. Fink, Gentoo Prefix, Homebrew ou MacPorts podem fornecê-lo facilmente.

2 DOS

Por vários motivos, prefere-se usar um compilador cruzado. http://www.delorie.com/howto/djgpp/linux-x-djgpp.html

3 OS/2

Para obter informações sobre como compilar o FFmpeg no OS/2, consulte http://www.edm2.com/index.php/FFmpeg.

4 Windows

4.1 Compilação nativa no Windows usando MinGW ou MinGW-w64

O FFmpeg pode ser compilado para ser executado nativamente no Windows usando o toolchain MinGW-w64. Instale as versões mais recentes do MSYS2 e do MinGW-w64 em http://msys2.github.io/ e/ou http://mingw-w64.sourceforge.net/. Você encontrará instruções de instalação detalhadas na seção de downloads e no FAQ.

Notas:

Compilar para o ambiente MSYS não é recomendado: o MSYS2 oferece um ambiente MinGW-w64 completo através do mingw64_shell.bat ou do mingw32_shell.bat, que deve ser usado em vez do ambiente fornecido pelo msys2_shell.bat.
Compilar usando o MSYS2 pode ser acelerado desativando as regras implícitas do Makefile, chamando make -r em vez do make simples. Esse ganho de velocidade é quase imperceptível em compilações normais de uma única vez e só é notado ao executar o make pela segunda vez (por exemplo, durante o make install).
Para compilar o FFplay, você precisa ter instalada a biblioteca de desenvolvimento MinGW do SDL e o pkg-config.
Usando ./configure --enable-shared ao configurar o FFmpeg, você pode compilar as bibliotecas do FFmpeg (por exemplo, libavutil, libavcodec, libavformat) como DLLs.

4.1.1 Compilação nativa no Windows usando MSYS2

O ambiente MinGW-w64 do MSYS2 oferece toolchains e dependências prontos para uso através do pacman.

Certifique-se de usar mingw64_shell.bat ou mingw32_shell.bat para ter o ambiente MinGW-w64 correto. A instalação padrão fornece atalhos para eles em MinGW-w64 Win64 Shell e MinGW-w64 Win32 Shell.

# normal msys2 packages
pacman -S make pkgconf diffutils

# mingw-w64 packages and toolchains
pacman -S mingw-w64-x86_64-nasm mingw-w64-x86_64-gcc mingw-w64-x86_64-SDL2

Para atingir 32 bits, substitua x86_64 por i686 no comando acima.

4.2 Microsoft Visual C++ ou Intel C++ Compiler para Windows

O FFmpeg pode ser compilado com o MSVC 2013 ou posterior.

Você precisará dos seguintes pré-requisitos:

MSYS2
NASM (também disponível através do gerenciador de pacotes do MSYS2.)

Para configurar um ambiente adequado no MSYS2, você precisa executar o msys_shell.bat a partir do prompt de comando do Visual Studio ou do Intel Compiler.

Coloque o nasm.exe em algum lugar do seu PATH.

Em seguida, certifique-se de que quaisquer outros cabeçalhos e bibliotecas que você queira usar, como a zlib, estejam em um local visível ao compilador. Para isso, modifique as variáveis de ambiente LIB e INCLUDE para incluir os caminhos no estilo Windows desses diretórios. Como alternativa, você pode tentar usar as opções do configure --extra-cflags/--extra-ldflags.

Por fim, execute:

For MSVC:
./configure --toolchain=msvc

For ICL:
./configure --toolchain=icl

make
make install

Se você quiser compilar bibliotecas compartilhadas, adicione --enable-shared às opções do configure. Observe que, devido à forma como o MSVC e o ICL lidam com importações e exportações de DLL, não é possível compilar bibliotecas estáticas e compartilhadas ao mesmo tempo: habilitar as compartilhadas desativa automaticamente as estáticas.

Notas:

Se você quiser compilar com suporte a zlib, precisará obter em algum lugar um binário zlib compatível, com uma import lib do MSVC, ou, se preferir vincular estaticamente, pode seguir as instruções abaixo para compilar um zlib.lib compatível com o MSVC. Seja qual for o método usado, você ainda deve seguir a etapa 3, ou a compilação falhará.
1. Obtenha as fontes da zlib.
2. Edite o win32/Makefile.msc para que use -MT em vez de -MD, já que é assim que o FFmpeg também é compilado.
3. Edite zconf.h e remova a inclusão de unistd.h. Isso é incluído por engano ao compilar o FFmpeg.
4. Execute nmake -f win32/Makefile.msc.
5. Mova zlib.lib, zconf.h e zlib.h para um local que o MSVC possa ver.
O FFmpeg foi testado com o seguinte em i686 e x86_64:
- Visual Studio 2013 Pro e Express
- Intel Composer XE 2013
- Intel Composer XE 2013 SP1

Qualquer outra combinação não é oficialmente compatível.

4.2.1 Vinculação ao FFmpeg com o Microsoft Visual C++

Se você for vincular com bibliotecas estáticas compiladas com o MSVC, precisará garantir que Runtime Library esteja configurado como Multi-threaded (/MT) nas configurações do seu projeto.

Você precisará definir inline como algo que o MSVC entenda:

#define inline __inline

Observe também que, conforme indicado em Microsoft Visual C++, você precisará de um inttypes.h compatível com o MSVC.

Se você for usar bibliotecas de importação criadas com o dlltool, precisará definir References como No (/OPT:NOREF) nas configurações de otimização do vinculador; caso contrário, os binários resultantes falharão em tempo de execução. Isso não é necessário ao usar bibliotecas de importação geradas pelo lib.exe. Esse problema está registrado no projeto original em http://sourceware.org/bugzilla/show_bug.cgi?id=12633.

Para criar bibliotecas de importação que funcionem com a opção /OPT:REF (habilitada por padrão no modo Release), siga estas etapas:

Abra o prompt de comando do Visual Studio.

Como alternativa, em um prompt de comando normal, chame vcvars32.bat, que configura as variáveis de ambiente das ferramentas do Visual C++ (o local padrão desse arquivo costuma ser algo como C:\Program Files (x86_\Microsoft Visual Studio 10.0\VC\bin\vcvars32.bat).

Entre no diretório bin onde os arquivos LIB e DLL gerados são armazenados.

Gere novas bibliotecas de importação com lib.exe:

 lib /machine:i386 /def:..\lib\foo-version.def  /out:foo.lib

Substitua foo-version e foo pelos nomes das bibliotecas correspondentes.

4.3 Compilação cruzada para Windows com Linux

Você deve usar as ferramentas de compilação cruzada do MinGW disponíveis em http://www.mingw.org/.

Em seguida, configure o FFmpeg com as seguintes opções:

./configure --target-os=mingw32 --cross-prefix=i386-mingw32msvc-

(você pode alterar o cross-prefix de acordo com o prefixo escolhido para as ferramentas do MinGW).

Depois disso, você pode testar o FFmpeg facilmente com o Wine.

4.4 Compilação no Cygwin

Use o Cygwin 1.7.x, já que as versões obsoletas 1.5.x do Cygwin não têm llrint() na sua biblioteca C.

Instale o Cygwin com todos os pacotes "Base", mais os seguintes pacotes "Devel":

binutils, gcc4-core, make, git, mingw-runtime, texinfo

Para executar o FATE, você também precisará dos seguintes pacotes "Utils":

diffutils

Se quiser compilar o FFmpeg com bibliotecas adicionais, baixe os pacotes "Devel" do Cygwin para Ogg e Vorbis de qualquer repositório de pacotes do Cygwin:

libogg-devel, libvorbis-devel

Estes pacotes de bibliotecas só estão disponíveis em Cygwin Ports:

libSDL-devel, libgsm-devel, libmp3lame-devel,
speex-devel, libtheora-devel, libxvidcore-devel

Para o x264, a recomendação é compilar a partir do código-fonte, já que ele evolui rápido demais para o Cygwin Ports se manter atualizado.

4.5 Compilação cruzada para Windows no Cygwin

Com o Cygwin, você pode criar binários do Windows que não precisam do cygwin1.dll.

Instale o Cygwin como explicado antes, mais estes pacotes "Devel" adicionais:

gcc-mingw-core, mingw-runtime, mingw-zlib

e adicione algumas flags especiais à sua chamada do configure.

Para uma compilação estática, execute

./configure --target-os=mingw32 --extra-cflags=-mno-cygwin --extra-libs=-mno-cygwin

e para uma compilação com bibliotecas compartilhadas

./configure --target-os=mingw32 --enable-shared --disable-static --extra-cflags=-mno-cygwin --extra-libs=-mno-cygwin

4.6 ARM64EC

O FFmpeg não pretende oferecer suporte à configuração de compilação ARM64EC do Windows; patches que alterem as bibliotecas individuais para fins de ARM64EC não serão aceitos.

Ainda assim, pode ser possível compilar o FFmpeg nessa configuração; uma compilação desse tipo pode até parecer funcionar em certa medida. No entanto, ela pode apresentar algumas inconsistências de ABI que não estamos dispostos a corrigir.

(Adaptar o código assembly do aarch64 para oferecer suporte estrito ao ARM64EC exigiria usar ifdef ou alterar praticamente todo esse código, o que representaria um enorme ônus de manutenção. Além disso, alterar as superfícies de ABI da biblioteca para corrigir as inconsistências poderia exigir mudanças extensas e invasivas.)

Hospedagem fornecida por telepoint.bg