FFmpeg解析视频保存为yuv

［作为自己备份代码使用，尚未优化］

#include "MyFilterVideo.h"

#define __STDC_CONSTANT_MACROS

#include "MyEncodeYUV.h"

#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavfilter/avfiltergraph.h>

#include <libavfilter/avcodec.h>

#include <libavfilter/buffersink.h>

#include <libavfilter/buffersrc.h>

#include <libavutil/avutil.h>

#include <libswscale/swscale.h>

#include <libavutil/eval.h>

#include <libavutil/display.h>

#include "MyMuxerToMP4.h"

#include "MyDecodAudioToAac.h"

#define ENABLE_YUVFILE 1

//add by nil 旋转角度

#define MT_VIDEO_ROTATE_0 0

#define MT_VIDEO_ROTATE_90 90

#define MT_VIDEO_ROTATE_180 180

#define MT_VIDEO_ROTATE_270 270

const char *filter_descr = "movie=my_logo.png[wm];[in][wm]overlay=5:5[out]";

AVFormatContext *pFormatCtx;

AVCodecContext *pCodecCtx;

AVFilterContext *buffersink_ctx;

AVFilterContext *buffersrc_ctx;

AVFilterGraph *filter_graph;

//add by nil

AVDictionary *format_opts = NULL;

//=======

static int video_stream_index = -1;

static int64_t last_pts = AV_NOPTS_VALUE;

int frameCount=0;//一个多少帧

int getRotateAngle(AVStream* avStream)

{

    AVDictionaryEntry *tag = NULL;

    int   m_Rotate=-1;

    tag = av_dict_get(avStream->metadata, "rotate", tag, 0);

    if (tag==NULL)

    {

        m_Rotate = 0;

    }

    else

    {

        int angle = atoi(tag->value);

        angle %= 360;

        if (angle == 90)

        {

            m_Rotate = MT_VIDEO_ROTATE_90;

        }

        else if (angle == 180)

        {

            m_Rotate = MT_VIDEO_ROTATE_180;

        }

        else if (angle == 270)

        {

            m_Rotate = MT_VIDEO_ROTATE_270;

        }

        else

        {

            m_Rotate = MT_VIDEO_ROTATE_0;

        }

    }

    return m_Rotate;

}

static int open_input_file(const char *filename)

{

    int ret;

    AVCodec *dec;

    

    if ((ret = avformat_open_input(&pFormatCtx, filename, NULL, &format_opts)) < 0) {

        printf( "Cannot open input file\n");

        return ret;

    }

    

   

    if ((ret = avformat_find_stream_info(pFormatCtx, NULL)) < 0) {

        printf( "Cannot find stream information\n");

        return ret;

    }

    

    

    /* select the video stream */

    ret = av_find_best_stream(pFormatCtx, AVMEDIA_TYPE_VIDEO, -1, -1, &dec, 0);

    if (ret < 0) {

        printf( "Cannot find a video stream in the input file\n");

        return ret;

    }

    video_stream_index = ret;

    pCodecCtx = pFormatCtx->streams[video_stream_index]->codec;

   

    

    

    /* init the video decoder */

    if ((ret = avcodec_open2(pCodecCtx, dec, NULL)) < 0) {

        printf( "Cannot open video decoder\n");

        return ret;

    }

    

    return 0;

}

static int init_filters(const char *filters_descr)

{

    char args[512];

    int ret;

    AVFilter *buffersrc  = avfilter_get_by_name("buffer");

    AVFilter *buffersink = avfilter_get_by_name("ffbuffersink");

    AVFilterInOut *outputs = avfilter_inout_alloc();

    AVFilterInOut *inputs  = avfilter_inout_alloc();

    enum PixelFormat pix_fmts[] = { PIX_FMT_YUV420P, PIX_FMT_NONE };

    AVBufferSinkParams *buffersink_params;

    

    filter_graph = avfilter_graph_alloc();

    

    /* buffer video source: the decoded frames from the decoder will be inserted here. */

    snprintf(args, sizeof(args),

             "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",

             pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt,

             pCodecCtx->time_base.num, pCodecCtx->time_base.den,

             pCodecCtx->sample_aspect_ratio.num, pCodecCtx->sample_aspect_ratio.den);

    

    ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",

                                       args, NULL, filter_graph);

    if (ret < 0) {

        printf("Cannot create buffer source\n");

        return ret;

    }

    

    /* buffer video sink: to terminate the filter chain. */

    buffersink_params = av_buffersink_params_alloc();

    buffersink_params->pixel_fmts = pix_fmts;

    ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",

                                       NULL, buffersink_params, filter_graph);

    av_free(buffersink_params);

    if (ret < 0) {

        printf("Cannot create buffer sink\n");

        return ret;

    }

    

    /* Endpoints for the filter graph. */

    outputs->name       = av_strdup("in");

    outputs->filter_ctx = buffersrc_ctx;

    outputs->pad_idx    = 0;

    outputs->next       = NULL;

    

    inputs->name       = av_strdup("out");

    inputs->filter_ctx = buffersink_ctx;

    inputs->pad_idx    = 0;

    inputs->next       = NULL;

    

    if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,

                                        &inputs, &outputs, NULL)) < 0)

        return ret;

    

    if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)

        return ret;

    return 0;

}

//获取视频旋转角度，add by nil

int leishaohua_main(char *video_file,char * overlay_filters,char *outFileNameYUV,char *outFileNameH264,char *outAacFileName,char *outMP4FileName)

{

    int ret;

    AVPacket packet;

    AVFrame frame;

    int got_frame;

    

    //nil add video width and height

    int video_width=480;

    int video_heigh=320;

    

    avcodec_register_all();

    av_register_all();

    avfilter_register_all();

    

    

    

    if ((ret = open_input_file(video_file)) < 0)

        goto end;

    if ((ret = init_filters(overlay_filters)) < 0)

        goto end;

    

    

#if ENABLE_YUVFILE

    FILE *fp_yuv=fopen(outFileNameYUV,"wb+");

#endif

    

    

    /* read all packets */

    while (1) {

        AVFilterBufferRef *picref;

        if ((ret = av_read_frame(pFormatCtx, &packet)) < 0)

            break;

        

        if (packet.stream_index == video_stream_index) {

            avcodec_get_frame_defaults(&frame);

            

            AVStream *stream=pFormatCtx->streams[packet.stream_index];

            

            int angle=getRotateAngle(stream);

            printf("======yes====angle:%d",angle);

            

//            double angle=get_rotation(stream);

//            printf("==============hello=======good====:%d\n",(int)angle);

            

            got_frame = 0;

            ret = avcodec_decode_video2(pCodecCtx, &frame, &got_frame, &packet);

            if (ret < 0) {

                printf( "Error decoding video\n");

                break;

            }

            

            video_width=frame.width;

            video_heigh=frame.height;

            printf("============VIDEO WIDTH:%d=HEIGHT:%d\n",video_width,video_heigh);

            

            

            if (got_frame) {

                frame.pts = av_frame_get_best_effort_timestamp(&frame);

                

                /* push the decoded frame into the filtergraph */

                if (av_buffersrc_add_frame(buffersrc_ctx, &frame) < 0) {

                    printf( "Error while feeding the filtergraph\n");

                    break;

                }

                

                /* pull filtered pictures from the filtergraph */

                

                while (1) {

                    ret = av_buffersink_get_buffer_ref(buffersink_ctx, &picref, 0);

                    if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

                        break;

                    if (ret < 0)

                        goto end;

                    

                    if (picref) {

#if ENABLE_YUVFILE

                        int y_size=picref->video->w*picref->video->h;

                        printf("=========video===width:%d===height:%d\n",picref->video->w,picref->video->h);

                        printf("=======num:%d\n",++frameCount);

                        fwrite(picref->data[0],1,y_size,fp_yuv);     //Y

                        fwrite(picref->data[1],1,y_size/4,fp_yuv);   //U

                        fwrite(picref->data[2],1,y_size/4,fp_yuv);   //V

#endif

                        

                        avfilter_unref_bufferp(&picref);

                    }

                }

            }

        }

        av_free_packet(&packet);

    }

#if ENABLE_YUVFILE

    fclose(fp_yuv);

#endif

end:

    //

    //

    printf("=====Success===save yuv=====\n");

    //    pCodecCtx->codec_id =AV_CODEC_ID_H264;

    //    pCodecCtx->codec_id = codecCtx->codec_id;

    //    pCodecCtx->codec_type = AVMEDIA_TYPE_VIDEO;

    //    pCodecCtx->pix_fmt = PIX_FMT_YUV420P;

    //    pCodecCtx->width = in_w;

    //    pCodecCtx->height = in_h;

    //    pCodecCtx->time_base.num = 1;

    //    pCodecCtx->time_base.den = 25;

    //    pCodecCtx->bit_rate = 400000;

    //    pCodecCtx->gop_size=250;

    int videoCodec[8];

    videoCodec[0]=pCodecCtx->pix_fmt;

    videoCodec[1]=pCodecCtx->time_base.num;

    videoCodec[2]=pCodecCtx->time_base.den;

    videoCodec[3]=pCodecCtx->bit_rate;

    videoCodec[4]=pCodecCtx->gop_size;

    videoCodec[5]=pCodecCtx->qmin;

    videoCodec[6]=pCodecCtx->qmax;

    videoCodec[7]=pCodecCtx->qcompress;

    

        printf("=99999video info==video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d=====bit_rate:%d==gop_size:%d===compress:%f\n",

                 pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt,

                 pCodecCtx->time_base.num, pCodecCtx->time_base.den,

                 pCodecCtx->sample_aspect_ratio.num, pCodecCtx->sample_aspect_ratio.den,pCodecCtx->bit_rate,pCodecCtx->gop_size,pCodecCtx->qcompress);

    

    if (pCodecCtx)

        avcodec_close(pCodecCtx);

    avfilter_graph_free(&filter_graph);

    avformat_close_input(&pFormatCtx);

    

    if (ret < 0 && ret != AVERROR_EOF) {

        char buf[1024];

        av_strerror(ret, buf, sizeof(buf));

        printf("Error occurred: %s\n", buf);

        return -1;

    }

    

    

    printf("=====begin=====ecode_main====\n");

    ecode_main(outFileNameYUV,outFileNameH264,video_width,video_heigh,frameCount,videoCodec);

    decodeToAacMain(video_file,outAacFileName);

    muxer_main(outFileNameH264,outAacFileName,outMP4FileName);

    

    printf("=====success===all＝＝＝ret：%d\n",ret);

    

    

    return 0;

}