Allen's Blog

I’ve used FFMPEG library for a while. Actually, the FFMPEG library’s decoding process flow can be described as the following picture. If you want to read the videos and then save to jpeg file, you can take a look on my programming code (tested on FFMPEG ver. 4 library).

// VideoProcessing.cpp 
//
#pragma once
using namespace std;
#include <iostream>
extern "C" 
{
    #include <libavcodec/avcodec.h>
    #include <libavdevice/avdevice.h>
    #include <libavformat/avformat.h>
    #include <libavfilter/avfilter.h>
    #include <libavutil/avutil.h>
    #include <libswscale/swscale.h>
    #pragma comment(lib, "avcodec.lib")
    #pragma comment(lib, "avdevice.lib")
    #pragma comment(lib, "avformat.lib")
    #pragma comment(lib, "avfilter.lib")
    #pragma comment(lib, "avutil.lib")
    #pragma comment(lib, "swscale.lib")
}

void SaveToJPEG(AVFrame* pFrame, const char * folderName, int index)

{

    // Setup Output Path
    char outFile[256] = { 0 };
    sprintf_s(outFile, sizeof(outFile)/sizeof(outFile[0]), "%s\OutputImages-%d.jpg", folderName, index);


    AVFormatContext* pFormatCtx = avformat_alloc_context();

    // Setup the output format
    pFormatCtx->oformat = av_guess_format("mjpeg", NULL, NULL);

    // Initializext 
    if (avio_open(&pFormatCtx->pb, outFile, AVIO_FLAG_READ_WRITE) < 0) {

        printf("Couldn't open output file.");

        return;

    }

    // Get a new Stream from the indicated format context
    AVStream* pAVStream = avformat_new_stream(pFormatCtx, 0);

    if (pAVStream == NULL) {

        return;

    }

    // Find encoder from the codec identifier.

    AVCodec* pCodec = avcodec_find_encoder(pFormatCtx->oformat->video_codec);
    
    if (!pCodec) {
        printf("Codec not found.");
        return;
    }
    // Setup the codec context
    AVCodecContext* codecCtx = avcodec_alloc_context3(pCodec);
    codecCtx->codec_id =  pFormatCtx->oformat->video_codec;
    codecCtx->codec_type = AVMEDIA_TYPE_VIDEO;
    codecCtx->pix_fmt = AV_PIX_FMT_YUVJ420P;
    codecCtx->width = pFrame->width;
    codecCtx->height = pFrame->height;
    codecCtx->time_base = AVRational{ 1,25 };
    
    // Open the codec
    if (avcodec_open2(codecCtx, pCodec, NULL) < 0) {

        printf("Could not open codec.");

        return;

    }
    // assign the codec context to the stream parameters.
    avcodec_parameters_from_context(pAVStream->codecpar, codecCtx);


    //Write Header 
    avformat_write_header(pFormatCtx, NULL);

    int y_size = (codecCtx->width) * (codecCtx->height);

    // assign large enough space
    AVPacket pkt;

    av_new_packet(&pkt, y_size); 

    int got_picture = 0;

    // Use avcodec_send_frame()/avcodec_receive_packet() instead
    int ret = avcodec_send_frame(codecCtx, pFrame);

    if (ret < 0) {

        printf("Encode Error.n");

        return;

    }
    else
    {
        ret = avcodec_receive_packet(codecCtx, &pkt);

        ret = av_write_frame(pFormatCtx, &pkt);

    }

    av_packet_unref(&pkt);

    //Write Trailer 
    av_write_trailer(pFormatCtx);

    printf("Encode Successful.n");

    avcodec_close(codecCtx);

    avio_close(pFormatCtx->pb);
    
    avformat_free_context(pFormatCtx);
    avcodec_free_context(&codecCtx);
}

int main(int argc, char * argv[])
{

    if (argc < 2) {
        cout << "You need to specify a media file." << endl;
        cout << "Command line : VideoProcessing.exe [input_video_path] [output_folder]" << endl;
        return -1;
    }

    AVFormatContext* pFormatContext = avformat_alloc_context();
    if (!pFormatContext) {
        cout << "ERROR could not allocate memory for Format Context" << endl;
        return -1;
    }

    if (avformat_open_input(&pFormatContext, argv[1], NULL, NULL) != 0) {
        cout << "ERROR could not open the file" << endl;
        return -1;
    }

    if (avformat_find_stream_info(pFormatContext, NULL) < 0) {
        cout << "ERROR could not get the stream info" << endl;
        return -1;
    }

    // Initialize the codec, paramters for subsequent useage. 
    AVCodec* pCodec = NULL;
    AVCodecParameters* pCodecParameters = NULL;
    int videoStreamIndex = -1;

    for (int i = 0; i < pFormatContext->nb_streams; i++)
    {
        AVCodecParameters* pLocalCodecParameters = NULL;
        // Read the codec parameters corresponding to each stream.
        pLocalCodecParameters = pFormatContext->streams[i]->codecpar;

        AVCodec* pLocalCodec = NULL;
        pLocalCodec = avcodec_find_decoder(pLocalCodecParameters->codec_id);

        if (pLocalCodec == NULL)
        {
            cout << "[ERROR] Cannot find the codec" << endl;
        }

        if (pLocalCodecParameters->codec_type == AVMEDIA_TYPE_VIDEO)
        {
            if (videoStreamIndex == -1)
            {
                videoStreamIndex = i;
                pCodec = pLocalCodec;
                pCodecParameters = pLocalCodecParameters;
            }
        }
    }

    AVCodecContext* pCodecContext = avcodec_alloc_context3(pCodec);
    if (pCodecContext == NULL)
    {
        cout << "Fail to allocate the memoery to the Codec Context." << endl;
        return -1;
    }

    if (avcodec_parameters_to_context(pCodecContext, pCodecParameters) < 0)
    {
        cout << "failed to copy codec params to codec context" << endl;
        return -1;
    }

    if (avcodec_open2(pCodecContext, pCodec, NULL) < 0)
    {
        cout << "failed to open codec through avcodec_open2" << endl;
        return -1;
    }

    AVFrame* pFrame = av_frame_alloc();
    if (!pFrame)
    {
        cout << "failed to allocated memory for AVFrame" << endl;
        return -1;
    }

    AVPacket* pPacket = av_packet_alloc();
    if (!pPacket)
    {
        cout << "failed to allocated memory for AVPacket" << endl;
        return -1;
    }

    int indexOfFrame = 0;
    while (av_read_frame(pFormatContext, pPacket) >= 0)
    {
        // if it's the video stream
        if (pPacket->stream_index == videoStreamIndex) {
            int response = avcodec_send_packet(pCodecContext, pPacket);
            if (response < 0)
            {
                break;
            }
            else
            {
                response = avcodec_receive_frame(pCodecContext, pFrame);

                if (response >= 0)
                {
                    indexOfFrame++;
                    SaveToJPEG(pFrame, argv[2], indexOfFrame);
                }
            }
        }
        av_packet_unref(pPacket);
        // Limit the number of output frame to be 5.
        if (indexOfFrame == 5)
        {
            break;
        }

    }
    // https://ffmpeg.org/doxygen/trunk/group__lavc__packet.html#ga63d5a489b419bd5d45cfd09091cbcbc2
    avformat_close_input(&pFormatContext);
    av_frame_free(&pFrame);
    avcodec_free_context(&pCodecContext);
}

Reference: