ffmpeg学习（二）通过rtsp获取H264裸流并保存到mp4文件

本篇将使用上节http://www.cnblogs.com/wenjingu/p/3977015.html中编译好的库文件通过rtsp获取网络上的h264裸流并保存到mp4文件中。

1、VS2010建立VC++ win32控制台项目

2、在工程目录下建立lib目录和include目录，将已编译好的lib拷打lib下，include拷到include下，dll拷到Debug目录下

3、工程属性–配置属性–VC++目录–包含目录，添加ffmpeg头文件目录及其他第三方头文件目录

链接器–输入–附加依赖项，添加各个lib名

4、设计和实现：

4.1 设计思路：

组件和网络初始化——>打开网络流——>获取网络流信息——>根据网络流信息初始化输出流信息——>创建并打开mp4文件——>写mp4文件头

——>循环读取输入流并写入mp4文件——>写文件尾——>关闭流，关闭文件

4.2 关键数据结构：

AVFormatContext，AVStream，AVCodecContext，AVPacket，AVFrame等，它们的关系解释如下：

一个AVFormatContext包含多个AVStream，每个码流包含了AVCodec和AVCodecContext，AVPicture是AVFrame的一个子集，

他们都是数据流在编解过程中用来保存数据缓存的对像，从数据流读出的数据首先是保存在AVPacket里，也可以理解为一个AVPacket最多只包含一个AVFrame，

而一个AVFrame可能包含好几个AVPacket，AVPacket是种数据流分包的概念。

4.3 关键函数：

int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options); //打开网络流或文件流

int avformat_write_header(AVFormatContext *s, AVDictionary **options);//根据文件名的后缀写相应格式的文件头

int av_read_frame(AVFormatContext *s, AVPacket *pkt);//从输入流中读取一个分包

int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt);//往输出流中写一个分包

int av_write_trailer(AVFormatContext *s);//写输出流（文件）的文件尾

4.4 代码：

#include "stdafx.h"#ifdef __cplusplus
extern "C" {
#endif#include <libavcodec/avcodec.h>
#include <libavdevice/avdevice.h>
#include <libavformat/avformat.h>
#include <libavfilter/avfilter.h>
#include <libavutil/avutil.h>
#include <libswscale/swscale.h>#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>#ifdef __cplusplus
}
#endif

以上为引用C库和ffmpeg库的头文件。

static AVFormatContext *i_fmt_ctx;
static AVStream *i_video_stream;static AVFormatContext *o_fmt_ctx;
static AVStream *o_video_stream;static bool bStop = false;static unsigned __stdcall rtsp2mp4(void * pThis)
{
    avcodec_register_all();
    av_register_all();
    avformat_network_init();    /* should set to NULL so that avformat_open_input() allocate a new one */
    i_fmt_ctx = NULL;
    char rtspUrl[] = "rtsp://admin:12345@192.168.10.76:554";
    const char *filename = "1.mp4";
    if (avformat_open_input(&i_fmt_ctx, rtspUrl, NULL, NULL)!=)
    {
        fprintf(stderr, "could not open input file\n");
        return -;
    }    if (avformat_find_stream_info(i_fmt_ctx, NULL)<)
    {
        fprintf(stderr, "could not find stream info\n");
        return -;
    }    //av_dump_format(i_fmt_ctx, 0, argv[1], 0);    /* find first video stream */
    for (unsigned i=; i<i_fmt_ctx->nb_streams; i++)
    {
        if (i_fmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
        {
            i_video_stream = i_fmt_ctx->streams[i];
            break;
        }
    }
    if (i_video_stream == NULL)
    {
        fprintf(stderr, "didn't find any video stream\n");
        return -;
    }    avformat_alloc_output_context2(&o_fmt_ctx, NULL, NULL, filename);    /*
    * since all input files are supposed to be identical (framerate, dimension, color format, ...)
    * we can safely set output codec values from first input file
    */
    o_video_stream = avformat_new_stream(o_fmt_ctx, NULL);
    {
        AVCodecContext *c;
        c = o_video_stream->codec;
        c->bit_rate = ;
        c->codec_id = i_video_stream->codec->codec_id;
        c->codec_type = i_video_stream->codec->codec_type;
        c->time_base.num = i_video_stream->time_base.num;
        c->time_base.den = i_video_stream->time_base.den;
        fprintf(stderr, "time_base.num = %d time_base.den = %d\n", c->time_base.num, c->time_base.den);
        c->width = i_video_stream->codec->width;
        c->height = i_video_stream->codec->height;
        c->pix_fmt = i_video_stream->codec->pix_fmt;
        printf("%d %d %d", c->width, c->height, c->pix_fmt);
        c->flags = i_video_stream->codec->flags;
        c->flags |= CODEC_FLAG_GLOBAL_HEADER;
        c->me_range = i_video_stream->codec->me_range;
        c->max_qdiff = i_video_stream->codec->max_qdiff;        c->qmin = i_video_stream->codec->qmin;
        c->qmax = i_video_stream->codec->qmax;        c->qcompress = i_video_stream->codec->qcompress;
    }    avio_open(&o_fmt_ctx->pb, filename, AVIO_FLAG_WRITE);    avformat_write_header(o_fmt_ctx, NULL);    int last_pts = ;
    int last_dts = ;    int64_t pts, dts;
    while (!bStop)
    {
        AVPacket i_pkt;
        av_init_packet(&i_pkt);
        i_pkt.size = ;
        i_pkt.data = NULL;
        if (av_read_frame(i_fmt_ctx, &i_pkt) < )
            break;
        /*
        * pts and dts should increase monotonically
        * pts should be >= dts
        */
        i_pkt.flags |= AV_PKT_FLAG_KEY;
        pts = i_pkt.pts;
        i_pkt.pts += last_pts;
        dts = i_pkt.dts;
        i_pkt.dts += last_dts;
        i_pkt.stream_index = ;        //printf("%lld %lld\n", i_pkt.pts, i_pkt.dts);
        static int num = ;
        printf("frame %d\n", num++);
        av_interleaved_write_frame(o_fmt_ctx, &i_pkt);
        //av_free_packet(&i_pkt);
        //av_init_packet(&i_pkt);
         Sleep();
    }
    last_dts += dts;
    last_pts += pts;    avformat_close_input(&i_fmt_ctx);    av_write_trailer(o_fmt_ctx);    avcodec_close(o_fmt_ctx->streams[]->codec);
    av_freep(&o_fmt_ctx->streams[]->codec);
    av_freep(&o_fmt_ctx->streams[]);    avio_close(o_fmt_ctx->pb);
    av_free(o_fmt_ctx);    return ;
}int _tmain(int argc, char **argv)
{
    //ffplayer();
    bStop = false;
    HANDLE   hth;
    unsigned  uiThreadID;      hth = (HANDLE)_beginthreadex( NULL,         // security
                                   ,            // stack size
                                   rtsp2mp4,
                                   NULL,           // arg list
                                   ,  //CREATE_SUSPENDED so we can later call ResumeThread()
                                   &uiThreadID );      if ( hth ==  )
    {
        printf("Failed to create thread\n");
        return -;
    }    printf("按任意键停止录像\n");
    getchar();
    bStop = true;
    printf("按任意键退出\n");
    getchar();    return ;
}