Why not use FFmpeg to open the video file? I hate giving out code, but this is what I use to open and play video files. It accepts anything FFmpeg can read, not just mpeg2video. It's a copy 'n' paste of a small portion of my code, and for my personal purposes I just needed the frame to be an 8-bit gray frame so I convert all frames to 8-bit gray. If there's a particular part you have a question about, feel free to ask. Otherwise, I'm going to assume the code is self-explanatory.


Video::Video(const std::string& filename) : imageConvertContext(NULL),
buffer(NULL),
grayFrame(NULL),
frame(NULL),
codecContext(NULL),
formatContext(NULL),
videoStreamIndex(-1),
endReached(true),
scaledWidth(0),
scaledHeight(0),
currentFrameNumber(-1)
{
int errorCode = 0;

if ((errorCode = avformat_open_input(&formatContext, filename.c_str(), NULL, NULL)) != 0)
{
throw std::runtime_error("Unable to open the stream");
}

if ((errorCode = avformat_find_stream_info(formatContext, NULL)) < 0)
{
throw std::runtime_error("Unable to find the stream's info");
}

for (unsigned int i = 0; i < formatContext->nb_streams; ++i)
{
if (formatContext->streams->codec->codec_type == AVMEDIA_TYPE_VIDEO)
{
videoStreamIndex = i;
break;
}
}

if (videoStreamIndex == -1)
{
throw std::runtime_error("Unable to find a video stream");
}

codecContext = formatContext->streams[videoStreamIndex]->codec;
codec = avcodec_find_decoder(codecContext->codec_id);
if (codec == NULL)
{
throw std::runtime_error("Unsupported codec");
}

if ((errorCode = avcodec_open2(codecContext, codec, NULL)) != 0)
{
throw std::runtime_error("Error opening the codec");
}

frameRate = formatContext->streams[videoStreamIndex]->avg_frame_rate;
if (!frameRate.num || ! frameRate.den)
{
throw std::runtime_error("This video does not have a constant frame rate");
}

//TODO: if one of these fail, we should release what has succeeded
frame = avcodec_alloc_frame();
grayFrame = avcodec_alloc_frame();
if (frame == NULL || grayFrame == NULL)
{
throw std::runtime_error("Unable to allocate frame memory");
}

int numBytes = avpicture_get_size(PIX_FMT_GRAY8, codecContext->width, codecContext->height);
buffer = (uint8_t*)av_malloc(numBytes * sizeof(uint8_t));

avpicture_fill((AVPicture*)grayFrame, buffer, PIX_FMT_GRAY8, codecContext->width, codecContext->height);

imageConvertContext = sws_getContext(codecContext->width,
codecContext->height,
codecContext->pix_fmt,
codecContext->width,
codecContext->height,
PIX_FMT_GRAY8,
SWS_FAST_BILINEAR,
NULL,
NULL,
NULL);

scaledWidth = codecContext->width;
scaledHeight = codecContext->height;

endReached = false;
}

Video::~Video()
{
sws_freeContext(imageConvertContext);
av_free_packet(&packet);
av_free(buffer);
av_free(grayFrame);
av_free(frame);
avcodec_close(codecContext);
av_close_input_file(formatContext);
}

const AVFrame* Video::getNextFrame()
{
while (av_read_frame(formatContext, &packet) == 0)
{
int frameFinished = 0;
if (packet.stream_index == videoStreamIndex)
{
avcodec_decode_video2(codecContext, frame, &frameFinished, &packet);
if (frameFinished)
{
sws_scale(imageConvertContext,
frame->data,
frame->linesize,
0,
frame->height,
grayFrame->data,
grayFrame->linesize);

++currentFrameNumber;
return grayFrame;
}
}
}

endReached = true;
return NULL;
}