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;
}