How parse and decode H264 file with libav/ffmpeg? - c++

Question

According to official documentations I try decode my test.mp4 with AV_CODEC_ID_H264.
Of course I can do this with av_read_frame(), but how do it with av_parser_parse2()?
The problem occurs at avcodec_send_packet(...) at decode_nal_units(...) at ff_h2645_packet_split(...) [h264dec.c]
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
}
//#define INBUF_SIZE 4096
#define INBUF_SIZE 256000
void decode(AVCodecContext* dec_ctx, AVFrame* frame, AVPacket* pkt, const char* filename);
int main(int argc, char** argv)
{
const char* filename;
const AVCodec* codec;
AVFormatContext* formatCtx = NULL;
AVCodecParserContext* parser;
AVCodecContext* c = NULL;
AVStream* videoStream = NULL;
FILE* f;
AVFrame* frame;
uint8_t inbuf[INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
uint8_t* data;
size_t data_size;
int ret;
AVPacket* pkt;
filename = "D:\\test.mp4";
//if (avformat_open_input(&formatCtx, filename, nullptr, nullptr) < 0) {
// throw std::exception("Could not open source file");
//}
//if (avformat_find_stream_info(formatCtx, nullptr) < 0) {
// throw std::exception("Could not find stream information");
//}
//videoStream = formatCtx->streams[0];
pkt = av_packet_alloc();
if (!pkt)
exit(1);
/* set end of buffer to 0 (this ensures that no overreading happens for damaged MPEG streams) */
memset(inbuf + INBUF_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);
/* find the MPEG-1 video decoder */
//codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
codec = avcodec_find_decoder(AV_CODEC_ID_H264);
if (!codec) {
fprintf(stderr, "Codec not found\n");
exit(1);
}
parser = av_parser_init(codec->id);
if (!parser) {
fprintf(stderr, "parser not found\n");
exit(1);
}
parser->flags = PARSER_FLAG_COMPLETE_FRAMES;
c = avcodec_alloc_context3(codec);
if (!c) {
fprintf(stderr, "Could not allocate video codec context\n");
exit(1);
}
/* For some codecs, such as msmpeg4 and mpeg4, width and height
MUST be initialized there because this information is not
available in the bitstream. */
//avcodec_parameters_to_context(c, videoStream->codecpar);
/* open it */
if (avcodec_open2(c, codec, NULL) < 0) {
fprintf(stderr, "Could not open codec\n");
exit(1);
}
f = fopen(filename, "rb");
if (!f) {
fprintf(stderr, "Could not open %s\n", filename);
exit(1);
}
frame = av_frame_alloc();
if (!frame) {
fprintf(stderr, "Could not allocate video frame\n");
exit(1);
}
// ---- Use parser to get packets ----
while (!feof(f)) {
/* read raw data from the input file */
data_size = fread(inbuf, 1, INBUF_SIZE, f);
if (!data_size)
break;
/* use the parser to split the data into frames */
data = inbuf;
while (data_size > 0) {
ret = av_parser_parse2(parser, c, &pkt->data, &pkt->size, data, data_size, AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0);
if (ret < 0) {
fprintf(stderr, "Error while parsing\n");
exit(1);
}
data += ret;
data_size -= ret;
if (pkt->size)
decode(c, frame, pkt, outfilename);
}
}
// ---- Use FormatContext to get packets ----
// while (av_read_frame(fmt_ctx, pkt) == 0)
// {
// if (pkt->stream_index == AVMEDIA_TYPE_VIDEO) {
// if (pkt->size > 0)
// decode(cdc_ctx, frame, pkt, fp_out);
// }
// }
/* flush the decoder */
decode(c, frame, NULL, outfilename);
fclose(f);
av_parser_close(parser);
avcodec_free_context(&c);
av_frame_free(&frame);
av_packet_free(&pkt);
return 0;
}
void decode(AVCodecContext* dec_ctx, AVFrame* frame, AVPacket* pkt, const char* filename)
{
char buf[1024];
int ret;
ret = avcodec_send_packet(dec_ctx, pkt);
if (ret < 0) {
char buff[255]{ 0 };
std::string strError = av_make_error_string(buff, 255, ret);
fprintf(stderr, "Error sending a packet for decoding\n");
exit(1);
}
while (ret >= 0) {
ret = avcodec_receive_frame(dec_ctx, frame);
if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
return;
else if (ret < 0) {
fprintf(stderr, "Error during decoding\n");
exit(1);
}
printf("saving frame %3d\n", dec_ctx->frame_number);
fflush(stdout);
/* the picture is allocated by the decoder. no need to
free it */
// handle frame ...
}
}