ffmpeg使用二:录屏数据直接264编码

       上一节实现了录屏数据保存为yuv420p文件；实际应用中yuv数据量是十分庞大的，需要进行编码即压缩。

本文先实现把录屏数据264编码后保存文件，并用VLC播放器播放测试，下篇再讲如何把编码的数据直接推流。

注：264编码的数据源是yuv420p格式，所以要把录屏的原始数据先转为yuv420p格式。

#include 

using namespace std;

#include 

#define __STDC_CONSTANT_MACROS
//Linux...
extern "C"
{
#include 
#include 
#include 
#include 
#include 
}

int main(int argc, char* argv[])
{
    //input
    AVFormatContext* pInputFormatContext=NULL;
    AVCodec* pInputCodec=NULL;
    AVCodecContext* pInputCodecContex=NULL;
    //output
    AVFormatContext *pOutputFormatContext=NULL;
    AVCodecContext* pOutCodecContext=NULL;
    AVCodec* pOutCodec=NULL;
    AVStream* pOutStream=NULL;

    av_register_all();

    avdevice_register_all();

    const char* out_file = "ds.h264";
    
    pInputFormatContext = avformat_alloc_context();
    AVDictionary* options = NULL;
    AVInputFormat *ifmt=av_find_input_format("x11grab");
    av_dict_set(&options,"framerate","25",0);
    av_dict_set(&options,"video_size","640x480",0);
    if(avformat_open_input(&pInputFormatContext,":0.0+10,20",ifmt,&options)!=0){ //Grab at position 10,20 真正的打开文件,这个函数读取文件的头部并且把信息保存到我们给的AVFormatContext结构体中
        printf("Couldn't open input stream.\n");
        return -1;
    }
    //
    if(avformat_find_stream_info(pInputFormatContext,NULL)<0)
    {
        printf("Couldn't find stream information.\n");
        return -1;
    }
    //
    int i,videoindex=-1;
    for(i=0; inb_streams; i++)
        if(pInputFormatContext->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO)
        {
            videoindex=i;
            break;
        }
    if(videoindex==-1)
    {
        printf("Didn't find a video stream.\n");
        return -1;
    }
    //
    pInputCodecContex=pInputFormatContext->streams[videoindex]->codec;// 相当于虚基类,具体参数流中关于编解码器的信息就是被我们叫做"codec context"（编解码器上下文）的东西。
    pInputCodec=avcodec_find_decoder(pInputCodecContex->codec_id);//这里面包含了流中所使用的关于编解码器的所有信息，现在我们有了一个指向他的指针。但是我们必需要找到真正的编解码器并且打开
    if(pInputCodec==NULL)
    {
        printf("Codec not found.\n");
        return -1;
    }
    //打开解码器
    if(avcodec_open2(pInputCodecContex, pInputCodec,NULL)<0)
    {
        printf("Could not open codec.\n");
        return -1;
    }
    //---------------------------------------------------------------

    //为一帧图像分配内存
    AVFrame *pFrame;
    AVFrame *pFrameYUV;
    pFrame=av_frame_alloc();
    pFrameYUV=av_frame_alloc();//为转换来申请一帧的内存(把原始帧->YUV)

    pFrameYUV->format=AV_PIX_FMT_YUV420P;
    pFrameYUV->width=pInputCodecContex->width;
    pFrameYUV->height=pInputCodecContex->height;

    //即使我们申请了一帧的内存，当转换的时候，我们仍然需要一个地方来放置原始的数据。我们使用avpicture_get_size来获得我们需要的大小，然后手工申请内存空间

    //获得帧图片大小

    unsigned char *out_buffer=(unsigned char *)av_malloc(avpicture_get_size(AV_PIX_FMT_YUV420P, pInputCodecContex->width, pInputCodecContex->height));
    //现在我们使用avpicture_fill来把帧和我们新申请的内存来结合
    avpicture_fill((AVPicture *)pFrameYUV, out_buffer, AV_PIX_FMT_YUV420P, pInputCodecContex->width, pInputCodecContex->height);


#if 0
    FILE *fp_yuv=fopen("output.yuv","wb+");
#endif

    //转换图像上下文
    struct SwsContext *img_convert_ctx;
    img_convert_ctx = sws_getContext(pInputCodecContex->width, pInputCodecContex->height, pInputCodecContex->pix_fmt, pInputCodecContex->width, pInputCodecContex->height, AV_PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);

//-----------------------------------------------------------------------------------------
    AVOutputFormat* fmt = av_guess_format(NULL, may_procotol, NULL);//根据out_file 猜测协议
    if(fmt == NULL)
    {
        printf("Faild out h264 file\n");
        return -1;
    }

    pOutputFormatContext = avformat_alloc_context();
    if(pOutputFormatContext == NULL)
    {
        printf("pOutFormatContext create error!\n");
        return -1;
    }
    pOutputFormatContext->oformat = fmt;

    //Open output URL 打开输入文件 返回AVIOContext(pFormatCtx->pb)
    if (avio_open(&pOutputFormatContext->pb,out_file, AVIO_FLAG_READ_WRITE) < 0){
        printf("Failed to open output file! \n");
        return -1;
    }

    //创建输出流,AVStream  与  AVCodecContext一一对应
    pOutStream = avformat_new_stream(pOutputFormatContext, 0);
    if(pOutStream == NULL)
    {
        printf("Failed create pOutStream!\n");
        return -1;
    }

    //相当于虚基类,用于设置编码的具体参数
    pOutCodecContext = pOutStream->codec;
    pOutCodecContext->codec_id = AV_CODEC_ID_H264;
    //type
    pOutCodecContext->codec_type = AVMEDIA_TYPE_VIDEO;
    //像素格式,
    pOutCodecContext->pix_fmt = AV_PIX_FMT_YUV420P;
    //size
    pOutCodecContext->width = 640;
    pOutCodecContext->height = 480;
    //目标码率
    pOutCodecContext->bit_rate = 400000;
    //每250帧插入一个I帧,I帧越小视频越小
    pOutCodecContext->gop_size=250;
    //Optional Param B帧
    pOutCodecContext->max_b_frames=3;
    pOutCodecContext->time_base.num = 1;
    pOutCodecContext->time_base.den = 25;
    pOutCodecContext->lmin=1;
    pOutCodecContext->lmax=50;
    //最大和最小量化系数
    pOutCodecContext->qmin = 10;
    pOutCodecContext->qmax = 51;
    pOutCodecContext->qblur=0.0;

    av_dump_format(pOutputFormatContext, 0, out_file, 1);

    AVDictionary *param = 0;
//    //H.264
    if(pOutCodecContext->codec_id == AV_CODEC_ID_H264) {
        av_dict_set(¶m, "preset", "slow", 0);
        av_dict_set(¶m, "tune", "zerolatency", 0);
    }
//
    av_dump_format(pOutputFormatContext, 0, out_file, 1);

    pOutCodec = avcodec_find_encoder(pOutCodecContext->codec_id);
    if (!pOutCodec){
        printf("Can not find encoder! \n");
        return -1;
    }

    if (avcodec_open2(pOutCodecContext, pOutCodec,¶m) < 0)
    {
        printf("Failed to open encoder! \n");
        return -1;
    }


    //Write File Header
   int r = avformat_write_header(pOutputFormatContext,NULL);
   if(r<0)
   {
        printf("Failed write header!\n");
        return -1;
   }

   AVPacket *packet=(AVPacket *)av_malloc(sizeof(AVPacket));
   int got_picture;

   AVPacket pkt;
   int picture_size = avpicture_get_size(pOutCodecContext->pix_fmt, pOutCodecContext->width, pOutCodecContext->height);
   av_new_packet(&pkt,picture_size);

    int frame_index=0;
   //通过读取包来读取整个视频流，然后把它解码成帧，最好后转换格式并且保存
   while((av_read_frame(pInputFormatContext, packet))>=0)
   {
       if(packet->stream_index==videoindex)
       {
           //真正解码,packet to pFrame
           avcodec_decode_video2(pInputCodecContex, pFrame, &got_picture, packet);
           if(got_picture)
           {

                   sws_scale(img_convert_ctx, (const unsigned char* const*)pFrame->data, pFrame->linesize, 0, pInputCodecContex->height, pFrameYUV->data, pFrameYUV->linesize);
#if 0
                   int y_size=pInputCodecContex->width*pInputCodecContex->height;
                   fwrite(pFrameYUV->data[0],1,y_size,fp_yuv);    //Y
                   fwrite(pFrameYUV->data[1],1,y_size/4,fp_yuv);  //U
                   fwrite(pFrameYUV->data[2],1,y_size/4,fp_yuv);  //V
#endif
                   //写入pts，pts用于记录每帧输出的时序，只要按规则，从小到大排列即可(若果是网络传输如rtmp推流，必须填写
                   //此处保存为文件可以不写)
                   pFrameYUV->pts=frame_index;
                   fram_index++;

                   int picture;
                   //真正编码
                   int ret=avcodec_encode_video2(pOutCodecContext, &pkt,pFrameYUV, &picture);
                   if(ret < 0){
                       printf("Failed to encode! \n");
                       return -1;
                   }
                   if (picture==1){
                       printf("mjhmjhm : size:%5d\n",pkt.size);
                       pkt.stream_index = pOutStream->index;
                       ret = av_write_frame(pOutputFormatContext, &pkt);
                       //
                       av_free_packet(&pkt);
                   }
           }
       }
       av_free_packet(packet);
   }

    //Write file trailer
    av_write_trailer(pOutputFormatContext);

    //Clean
        sws_freeContext(img_convert_ctx);
        //fclose(fp_yuv);
        av_free(out_buffer);
        av_free(pFrameYUV);
        av_free(pFrame);
        avcodec_close(pInputCodecContex);
        avformat_close_input(&pInputFormatContext);

    avcodec_close(pOutStream->codec);
    av_free(pOutCodec);
    av_free(fmt);
    avcodec_close(pOutCodecContext);

    avformat_free_context(pOutputFormatContext);

    return 0;
}

      从代码可以看出整体流程跟上一节差不多，只不过多了264编码的过程，只用一个函数就搞定了；

另要注意不要忘了给每一帧设置pts；

     因为要编码，所以要通过AVCodecContext设置编码的参数。参数的具体含义大部分都没有搞清楚，留给以后吧。