Windows 10 using MSYS2 and VS2019 compilation FFmpeg details

1 Environmental preparation

1.1 Installing Visual Studio 2019

This step is relatively simple and will not be explained in detail.

1.2 Installing msys2

First you need to install the msys2 environment and related compilation dependencies, the official URL is:

https:///

After downloading the installation program from the official website, follow the instructions directly to install it.

After installation, you need to replace the address of the download library with a domestic source, otherwise the download speed may be extremely slow or even fail. Configuration file is located in: C:\msys64\etc\, respectively, mirrorlist.mingw32, mirrorlist.mingw64, three configuration files of the preferred Server address, replace the Tsinghua University and the Chinese University of Science and Technology mirror!

# See https:///dev/mirrors

## Primary
## Tsinghua University
Server= https:///msys2/mingw/i686/
## CSU
Server= https:///msys2/mingw/i686/

Server = https://mirror./mingw/i686/
Server = https://repo./mingw/i686/

## Tier 1
Server = https:///msys2/mingw/i686/
Server = https:///mirrors/msys2/mingw/i686/
Server = https:///mirror/msys2/mingw/i686/
Server = https:///mirror//mingw/i686/
Server = https:///pub/os/windows/msys2/builds/mingw/i686/
Server = https:///pub/msys2/mingw/i686/
Server = https:///pub/msys2/mingw/i686/
Server = https:///msys2/mingw/i686/
Server = https:///msys2/mingw/i686/
Server = https:///msys2/mingw/i686/
Server = https:///msys2/mingw/i686/
Server = https:///msys2/mingw/i686/
Server = https:///msys2/mingw/i686/
Server = https:///mirrors/pub/msys2/mingw/i686/
Server = https:///MSYS2/mingw/i686/
Server = https:///msys2/mingw/i686/

## Tier 2
Server = https:///mirrors/msys2/mingw/i686/
Server = https:///pub/msys2/mingw/i686/
Server = https:///msys2-mirror/mingw/i686/
Server = https:///~nickoe/msys2-mirror/mingw/i686/
Server = https:///msys2/mingw/i686/
Server = https:///msys2/mingw/i686/
Server = https:///msys2/mingw/i686/
Server = https:///msys2/mingw/i686/
Server = https:///msys2/mingw/i686/

mirrorlist.mingw32

# See https:///dev/mirrors

## Primary
Server = https:///msys2/mingw/x86_64/
Server = https:///msys2/mingw/x86_64/
Server = https://mirror./mingw/x86_64/
Server = https://repo./mingw/x86_64/

## Tier 1
Server = https:///msys2/mingw/x86_64/
Server = https:///mirrors/msys2/mingw/x86_64/
Server = https:///mirror/msys2/mingw/x86_64/
Server = https:///mirror//mingw/x86_64/
Server = https:///pub/os/windows/msys2/builds/mingw/x86_64/
Server = https:///pub/msys2/mingw/x86_64/
Server = https:///pub/msys2/mingw/x86_64/
Server = https:///msys2/mingw/x86_64/
Server = https:///msys2/mingw/x86_64/
Server = https:///msys2/mingw/x86_64/
Server = https:///msys2/mingw/x86_64/
Server = https:///msys2/mingw/x86_64/
Server = https:///msys2/mingw/x86_64/
Server = https:///mirrors/pub/msys2/mingw/x86_64/
Server = https:///MSYS2/mingw/x86_64/
Server = https:///msys2/mingw/x86_64/

## Tier 2
Server = https:///mirrors/msys2/mingw/x86_64/
Server = https:///pub/msys2/mingw/x86_64/
Server = https:///msys2-mirror/mingw/x86_64/
Server = https:///~nickoe/msys2-mirror/mingw/x86_64/
Server = https:///msys2/mingw/x86_64/
Server = https:///msys2/mingw/x86_64/
Server = https:///msys2/mingw/x86_64/
Server = https:///msys2/mingw/x86_64/
Server = https:///msys2/mingw/x86_64/

mirrorlist.mingw64

# See https:///dev/mirrors

## Primary
Server = https:///msys2/msys/$arch/
Server = https:///msys2/msys/$arch/
Server = https://mirror./msys/$arch/
Server = https://repo./msys/$arch/

## Tier 1
Server = https:///msys2/msys/$arch/
Server = https:///mirrors/msys2/msys/$arch/
Server = https:///mirror/msys2/msys/$arch/
Server = https:///mirror//msys/$arch/
Server = https:///pub/os/windows/msys2/builds/msys/$arch/
Server = https:///pub/msys2/msys/$arch/
Server = https:///pub/msys2/msys/$arch/
Server = https:///msys2/msys/$arch/
Server = https:///msys2/msys/$arch/
Server = https:///msys2/msys/$arch/
Server = https:///msys2/msys/$arch/
Server = https:///msys2/msys/$arch/
Server = https:///msys2/msys/$arch/
Server = https:///mirrors/pub/msys2/msys/$arch/
Server = https:///MSYS2/msys/$arch/
Server = https:///msys2/msys/$arch/

## Tier 2
Server = https:///mirrors/msys2/msys/$arch/
Server = https:///pub/msys2/msys/$arch/
Server = https:///msys2-mirror/msys/$arch/
Server = https:///~nickoe/msys2-mirror/msys/$arch/
Server = https:///msys2/msys/$arch/
Server = https:///msys2/msys/$arch/
Server = https:///msys2/msys/$arch/
Server = https:///msys2/msys/$arch/
Server = https:///msys2/msys/$arch/

Run C:\msys64\ and install and upgrade all libraries with one click via pacman -Syu at the command line.

During the compilation process, you may encounter some other libraries are missing, just follow the instructions to install them. For example, you may need to install the following libraries:

pacman -S make cmake#Regular compilation tools
pacman-S yasm #assembly tools
pacman-S nasm #assembly tools
pacman-S pkg-config#Library configuration tool, compiled to support x264 and x265 will use the
pacman-S mingw-w64-x86_64-gcc#Compilation Tools
pacman -S diffutils #Comparison tools，ffmpeg configure generatingmakefilewhen using
pacman -S git　  #Source code download tool

1.3 Configuring the VC environment

First of all, in order to make msys2 access the windows PATH environment variable, you need to find the script file msys2_shell.cmd in the msys2 installation directory, use any editor to open it, and change rem set MSYS2_PATH_TYPE=inherit to set MSYS2_PATH_TYPE= inherit, i.e. remove the rem comment inherit system environment variables.

Next, find Visual Studio 2019 in the windows start menu, right-click on "x64_x86 Cross Tools Command Prompt For VS 2019" and choose to run as administrator (it's better to run with administrator privileges, or else subsequent problems may occur when the (It is better to run with administrator privileges, otherwise the make install command may not have enough privileges, remember).

Regarding the selection of several options

If you have 32-bit Windows and want to compile 32-bit FFmpeg, it is recommended to choose:x86 Native Tools Command Prompt;

If you have 64-bit Windows and want to compile 64-bit FFmpeg, it is recommended to choose:x64 Native Tools Command Prompt

If you are on 32-bit Windows and want to compile 64-bit FFmpeg, it is recommended to choose:x86_x64 Cross Tools Command Prompt

Recommended if you have 64-bit Windows and want to compile 32-bit FFmpeg:x64_x86 Cross Tools Command Prompt

See the Microsoft website for details:Use the Microsoft C++ toolset from the command line

My OS is Win10 64-bit and it's 32-bit FFmpeg that needs to be compiled, so that's the choice:x64_x86 Cross Tools Command Prompt For VS 2019

Then, cd to C:\msys64 and run msys2_shell.cmd in 32-bit mode (msys2_shell.cmd -mingw64 will run msys2 in 64-bit mode) to enable the MinGW runtime environment. At this time, type cl in the popped-up msys2 command window, and the output of the MSVC message, then it means that the compiler configuration is successful. The compiler has been successfully configured.

Type which cl and which link in the msys window to see the current compiler and linker locations, respectively:

You can see that the location of the cl compiler is correct, the link linker is incorrect, this is because the linker found for the default MSYS linker, MSYS default also carries a linker named (in the :msys installation directory /usr/bin/), which conflicts with Visual Studio's own, which affects the build system after the construction of the build (in my compilation process is because I ignored this problem, resulting in an unusually slow compilation process and the generation of dll files can not be used). This will affect the build of the build system (I ignored this problem during my build, resulting in an unusually slow build and unusable dll files), so we must make sure that Visual Studio comes with it. Find the one that comes with MSYS, rename it to something else, for example I renamed it link.exe_back. type which link again:

You can see that it has been for the Visual Studio directory.

2 FFMPEG compilation

2.1 Source Code Download

The source code can be used by the/FFmpeg/FFmpeg/tagsmaybeFFmpeg official websiteDownload, e.g. I downloaded the latest version 4.3.

2.2 Compiling dependent libraries

2.2.1 Compiling SDL

First get the SDL source code from github with the following command:

git clone https:///libsdl-org/
cd SDL
git checkout release-2.30.0

Note that SDL has now released version 3.0, and ffmpeg is currently only available in SDL2, so after pulling the code, you need to switch to version 2.30.0.

After downloading the SDL2 source code, we need to generate a VS project for it using CMake, so let's first go hereDownload CMakeAfter that, open CMake-GUI, and execute Configure, and then configure the following. After that, open CMake-GUI, specify the path where the SDL2 source code is located and the output path after compilation in CMake-GUI, and then execute Configure, and then configure as follows

Then keep the default configuration and Generate VS2019 project.

With VS project, you can compile SDL by VS2019. The compiled SDL will be saved to the Release or Debug directory of the specified output directory, while the path we want to output is /usr/local/sdl2/lib, we need to create the lib directory under the specified output directory, and copy and files to the lib directory. Also create a pkgconfig directory in the lib directory and copy the files to it. In addition, we also need to modify the contents of the lib directory to change the library path to the specified output path, so that the complete directory structure is as follows:

2.2.2 Compiling x264

Like SDL we have to get its source code first, you can get the x264 source code by the following command:

git clone https:///videolan/

Once the source code is obtained, you can compile the dynamic libraries available under Windows directly in the MSYS2 environment as follows:

cd x264                             # existMSYS2hit the targetx264source code directory
pacman -S automake autoconf libtool # Install tools for generating Makefiles
CC=cl ./configure --prefix=/usr/local/x264 --enable-shared
make -j 4 && make install

With the above command, you can compile x264. x264 compiled, its output directory structure is the same as SDL2, in /usr/local/x264 includes include, lib, bin and other directories. One point to emphasize is that we need to change the filenames in the lib directory, otherwise ffmpeg will report "Cannot find the library" error when compiling.

2.2.3 Compiling fdk-aac

The compilation of fdk-aac is similar to that of SDL, it also uses CMake to generate VS project file, and then compiles the library through VS. First, pass the following command to get the fdk-aac source code:

git clone https:///mstorsjo/

After that, generate the VS project file through CMake, please refer to the steps of SDL to generate VS project for the specific execution steps, which will not be repeated here.
Next, use VS2019 to compile fdk-aac, the compiled library will be put into the Release or Debug directory, so we have to manually organize the output directory tree of fdk-aac as we did with the SDL library. At this point, fdk-aac is compiled.

There is a special case when compiling fdk-aac, that is, I can't generate include header file by using CMake (it is also possible that I didn't execute any piece correctly). In order to solve this problem, I used MSYS2+mingw to recompile fdk-aac, which can generate include header files, and then manually copy the generated header files to the /usr/local/fdk-aac directory.

./
./configure --prefix=/c/work/Opensource/ffmpegbuild/fdk-aac/migwbuild
make
make install

2.2.4 Compiling x265

First download the x265 source code

git clone https:///videolan/

Query VS2019 cmake path Query VS2019 cmake path, execute whereis cmake

Edit the file /c/work/Opensource/ffmpegbuild/x265/build/msys-cl/, change the path in it to the absolute path of the VC version, otherwise it will use the cmake in the default msys2, which is about to:

cmake -G "NMake Makefiles" -DCMAKE_CXX_FLAGS="-DWIN32 -D_WINDOWS -W4 -GR -EHsc" -DCMAKE_C_FLAGS="-DWIN32 -D_WINDOWS -W4"  ../../source

Modified to:

/c/"Program Files (x86)/Microsoft Visual Studio/2019"/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/cmake -G "NMake Makefiles" -DCMAKE_CXX_FLAGS="-DWIN32 -D_WINDOWS -W4 -GR -EHsc" -DCMAKE_C_FLAGS="-DWIN32 -D_WINDOWS -W4"  ../../source

Go to the source directory and execute the following 3 commands to complete the compilation

cd /home/source/x265/build/msys-cl/
./make-
nmake install

After executing nmake install, we can see that x265 is compiled to C:/Program Files (x86)/x265/ directory, we need to copy it to /usr/local/ directory of msys2, and change the paths in the corresponding files.

2.2.5 ffmpeg using compiled libraries

First of all, we have to set the environment variable PKG_CONFIG_PATH, through which we tell FFmpeg where the above libraries can be found, the specific settings are as follows:

Run the command pacman -S vim in the msys2 window to install vim, vim ~/.bashrc to edit the file, and set environment variables in ~/.bashrc

export PKG_CONFIG_PATH=/usr/local/sdl2/lib/pkgconfig:/usr/local/x264/lib/pkgconfig:/usr/local/fdk-aac/lib/pkgconfig:/usr/local/x265/lib/pkgconfig:$PKG_CONFIG_PATH

Then execute the command source ~/.bashrc to let the environment variables take effect. The contents of the four library pkgconfig configuration files are as follows:

# sdl pkg-config source file

prefix=/usr/local/sdl2
exec_prefix=${prefix}
libdir=${exec_prefix}/lib
includedir=${prefix}/include

Name: sdl2
Description: Simple DirectMedia Layer is a cross-platform multimedia library designed to provide low level access to audio, keyboard, mouse, joystick, 3D hardware via OpenGL, and 2D video framebuffer.
Version: 2.30.0
Requires.private: 
Conflicts:
Libs: -L${libdir}   -lSDL2 
Libs.private:  -lSDL2-static  -lkernel32 -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lversion -luuid -ladvapi32 -lsetupapi -lshell32 -ldinput8
Cflags: -I${includedir} -I${includedir}/SDL2 

prefix=/usr/local/x264
exec_prefix=${prefix}
libdir=${exec_prefix}/lib
includedir=${prefix}/include

Name: x264
Description: H.264 (MPEG4 AVC) encoder library
Version: 0.164.3191
Libs: -L${exec_prefix}/lib -llibx264 
Libs.private: 
Cflags: -I${prefix}/include -DX264_API_IMPORTS

prefix=/usr/local/fdk-aac
exec_prefix=${prefix}
libdir=${exec_prefix}/lib
includedir=${prefix}/include

Name: Fraunhofer FDK AAC Codec Library
Description: AAC codec library
Version: 2.0.3
Libs: -L${libdir} -lfdk-aac 
Libs.private: -lm 
Cflags: -I${includedir}

prefix=/usr/local/x265
exec_prefix=${prefix}/bin
libdir=${prefix}/lib
includedir=${prefix}/include

Name: x265
Description: H.265/HEVC video encoder
Version: 3.4
Libs: -L${libdir} -llibx265
Libs.private: 
Cflags: -I${includedir}

2.3 Compiling ffmpeg

Go to the ffmpeg source decompression directory and execute . /configure --help to see all supported compilation parameters:

As you can see, there are many compilation parameters supported natively, we only focus on the following parts here, and the cropping function can be completed by configuring the following parameters.

Individual component options:
--disable-everything Disable all components below
--disable-encoder=NAME Disable the specified encoder
--enable-encoder=NAME Enable the specified encoder
--disable-encoders Disable all encoders
--disable-decoder=NAME Disable the specified decoder
--enable-decoder=NAME Enable the specified decoder
--disable-decoders Disable all decoders
--disable-hwaccel=NAME Disable hardware acceleration (hardware decoding)
--enable-hwaccel=NAME Enable Hardware Acceleration
--disable-hwaccels Disable all hardware acceleration
--disable-muxer=NAME Disable the specified wrapper
--enable-muxer=NAME Enable the specified wrapper
--disable-muxers Disable all wrappers
--disable-demuxer=NAME Disable the specified unwrapper
--enable-demuxer=NAME Enable the specified wrapper
--disable-demuxers Disable all demuxers
--enable-parser=NAME Enable the specified parser
--disable-parser=NAME Disable the specified parser
--disable-parsers Disable all parsers
--enable-bsf=NAME Enables the specified bitstream filter.
--disable-bsf=NAME Disable the specified bitstream filters
--disable-bsfs disable all bitstream filters
--enable-protocol=NAME   Enable the specified protocol(The protocol here isTCP/UDP/FILE)
--disable-protocol=NAME Disable the specified protocol
--disable-protocols Disable all protocols
--enable-indev=NAME Enable the specified input device
--disable-indev=NAME Disable the specified input device
--disable-indevs Disable all input devices
--enable-outdev=NAME Enable the specified output device
--disable-outdev=NAME Disable the specified output device
--disable-outdevs Disable all output devices
--disable-devices Disable all devices
--enable-filter=NAME Enable the specified filter
--disable-filter=NAME Disable the specified filter
--disable-filters        Disable all filters

A brief description of a few of the options above:

• encoder: Corresponding to the encoder, such as the need to convert mp3 format to aac format, after the conversion will inevitably use the aac format encoder;
• decoder: The counterpart is the decoder, same as above, if you want to convert to aac format, you have to decode the mp3 format first, which will use the mp3 format decoder.
• muxer: The counterpart is the wrapper, which is mainly used to generate the final wrapper format. Different audio and video formats have their own fixed file content format, which is convenient for the player to recognize and parse them.
• demuxer: The counterpart is the unwrapper, for example, an MP4 wrapper format can hold both H264 encoded video and AAC encoded audio, if you want to take out the audio in it, you need to find the stream where the audio is located according to certain rules.
• protocol: file protocol, FFmpeg not only supports reading and writing of local audio and video files, but also supports reading and writing of network streaming media, for example, if you want to watch a network TV locally, then you can pass the http/rtsp/rtmp address of this network TV in FFmpeg, so that you can realize local playback.
• parser: Parses and populates internal data structures, e.g. AVCodecParser, which is usually used in conjunction with a decoder.

Here is a list of some common compilation options, for a complete list of compilation options, please refer to: Appendix I: "Summary of FFmpeg Compilation Parameters".

I use the following compilation options when compiling:

./configure --prefix=./buildout --toolchain=msvc --disable-doc --enable-shared --enable-libx264 --enable-gpl --enable-libfdk-aac --enable-nonfree --enable-libx265 --enable-ffplay  --disable-debug

The last option --disable-debug -- was added because without it, the compiler would get stuck generating libraries with the message "Creating library libavcodec/ and object libavcodec/".writingsAlso encountered this problem, but Microsoft official also did not give a solution, it is not clear whether it is only in a specific version of VS2019 (I am the community version) to reproduce the problem, so temporarily add --disable-debug cancel debugging information generation.

After that, execute the make command to compile. During compilation, if the following error occurs [error C2065: "slib": undeclared identifier]:

Then you need to modify the fftools/source file by commenting out line 1153, which is caused by the undefined CC_IDENT logo, as shown below:

If you encounter similar compilation errors during the subsequent compilation process, please handle them in the same way. After the compilation is complete, execute make install, which will install the executable program, libraries, header files, etc. to the specified directory.

So far the compilation is complete, followed by the direct installation of ffmpeg through the vcpkg method and a simple ffmpeg-based player example.

Appendix I: Summary of FFmpeg Compilation Parameters

1.1 Help options

1.2 Standard options

1.3 Licensing options

1.4 Configuration options Configuration options

1.5 Program options

1.6 Documentation options

1.7 Component options Component options

1.8 Individual component options Standalone Component Options

1.9 External library support Extended Library Support

Using any of the following options will allow FFmpeg to link to the corresponding external library. If all other dependencies are met and they are not explicitly disabled, all components that depend on the library will be enabled. For example. --enable-libopus will enable linking to libopus and allow the libopus encoder to be built, unless it is explicitly disabled with --disable-encoder=libopus.

Please note that only system libraries are automatically detected. All other external libraries must be explicitly enabled.

Also note that the following help text describes the use of the libraries themselves, not all of their features must be used by FFmpeg.

The following libraries provide various hardware acceleration features:

1.10 Toolchain options Toolchain options

1.11 Advanced options

1.12 Optimization options Optimization Options

1.13 Developer Options

Parts of this blog post are referenced in the following article, with thanks:

/yongdaimi/p/

/post/7076719206573539336