Decode a video file from memory using libav

Question

Supose I have an entire video file in memory and I want to use libav to decode the whole frames. How should I do it? The point is that I can do it reading directly from a file using avformat_open_input() function but I do need to do it from a file which is stored in memory.

My AVIOContext implementation:

class AVIOMemContext
{

public:

    AVIOMemContext(char* videoData, const int videoLen)
    {
        // Output buffer
        bufferSize = 32768;
        buffer = static_cast<char*>(av_malloc(bufferSize));

        // Internal buffer
        pos = 0;
        this->videoData = videoData;
        this->videoLen = videoLen;

        ctx_ = avio_alloc_context((unsigned char*) buffer, bufferSize, AVIO_FLAG_READ, this, &AVIOMemContext::read, &AVIOMemContext::write, &AVIOMemContext::seek);
    }

    ~AVIOMemContext()
    {
        av_free(videoData);
    }

    static int read(void *opaque, unsigned char *buf, int buf_size)
    {
        AVIOMemContext* This = static_cast<AVIOMemContext*>(opaque);

        // Read from pos to pos + buf_size
        if (This->pos + buf_size > This->videoLen)
        {
            int len = This->videoLen - This->pos;
            memcpy(buf, This->videoData + This->pos, len);
            return len;
        }
        else
        {
            memcpy(buf, This->videoData + This->pos, buf_size);
            return buf_size;
        }
    }

    static int write(void *opaque, unsigned char *buf, int buf_size)
    {
        /*
        AVIOMemContext* This = static_cast<AVIOMemContext*>(opaque);
        return fwrite(buf, 1, buf_size, This->f_);
        */

        return 0;
    }

    static int64_t seek(void *opaque, int64_t offset, int whence)
    {
        AVIOMemContext* This = static_cast<AVIOMemContext*>(opaque);

        if (offset + whence > This->videoLen)
        {
            This->pos = This->videoLen;

            return -1;
        }
        else
        {
            This->pos = offset + whence;

            return 0;
        }
    }

    AVIOContext *get_avio()
    {
        return ctx_;
    }

private:

    // Output buffer
    int bufferSize;
    char* buffer;

    // Internal buffer
    int pos;
    char* videoData;
    int videoLen;

    AVIOContext* ctx_;

};

My current code:

[...]

av_register_all();
avcodec_register_all();

AVFormatContext* context;
AVCodec* pCodec;
AVPacket packet;
AVCodecContext* pCodecCtx;
int video_stream_index;
int res;
int got_picture;

// Init variables and objects
context = avformat_alloc_context();

AVIOMemContext priv_ctx(videoData, videoLen); 
context->pb = priv_ctx.get_avio();

res = avformat_find_stream_info(context, NULL);

if (res < 0)
{
    // Error
    avformat_free_context(context);

    return 0;
}

// Obtain the video stream of the total set of streams
for (unsigned int k = 0; k < context->nb_streams; ++k)
{
    if (context->streams[k]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
        video_stream_index = k;
    context->streams[k]->codec->time_base.den = 90000;
}

pCodecCtx = context->streams[video_stream_index]->codec;
pCodec = avcodec_find_decoder(pCodecCtx->codec_id);

avcodec_open(pCodecCtx, pCodec);

//allocate video frame
AVFrame *pFrame = avcodec_alloc_frame();

unsigned int nFrame = 0;

while (av_read_frame(context, &packet) >= 0)

[...]

Thanks in advance,

Dídac Pérez

Answer 1

You can create your own AVIOContext. You have to call ::avio_alloc_context then set it to AVFormatContext::pb. For details, see my answer to How can libavformat be used without using other libav libraries?