Isso é mais fácil dizer do que fazer e levei mais de um mês para descobrir como fazer sem problemas, mas gastei tempo suficiente nisso e decidi documentar o processo bem o suficiente para ser concluído praticamente sem problemas por alguém me seguindo.

Infelizmente, a cadeia de ferramentas padrão do Cygwin (ou seja, o gcc-corepacote incluído com o instalador do Cygwin) é inerentemente quebrada para fins de compilação cruzada, e não parece haver nenhuma intenção dos mantenedores do Cygwin de consertar isso, então atualmente, a única maneira de compilar software para Windows com Cygwin é configurar uma cadeia de ferramentas MinGW-w64 sob ele. Felizmente, isso é tão fácil quanto instalar alguns pacotes. Depois disso, compilaremos os pacotes restantes, antes de usar uma combinação de ambos para compilar o próprio FFmpeg.

Usando este guia

Seguir este guia na íntegra criará uma instalação estática do FFmpeg com bibliotecas externas, como , fdk-aace o resampler SOX. Posso considerar adicionar instruções para compilar bibliotecas externas específicas ao guia se receber solicitações suficientes para fazer isso para uma biblioteca específica.libopusx265

As dependências usadas por este guia - compostas pela própria cadeia de ferramentas de compilação cruzada MinGW-w64, todos os pacotes instalados por apt-cyge todos os pacotes compilados a partir do código-fonte - consumirão até 2,8 GB de espaço em disco, embora o guia também inclua comandos para limpar tudo, exceto a instalação do FFmpeg, uma vez concluída. A própria instalação, composta pelos binários e documentação, ocupa pouco mais de 200 MB de espaço em disco.

Este guia criará uma pasta em seu diretório Home chamada ffmpeg_sources, onde fará o download e compilará todos os pacotes que estão sendo compilados a partir do código-fonte. O FFmpeg será instalado em /usr/local, onde o padrão FHS recomenda que o software compilado pelo usuário seja instalado. Esse local também tem a vantagem secundária de estar no sistema PATHpor padrão no Cygwin e, portanto, não requer que a $PATHvariável de ambiente seja atualizada.

Instalar dependências do gerenciador de pacotes

Para começar, baixe a versão mais recente do instalador do Cygwin para instalar os pacotes wget, tare . A boa notícia é que esses pacotes são dependências de uma ferramenta que pode impedir que você precise usar o instalador do Cygwin novamente.gawkgit

Instale o apt-cyggerenciador de pacotes

Em seguida, instale o fork de kou1okada do gerenciador de pacotes apt-cyg . Se você atualmente não usa um gerenciador de pacotes para o Cygwin, esta etapa não apenas facilitará o restante do guia, mas também fará com que sua experiência com o Cygwin rivalize com a de qualquer distribuição Linux.

Mesmo se você já usa um gerenciador de pacotes para Cygwin, como um fork diferente do original apt-cyg, eu recomendo que você o substitua por este, que é um software muito mais completo em comparação com o original, bem como o único gerenciador de pacotes para Cygwin que está atualmente em desenvolvimento ativo.

Para instalar o kou1okada apt-cyg:

mkdir -p /usr/local/src &&
cd /usr/local/src &&
git clone https://github.com/kou1okada/apt-cyg.git &&
ln -s "$(realpath apt-cyg/apt-cyg)" /usr/local/bin/

Instalar ferramentas de compilação e configurar o compilador cruzado MinGW-w64

apt-cyg install \
autoconf \
automake \
binutils \
cmake \
doxygen \
git \
libtool \
make \
mercurial \
mingw64-x86_64-SDL2 \
mingw64-x86_64-binutils \
mingw64-x86_64-fribidi \
mingw64-x86_64-gcc-core \
mingw64-x86_64-gcc-g++ \
mingw64-x86_64-headers \
mingw64-x86_64-libtheora \
mingw64-x86_64-libvpx \
mingw64-x86_64-runtime \
mingw64-x86_64-win-iconv \
mingw64-x86_64-windows-default-manifest \
mingw64-x86_64-zlib \
nasm \
pkg-config \
subversion \
texinfo \
yasm

Compile as dependências

Cada seção abaixo compila uma biblioteca externa que permitirá compilar o FFmpeg com suporte para essa biblioteca habilitada. Copie e cole todo o comando em seu shell.

Se você decidir que não precisa que sua compilação do FFmpeg suporte uma determinada biblioteca, pule sua seção e remova a linha correspondente ao compilar o FFmpeg no estágio final deste guia.--enable-package

Crie um diretório na raiz da instalação do Cygwin com o seguinte:

rm -rf /ffmpeg_sources &&
mkdir -p /ffmpeg_sources

Este é o diretório para o qual faremos o download do nosso código-fonte e de onde o compilaremos.

libmp3lame

Para compilar o codec de áudio LAME para MP3:

cd /ffmpeg_sources && rm -rf lame-svn &&
svn checkout https://svn.code.sf.net/p/lame/svn/trunk/lame lame-svn &&
cd lame-svn &&
./configure --host=x86_64-w64-mingw32 --prefix="/usr/x86_64-w64-mingw32/sys-root/mingw" \
--enable-static --disable-shared &&
make -j$(nproc) &&
make install 

libx264

Para compilar o codec de vídeo x264:

cd /ffmpeg_sources && rm -rf x264 && 
git clone --depth 1 https://code.videolan.org/videolan/x264.git && 
cd x264 &&
./configure --cross-prefix=x86_64-w64-mingw32- --host=x86_64-w64-mingw32 \
--prefix="/usr/x86_64-w64-mingw32/sys-root/mingw" --enable-static &&
make -j$(nproc) &&
make install 

libx265

Para compilar o codec de vídeo x265:

cd /ffmpeg_sources && rm -rf x265 && 
hg clone https://bitbucket.org/multicoreware/x265 &&
cd x265/build/linux &&
cmake -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX="/usr/x86_64-w64-mingw32/sys-root/mingw" \
-DENABLE_SHARED=OFF -DCMAKE_EXE_LINKER_FLAGS="-static" ../../source \
-DCMAKE_TOOLCHAIN_FILE="/ffmpeg_sources/x265/build/msys/toolchain-x86_64-w64-mingw32.cmake" &&
make -j$(nproc) &&
make install

libogg/libvorbis

O formato Ogg é uma dependência do codec de áudio Vorbis, portanto, precisará ser compilado antes dele:

cd /ffmpeg_sources && rm -rf ogg &&
git clone --depth 1 https://gitlab.xiph.org/xiph/ogg.git &&
cd ogg && ./autogen.sh &&
./configure --host=x86_64-w64-mingw32 --prefix="/usr/x86_64-w64-mingw32/sys-root/mingw" \
--enable-static --disable-shared &&
make -j$(nproc) &&
make install

Em seguida, compile o Vorbis normalmente:

cd /ffmpeg_sources && rm -rf vorbis && 
git clone --depth 1 https://gitlab.xiph.org/xiph/vorbis.git &&
cd vorbis && ./autogen.sh &&
./configure --host=x86_64-w64-mingw32 --prefix="/usr/x86_64-w64-mingw32/sys-root/mingw" \
--enable-static --disable-shared &&
make -j$(nproc) &&
make install

libaom

Para compilar o codificador de vídeo AV1:

cd /ffmpeg_sources && rm -rf aom && 
git clone --depth 1 https://aomedia.googlesource.com/aom && 
mkdir -p /ffmpeg_sources/aom/build && cd /ffmpeg_sources/aom/build && 
cmake -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX="/usr/x86_64-w64-mingw32/sys-root/mingw" \
-DCMAKE_EXE_LINKER_FLAGS="-static" .. \
-DCMAKE_TOOLCHAIN_FILE="/ffmpeg_sources/aom/build/cmake/toolchains/x86_64-mingw-gcc.cmake" && 
make -j$(nproc) && 
make install

libopus

Para compilar o codificador de áudio Opus:

cd /ffmpeg_sources && rm -rf opus && 
git clone --depth 1 https://github.com/xiph/opus.git &&
cd opus && ./autogen.sh &&
./configure CFLAGS="-I/usr/local/llsp" --host=x86_64-w64-mingw32 --prefix="/usr/x86_64-w64-mingw32/sys-root/mingw" \
--enable-static --disable-shared &&
make -j$(nproc) &&
make install

libfdk-aac

Para compilar o codificador Fraunhofer FDK para AAC:

cd /ffmpeg_sources && rm -rf fdk-aac && 
git clone --depth 1 https://github.com/mstorsjo/fdk-aac &&
cd fdk-aac && autoreconf -fiv &&
./configure --host=x86_64-w64-mingw32 --prefix="/usr/x86_64-w64-mingw32/sys-root/mingw" \
--enable-static --disable-shared &&
make -j$(nproc) &&
make install 

libsoxr

Para compilar a biblioteca do reamostrador SOX, você primeiro precisará criar um arquivo de cadeia de ferramentas CMAKE para a cadeia de ferramentas MinGW-w64, pois o projeto não inclui um por padrão.

Crie um novo arquivo no diretório raiz do Cygwin e chame-o toolchain-x86_64-mingw32.cmake(verifique se o Windows está mostrando as extensões e se a extensão é .cmake).

Copie e cole o seguinte no arquivo:

SET(CMAKE_SYSTEM_NAME Windows)
SET(CMAKE_C_COMPILER /usr/bin/x86_64-w64-mingw32-gcc)
SET(CMAKE_CXX_COMPILER /usr/bin/x86_64-w64-mingw32-g++)
SET(CMAKE_RC_COMPILER /usr/bin/x86_64-w64-mingw32-windres)
SET(CMAKE_Fortran_COMPILER /usr/bin/x86_64-w64-mingw32-gfortran)
SET(CMAKE_AR:FILEPATH /usr/bin/x86_64-w64-mingw32-ar)
SET(CMAKE_RANLIB:FILEPATH /usr/bin/x86_64-w64-mingw32-ranlib)
SET(CMAKE_FIND_ROOT_PATH /usr/x86_64-w64-mingw32)
SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
SET(QT_BINARY_DIR /usr/x86_64-w64-mingw32/bin /usr/bin)
SET(Boost_COMPILER -gcc47)

Agora você pode compilar o reamostrador SOX normalmente:

cd /ffmpeg_sources && rm -rf soxr &&  
git clone --depth 1 https://git.code.sf.net/p/soxr/code soxr &&
mkdir -p soxr/build && cd soxr/build &&
cmake -Wno-dev -DCMAKE_BUILD_TYPE=Release \
-DCMAKE_INSTALL_PREFIX="/usr/x86_64-w64-mingw32/sys-root/mingw" \
-DBUILD_SHARED_LIBS=OFF .. -DCMAKE_TOOLCHAIN_FILE="/toolchain-x86_64-mingw32.cmake" &&
make -j$(nproc) &&
make install

Compilar o binário FFmpeg

Resta apenas compilar o próprio FFmpeg, usando as bibliotecas baixadas ou compiladas acima:

cd /ffmpeg_sources && rm -rf ffmpeg &&
wget -O ffmpeg-snapshot.tar.bz2 https://ffmpeg.org/releases/ffmpeg-snapshot.tar.bz2 &&
tar xvf ffmpeg-snapshot.tar.bz2 && rm -f ffmpeg-snapshot.tar.bz2 && cd ffmpeg &&
CFLAGS=-I/usr/x86_64-w64-mingw32/sys-root/mingw/include &&
LDFLAGS=-L/usr/x86_64-w64-mingw32/sys-root/mingw/lib &&
export PKG_CONFIG_PATH= &&
export PKG_CONFIG_LIBDIR=/usr/x86_64-w64-mingw32/sys-root/mingw/lib/pkgconfig &&
./configure \
--arch=x86_64 \
--target-os=mingw32 \
--cross-prefix=x86_64-w64-mingw32- \
--prefix=/usr/local \
--pkg-config=pkg-config \
--pkg-config-flags=--static \
--extra-cflags=-static \
--extra-ldflags=-static \
--extra-libs="-lm -lz -fopenmp" \
--enable-static \
--disable-shared \
--enable-nonfree \
--enable-gpl \
--enable-avisynth \
--enable-libaom \
--enable-libfdk-aac \
--enable-libfribidi \
--enable-libmp3lame \
--enable-libopus \
--enable-libsoxr \
--enable-libvorbis \
--enable-libvpx \
--enable-libx264 \
--enable-libx265 &&
make -j$(nproc) &&
make install

Lembre-se de remover --enable-\*package\*as linhas de cada pacote na lista acima para o qual você não baixou ou compilou uma biblioteca.

A compilação do FFmpeg levará muito mais tempo do que a compilação das bibliotecas externas, mas, uma vez concluída, você deve ter um binário totalmente funcional ativado com todas as bibliotecas com as quais você o compilou. Para executá-lo, basta executar ffmpegno terminal Cygwin.

Limpar/desinstalar

A essa altura do guia, você terá ocupado cerca de 2,8 GB de espaço em disco com download, instalação e compilação. A maior parte disso agora é redundante e deve ser limpa. Mais de 2,6 GB dele podem ser eliminados com segurança, o que reduz a pegada total de nossa instalação FFmpeg para apenas 200 MB.

Limpeza pós-instalação

A execução do seguinte liberará mais de 2,3 GB de espaço em disco:

apt-cyg remove \
cmake \
doxygen \
git \
mercurial \
subversion \
texinfo \
yasm &&
rm -rf /ffmpeg_sources &&
rm -rf /usr/local/lib/{libav*,libpost*,libsw*} &&
rm -rf /usr/local/lib/pkgconfig/{libav*,libpost*,libsw*} &&
rm -rf /usr/local/include/{libav*,libpost*,libsw*} &&
rm -rf /toolchain-x86_64-mingw32.cmake

As well as removing the ffmpeg_sources directory and unneeded static libraries, this will also remove any packages installed earlier that are no longer needed, except for those that are commonly needed for building tools on Cygwin/Linux.

Remove the cross-compiler

If you no longer intend to compile any other programs using the MinGW-w64 cross-compiling toolchain built earlier in this guide, you can safely uninstall it, as well as all the remaining packages installed earlier:

apt-cyg remove \
autotools \
autoconf \
automake \
gcc-core \
gcc-g++ \
pkg-config \
libtool \
make \
nasm \
mingw64-x86_64-SDL2 \
mingw64-x86_64-binutils \
mingw64-x86_64-fribidi \
mingw64-x86_64-gcc-core \
mingw64-x86_64-gcc-g++ \
mingw64-x86_64-headers \
mingw64-x86_64-libtheora \
mingw64-x86_64-libvpx \
mingw64-x86_64-runtime \
mingw64-x86_64-win-iconv \
mingw64-x86_64-windows-default-manifest \
mingw64-x86_64-zlib &&
rm -rf /usr/x86_64-w64-mingw32

This will free up an additional ~450 MB of space.

Uninstalling FFmpeg

If you ever need to reverse all of the steps in this guide and purge the FFmpeg binaries from your system, simply run the following:

apt-cyg remove \
autotools \ 
autoconf \
automake \
binutils \
cmake \
doxygen \
gcc-core \
gcc-g++ \
git \
libtool \
make \
mercurial \
mingw64-x86_64-SDL2 \
mingw64-x86_64-binutils \
mingw64-x86_64-fribidi \
mingw64-x86_64-gcc-core \
mingw64-x86_64-gcc-g++ \
mingw64-x86_64-headers \
mingw64-x86_64-libtheora \
mingw64-x86_64-libvpx \
mingw64-x86_64-runtime \
mingw64-x86_64-win-iconv \
mingw64-x86_64-windows-default-manifest \
mingw64-x86_64-zlib \
nasm \
pkg-config \
subversion \
texinfo \
yasm &&
rm -rf /ffmpeg_sources &&
rm -rf /usr/local/bin{ffmpeg,ffprobe,ffplay} &&
rm -rf /usr/local/lib/{libav*,libpost*,libsw*} &&
rm -rf /usr/local/lib/pkgconfig/{libav*,libpost*,libsw*} &&
rm -rf /usr/local/include/{libav*,libpost*,libsw*} &&
rm -rf /usr/local/share/doc/ffmpeg &&
rm -rf /usr/local/share/ffmpeg &&
rm -rf /usr/local/share/man/man1/ff* &&
rm -rf /usr/local/share/man/man3/{libav*,libpost*,libsw*} &&
rm -rf /usr/x86_64-w64-mingw32/ &&
rm -rf /toolchain-x86_64-mingw32.cmake 

This will remove everything installed during the process of this guide, and revert your system to exactly how it was before starting it.

Instead of doing everything manually, you can use the media-autobuild_suite for Windows, which builds FFmpeg with almost all of its dependencies:

This Windows Batchscript setups a MinGW/GCC compiler environment for building ffmpeg and other media tools under Windows. After building the environment it retrieves and compiles all tools. All tools get static compiled, no external .dlls needed (with some optional exceptions)

The script gets continuously updated, and for most users, it will be the preferred way to get FFmpeg compiled under Windows.