#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <libavformat/avformat.h>
#include  <libavcodec/avcodec.h>
#include <libswscale/swscale.h>

int main(int argc, char* argv[])
{
    AVCodec *pCodec;
    AVCodecContext *pCodecCtx= NULL;
    AVCodecParserContext *pCodecParserCtx=NULL;

    int frame_count,i;
    FILE *fp_in;
    FILE *fp_out;
    AVFrame    *pFrame,*pFrameYUV;
    uint8_t *out_buffer;
    const int in_buffer_size=300000;
    uint8_t  in_buffer[300000+32]={0};
    uint8_t *cur_ptr;
    int cur_size;

    AVPacket packet;
    int ret, got_picture;

    int y_size;
    enum AVCodecID codec_id;

    codec_id=AV_CODEC_ID_H264;
    
    char filepath_out[]="test.yuv";
    int first_time=1;
    int m_skippedframe=0;
    int    DecFrameNum=0;
    int filesize =0;
    struct SwsContext *img_convert_ctx;

    avcodec_register_all();
    pCodec = avcodec_find_decoder(codec_id);
    if (!pCodec) 
    {
        printf("Codec not found\n");
        return -1;
    }
    pCodecCtx = avcodec_alloc_context3(pCodec);
    if (!pCodecCtx)
    {
        printf("Could not allocate video codec context\n");
        return -1;
    }

    /*必须设置，否则程序解码会报error*/
    pCodecCtx->width =1920 ;
      pCodecCtx->height=1080;

    pCodecParserCtx=av_parser_init(codec_id);
    if (!pCodecParserCtx)
    {
        printf("Could not allocate video parser context\n");
        return -1;
    }

    if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0)
    {
        printf("Could not open codec\n");
        return -1;
    }

    //Output File
    fp_out = fopen(filepath_out, "wb");
    if (!fp_out) 
    {
        printf("Could not open output YUV file\n");
        return -1;
    }
        
    //Input File
    char filename_body[10];
       for(i =1;i<=20;i++)
    {
        char filename[20] ={0};
        memset(filename_body,0,sizeof(filename_body));
        sprintf(filename_body,"%d",i);
        strcat(filename,filename_body);
        char filename_tail[5] = ".h264";
        strcat(filename,filename_tail);

        printf("filename =%s\n",filename);
        
        fp_in = fopen(filename, "rb");
        if (!fp_in) 
        {
            printf("Could not open input stream\n");
            return -1;
          }
         fseek(fp_in, 0L, SEEK_END);
         filesize=ftell(pInFile);
        
            pFrame = av_frame_alloc();
        av_init_packet(&packet);

        while (1) 
        {
            cur_size = fread(in_buffer, 1, in_buffer_size, fp_in);
            printf("cur_size =%d\n",cur_size);
            if (cur_size == 0)
                break;
            cur_ptr=in_buffer;

            while (cur_size>0)
            {
            
                int len = av_parser_parse2(
                pCodecParserCtx, pCodecCtx,
                &packet.data, &packet.size,
                cur_ptr , cur_size ,
                AV_NOPTS_VALUE, AV_NOPTS_VALUE, AV_NOPTS_VALUE);

                cur_ptr += len;
                cur_size -= len;
                if(packet.size==0)
                    continue;

                //Some Info from AVCodecParserContext
                printf("Packet Size:%6d\t",packet.size);
                switch(pCodecParserCtx->pict_type)
                {
                    case AV_PICTURE_TYPE_I: printf("Type: I\t");break;
                    case AV_PICTURE_TYPE_P: printf("Type: P\t");break;
                    case AV_PICTURE_TYPE_B: printf("Type: B\t");break;
                        default: printf("Type: Other\t");break;
                }
                printf("Output Number:%4d\t",pCodecParserCtx->output_picture_number);
                printf("Offset:%lld\n",pCodecParserCtx->cur_offset);

                

                ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, &packet);
                if (ret < 0) 
                {
                    printf("Decode Error.\n");
                    return ret;
                }
                if (got_picture) 
                {
                    if(first_time)
                    {
                        printf("\nCodec Full Name:%s\n",pCodecCtx->codec->long_name);
                        printf("width:%d\nheight:%d\n\n",pCodecCtx->width,pCodecCtx->height);
                        //SwsContext
                        img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, 
                            pCodecCtx->width, pCodecCtx->height, PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL); 
                        
                        pFrameYUV=av_frame_alloc();
                        out_buffer=(uint8_t *)av_malloc(avpicture_get_size(PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height));
                        avpicture_fill((AVPicture *)pFrameYUV, out_buffer, PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height);
                        
                        y_size=pCodecCtx->width*pCodecCtx->height;

                        first_time=0;
                    }
                    DecFrameNum++;
                    printf("Succeed to decode 1 frame!,DecFrameNum =%d\n",DecFrameNum);
                    sws_scale(img_convert_ctx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0, pCodecCtx->height, 
                        pFrameYUV->data, pFrameYUV->linesize);

                    fwrite(pFrameYUV->data[0],1,y_size,fp_out);     //Y 
                    fwrite(pFrameYUV->data[1],1,y_size/4,fp_out);   //U
                    fwrite(pFrameYUV->data[2],1,y_size/4,fp_out);   //V
                    usleep(40*1000);
                    
            }
        else
            {
                m_skippedframe++;
                printf("\n ******m_skippedframe =%d\n",m_skippedframe);
            }    
                    av_free_packet(&packet);
        }

    }
    }

        //Flush Decoder
        while(1)
        {
            printf("8888\n");
            ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, &packet);
            printf("flush got_picture =%d\n",got_picture);
            if (ret < 0) 
            {
                printf("Decode Error.\n");
                return ret;
            }
            if (!got_picture)
                break;
            if (got_picture) 
            {
                printf("Flush Decoder: Succeed to decode 1 frame!\n");
                sws_scale(img_convert_ctx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0, pCodecCtx->height, 
                    pFrameYUV->data, pFrameYUV->linesize);

                fwrite(pFrameYUV->data[0],1,y_size,fp_out);     //Y
                fwrite(pFrameYUV->data[1],1,y_size/4,fp_out);   //U
                fwrite(pFrameYUV->data[2],1,y_size/4,fp_out);   //V
            }
            av_free_packet(&packet);
        }

    printf("99999\n");
        fclose(fp_in);
    fclose(fp_out);
    
    sws_freeContext(img_convert_ctx);
    av_parser_close(pCodecParserCtx);

    av_frame_free(&pFrameYUV);
    av_frame_free(&pFrame);
    avcodec_close(pCodecCtx);
    av_free(pCodecCtx);

    return 0;
}