Video creation with the most recent ffmpeg API (20

Question

I have started learning how to work with ffmpeg which has a suffering deprecation of all tutorial and available examples such as this.

I am looking for a code which creates an output video.

Unfortunately, most of good examples are focusing on reading from a file rather than creating one.

Here, I have found a deprecated example and I spent a long time to fix its errors until it became like this:

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string>

extern "C" {
        #include <libavcodec/avcodec.h>
        #include <libavformat/avformat.h>
        #include <libswscale/swscale.h>
        #include <libavformat/avio.h>
        #include <libavutil/opt.h>
}

#define WIDTH 800
#define HEIGHT 480
#define STREAM_NB_FRAMES  ((int)(STREAM_DURATION * FRAME_RATE))
#define FRAME_RATE 24
#define PIXEL_FORMAT AV_PIX_FMT_YUV420P
#define STREAM_DURATION 5.0 //seconds
#define BIT_RATE 400000

#define AV_CODEC_FLAG_GLOBAL_HEADER (1 << 22)
#define CODEC_FLAG_GLOBAL_HEADER AV_CODEC_FLAG_GLOBAL_HEADER
#define AVFMT_RAWPICTURE 0x0020

using namespace std;

static int sws_flags = SWS_BICUBIC;

AVFrame *picture, *tmp_picture;
uint8_t *video_outbuf;
int frame_count, video_outbuf_size;


/****** IF LINUX ******/
inline int sprintf_s(char* buffer, size_t sizeOfBuffer, const char* format, ...)
{
    va_list ap;
    va_start(ap, format);
    int result = vsnprintf(buffer, sizeOfBuffer, format, ap);
    va_end(ap);
    return result;
}

/****** IF LINUX ******/
template<size_t sizeOfBuffer>
inline int sprintf_s(char (&buffer)[sizeOfBuffer], const char* format, ...)
{
    va_list ap;
    va_start(ap, format);
    int result = vsnprintf(buffer, sizeOfBuffer, format, ap);
    va_end(ap);
    return result;
}


static void closeVideo(AVFormatContext *oc, AVStream *st)
{
    avcodec_close(st->codec);
    av_free(picture->data[0]);
    av_free(picture);
    if (tmp_picture)
    {
        av_free(tmp_picture->data[0]);
        av_free(tmp_picture);
    }
    av_free(video_outbuf);
}

static AVFrame *alloc_picture(enum AVPixelFormat pix_fmt, int width, int height)
{
    AVFrame *picture;
    uint8_t *picture_buf;
    int size;

    picture = av_frame_alloc();
    if(!picture)
        return NULL;
    size = avpicture_get_size(pix_fmt, width, height);
    picture_buf = (uint8_t*)(av_malloc(size));
    if (!picture_buf)
    {
        av_free(picture);
        return NULL;
    }
    avpicture_fill((AVPicture *) picture, picture_buf, pix_fmt, WIDTH, HEIGHT);
    return picture;
}

static void openVideo(AVFormatContext *oc, AVStream *st)
{
    AVCodec *codec;
    AVCodecContext *c;

    c = st->codec;
    if(c->idct_algo == AV_CODEC_ID_H264)
        av_opt_set(c->priv_data, "preset", "slow", 0);

    codec = avcodec_find_encoder(c->codec_id);
    if(!codec)
    {
        std::cout << "Codec not found." << std::endl;
        std::cin.get();std::cin.get();exit(1);
    }

    if(codec->id == AV_CODEC_ID_H264)
        av_opt_set(c->priv_data, "preset", "medium", 0);

    if(avcodec_open2(c, codec, NULL) < 0)
    {
        std::cout << "Could not open codec." << std::endl;
        std::cin.get();std::cin.get();exit(1);
    }
    video_outbuf = NULL;
    if(!(oc->oformat->flags & AVFMT_RAWPICTURE))
    {
        video_outbuf_size = 200000;
        video_outbuf = (uint8_t*)(av_malloc(video_outbuf_size));
    }
    picture = alloc_picture(c->pix_fmt, c->width, c->height);
    if(!picture)
    {
        std::cout << "Could not allocate picture" << std::endl;
        std::cin.get();exit(1);
    }
    tmp_picture = NULL;
    if(c->pix_fmt != AV_PIX_FMT_YUV420P)
    {
        tmp_picture = alloc_picture(AV_PIX_FMT_YUV420P, WIDTH, HEIGHT);
        if(!tmp_picture)
        {
            std::cout << " Could not allocate temporary picture" << std::endl;
            std::cin.get();exit(1);
        }
    }
}


static AVStream* addVideoStream(AVFormatContext *context, enum AVCodecID codecID)
{
    AVCodecContext *codec;
    AVStream *stream;
    stream = avformat_new_stream(context, NULL);
    if(!stream)
    {
        std::cout << "Could not alloc stream." << std::endl;
        std::cin.get();exit(1);
    }

    codec = stream->codec;
    codec->codec_id = codecID;
    codec->codec_type = AVMEDIA_TYPE_VIDEO;

    // sample rate
    codec->bit_rate = BIT_RATE;
    // resolution must be a multiple of two
    codec->width = WIDTH;
    codec->height = HEIGHT;
    codec->time_base.den = FRAME_RATE; // stream fps
    codec->time_base.num = 1;
    codec->gop_size = 12; // intra frame every twelve frames at most
    codec->pix_fmt = PIXEL_FORMAT;
    if(codec->codec_id == AV_CODEC_ID_MPEG2VIDEO)
        codec->max_b_frames = 2; // for testing, B frames

    if(codec->codec_id == AV_CODEC_ID_MPEG1VIDEO)
        codec->mb_decision = 2;

    if(context->oformat->flags & AVFMT_GLOBALHEADER)
        codec->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

    return stream;
}

static void fill_yuv_image(AVFrame *pict, int frame_index, int width, int height)
{
    int x, y, i;
    i = frame_index;

    /* Y */
    for(y=0;y<height;y++) {
        for(x=0;x<width;x++) {
            pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;
        }
    }

    /* Cb and Cr */
    for(y=0;y<height/2;y++) {
        for(x=0;x<width/2;x++) {
            pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
            pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
        }
    }
}

static void write_video_frame(AVFormatContext *oc, AVStream *st)
{
    int out_size, ret;
    AVCodecContext *c;
    static struct SwsContext *img_convert_ctx;
    c = st->codec;

    if(frame_count >= STREAM_NB_FRAMES)
    {

    }
    else
    {
        if(c->pix_fmt != AV_PIX_FMT_YUV420P)
        {
            if(img_convert_ctx = NULL)
            {
                img_convert_ctx = sws_getContext(WIDTH, HEIGHT, AV_PIX_FMT_YUV420P, WIDTH, HEIGHT,
                                                c->pix_fmt, sws_flags, NULL, NULL, NULL);
                if(img_convert_ctx == NULL)
                {
                    std::cout << "Cannot initialize the conversion context" << std::endl;
                    std::cin.get();exit(1);
                }
            }
            fill_yuv_image(tmp_picture, frame_count, WIDTH, HEIGHT);
            sws_scale(img_convert_ctx, tmp_picture->data, tmp_picture->linesize, 0, HEIGHT,
                        picture->data, picture->linesize);
        }
        else
        {
            fill_yuv_image(picture, frame_count, WIDTH, HEIGHT);
        }
    }

    if (oc->oformat->flags & AVFMT_RAWPICTURE)
    {
        /* raw video case. The API will change slightly in the near
           futur for that */
        AVPacket pkt;
        av_init_packet(&pkt);

        pkt.flags |= AV_PKT_FLAG_KEY;
        pkt.stream_index= st->index;
        pkt.data= (uint8_t *)picture;
        pkt.size= sizeof(AVPicture);

        ret = av_interleaved_write_frame(oc, &pkt);
    }
    else
    {
        /* encode the image */
        out_size = avcodec_encode_video(c, video_outbuf, video_outbuf_size, picture);
        /* if zero size, it means the image was buffered */
        if (out_size > 0)
        {
            AVPacket pkt;
            av_init_packet(&pkt);

            if (c->coded_frame->pts != AV_NOPTS_VALUE)
                pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);
            if(c->coded_frame->key_frame)
                pkt.flags |= AV_PKT_FLAG_KEY;
            pkt.stream_index= st->index;
            pkt.data= video_outbuf;
            pkt.size= out_size;
            /* write the compressed frame in the media file */
            ret = av_interleaved_write_frame(oc, &pkt);
        } else {
            ret = 0;
        }
    }
    if (ret != 0) {
        std::cout << "Error while writing video frames" << std::endl;
        std::cin.get();exit(1);
    }
    frame_count++;
}

int main ( int argc, char *argv[] )
{
    const char* filename = "test.h264";
    AVOutputFormat *outputFormat;
    AVFormatContext *context;
    AVCodecContext *codec;
    AVStream *videoStream;
    double videoPTS;

    // init libavcodec, register all codecs and formats
    av_register_all(); 
    // auto detect the output format from the name
    outputFormat = av_guess_format(NULL, filename, NULL);
    if(!outputFormat)
    {
        std::cout << "Cannot guess output format! Using mpeg!" << std::endl;
        std::cin.get();
        outputFormat = av_guess_format(NULL, "h263" , NULL);
    }
    if(!outputFormat)
    {
        std::cout << "Could not find suitable output format." << std::endl;
        std::cin.get();exit(1);
    }

    context = avformat_alloc_context();
    if(!context)
    {
        std::cout << "Cannot allocate avformat memory." << std::endl;
        std::cin.get();exit(1);
    }
    context->oformat = outputFormat;
    sprintf_s(context->filename, sizeof(context->filename), "%s", filename);
    std::cout << "Is '" << context->filename << "' = '" << filename << "'" << std::endl;


    videoStream = NULL;
    outputFormat->audio_codec = AV_CODEC_ID_NONE;
    videoStream = addVideoStream(context, outputFormat->video_codec);

    /* still needed?
    if(av_set_parameters(context, NULL) < 0)
    {
        std::cout << "Invalid output format parameters." << std::endl;
        exit(0);
    }*/

    av_dump_format(context, 0, filename, 1);

    if(videoStream)
        openVideo(context, videoStream);

    if(!outputFormat->flags & AVFMT_NOFILE)
    {
        if(avio_open(&context->pb, filename, AVIO_FLAG_READ_WRITE) < 0)
        {
            std::cout << "Could not open " << filename << std::endl;
            std::cin.get();exit(1);
        }
    }

    avformat_write_header(context, 0);

    while(true)
    {
        if(videoStream)
            videoPTS = (double) videoStream->pts.val * videoStream->time_base.num / videoStream->time_base.den;
        else
            videoPTS = 0.;

        if((!videoStream || videoPTS >= STREAM_DURATION))
        {
            break;
        }
        write_video_frame(context, videoStream);
    }
    av_write_trailer(context);
    if(videoStream)
        closeVideo(context, videoStream);
    for(int i = 0; i < context->nb_streams; i++)
    {
        av_freep(&context->streams[i]->codec);
        av_freep(&context->streams[i]);
    }

    if(!(outputFormat->flags & AVFMT_NOFILE))
    {
        avio_close(context->pb);
    }
    av_free(context);
    std::cin.get();
    return 0;
}

Compile:

g++ -I ./FFmpeg/ video.cpp -L fflibs -lavcodec -lavformat

The code comes with two errors:

video.cpp:249:84: error: ‘avcodec_encode_video’ was not declared in this scope
         out_size = avcodec_encode_video(c, video_outbuf, video_outbuf_size, picture);
                                                                                    ^


video.cpp: In function ‘int main(int, char**)’:
video.cpp:342:46: error: ‘AVStream {aka struct AVStream}’ has no member named ‘pts’
             videoPTS = (double) videoStream->pts.val * videoStream->time_base.num / videoStream->time_base.den;
                                              ^

and a huge number of warnings for deprecation.

video.cpp: In function ‘void closeVideo(AVFormatContext*, AVStream*)’:
video.cpp:60:23: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
     avcodec_close(st->codec);
                       ^
In file included from video.cpp:9:0:
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
     AVCodecContext *codec;
                     ^
video.cpp:60:23: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
     avcodec_close(st->codec);
                       ^
In file included from video.cpp:9:0:
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
     AVCodecContext *codec;
                     ^
video.cpp:60:23: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
     avcodec_close(st->codec);
                       ^
In file included from video.cpp:9:0:
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
     AVCodecContext *codec;
                     ^
video.cpp: In function ‘AVFrame* alloc_picture(AVPixelFormat, int, int)’:
video.cpp:80:12: warning: ‘int avpicture_get_size(AVPixelFormat, int, int)’ is deprecated [-Wdeprecated-declarations]
     size = avpicture_get_size(pix_fmt, width, height);
            ^
In file included from video.cpp:8:0:
./FFmpeg/libavcodec/avcodec.h:5228:5: note: declared here
 int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height);
     ^
video.cpp:80:12: warning: ‘int avpicture_get_size(AVPixelFormat, int, int)’ is deprecated [-Wdeprecated-declarations]
     size = avpicture_get_size(pix_fmt, width, height);
            ^
In file included from video.cpp:8:0:
./FFmpeg/libavcodec/avcodec.h:5228:5: note: declared here
 int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height);
     ^
video.cpp:80:53: warning: ‘int avpicture_get_size(AVPixelFormat, int, int)’ is deprecated [-Wdeprecated-declarations]
     size = avpicture_get_size(pix_fmt, width, height);
                                                     ^
In file included from video.cpp:8:0:
./FFmpeg/libavcodec/avcodec.h:5228:5: note: declared here
 int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height);
     ^
video.cpp:87:5: warning: ‘int avpicture_fill(AVPicture*, const uint8_t*, AVPixelFormat, int, int)’ is deprecated [-Wdeprecated-declarations]
     avpicture_fill((AVPicture *) picture, picture_buf, pix_fmt, WIDTH, HEIGHT);
     ^
In file included from video.cpp:8:0:
./FFmpeg/libavcodec/avcodec.h:5213:5: note: declared here
 int avpicture_fill(AVPicture *picture, const uint8_t *ptr,
     ^
video.cpp:87:5: warning: ‘int avpicture_fill(AVPicture*, const uint8_t*, AVPixelFormat, int, int)’ is deprecated [-Wdeprecated-declarations]
     avpicture_fill((AVPicture *) picture, picture_buf, pix_fmt, WIDTH, HEIGHT);
     ^
In file included from video.cpp:8:0:
./FFmpeg/libavcodec/avcodec.h:5213:5: note: declared here
 int avpicture_fill(AVPicture *picture, const uint8_t *ptr,
     ^
video.cpp:87:78: warning: ‘int avpicture_fill(AVPicture*, const uint8_t*, AVPixelFormat, int, int)’ is deprecated [-Wdeprecated-declarations]
     avpicture_fill((AVPicture *) picture, picture_buf, pix_fmt, WIDTH, HEIGHT);
                                                                              ^
In file included from video.cpp:8:0:
./FFmpeg/libavcodec/avcodec.h:5213:5: note: declared here
 int avpicture_fill(AVPicture *picture, const uint8_t *ptr,
     ^
video.cpp: In function ‘void openVideo(AVFormatContext*, AVStream*)’:
video.cpp:96:13: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
     c = st->codec;
             ^
In file included from video.cpp:9:0:
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
     AVCodecContext *codec;
                     ^
video.cpp:96:13: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
     c = st->codec;
             ^
In file included from video.cpp:9:0:
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
     AVCodecContext *codec;
                     ^
video.cpp:96:13: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
     c = st->codec;
             ^
In file included from video.cpp:9:0:
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
     AVCodecContext *codec;
                     ^
video.cpp: In function ‘AVStream* addVideoStream(AVFormatContext*, AVCodecID)’:
video.cpp:151:21: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
     codec = stream->codec;
                     ^
In file included from video.cpp:9:0:
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
     AVCodecContext *codec;
                     ^
video.cpp:151:21: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
     codec = stream->codec;
                     ^
In file included from video.cpp:9:0:
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
     AVCodecContext *codec;
                     ^
video.cpp:151:21: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
     codec = stream->codec;
                     ^
In file included from video.cpp:9:0:
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
     AVCodecContext *codec;
                     ^
video.cpp: In function ‘void write_video_frame(AVFormatContext*, AVStream*)’:
video.cpp:202:13: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
     c = st->codec;
             ^
In file included from video.cpp:9:0:
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
     AVCodecContext *codec;
                     ^
video.cpp:202:13: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
     c = st->codec;
             ^
In file included from video.cpp:9:0:
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
     AVCodecContext *codec;
                     ^
video.cpp:202:13: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
     c = st->codec;
             ^
In file included from video.cpp:9:0:
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
     AVCodecContext *codec;
                     ^
video.cpp:256:20: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
             if (c->coded_frame->pts != AV_NOPTS_VALUE)
                    ^
In file included from video.cpp:8:0:
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
     attribute_deprecated AVFrame *coded_frame;
                                   ^
video.cpp:256:20: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
             if (c->coded_frame->pts != AV_NOPTS_VALUE)
                    ^
In file included from video.cpp:8:0:
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
     attribute_deprecated AVFrame *coded_frame;
                                   ^
video.cpp:256:20: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
             if (c->coded_frame->pts != AV_NOPTS_VALUE)
                    ^
In file included from video.cpp:8:0:
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
     attribute_deprecated AVFrame *coded_frame;
                                   ^
video.cpp:257:42: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
                 pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);
                                          ^
In file included from video.cpp:8:0:
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
     attribute_deprecated AVFrame *coded_frame;
                                   ^
video.cpp:257:42: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
                 pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);
                                          ^
In file included from video.cpp:8:0:
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
     attribute_deprecated AVFrame *coded_frame;
                                   ^
video.cpp:257:42: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
                 pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);
                                          ^
In file included from video.cpp:8:0:
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
     attribute_deprecated AVFrame *coded_frame;
                                   ^
video.cpp:258:19: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
             if(c->coded_frame->key_frame)
                   ^
In file included from video.cpp:8:0:
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
     attribute_deprecated AVFrame *coded_frame;
                                   ^
video.cpp:258:19: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
             if(c->coded_frame->key_frame)
                   ^
In file included from video.cpp:8:0:
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
     attribute_deprecated AVFrame *coded_frame;
                                   ^
video.cpp:258:19: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
             if(c->coded_frame->key_frame)
                   ^
In file included from video.cpp:8:0:
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
     attribute_deprecated AVFrame *coded_frame;
                                   ^
video.cpp:357:40: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
         av_freep(&context->streams[i]->codec);
                                        ^
In file included from video.cpp:9:0:
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
     AVCodecContext *codec;
                     ^
video.cpp:357:40: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
         av_freep(&context->streams[i]->codec);
                                        ^
In file included from video.cpp:9:0:
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
     AVCodecContext *codec;
                     ^
video.cpp:357:40: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
         av_freep(&context->streams[i]->codec);
                                        ^
In file included from video.cpp:9:0:
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
     AVCodecContext *codec;
                     ^
video.cpp:337:38: warning: ignoring return value of ‘int avformat_write_header(AVFormatContext*, AVDictionary**)’, declared with attribute warn_unused_result [-Wunused-result]
     avformat_write_header(context, 0);
                                      ^

I have also defined a few macros to redefine those who have been omited. In a modern ffmpeg API, they must be replaced.

Could someone please help me solving errors and deprecation warnings to comply with recent ffmpeg API?

Answer 1

As the comment says your API is very old one. Check newer samples from here: https://github.com/FFmpeg/FFmpeg/tree/master/doc/examples

Some deprecation warnings may not be solved like as in ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]. Last time I check latest FFmpeg itself uses this too. Hope that helps.