c++ffmpeg

cannot assign to type: what is wrong in the FFMPEG example?

I am trying the example hw_decode.c from FFMPEG, however, I am using those functions inside a class:

class FFreader
{
    AVPixelFormat get_hw_format(AVCodecContext* ctx, const AVPixelFormat* pix_fmts)
    {

etc.

VS2022 is complaining about the assignment: why ? how to correct this ?

decoder_ctx->get_format  = get_hw_format;

I tried with a lambda:

decoder_ctx->get_format = [this](AVCodecContext* a, const AVPixelFormat* b){return get_hw_format(a, b); };

with no success.

Here is the error message:

Error C2440 '=': cannot convert from 'FFreader::maindecode::<lambda_1>' to 'AVPixelFormat (__cdecl *)(AVCodecContext *,const AVPixelFormat *)' projectname FFreader.h 210

Full source:

#pragma once
#include <string>
#include <stdio.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/mem.h>
#include <libavutil/pixdesc.h>
#include <libavutil/hwcontext.h>
#include <libavutil/opt.h>
#include <libavutil/avassert.h>
#include <libavutil/imgutils.h>

class FFreader
{
    AVBufferRef* hw_device_ctx{};
    AVPixelFormat hw_pix_fmt{};
    FILE* output_file{};

    int hw_decoder_init(AVCodecContext* ctx, const enum AVHWDeviceType type)
    {
        int err{};
        if ((err = av_hwdevice_ctx_create(&hw_device_ctx, type, NULL, NULL, 0)) < 0)
        {
            fprintf(stderr, "Failed to create specified HW device.\n");
            return err;
        }
        ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);
        return err;
    }

    AVPixelFormat get_hw_format(AVCodecContext* ctx, const AVPixelFormat* pix_fmts)
    {
        const AVPixelFormat* p{};
        for (p = pix_fmts; *p != -1; p++)
        {
            if (*p == hw_pix_fmt)
                return *p;
        }
        fprintf(stderr, "Failed to get HW surface format.\n");
        return AV_PIX_FMT_NONE;
    }

    int decode_write(AVCodecContext* avctx, AVPacket* packet)
    {
        AVFrame* frame{};
        AVFrame*sw_frame{};
        AVFrame* tmp_frame{};
        uint8_t* buffer{};
        int size{};
        int status{};

        status = avcodec_send_packet(avctx, packet);
        if (status < 0)
        {
            fprintf(stderr, "Error during decoding\n");
            return status;
        }

        while (true)
        {
            frame = av_frame_alloc();
            sw_frame = av_frame_alloc();
            if (!frame || !sw_frame)
            {
                fprintf(stderr, "Can not alloc frame\n");
                status = AVERROR(ENOMEM);
                break;
            }
            status = avcodec_receive_frame(avctx, frame);
            if (status == AVERROR(EAGAIN) || status == AVERROR_EOF)
            {
                av_frame_free(&frame);
                av_frame_free(&sw_frame);
                return 0;
            }
            if (status < 0)
            {
                fprintf(stderr, "Error while decoding\n");
                break;
            }

            // TODO keep in gpu
            if (frame->format == hw_pix_fmt)
            {
                /* retrieve data from GPU to CPU */
                status = av_hwframe_transfer_data(sw_frame, frame, 0);
                if (status < 0)
                {
                    fprintf(stderr, "Error transferring the data to system memory\n");
                    break;
                }
                tmp_frame = sw_frame;
            }
            else
                tmp_frame = frame;

            size = av_image_get_buffer_size(static_cast<AVPixelFormat>(tmp_frame->format), tmp_frame->width, tmp_frame->height, 1);
            buffer = static_cast<uint8_t*>(av_malloc(size));
            if (!buffer)
            {
                fprintf(stderr, "Can not alloc buffer\n");
                status = AVERROR(ENOMEM);
                break;

            }
            status = av_image_copy_to_buffer(buffer, size, tmp_frame->data, tmp_frame->linesize,
                static_cast<AVPixelFormat>(tmp_frame->format), tmp_frame->width, tmp_frame->height, 1);
            if (status < 0)
            {
                fprintf(stderr, "Can not copy image to buffer\n");
                break;
            }
            if ((status = fwrite(buffer, 1, size, output_file)) < 0)
            {
                fprintf(stderr, "Failed to dump raw data.\n");
                break;
            }
        }

        av_frame_free(&frame);
        av_frame_free(&sw_frame);
        av_freep(&buffer);
        if (status < 0)
            return status;
    }

    int maindecode(int argc, char* argv[])
    {
        AVFormatContext* input_ctx = NULL;
        int video_stream, ret;
        AVStream* video = NULL;
        AVCodecContext* decoder_ctx = NULL;
        const AVCodec* decoder = NULL;
        AVPacket* packet = NULL;
        enum AVHWDeviceType type;
        int i;

        if (argc < 4)
        {
            fprintf(stderr, "Usage: %s <device type> <input file> <output file>\n", argv[0]);
            return -1;
        }

        type = av_hwdevice_find_type_by_name(argv[1]);
        if (type == AV_HWDEVICE_TYPE_NONE)
        {
            fprintf(stderr, "Device type %s is not supported.\n", argv[1]);
            fprintf(stderr, "Available device types:");
            while ((type = av_hwdevice_iterate_types(type)) != AV_HWDEVICE_TYPE_NONE)
                fprintf(stderr, " %s", av_hwdevice_get_type_name(type));
            fprintf(stderr, "\n");
            return -1;
        }

        packet = av_packet_alloc();
        if (!packet)
        {
            fprintf(stderr, "Failed to allocate AVPacket\n");
            return -1;
        }

        /* open the input file */
        if (avformat_open_input(&input_ctx, argv[2], NULL, NULL) != 0)
        {
            fprintf(stderr, "Cannot open input file '%s'\n", argv[2]);
            return -1;
        }

        if (avformat_find_stream_info(input_ctx, NULL) < 0)
        {
            fprintf(stderr, "Cannot find input stream information.\n");
            return -1;
        }

        /* find the video stream information */
        ret = av_find_best_stream(input_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &decoder, 0);
        if (ret < 0)
        {
            fprintf(stderr, "Cannot find a video stream in the input file\n");
            return -1;
        }
        video_stream = ret;

        for (i = 0;; i++)
        {
            const AVCodecHWConfig* config = avcodec_get_hw_config(decoder, i);
            if (!config)
            {
                fprintf(stderr, "Decoder %s does not support device type %s.\n",
                        decoder->name, av_hwdevice_get_type_name(type));
                return -1;
            }
            if (config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX &&
                config->device_type == type)
            {
                hw_pix_fmt = config->pix_fmt;
                break;
            }
        }

        if (!(decoder_ctx = avcodec_alloc_context3(decoder)))
            return AVERROR(ENOMEM);

        video = input_ctx->streams[video_stream];
        if (avcodec_parameters_to_context(decoder_ctx, video->codecpar) < 0)
            return -1;


        //set callback
        decoder_ctx->get_format = [this](AVCodecContext* a, const AVPixelFormat* b){return get_hw_format(a, b); };

        if (hw_decoder_init(decoder_ctx, type) < 0)
            return -1;

        if ((ret = avcodec_open2(decoder_ctx, decoder, NULL)) < 0)
        {
            fprintf(stderr, "Failed to open codec for stream #%u\n", video_stream);
            return -1;
        }

        /* open the file to dump raw data */
        output_file = fopen(argv[3], "w+b");

        /* actual decoding and dump the raw data */
        while (ret >= 0)
        {
            if ((ret = av_read_frame(input_ctx, packet)) < 0)
                break;

            if (video_stream == packet->stream_index)
                ret = decode_write(decoder_ctx, packet);

            av_packet_unref(packet);
        }

        /* flush the decoder */
        ret = decode_write(decoder_ctx, NULL);

        if (output_file)
            fclose(output_file);
        av_packet_free(&packet);
        avcodec_free_context(&decoder_ctx);
        avformat_close_input(&input_ctx);
        av_buffer_unref(&hw_device_ctx);

        return 0;
    }
};

Original example: the assignment in the context: https://github.com/FFmpeg/FFmpeg/blob/7f51cf75c6efb6a358b4cdb683cfbd8370d56a8f/doc/examples/hw_decode.c#L221

Solution

  • C library can not handle pointer to non-static class member. You need to make callback static (and noexcept). In order to pass class instance you can use AVCodecContext::opaque field:

    class FFreader
{
    static AVPixelFormat
    get_hw_format_sink(AVCodecContext* ctx, const AVPixelFormat* pix_fmts) noexcept
    {
         return static_cast<FFreader*>(ctx->opaque)->get_hw_format(ctx,pix_fmts);
    }

    AVPixelFormat
    get_hw_format(AVCodecContext* ctx, const AVPixelFormat* pix_fmts)
    {
        ...