通过ffmpeg实时读取宇视摄像头的高清帧流数据，并保存4张图片进行4合一照片的生成。

通过ffmpeg实时读取宇视摄像头的高清帧流数据，并保存4张图片进行4合一照片的生成。

FFmpeg视频解码过程

通常来说，FFmpeg的视频解码过程有以下几个步骤：

注册所支持的所有的文件（容器）格式及其对应的CODEC av_register_all()
打开文件 avformat_open_input()
从文件中提取流信息 avformat_find_stream_info()
在多个数据流中找到视频流 video stream（类型为MEDIA_TYPE_VIDEO）
查找video stream 相对应的解码器 avcodec_find_decoder
打开解码器 avcodec_open2()
为解码帧分配内存 av_frame_alloc()
从流中读取读取数据到Packet中 av_read_frame()
对video 帧进行解码，调用 avcodec_decode_video2()

SaveAsJPEG（); 函数
1.分配AVFormatContext对象  AVFormatContext* pFormatCtx = avformat_alloc_context();
2.设置输出文件格式                 pFormatCtx->oformat = av_guess_format("mjpeg", NULL, NULL);
3.建并初始化一个和该url相关的AVIOContext
4.// 构建一个新stream
5.// 设置该stream的信息
6.查找编码器
7.设置pCodecCtx的解码器为pCodec
8.给AVPacket分配足够大的空间

代码如下：
//通过ffmpeg实时读取宇视摄像头的高清帧流数据，并保存一张图片进行4合一照片的生成。
#include
#include
#include

//#include

using namespace std;
using namespace cv;

extern "C"
{
    #include "libavcodec/avcodec.h"
    #include "libavformat/avformat.h"
    #include "libswscale/swscale.h"
    #include "libavdevice/avdevice.h"
    #include "libavutil/pixfmt.h"
}
//由于我们建立的是C++的工程  编译的时候使用的C++的编译器编译
//而FFMPEG是C的库  因此这里需要加上extern "C"
//否则会提示各种未定义

//void SaveAsBMP(AVFrame *pFrameRGB, int width, int height, int index, int bpp);
int  SaveAsJPEG(AVFrame* pFrame, int width, int height, int index);
void FourToOne(int x,int y);//生成4合1照片合成图

Mat image_1;
Mat image_2;
Mat image_3;
Mat image_4;

int main()
{
    cout << "Hello FFmpeg!" << endl;
    av_register_all(); //初始化FFMPEG  调用了这个才能正常适用编码器和解码器

    // 初始化网络模块
    avformat_network_init();

    //=========================== 创建AVFormatContext结构体 ===============================//
    //分配一个AVFormatContext，FFMPEG所有的操作都要通过这个AVFormatContext来进行
    AVFormatContext *pFormatCtx = avformat_alloc_context();

    //==================================== 打开文件 ======================================//
    char file_path[] = "rtsp://admin:[email protected]:554/video2";

    AVDictionary* options = NULL;
    av_dict_set(&options, "buffer_size", "102400", 0); //设置缓存大小，1080p可将值调大
    av_dict_set(&options, "rtsp_transport", "tcp", 0); //以udp方式打开，如果以tcp方式打开将udp替换为tcp
    av_dict_set(&options, "stimeout", "2000000", 0); //设置超时断开连接时间，单位微秒
    av_dict_set(&options, "max_delay", "500000", 0); //设置最大时延
//    packet = (AVPacket *)av_malloc(sizeof(AVPacket));

    
   //打开网络流或文件流  
    if (avformat_open_input(&pFormatCtx, file_path, NULL, &options) != 0)    
    {
        printf("Couldn't open input stream.\n");
        return -1;
    }

    //循环查找视频中包含的流信息，直到找到视频类型的流
    //便将其记录下来 保存到videoStream变量中
    int i;
    int videoStream;

    //=================================== 获取视频流信息 ===================================//
    if (avformat_find_stream_info(pFormatCtx, NULL) < 0)
    {
        cout << "Could't find stream infomation." << endl;
        return -1;
    }

    videoStream = -1;

    for (i = 0; i < pFormatCtx->nb_streams; i++)
    {
        if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
        {
            videoStream = i;
        }
    }

    //如果videoStream为-1 说明没有找到视频流
    if (videoStream == -1)
    {
        cout << "Didn't find a video stream." << endl;
        return -1;
    }

   //=================================  查找解码器 ===================================//
    AVCodecContext* pCodecCtx = pFormatCtx->streams[videoStream]->codec;
    AVCodec* pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
    if (pCodec == NULL)
    {
        cout << "Codec not found." << endl;
        return -1;
    }

    //================================  打开解码器 ===================================//
    if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0)// 具体采用什么解码器ffmpeg经过封装  我们无须知道
    {
        cout << "Could not open codec." << endl;
        return -1;
    }

    //================================ 设置数据转换参数 ================================//
    SwsContext * img_convert_ctx;
    img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, //源地址长宽以及数据格式
                                     pCodecCtx->width, pCodecCtx->height,AV_PIX_FMT_YUVJ420P,    //目的地址长宽以及数据格式
                                     SWS_BICUBIC, NULL, NULL, NULL);//算法类型  AV_PIX_FMT_YUVJ420P   AV_PIX_FMT_BGR24

    //==================================== 分配空间 ==================================//
    //一帧图像数据大小
    int numBytes = avpicture_get_size(AV_PIX_FMT_YUVJ420P, pCodecCtx->width,pCodecCtx->height);

    unsigned char *out_buffer;
    out_buffer = (unsigned char *) av_malloc(numBytes * sizeof(unsigned char));

    AVFrame * pFrame;
    pFrame = av_frame_alloc();
    AVFrame * pFrameRGB;
    pFrameRGB = av_frame_alloc();
    avpicture_fill((AVPicture *) pFrameRGB, out_buffer, AV_PIX_FMT_YUVJ420P,pCodecCtx->width, pCodecCtx->height);
    //会将pFrameRGB的数据按RGB格式自动"关联"到buffer  即pFrameRGB中的数据改变了 out_buffer中的数据也会相应的改变

    //=========================== 分配AVPacket结构体 ===============================//
    int y_size = pCodecCtx->width * pCodecCtx->height;
    AVPacket *packet = (AVPacket *) malloc(sizeof(AVPacket)); //分配一个packet
    av_new_packet(packet, y_size); //分配packet的数据

    //打印输入和输出信息：长度 比特率 流格式等
    av_dump_format(pFormatCtx, 0, file_path, 0); //输出视频信息

    int index = 0;

    while(1)
    {
        //===========================  读取视频信息 ===============================//
        if (av_read_frame(pFormatCtx, packet) < 0) //读取的是一帧视频  数据存入一个AVPacket的结构中
        {
            cout << "read error." << endl;
            return -1;
        }
        //此时数据存储在packet中

        //=========================== 对视频数据进行解码 ===============================//

        int got_picture;
        if (packet->stream_index == videoStream)
        {
            //视频解码函数  解码之后的数据存储在 pFrame中
            int ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, packet);
            if (ret < 0)
            {
                cout << "decode error." << endl;
                return -1;
            }

            //=========================== YUV=>RGB ===============================//

            if (got_picture)
            {
                //翻转图像
                //有多少个像素就有多少个y  对于yuv420p。data[0]存放的是y，对应地linesize[0]就指明一行有多少个y
                //data[1]存放的是u 个数是y的一半   data[2]存放的是v 个数是y的一半
                /*
                pFrame->data[0] += pFrame->linesize[0] * (pCodecCtx->height - 1);
                pFrame->linesize[0] *= -1;
                pFrame->data[1] += pFrame->linesize[1] * (pCodecCtx->height / 2 - 1);
                pFrame->linesize[1] *= -1;
                pFrame->data[2] += pFrame->linesize[2] * (pCodecCtx->height / 2 - 1);
                pFrame->linesize[2] *= -1;
                */

                //转换一帧图像
                sws_scale(img_convert_ctx,pFrame->data, pFrame->linesize, 0, pCodecCtx->height,  //源
                          pFrameRGB->data, pFrameRGB->linesize);                                 //目的

                //SaveAsBMP(pFrameRGB, pCodecCtx->width,pCodecCtx->height,index++,24); //保存图片
                SaveAsJPEG(pFrameRGB, pCodecCtx->width,pCodecCtx->height,index++); //保存图片
                if (index > 3)
                    {
                    FourToOne(800,600);
                       return 0; //这里我们就保存4张图片
                    }

            }
        }

        av_free_packet(packet);

    }
    

    av_free(out_buffer);
    av_free(pFrameRGB);
    avcodec_close(pCodecCtx);
    avformat_close_input(&pFormatCtx);

    return 0;
}

/*==================================================================================
 *                  将AVFrame(BGR24格式)保存为BMP格式的图片
 ===================================================================================*/
/*void SaveAsBMP(AVFrame *pFrameRGB, int width, int height, int index, int bpp)
{
    char buf[5] = {0};
    BITMAPFILEHEADER bmpheader;
    BITMAPINFOHEADER bmpinfo;
    FILE *fp;

    char *filename = new char[255];

    //文件存放路径
    sprintf_s(filename, 255, "%s%d.bmp", "E:/QT/test_ffmpegSavePic/ffmpeg/output/", index);
    if( (fp = fopen(filename,"w")) == NULL )
    {
        printf ("open file failed!\n");
        return;
    }

    bmpheader.bfType = 0x4d42;
    bmpheader.bfReserved1 = 0;
    bmpheader.bfReserved2 = 0;
    bmpheader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
    bmpheader.bfSize = bmpheader.bfOffBits + width*height*bpp/8;

    bmpinfo.biSize = sizeof(BITMAPINFOHEADER);
    bmpinfo.biWidth = width;
    bmpinfo.biHeight = height;
    bmpinfo.biPlanes = 1;
    bmpinfo.biBitCount = bpp;
    bmpinfo.biCompression = BI_RGB;
    bmpinfo.biSizeImage = (width*bpp+31)/32*4*height;
    bmpinfo.biXPelsPerMeter = 100;
    bmpinfo.biYPelsPerMeter = 100;
    bmpinfo.biClrUsed = 0;
    bmpinfo.biClrImportant = 0;

    fwrite(&bmpheader, sizeof(bmpheader), 1, fp);
    fwrite(&bmpinfo, sizeof(bmpinfo), 1, fp);
    fwrite(pFrameRGB->data[0], width*height*bpp/8, 1, fp);

    fclose(fp);
}
*/

/*==================================================================================
 *                  将AVFrame(YUV420格式)保存为JPEG格式的图片
 ===================================================================================*/
int SaveAsJPEG(AVFrame* pFrame, int width, int height, int index)
{
    // 输出文件路径
    char out_file[30];
     sprintf(out_file,"./%d.jpg",index+1);
   // sprintf_s(out_file, sizeof(out_file), "%s%d.jpg", "./", index);

    // 分配AVFormatContext对象
    AVFormatContext* pFormatCtx = avformat_alloc_context();

    // 设置输出文件格式
    pFormatCtx->oformat = av_guess_format("mjpeg", NULL, NULL);

    // 创建并初始化一个和该url相关的AVIOContext
    if( avio_open(&pFormatCtx->pb, out_file, AVIO_FLAG_READ_WRITE) < 0)
    {
        printf("Couldn't open output file.");
        return -1;
    }

    // 构建一个新stream
    AVStream* pAVStream = avformat_new_stream(pFormatCtx, 0);
    if( pAVStream == NULL )
    {
        return -1;
    }

    // 设置该stream的信息
    AVCodecContext* pCodecCtx = pAVStream->codec;

    pCodecCtx->codec_id   = pFormatCtx->oformat->video_codec;
    pCodecCtx->codec_type = AVMEDIA_TYPE_VIDEO;
    pCodecCtx->pix_fmt    = AV_PIX_FMT_YUVJ420P;
    pCodecCtx->width      = width;
    pCodecCtx->height     = height;
    pCodecCtx->time_base.num = 1;
    pCodecCtx->time_base.den = 25;

    //打印输出相关信息
    av_dump_format(pFormatCtx, 0, out_file, 1);

    //================================== 查找编码器 ==================================//
    AVCodec* pCodec = avcodec_find_encoder(pCodecCtx->codec_id);
    if( !pCodec )
    {
        printf("Codec not found.");
        return -1;
    }

    // 设置pCodecCtx的解码器为pCodec
    if( avcodec_open2(pCodecCtx, pCodec, NULL) < 0 )
    {
        printf("Could not open codec.");
        return -1;
    }

    //================================Write Header ===============================//
    avformat_write_header(pFormatCtx, NULL);

    int y_size = pCodecCtx->width * pCodecCtx->height;

    //==================================== 编码 ==================================//
    // 给AVPacket分配足够大的空间
    AVPacket pkt;
    av_new_packet(&pkt, y_size * 3);

    //
    int got_picture = 0;
    int ret = avcodec_encode_video2(pCodecCtx, &pkt, pFrame, &got_picture);
    if( ret < 0 )
    {
        printf("Encode Error.\n");
        return -1;
    }
    if( got_picture == 1 )
    {
        pkt.stream_index = pAVStream->index;
        ret = av_write_frame(pFormatCtx, &pkt);
    }

    av_free_packet(&pkt);

    //Write Trailer
    av_write_trailer(pFormatCtx);

    if( pAVStream )
    {
        avcodec_close(pAVStream->codec);
    }
    avio_close(pFormatCtx->pb);
    avformat_free_context(pFormatCtx);

    return 0;
}
void FourToOne(int x,int y)
{

    //添加云图效果
    int X_cloud=x;
    int Y_cloud=y;
    int m_fZoomIn=6;
    
    //读入四幅图片
    Mat image_1 = imread("1.jpg");
    Mat image_2 = imread("2.jpg");
    Mat image_3 = imread("3.jpg");
    Mat image_4 = imread("4.jpg");

    circle(image_2, Point(X_cloud, Y_cloud), 12*m_fZoomIn , Scalar(255, 0, 0), -1);
    circle(image_2, Point(X_cloud, Y_cloud), 10*m_fZoomIn , Scalar(200, 100, 0),-1);
    circle(image_2, Point(X_cloud, Y_cloud), 9*m_fZoomIn  , Scalar(100, 200, 0), -1);
    circle(image_2, Point(X_cloud, Y_cloud), 8*m_fZoomIn  , Scalar(0, 255, 0), -1);
    circle(image_2, Point(X_cloud, Y_cloud), 6*m_fZoomIn  , Scalar(0, 200, 255),-1);
    circle(image_2, Point(X_cloud, Y_cloud), 5*m_fZoomIn  , Scalar(0, 125, 255), -1);
    circle(image_2, Point(X_cloud, Y_cloud), 4*m_fZoomIn  , Scalar(0, 0, 255), -1);

    Rect rect(400,500,800,600);        //裁剪车牌图片
    image_3=image_3(rect);

    //归一化为相同的大小：320*240
    Size sz = Size(640, 480);
    resize(image_1, image_1, sz);
    resize(image_2, image_2, sz);
    resize(image_3, image_3, sz);
    resize(image_4, image_4, sz);

    //创建连接后存入的图像
    Mat result(sz.height*2+1, sz.width * 2 + 1, image_1.type());

    //四幅图像拷贝,中间的一行（列）作为图像间分割线
    //第1幅，拷贝到左上角
    Rect roi_rect = Rect(0, 0, sz.width, sz.height);
    image_1.copyTo(result(roi_rect));

    //第2幅，拷贝到右上角
    roi_rect = Rect(sz.width+1, 0, sz.width, sz.height);
    image_2.copyTo(result(roi_rect));

    //第3幅，拷贝到左下角
    roi_rect = Rect(0, sz.height+1, sz.width, sz.height);
    image_3.copyTo(result(roi_rect));

    //第4幅，拷贝到右下角
    roi_rect = Rect(sz.width+1, sz.height+1, sz.width, sz.height);
    image_4.copyTo(result(roi_rect));

    //显示四幅图像连接后的图像
    imshow("result", result);
    waitKey(0);
}

编译时加上-I/monchickey/ffmpeg/include -L/monchickey/ffmpeg/lib -lavdevice -lavfilter -lavformat -lavcodec -lswresample -lswscale -lavutil `pkg-config --cflags --libs opencv`