Usando FFmpeg para codificar um vídeo para h264 usando Intel QuickSync

Preste atenção na saída do console:

[AVHWDeviceContext @ 0x556f744cf5c0] VAAPI driver: Intel i965 driver for Intel(R) Skylake - 2.1.0.
[AVHWDeviceContext @ 0x556f744cf5c0] Driver not found in known nonstandard list, using standard behaviour.
[AVHWDeviceContext @ 0x556f744cf140] Error initializing an MFX session: -3.
Device creation failed: -1313558101.
Failed to set value 'qsv=hw' for option 'init_hw_device': Unknown error occurred

Isso ocorre porque você está usando o driver VAAPI errado para QuickSync. O driver correto deve ser definido como o driver de mídia inteliHD , pois você está usando o SDK de mídia para QuickSync e não os codificadores baseados em VAAPI.

Vou documentar as etapas necessárias para derivar uma compilação FFmpeg com os recursos necessários (QuickSync) com suporte para codecs extras conforme necessário, com notas extras sobre o uso do driver correto abaixo:

Verifique se a plataforma está atualizada:

Percebi que você está no Ubuntu 18.04 LTS, então estas instruções servirão:

sudo apt update && sudo apt -y upgrade && sudo apt -y dist-upgrade

Instale as dependências da linha de base primeiro:

sudo apt-get -y install autoconf automake build-essential libass-dev libtool pkg-config texinfo zlib1g-dev libva-dev cmake mercurial libdrm-dev libvorbis-dev libogg-dev git libx11-dev libperl-dev libpciaccess-dev libpciaccess0 xorg-dev intel-gpu-tools libwayland-dev xutils-dev libssl-dev

Em seguida, adicione o Oibaf PPA, necessário para instalar os cabeçalhos de desenvolvimento mais recentes para libva:

sudo add-apt-repository ppa:oibaf/graphics-drivers
sudo apt-get update && sudo apt-get -y upgrade && sudo apt-get -y dist-upgrade

Para resolver problemas de linker na linha com o Ubuntu 18.04LTS:

Atualização: isso não é mais necessário, mas permanece para referência futura.

Referindo-se a isso: https://forum.openframeworks.cc/t/ubuntu-unable-to-compile-missing-glx-mesa/29367/2

Crie o seguinte link simbólico como mostrado:

sudo ln -s /usr/lib/x86_64-linux-gnu/libGLX_mesa.so.0 /usr/lib/x86_64-linux-gnu/libGLX_mesa.so

Crie a libva mais recente e todos os drivers da fonte:

Ambiente de compilação de configuração:

Inicialização do espaço de trabalho:

mkdir -p ~/vaapi
mkdir -p ~/ffmpeg_build
mkdir -p ~/ffmpeg_sources
mkdir -p ~/bin

Comece com libva:

1. Libva:

Libva é uma implementação para VA-API (API de aceleração de vídeo)

VA-API é uma biblioteca de código aberto e especificação de API, que fornece acesso a recursos de aceleração de hardware gráfico para processamento de vídeo. Ele consiste em uma biblioteca principal e back-ends de aceleração específicos do driver para cada fornecedor de hardware suportado. É um pré-requisito para construir os componentes do driver VAAPI abaixo.

cd ~/vaapi
git clone https://github.com/01org/libva
cd libva
./autogen.sh --prefix=/usr --libdir=/usr/lib/x86_64-linux-gnu
time make -j$(nproc) VERBOSE=1
sudo make -j$(nproc) install
sudo ldconfig -vvvv

2. Gmmlib:

A biblioteca de gerenciamento de memória gráfica Intel(R) fornece gerenciamento específico de dispositivo e buffer para o Intel(R) Graphics Compute Runtime para OpenCL(TM) e o driver de mídia Intel(R) para VAAPI.

O componente é um pré-requisito para a etapa de compilação do driver Intel Media abaixo.

Para compilar isso, crie um diretório de espaço de trabalho dentro do subdiretório vaapi e execute a compilação:

mkdir -p ~/vaapi/workspace
cd ~/vaapi/workspace
git clone https://github.com/intel/gmmlib
mkdir -p build
cd build
cmake -DCMAKE_BUILD_TYPE= Release ../gmmlib
make -j$(nproc)

Em seguida, instale o pacote:

sudo make -j$(nproc) install 

E prossiga.

3. Driver de mídia Intel:

O driver de mídia Intel(R) para VAAPI é um novo driver de modo de usuário VA-API (API de aceleração de vídeo) compatível com decodificação acelerada por hardware, codificação e pós-processamento de vídeo para hardware gráfico baseado em GEN, lançado sob a licença MIT.

cd ~/vaapi/workspace
git clone https://github.com/intel/media-driver
cd media-driver
git submodule init
git pull
mkdir -p ~/vaapi/workspace/build_media
cd ~/vaapi/workspace/build_media

Configure o projeto com cmake:

cmake ../media-driver \
-DMEDIA_VERSION="2.0.0" \
-DBS_DIR_GMMLIB=$PWD/../gmmlib/Source/GmmLib/ \
-DBS_DIR_COMMON=$PWD/../gmmlib/Source/Common/ \
-DBS_DIR_INC=$PWD/../gmmlib/Source/inc/ \
-DBS_DIR_MEDIA=$PWD/../media-driver \
-DCMAKE_INSTALL_PREFIX=/usr \
-DCMAKE_INSTALL_LIBDIR=/usr/lib/x86_64-linux-gnu \
-DINSTALL_DRIVER_SYSCONF=OFF \
-DLIBVA_DRIVERS_PATH=/usr/lib/x86_64-linux-gnu/dri

Em seguida, crie o driver de mídia:

time make -j$(nproc) VERBOSE=1

Em seguida, instale o projeto:

sudo make -j$(nproc) install VERBOSE=1

Adicione-se ao grupo de vídeos:

sudo usermod -a -G video $USER

Observação: o FFmpeg agora pode selecionar o driver QSV correto na inicialização, normalmente iHDse estiver instalado e presente nas ldconfigentradas. Você não precisa mais definir o driver correto em todo o sistema /etc/environmentou por sessão de inicialização no FFmpeg.

4. libva-utils:

Este pacote fornece uma coleção de testes para VA-API, como vainfo, necessários para validar os recursos com suporte de uma plataforma (codificar, decodificar e atributos pós-procedimento por codec por informações de pontos de entrada VAAPI).

cd ~/vaapi
git clone https://github.com/intel/libva-utils
cd libva-utils
./autogen.sh --prefix=/usr --libdir=/usr/lib/x86_64-linux-gnu
time make -j$(nproc) VERBOSE=1
sudo make -j$(nproc) install

Neste ponto, emita uma reinicialização:

sudo systemctl reboot

Isso é necessário para refletir as alterações feitas acima, como adicionar seu usuário ao grupo de vídeos.

Em seguida, ao retomar, prossiga com as etapas abaixo.

Crie o MSDK da Intel :

Este pacote fornece uma API para acessar a decodificação, codificação e filtragem de vídeo acelerada por hardware em plataformas Intel® com gráficos integrados. Ele é suportado em plataformas para as quais o driver de mídia intel é direcionado.

Para recursos suportados por geração, consulte isto .

Etapas de construção:

(uma). Busque as fontes no diretório de trabalho ~/vaapi:

cd ~/vaapi
git clone https://github.com/Intel-Media-SDK/MediaSDK msdk
cd msdk
git submodule init
git pull

(b). Configurar a compilação:

mkdir -p ~/vaapi/build_msdk
cd ~/vaapi/build_msdk
cmake -DCMAKE_BUILD_TYPE=Release -DENABLE_WAYLAND=ON -DENABLE_X11_DRI3=ON ../msdk
time make -j$(nproc) VERBOSE=1
sudo make install -j$(nproc) VERBOSE=1

O CMake detectará automaticamente a plataforma em que você está e ativará os ganchos específicos da plataforma necessários para uma compilação funcional.

Crie um arquivo de configuração de biblioteca para o iMSDK:

sudo nano /etc/ld.so.conf.d/imsdk.conf

Contente:

/opt/intel/mediasdk/lib
/opt/intel/mediasdk/plugins

Então corra:

sudo ldconfig -vvvv

Para prosseguir.

Crie um binário FFmpeg utilizável com o iMSDK:

Inclua componentes extras conforme necessário:

(uma). Construir e implantar nasm: Nasm é um montador para otimizações x86 usado por x264 e FFmpeg. Altamente recomendado ou sua compilação resultante pode ser muito lenta.

Observe que agora mudamos de Yasm para nasm, pois este é o montador atual que x265, x264, entre outros, está adotando.

cd ~/ffmpeg_sources
wget https://www.nasm.us/pub/nasm/releasebuilds/2.14.02/nasm-2.14.02.tar.gz
tar xzvf nasm-2.14.02.tar.gz
cd nasm-2.14.02
./configure --prefix="$HOME/ffmpeg_build" --bindir="$HOME/bin"
make -j$(nproc)
make -j$(nproc) install
make -j$(nproc) distclean

(b). Crie e implemente libx264 estaticamente: esta biblioteca fornece um codificador de vídeo H.264. Consulte o Guia de Codificação H.264 para obter mais informações e exemplos de uso. Isso requer que o ffmpeg seja configurado com --enable-gpl --enable-libx264.

cd ~/ffmpeg_sources
git clone https://code.videolan.org/videolan/x264.git
cd ~/ffmpeg_sources/x264
git pull
PATH="$HOME/bin:$PATH" ./configure --prefix="$HOME/ffmpeg_build" --bindir="$HOME/bin" --enable-static --disable-opencl --bit-depth=all --enable-pic
PATH="$HOME/bin:$PATH" make -j$(nproc)
make -j$(nproc) install
make -j$(nproc) distclean

(c). Construir e configurar libx265: Esta biblioteca fornece um codificador de vídeo H.265/HEVC. Consulte o Guia de Codificação H.265 para obter mais informações e exemplos de uso.

cd ~/ffmpeg_sources
hg clone https://bitbucket.org/multicoreware/x265
cd ~/ffmpeg_sources/x265/build/linux
PATH="$HOME/bin:$PATH" cmake -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX="$HOME/ffmpeg_build" -DENABLE_SHARED:bool=off ../../source
make -j$(nproc) VERBOSE=1
make -j$(nproc) install VERBOSE=1
make -j$(nproc) clean VERBOSE=1

(d). Crie e implemente a biblioteca libfdk-aac: fornece um codificador de áudio AAC. Consulte o Guia de codificação de áudio AAC para obter mais informações e exemplos de uso. Isso requer que o ffmpeg seja configurado com --enable-libfdk-aac(e --enable-nonfreese você também incluiu --enable-gpl).

cd ~/ffmpeg_sources
git clone https://github.com/mstorsjo/fdk-aac
cd fdk-aac
autoreconf -fiv
./configure --prefix="$HOME/ffmpeg_build" --disable-shared
make -j$(nproc)
make -j$(nproc) install
make -j$(nproc) distclean

(e). Crie e configure libvpx:

cd ~/ffmpeg_sources
git clone https://github.com/webmproject/libvpx
cd libvpx
./configure --prefix="$HOME/ffmpeg_build" --enable-runtime-cpu-detect --enable-vp9 --enable-vp8 \
--enable-postproc --enable-vp9-postproc --enable-multi-res-encoding --enable-webm-io --enable-better-hw-compatibility --enable-vp9-highbitdepth --enable-onthefly-bitpacking --enable-realtime-only --cpu=native --as=nasm 
time make -j$(nproc)
time make -j$(nproc) install
time make clean -j$(nproc)
time make distclean

(f). Construir LibVorbis:

cd ~/ffmpeg_sources
wget -c -v http://downloads.xiph.org/releases/vorbis/libvorbis-1.3.6.tar.xz
tar -xvf libvorbis-1.3.6.tar.xz
cd libvorbis-1.3.6
./configure --enable-static --prefix="$HOME/ffmpeg_build"
time make -j$(nproc)
time make -j$(nproc) install
time make clean -j$(nproc)
time make distclean

(g). Construir FFmpeg:

Build an FFmpeg binary with the required options:

cd ~/ffmpeg_sources
git clone https://github.com/FFmpeg/FFmpeg -b master
cd FFmpeg
PATH="$HOME/bin:$PATH" PKG_CONFIG_PATH="$HOME/ffmpeg_build/lib/pkgconfig:/opt/intel/mediasdk/lib/pkgconfig" ./configure \
  --pkg-config-flags="--static" \
  --prefix="$HOME/bin" \
  --bindir="$HOME/bin" \
  --extra-cflags="-I$HOME/bin/include" \
  --extra-ldflags="-L$HOME/bin/lib" \
  --extra-cflags="-I/opt/intel/mediasdk/include" \
  --extra-ldflags="-L/opt/intel/mediasdk/lib" \
  --extra-ldflags="-L/opt/intel/mediasdk/plugins" \
  --enable-libmfx \
  --enable-vaapi \
  --enable-opencl \
  --disable-debug \
  --enable-libvorbis \
  --enable-libvpx \
  --enable-libdrm \
  --enable-gpl \
  --cpu=native \
  --enable-libfdk-aac \
  --enable-libx264 \
  --enable-libx265 \
  --enable-openssl \
  --enable-pic \
  --extra-libs="-lpthread -lm -lz -ldl" \
  --enable-nonfree 
PATH="$HOME/bin:$PATH" make -j$(nproc) 
make -j$(nproc) install 
make -j$(nproc) distclean 
hash -r

Now you can launch your FFmpeg binary from ~/bin/ffmpeg, with the required features.

Notes on encoding with the QSV encoders:

Typically, you will need to initialize a hardware device that will be used by both the encoder(s) in use and filtering, as shown in the example below:

ffmpeg -y -loglevel debug -init_hw_device qsv=hw -filter_hw_device hw -hwaccel qsv -hwaccel_output_format qsv \
-i simpsons.mp4 -vf 'format=qsv,hwupload=extra_hw_frames=64'  \
-c:v hevc_qsv \
-bf 3 -b:v 3.75M -maxrate:v 3.75M -bufsize:v 0.5M -r:v 30 -c:a copy -f mp4 trolled.mp4

See how the hardware device for use with MFX sessions has been initialized (-init_hw_device qsv=hw) and mapped as available to filters such as hwupload (-filter_hw_device hw). Recommended for further reading: The Advanced Video Options section on FFmpeg wiki.

The example above demonstrates the use of the hevc_qsv encoders with some private options passed to it, for reference.

Another example, showing the use of the h264_qsv encoder:

ffmpeg -y -loglevel debug -init_hw_device qsv=hw -filter_hw_device hw -hwaccel qsv -hwaccel_output_format qsv \
-i simpsons.mp4 -vf 'format=qsv,hwupload=extra_hw_frames=64'  \
-c:v h264_qsv \
-bf 3 -b:v 15M -maxrate:v 15M -bufsize:v 2M -r:v 30 -c:a copy -f mp4 trolled.mp4

Take note that both examples above will use the constant bitrate control (CBR) method in MFX, as shown in the console log:

[hevc_qsv @ 0x55faf21eedc0] Using the constant bitrate (CBR) ratecontrol method

Rate control, similar to how the VAAPI implementation governs it, is driven by the parameters -b:v (target video bitrate) and the -maxrate:v (maximum video bitrate) passed to the encoder. If they are equal, CBR (constant bitrate control) is used. If maxrate is greater than target bitrate, then VBR, and in effect, look-ahead based control (if so desired) are enabled.

Observe how we call up the hwupload filter, chained with the format=qsv filter to ensure that the MFX runtime receives a supported pixel format. Failure to pass this video filter chain will result in initialization failure, with output similar to this:

[h264_qsv @ 0x560e1bda7280] Selected ratecontrol mode is unsupported
[h264_qsv @ 0x560e1bda7280] Low power mode is unsupported
[h264_qsv @ 0x560e1bda7280] Current frame rate is unsupported
[h264_qsv @ 0x560e1bda7280] Current picture structure is unsupported
[h264_qsv @ 0x560e1bda7280] Current resolution is unsupported
[h264_qsv @ 0x560e1bda7280] Current pixel format is unsupported
[h264_qsv @ 0x560e1bda7280] some encoding parameters are not supported by the QSV runtime. Please double check the input parameters.
Error initializing output stream 0:0 -- Error while opening encoder for output stream #0:0 - maybe incorrect parameters such as bit_rate, rate, width or height

The error message may seem ambiguous at first, but it stems primarily from mapping invalid options to the underlying MFX library, such as an unsupported pixel format.

The extra argument extra_hw_frames=64 passed to hwupload has to do with the MFX runtime requiring a fixed frame pool size to be per-allocated. Use a number suitable to your requirements. Generally, you'll need a larger number (64, or thereabouts) if using features such as look-ahead (LA-ICQ).