How do you properly free a BitStreamFilter (bsf) without getting a double free error?

I'm trying to write a C++ class handling MP4 movies via ffmpeg.

First I created a couple of functions to use with std::unique<>() so that way things get released even on exceptions.

However, I get a double free when I try to free the BitStreamFilter object, yet the documentation clearly says that each av_bsf_alloc() must be paired with an av_bsf_free() call.

@param ctx a pointer into which the pointer to the newly-allocated context will be written. It must be freed with av_bsf_free() after the filtering is done.

Note: emphasis mine.

However, at the time I call the avformat_close_input() I get a double free error, even if I haven't used the two contexts for anything!? I'm thinking that there may be a packet that both allocate and both try to free. But since these two contexts are not directly connected, I really don't understand how they end up freeing something twice.

Below is code which reproduce the error (at least on an amd64 platform). Once compiled, you can just execute it. Make sure to specify a filename as in:

./ffmpeg_demuxer_test mymovie.mp4

I used the following command to compile & link the code:

$ /usr/bin/c++ -std=c++17 -DDEBUG -D_DEBUG -D_GLIBCXX_ASSERTIONS -g -O0 \
    -fsanitize=address -fsanitize=enum -fsanitize=unreachable \
    -o ffmpeg_demuxer_test ffmpeg_demuxer_test.cpp \
    -lavformat -lavcodec

Notice the -fsanitize=... options to capture errors such as a double free error.

Here is the code:

extern "C" {
#include    <libavformat/avformat.h>
#include    <libavformat/avio.h>
#include    <libavcodec/avcodec.h>
}
#include    <iostream>
#include    <memory>


void ffmpeg_demuxer_avformat_context_free(AVFormatContext * context)
{
    if(context != nullptr) avformat_close_input(&context);
}

void ffmpeg_demuxer_av_bsf_free(AVBSFContext * context)
{
    if(context != nullptr) av_bsf_free(&context);
}


int main(int argc, char * argv [])
{
    if(argc != 2)
    {
        std::cout << "Usage: " << argv[0] << " movie.mp4" << std::endl;
        exit(1);
    }

    // init the AV libraries
    //
    av_register_all();
    avformat_network_init();

    // allocate the AVFormatContext
    //
    AVFormatContext * format_context(nullptr);
    int const r1(avformat_open_input(
                  &format_context
                , argv[1]
                , nullptr           // input format
                , nullptr));        // options
    if(r1 != 0
    || format_context == nullptr)
    {
        throw std::bad_alloc();
    }

    auto f_format_context = std::unique_ptr<
              AVFormatContext
            , decltype(&ffmpeg_demuxer_avformat_context_free)>(
                      format_context
                    , &ffmpeg_demuxer_avformat_context_free);


    // now allocate a stream
    //
    if(avformat_find_stream_info(f_format_context.get(), nullptr) < 0)
    {
        throw std::runtime_error("ffmpeg: Could not find stream info");
    }

    auto f_video_stream_index = av_find_best_stream(
              f_format_context.get()
            , AVMEDIA_TYPE_VIDEO
            , -1            // wanted stream (any)
            , -1            // related stream (none)
            , nullptr       // AVCodec *
            , 0);           // flags
    if(f_video_stream_index < 0)
    {
        throw std::runtime_error("ffmpeg: Could not find stream in input file");
    }
    if(static_cast<unsigned int>(f_video_stream_index) >= f_format_context->nb_streams)
    {
        throw std::range_error("ffmpeg: Stream index out of range");
    }

    auto f_stream = f_format_context->streams[f_video_stream_index];

    auto f_video_codec = f_stream->codecpar->codec_id;

    int f_bit_depth(0);
    switch(f_stream->codecpar->format)
    {
    case AV_PIX_FMT_YUV420P10LE:
        f_bit_depth = 10;
        break;

    case AV_PIX_FMT_YUV420P12LE:
        f_bit_depth = 12;
        break;

    default:
        f_bit_depth = 8;
        break;

    }

    bool f_mp4_h264 = f_video_codec == AV_CODEC_ID_H264 && (
               strcmp(f_format_context->iformat->long_name, "QuickTime / MOV") == 0
            || strcmp(f_format_context->iformat->long_name, "FLV (Flash Video)") == 0
            || strcmp(f_format_context->iformat->long_name, "Matroska / WebM") == 0
        );

    if(f_mp4_h264)
    {
        AVBitStreamFilter const * bsf_stream_filter(av_bsf_get_by_name("h264_mp4toannexb"));
        if(bsf_stream_filter == nullptr)
        {
            throw std::runtime_error("av_bsf_get_by_name(\"h264_mp4toannexb\") failed");
        }
        AVBSFContext * bsf_context(nullptr);
        int const r2(av_bsf_alloc(bsf_stream_filter, &bsf_context));
        if(r2 < 0
        || bsf_context == nullptr)
        {
            throw std::bad_alloc();
        }
        auto f_bsf_context = std::unique_ptr<
                  AVBSFContext
                , decltype(&ffmpeg_demuxer_av_bsf_free)>(
                          bsf_context
                        , &ffmpeg_demuxer_av_bsf_free);
        f_bsf_context->par_in = f_stream->codecpar;
        if(av_bsf_init(f_bsf_context.get()) < 0)
        {
            throw std::runtime_error("av_bsf_init() failed");
        }
    }

    return 0;
}

So. Am I misreading the documentation or misusing one of the free/close function? I don't think that the AVBSFContext itself gets released when I close the AVFormatContext, but I may be mistaken?

I won't put "C" as a tag since it will get removed even though this applies to C. It's not because I use C++ that I get a double free (i.e. it happens in the ffmpeg C library).