ffmpeg undefined reference to sws_getContext - c++

Question

I am learning to use ffmpeg libraries, and have successfully compiled and run a program that demuxes and decodes a video. However, when I was trying to use the swscale library, I got a linking error "undefined reference to sws_getContext". There are similar problems on the Internet but none of them solves my problem.
The full error message is
/usr/bin/ld: CMakeFiles/ffmpeg_test.dir/main.cpp.o: in function `main':
main.cpp:(.text+0x44f): undefined reference to `sws_getContext'
collect2: error: ld returned 1 exit status
make[2]: *** [CMakeFiles/ffmpeg_test.dir/build.make:93: ffmpeg_test] Error 1
make[1]: *** [CMakeFiles/Makefile2:76: CMakeFiles/ffmpeg_test.dir/all] Error 2
make: *** [Makefile:84: all] Error 2
Here is my Dockerfile, source file and CMakeList.
# FFMPEG Image
# ref：https://trac.ffmpeg.org/wiki/CompilationGuide/Ubuntu
FROM ubuntu:20.04
ARG http_proxy=''
ARG https_proxy=''
ENV HTTP_PROXY=${http_proxy}
ENV HTTPS_PROXY=${https_proxy}
RUN apt-get update \
&& DEBIAN_FRONTEND="noninteractive" \
apt-get install -y --no-install-recommends \
autoconf \
automake \
build-essential \
cmake \
git \
libass-dev \
libfreetype6-dev \
libgnutls28-dev \
# libsdl2-dev \
libtool \
# libva-dev \
# libvdpau-dev \
libvorbis-dev \
# libxcb1-dev \
# libxcb-shm0-dev \
# libxcb-xfixes0-dev \
meson \
ninja-build \
pkg-config \
texinfo \
wget \
yasm \
zlib1g-dev \
libunistring-dev \
python3.8-dev \
ca-certificates
ARG FFMPEG_ROOT=/root/ffmpeg
RUN mkdir ${FFMPEG_ROOT}
WORKDIR ${FFMPEG_ROOT}
RUN mkdir sources && mkdir build && mkdir bin
# NASM
RUN cd sources \
&& wget https://www.nasm.us/pub/nasm/releasebuilds/2.15.05/nasm-2.15.05.tar.bz2 \
&& tar xjvf nasm-2.15.05.tar.bz2 \
&& cd nasm-2.15.05 \
&& ./autogen.sh \
&& PATH="${FFMPEG_ROOT}/bin:$PATH" \
./configure \
--prefix="${FFMPEG_ROOT}/build" \
--bindir="${FFMPEG_ROOT}/bin" \
--enable-shared \
--enable-pic \
&& make -j$(nproc) \
&& make install
# H.264 video encoder (GPL License!!! --enable-gpl --enable-libx264)
RUN cd sources \
&& git -C x264 pull 2> /dev/null || git clone --depth 1 https://code.videolan.org/videolan/x264.git \
&& cd x264 \
&& PATH="${FFMPEG_ROOT}/bin:$PATH" \
PKG_CONFIG_PATH="${FFMPEG_ROOT}/build/lib/pkgconfig" \
./configure \
--prefix="${FFMPEG_ROOT}/build" \
--bindir="${FFMPEG_ROOT}/bin" \
--enable-shared \
--enable-pic \
--disable-cli \
&& PATH="${FFMPEG_ROOT}/bin:$PATH" make -j$(nproc) \
&& make install
# H.265/HEVC video encoder (GPL License!!! --enable-gpl --enable-libx265)
RUN apt-get install -y --no-install-recommends libnuma-dev \
&& cd sources \
&& git -C x265_git pull 2> /dev/null || git clone https://bitbucket.org/multicoreware/x265_git \
&& cd x265_git/build/linux \
&& PATH="${FFMPEG_ROOT}/bin:$PATH" \
cmake \
-G "Unix Makefiles" \
-DCMAKE_INSTALL_PREFIX="${FFMPEG_ROOT}/build" \
-DENABLE_SHARED=on \
-DENABLE_CLI=off \
../../source \
&& PATH="${FFMPEG_ROOT}/bin:$PATH" make -j$(nproc) \
&& make install
# VP8/VP9 video encoder/decoder (--enable-libvpx)
RUN cd sources \
&& git -C libvpx pull 2> /dev/null || git clone --depth 1 https://chromium.googlesource.com/webm/libvpx.git \
&& cd libvpx \
&& PATH="${FFMPEG_ROOT}/bin:$PATH" \
./configure \
--prefix="${FFMPEG_ROOT}/build" \
--disable-debug \
--disable-examples \
--disable-docs \
--disable-unit-tests \
--enable-vp9-highbitdepth \
--as=yasm \
--enable-pic \
--enable-shared \
&& PATH="${FFMPEG_ROOT}/bin:$PATH" make -j$(nproc) \
&& make install
# # AAC audio encoder (NON-FREE!!! --enable-gpl --enable-nonfree --enable-libfdk-aac)
# RUN cd sources \
# && git -C fdk-aac pull 2> /dev/null || git clone --depth 1 https://github.com/mstorsjo/fdk-aac \
# && cd fdk-aac \
# && autoreconf -fiv \
# && ./configure \
# --prefix="${FFMPEG_ROOT}/build" \
# --disable-shared \
# && make -j$(nproc) \
# && make install
# MP3 audio encoder (--enable-libmp3lame)
RUN cd sources \
&& wget -O lame-3.100.tar.gz https://downloads.sourceforge.net/project/lame/lame/3.100/lame-3.100.tar.gz \
&& tar xzvf lame-3.100.tar.gz \
&& cd lame-3.100 \
&& PATH="${FFMPEG_ROOT}/bin:$PATH" \
./configure \
--prefix="${FFMPEG_ROOT}/build" \
--bindir="${FFMPEG_ROOT}/bin" \
--enable-shared \
--enable-pic \
--enable-nasm \
&& PATH="${FFMPEG_ROOT}/bin:$PATH" make -j$(nproc) \
&& make install
# Opus audio decoder and encoder (--enable-libopus)
RUN cd sources \
&& git -C opus pull 2> /dev/null || git clone --depth 1 https://github.com/xiph/opus.git \
&& cd opus \
&& ./autogen.sh \
&& ./configure \
--prefix="${FFMPEG_ROOT}/build" \
--enable-shared \
&& make -j$(nproc) \
&& make install
# AV1 video encoder/decoder
# encoder (--enable-libsvtav1)
RUN cd sources \
&& git -C SVT-AV1 pull 2> /dev/null || git clone https://gitlab.com/AOMediaCodec/SVT-AV1.git \
&& mkdir -p SVT-AV1/build \
&& cd SVT-AV1/build \
&& PATH="${FFMPEG_ROOT}/bin:$PATH" \
cmake \
-G "Unix Makefiles" \
-DCMAKE_INSTALL_PREFIX="${FFMPEG_ROOT}/build" \
-DCMAKE_BUILD_TYPE=Release \
-DBUILD_DEC=OFF \
-DBUILD_SHARED_LIBS=ON \
.. \
&& PATH="${FFMPEG_ROOT}/bin:$PATH" make -j$(nproc)\
&& make install
# decoder (--enable-libdav1d)
RUN cd sources \
&& git -C dav1d pull 2> /dev/null || git clone --depth 1 https://code.videolan.org/videolan/dav1d.git \
&& mkdir -p dav1d/build \
&& cd dav1d/build \
&& PATH="${FFMPEG_ROOT}/bin:$PATH" \
meson setup \
-Denable_tools=false \
-Denable_tests=false \
--default-library=shared \
.. \
--prefix="${FFMPEG_ROOT}/build" \
--libdir="${FFMPEG_ROOT}/build/lib" \
&& ninja -j$(nproc) \
&& ninja install
# Library for calculating the ​VMAF video quality metric (--enable-libvmaf --ld="g++")
RUN cd sources \
&& wget https://github.com/Netflix/vmaf/archive/v2.1.1.tar.gz \
&& tar xvf v2.1.1.tar.gz \
&& mkdir -p vmaf-2.1.1/libvmaf/build \
&& cd vmaf-2.1.1/libvmaf/build \
&& PATH="${FFMPEG_ROOT}/bin:$PATH" \
meson setup \
-Denable_tests=false \
-Denable_docs=false \
--buildtype=release \
--default-library=shared \
.. \
--prefix "${FFMPEG_ROOT}/build" \
--bindir="${FFMPEG_ROOT}/build/bin" \
--libdir="${FFMPEG_ROOT}/build/lib" \
&& ninja -j$(nproc) \
&& ninja install
# FFMPEG
RUN cd sources \
&& wget -O ffmpeg-snapshot.tar.bz2 https://ffmpeg.org/releases/ffmpeg-snapshot.tar.bz2 \
&& tar xjvf ffmpeg-snapshot.tar.bz2 \
&& cd ffmpeg \
&& PATH="${FFMPEG_ROOT}/bin:$PATH" \
PKG_CONFIG_PATH="${FFMPEG_ROOT}/build/lib/pkgconfig" \
./configure \
--prefix="${FFMPEG_ROOT}/build" \
--pkg-config-flags="--static" \
--extra-cflags="-I${FFMPEG_ROOT}/build/include" \
--extra-ldflags="-L${FFMPEG_ROOT}/build/lib" \
--extra-libs="-lpthread -lm" \
--ld="g++" \
--bindir="${FFMPEG_ROOT}/bin" \
--disable-debug \
--disable-doc \
--disable-ffplay \
--enable-shared \
--enable-pic \
--enable-gpl \
--enable-gnutls \
# --enable-libaom \
--enable-libass \
# --enable-libfdk-aac \
--enable-libfreetype \
--enable-libmp3lame \
--enable-libopus \
--enable-libsvtav1 \
--enable-libdav1d \
--enable-libvorbis \
--enable-libvpx \
--enable-libx264 \
--enable-libx265 \
# --enable-nonfree \
&& PATH="${FFMPEG_ROOT}/bin:$PATH" make -j$(nproc) \
&& make install \
&& hash -r
# opencv
RUN apt-get update \
& apt-get install -y --no-install-recommends libopencv-dev
#include <iostream>
extern "C" {
#include <libavutil/avutil.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
}
#include <opencv2/core.hpp>
// fix c++ av_err2str problem
// ref: https://github.com/joncampbell123/composite-video-simulator/issues/5
#ifdef av_err2str
#undef av_err2str
#include <string>
av_always_inline std::string av_err2string(int errnum) {
char str[AV_ERROR_MAX_STRING_SIZE];
return av_make_error_string(str, AV_ERROR_MAX_STRING_SIZE, errnum);
}
#define av_err2str(err) av_err2string(err).c_str()
#endif // av_err2str
static int decode_packet(AVPacket *, AVCodecContext *, AVFrame *, AVStream *);
int main(int argc, const char *argv[]) {
std::cout << "hello world" << std::endl;
AVFormatContext *pFormatContext = avformat_alloc_context();
if (avformat_open_input(&pFormatContext, argv[1], NULL, NULL) != 0) {
std::cout << "ERROR could not open the file\n";
return -1;
}
printf("File format %s, duration %.2fs, bit_rate %ld\n", pFormatContext->iformat->long_name, pFormatContext->duration / 1e6, pFormatContext->bit_rate);
if (avformat_find_stream_info(pFormatContext, NULL) < 0) {
std::cout << "ERROR could not get the stream info\n";
return -1;
}
int video_stream_index = -1;
printf("Number of streams %d\n", pFormatContext->nb_streams);
AVCodecParameters *pVideoCodecParameters;
const AVCodec *pVideoCodec;
AVStream *pVideoStream;
for (int i = 0; i < pFormatContext->nb_streams; i++)
{
AVCodecParameters *pLocalCodecParameters = pFormatContext->streams[i]->codecpar;
const AVCodec *pLocalCodec = NULL;
pLocalCodec = avcodec_find_decoder(pLocalCodecParameters->codec_id);
// print its name and bitrate
printf("Codec %s, bit_rate %ld\n", pLocalCodec->long_name, pLocalCodecParameters->bit_rate);
if (pLocalCodecParameters->codec_type == AVMEDIA_TYPE_VIDEO) {
if (video_stream_index == -1) {
video_stream_index = i;
pVideoCodecParameters = pLocalCodecParameters;
pVideoCodec = pLocalCodec;
}
pVideoStream = pFormatContext->streams[i];
AVRational *fps = &pVideoStream->avg_frame_rate;
AVRational *rfps = &pVideoStream->r_frame_rate;
AVRational *time_base = &pVideoStream->time_base;
printf("Video Codec: resolution %d x %d, fps %d/%d, frames %ld, time base %d/%d, rfps %d/%d\n",
pLocalCodecParameters->width, pLocalCodecParameters->height,
fps->num, fps->den, pVideoStream->nb_frames, time_base->num, time_base->den,
rfps->num, rfps->den);
} else if (pLocalCodecParameters->codec_type == AVMEDIA_TYPE_AUDIO) {
printf("Audio Codec: %d channels, sample rate %d\n", pLocalCodecParameters->channels, pLocalCodecParameters->sample_rate);
}
if (pLocalCodec==NULL) {
printf("ERROR unsupported codec!\n");
// In this example if the codec is not found we just skip it
continue;
}
}
if (video_stream_index == -1) {
printf("File %s does not contain a video stream!\n", argv[1]);
return -1;
}
AVCodecContext *pCodecContext = avcodec_alloc_context3(pVideoCodec);
if (!pCodecContext)
{
printf("failed to allocated memory for AVCodecContext\n");
return -1;
}
if (avcodec_parameters_to_context(pCodecContext, pVideoCodecParameters) < 0)
{
printf("failed to copy codec params to codec context\n");
return -1;
}
if (avcodec_open2(pCodecContext, pVideoCodec, NULL) < 0)
{
printf("failed to open codec through avcodec_open2\n");
return -1;
}
// https://ffmpeg.org/doxygen/trunk/structAVPacket.html
AVPacket *pPacket = av_packet_alloc();
if (!pPacket)
{
printf("failed to allocated memory for AVPacket\n");
return -1;
}
// https://ffmpeg.org/doxygen/trunk/structAVFrame.html
AVFrame *pFrame = av_frame_alloc();
if (!pFrame)
{
printf("failed to allocated memory for AVFrame\n");
return -1;
}
SwsContext *pImgConvertContext = sws_getContext(
pCodecContext->width,
pCodecContext->height,
pCodecContext->pix_fmt,
pCodecContext->width,
pCodecContext->height,
AV_PIX_FMT_BGR24,
SWS_BICUBIC,
NULL,
NULL,
NULL
);
int response = 0;
int how_many_packets_to_process = 8;
// fill the Packet with data from the Stream
// https://ffmpeg.org/doxygen/trunk/group__lavf__decoding.html#ga4fdb3084415a82e3810de6ee60e46a61
while (av_read_frame(pFormatContext, pPacket) >= 0)
{
// if it's the video stream
if (pPacket->stream_index == video_stream_index) {
printf("AVPacket->pts %" PRId64, pPacket->pts);
std::cout << std::endl;
response = decode_packet(pPacket, pCodecContext, pFrame, pVideoStream);
if (response < 0)
break;
// stop it, otherwise we'll be saving hundreds of frames
if (--how_many_packets_to_process <= 0) break;
}
// https://ffmpeg.org/doxygen/trunk/group__lavc__packet.html#ga63d5a489b419bd5d45cfd09091cbcbc2
av_packet_unref(pPacket);
}
avformat_close_input(&pFormatContext);
av_packet_free(&pPacket);
av_frame_free(&pFrame);
avcodec_free_context(&pCodecContext);
std::cout << "bye world" << std::endl;
return 0;
}
static int decode_packet(AVPacket *pPacket, AVCodecContext *pCodecContext, AVFrame *pFrame, AVStream *pStream)
{
// Supply raw packet data as input to a decoder
// https://ffmpeg.org/doxygen/trunk/group__lavc__decoding.html#ga58bc4bf1e0ac59e27362597e467efff3
int response = avcodec_send_packet(pCodecContext, pPacket);
// printf("response %d\n", response);
if (response < 0) {
printf("Error while sending a packet to the decoder: %s\n", av_err2str(response));
return response;
}
while (response >= 0)
{
// Return decoded output data (into a frame) from a decoder
// https://ffmpeg.org/doxygen/trunk/group__lavc__decoding.html#ga11e6542c4e66d3028668788a1a74217c
response = avcodec_receive_frame(pCodecContext, pFrame);
if (response == AVERROR(EAGAIN) || response == AVERROR_EOF) {
break;
} else if (response < 0) {
printf("Error while receiving a frame from the decoder: %s\n", av_err2str(response));
return response;
}
if (response >= 0) {
float time_base = pStream->time_base.num / float(pStream->time_base.den);
printf(
"Frame %d (type=%c, size=%d bytes, format=%d) pts %ld timestampe %.2f key_frame %d [DTS %d]\n",
pCodecContext->frame_number,
av_get_picture_type_char(pFrame->pict_type),
pFrame->pkt_size,
pFrame->format,
pFrame->pts,
pFrame->pts * time_base,
pFrame->key_frame,
pFrame->coded_picture_number
);
// char frame_filename[1024];
// snprintf(frame_filename, sizeof(frame_filename), "%s-%d.pgm", "frame", pCodecContext->frame_number);
// Check if the frame is a planar YUV 4:2:0, 12bpp
// That is the format of the provided .mp4 file
// RGB formats will definitely not give a gray image
// Other YUV image may do so, but untested, so give a warning
// if (pFrame->format != AV_PIX_FMT_YUV420P)
// {
// printf("Warning: the generated file may not be a grayscale image, but could e.g. be just the R component if the video format is RGB");
// }
// save a grayscale frame into a .pgm file
// save_gray_frame(pFrame->data[0], pFrame->linesize[0], pFrame->width, pFrame->height, frame_filename);
}
}
return 0;
}
cmake_minimum_required(VERSION 3.10)
# set the project name
project(ffmpeg_test)
# specify the C++ standard
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# add the executable
add_executable(ffmpeg_test main.cpp)
# link ffmpeg
set(FFMPEG_ROOT "/root/ffmpeg/build")
target_include_directories(ffmpeg_test PUBLIC "${FFMPEG_ROOT}/include")
target_link_libraries(ffmpeg_test
"${FFMPEG_ROOT}/lib/libavutil.so"
"${FFMPEG_ROOT}/lib/libpostproc.so"
"${FFMPEG_ROOT}/lib/libswresample.so"
"${FFMPEG_ROOT}/lib/libswscale.so"
"${FFMPEG_ROOT}/lib/libavfilter.so"
"${FFMPEG_ROOT}/lib/libavdevice.so"
"${FFMPEG_ROOT}/lib/libavformat.so"
"${FFMPEG_ROOT}/lib/libavcodec.so"
)
# link opencv
target_include_directories(ffmpeg_test PUBLIC "/usr/include/opencv4")
target_link_libraries(ffmpeg_test
"/usr/lib/x86_64-linux-gnu/libopencv_core.so"
)
# find_library(OpenCV REQUIRED)
# message(STATUS ${OpenCV_VERSION})
# message(STATUS ${OpenCV_LIBS})
# message(STATUS ${OpenCV_INCLUDE_DIRS})