FFMpeg写MP4文件例子分析

最新推荐文章于 2023-08-27 14:02:11 发布
最新推荐文章于 2023-08-27 14:02:11 发布
阅读量762 收藏
点赞数
分类专栏： ffmpeg

 这段时间看了FFMpeg提供的例子muxing.c，我略微修改了下源代码，使其生成一个MP4文件，音频使用AAC编码，视频使用H.264编码。代码很简单，我就不做说明了，代码如下。以后我们继续写如何将DirectShow中采集的音视频数据编码并生成MP4文件。[cpp] view plaincopy

/* 5 seconds stream duration */  

#define STREAM_DURATION   5.0  

#define STREAM_FRAME_RATE 25 /* 25 images/s */  

#define STREAM_NB_FRAMES  ((int)(STREAM_DURATION * STREAM_FRAME_RATE))  

#define STREAM_PIX_FMT PIX_FMT_YUV420P /* default pix_fmt */    

static int sws_flags = SWS_BICUBIC;    /* audio output */    

static float t, tincr, tincr2;  

static int16_t *samples;  

static uint8_t *audio_outbuf;  

static int audio_outbuf_size;  

static int audio_input_frame_size; /** add an audio output stream */  

static AVStream *add_audio_stream(AVFormatContext *oc, enum CodecID codec_id)  

{  

    AVCodecContext *c;  

    AVStream *st;    

    st = avformat_new_stream(oc, NULL);  

    if (!st) {  

        fprintf(stderr, "Could not alloc stream\n");  

        exit(1);  

    }  

    st->id = 1;    

    c = st->codec;  

    c->codec_id = codec_id;  

    c->codec_type = AVMEDIA_TYPE_AUDIO;       /* put sample parameters */  

    c->sample_fmt = AV_SAMPLE_FMT_S16;  

    c->bit_rate = 64000;  

    c->sample_rate = 44100;  

    c->channels = 2;        // some formats want stream headers to be separate  

    if (oc->oformat->flags & AVFMT_GLOBALHEADER)  

        c->flags |= CODEC_FLAG_GLOBAL_HEADER;    

    return st;  

}    

static void open_audio(AVFormatContext *oc, AVStream *st)  

{  

    AVCodecContext *c;  

    AVCodec *codec;    

    c = st->codec;        /* find the audio encoder */  

    codec = avcodec_find_encoder(c->codec_id);  

    if (!codec) {  

        fprintf(stderr, "codec not found\n");  

        exit(1);  

    }        /* open it */  

    if (avcodec_open(c, codec) < 0) {  

        fprintf(stderr, "could not open codec\n");  

        exit(1);  

    }        /* init signal generator */  

    t = 0;  

    tincr = 2 * M_PI * 110.0 / c->sample_rate;      /* increment frequency by 110 Hz per second */  

    tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;   

    audio_outbuf_size = 10000;  

    audio_outbuf = (uint8_t *)av_malloc(audio_outbuf_size);    

    /* ugly hack for PCM codecs (will be removed ASAP with new PCM     support to compute the input frame size in samples */  

    if (c->frame_size <= 1) {  

        audio_input_frame_size = audio_outbuf_size / c->channels;  

        switch(st->codec->codec_id) {  

        case CODEC_ID_PCM_S16LE:  

        case CODEC_ID_PCM_S16BE:  

        case CODEC_ID_PCM_U16LE:  

        case CODEC_ID_PCM_U16BE:  

            audio_input_frame_size >>= 1;  

            break;  

        default:  

            break;  

        }  

    } else {  

        audio_input_frame_size = c->frame_size;  

    }  

    samples = (int16_t *)av_malloc(audio_input_frame_size * 2 * c->channels);  

}    

/* prepare a 16 bit dummy audio frame of 'frame_size' samples and 'nb_channels' channels */  

static void get_audio_frame(int16_t *samples, int frame_size, int nb_channels)  

{  

    int j, i, v;  

    int16_t *q;    

    q = samples;  

    for (j = 0; j < frame_size; j++) {  

        v = (int)(sin(t) * 10000);  

        for(i = 0; i < nb_channels; i++)  

            *q++ = v;  

        t += tincr;  

        tincr += tincr2;  

    }  }    

static void write_audio_frame(AVFormatContext *oc, AVStream *st)  

{  

    AVCodecContext *c;  

    AVPacket pkt;  

    av_init_packet(&pkt);   

    c = st->codec;    

    get_audio_frame(samples, audio_input_frame_size, c->channels);    

    pkt.size = avcodec_encode_audio(c, audio_outbuf, audio_outbuf_size, samples);    

    if (c->coded_frame && c->coded_frame->pts != AV_NOPTS_VALUE)  

        pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);  

    pkt.flags |= AV_PKT_FLAG_KEY;  

    pkt.stream_index = st->index;  

    pkt.data = audio_outbuf;    

    /* write the compressed frame in the media file */  

    if (av_interleaved_write_frame(oc, &pkt) != 0) {  

        fprintf(stderr, "Error while writing audio frame\n");  

        exit(1);  

    }  }    

static void close_audio(AVFormatContext *oc, AVStream *st)  

{      avcodec_close(st->codec);    

    av_free(samples);  

    av_free(audio_outbuf);  

}    

/**************************************************************/  /* video output */    

static AVFrame *picture, *tmp_picture;  

static uint8_t *video_outbuf;  

static int frame_count, video_outbuf_size; /* add a video output stream */  

static AVStream *add_video_stream(AVFormatContext *oc, enum CodecID codec_id)  

{  

    AVCodecContext *c;  

    AVStream *st;  

    AVCodec *codec;  

  

    st = avformat_new_stream(oc, NULL);  

    if (!st) {  

        fprintf(stderr, "Could not alloc stream\n");  

        exit(1);  

    }    

    c = st->codec;       /* find the video encoder */  

    codec = avcodec_find_encoder(codec_id);  

    if (!codec) {  

        fprintf(stderr, "codec not found\n");  

        exit(1);  

    }  

    avcodec_get_context_defaults3(c, codec);    

    c->codec_id = codec_id;        /* put sample parameters */  

    c->bit_rate = /*400000*/3000000;      /* resolution must be a multiple of two */  

    c->width = /*352*/640;  

    c->height = /*288*/480;  

    /* time base: this is the fundamental unit of time (in seconds) in terms     of which frame timestamps are represented. for fixed-fps content,     timebase should be 1/framerate and timestamp increments should be     identically 1. */  

    c->time_base.den = STREAM_FRAME_RATE;  

    c->time_base.num = 1;  

    c->gop_size = 12; /* emit one intra frame every twelve frames at most */  

    c->pix_fmt = STREAM_PIX_FMT;  

    if (c->codec_id == CODEC_ID_MPEG2VIDEO) {          /* just for testing, we also add B frames */  

        c->max_b_frames = 2;  

    }  

    if (c->codec_id == CODEC_ID_MPEG1VIDEO){  

        /* Needed to avoid using macroblocks in which some coeffs overflow. 

        This does not happen with normal video, it just happens here as 

        the motion of the chroma plane does not match the luma plane. */  

        c->mb_decision=2;  

    }  

    // some formats want stream headers to be separate  

    if (oc->oformat->flags & AVFMT_GLOBALHEADER)  

        c->flags |= CODEC_FLAG_GLOBAL_HEADER;    

    return st;  

}    

static AVFrame *alloc_picture(enum PixelFormat pix_fmt, int width, int height)  

{  

    AVFrame *picture;  

    uint8_t *picture_buf;  

    int size;    

    picture = avcodec_alloc_frame();  

    if (!picture)  

        return NULL;  

    size = avpicture_get_size(pix_fmt, width, height);  

    picture_buf = (uint8_t *)av_malloc(size);  

    if (!picture_buf) {  

        av_free(picture);  

        return NULL;  

    }  

    avpicture_fill((AVPicture *)picture, picture_buf,  

        pix_fmt, width, height);  

    return picture;  

}    

static void open_video(AVFormatContext *oc, AVStream *st)  

{  

    AVCodec *codec;  

    AVCodecContext *c;    

    c = st->codec;        /* find the video encoder */  

    codec = avcodec_find_encoder(c->codec_id);  

    if (!codec) {  

        fprintf(stderr, "codec not found\n");  

        exit(1);  

    }        /* open the codec */  

    if (avcodec_open(c, codec) < 0) {  

        fprintf(stderr, "could not open codec\n");  

        exit(1);  

    }    

    video_outbuf = NULL;  

    if (!(oc->oformat->flags & AVFMT_RAWPICTURE)) {  

        /* allocate output buffer */  

        /* XXX: API change will be done */  

        /* buffers passed into lav* can be allocated any way you prefer, 

        as long as they're aligned enough for the architecture, and 

        they're freed appropriately (such as using av_free for buffers 

        allocated with av_malloc) */  

        video_outbuf_size = 200000;  

        video_outbuf = (uint8_t *)av_malloc(video_outbuf_size);  

    }        /* allocate the encoded raw picture */  

    picture = alloc_picture(c->pix_fmt, c->width, c->height);  

    if (!picture) {  

        fprintf(stderr, "Could not allocate picture\n");  

        exit(1);  

    }        /* if the output format is not YUV420P, then a temporary YUV420P    picture is needed too. It is then converted to the required    output format */  

    tmp_picture = NULL;  

    if (c->pix_fmt != PIX_FMT_YUV420P) {  

        tmp_picture = alloc_picture(PIX_FMT_YUV420P, c->width, c->height);  

        if (!tmp_picture) {  

            fprintf(stderr, "Could not allocate temporary picture\n");  

            exit(1);  

        }      }  }    /* prepare a dummy image */  

static void fill_yuv_image(AVFrame *pict, int frame_index, int width, int height)  

{  

    int x, y, i;    

    i = frame_index;        /* Y */  

    for (y = 0; y < height; y++) {  

        for (x = 0; x < width; x++) {  

            pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;  

        }  

    }      /* Cb and Cr */  

    for (y = 0; y < height/2; y++) {  

        for (x = 0; x < width/2; x++) {  

            pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;  

            pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;  

        }     }  }    

static void write_video_frame(AVFormatContext *oc, AVStream *st)  

{  

    int out_size, ret;  

    AVCodecContext *c;  

    static struct SwsContext *img_convert_ctx;    

    c = st->codec;    

    if (frame_count >= STREAM_NB_FRAMES) {  

        /* no more frame to compress. The codec has a latency of a few 

        frames if using B frames, so we get the last frames by 

        passing the same picture again */  

    } else {  

        if (c->pix_fmt != PIX_FMT_YUV420P) {  

            /* as we only generate a YUV420P picture, we must convert it 

            to the codec pixel format if needed */  

            if (img_convert_ctx == NULL) {  

                img_convert_ctx = sws_getContext(c->width, c->height,  

                    PIX_FMT_YUV420P,  

                    c->width, c->height,  

                    c->pix_fmt,  

                    sws_flags, NULL, NULL, NULL);  

                if (img_convert_ctx == NULL) {  

                    fprintf(stderr, "Cannot initialize the conversion context\n");  

                    exit(1);  

                }             }  

            fill_yuv_image(tmp_picture, frame_count, c->width, c->height);  

            sws_scale(img_convert_ctx, tmp_picture->data, tmp_picture->linesize,  

                0, c->height, picture->data, picture->linesize);  

        } else {  

            fill_yuv_image(picture, frame_count, c->width, c->height);  

        }  

    }    

    if (oc->oformat->flags & AVFMT_RAWPICTURE) {  

        /* raw video case. The API will change slightly in the near 

        future for that. */  

        AVPacket pkt;  

        av_init_packet(&pkt);    

        pkt.flags |= AV_PKT_FLAG_KEY;  

        pkt.stream_index = st->index;  

        pkt.data = (uint8_t *)picture;  

        pkt.size = sizeof(AVPicture);    

        ret = av_interleaved_write_frame(oc, &pkt);  

    } else {  

        /* encode the image */  

        out_size = avcodec_encode_video(c, video_outbuf, video_outbuf_size, picture);  

        /* if zero size, it means the image was buffered */  

        if (out_size > 0) {  

            AVPacket pkt;  

            av_init_packet(&pkt);    

            if (c->coded_frame->pts != AV_NOPTS_VALUE)  

                pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);  

            if(c->coded_frame->key_frame)  

                pkt.flags |= AV_PKT_FLAG_KEY;  

            pkt.stream_index = st->index;  

            pkt.data = video_outbuf;  

            pkt.size = out_size;    

//          printf("pts %d \n", c->coded_frame->pts);    

            /* write the compressed frame in the media file */  

            ret = av_interleaved_write_frame(oc, &pkt);  

        } else {  

            ret = 0;  

        }  

    }  

    if (ret != 0) {  

        fprintf(stderr, "Error while writing video frame\n");  

        exit(1);  

    }  

    frame_count++;  

}    

static void close_video(AVFormatContext *oc, AVStream *st)  

{     avcodec_close(st->codec);  

    av_free(picture->data[0]);  

    av_free(picture);  

    if (tmp_picture) {  

        av_free(tmp_picture->data[0]);  

        av_free(tmp_picture);  

    }  

    av_free(video_outbuf);  

}  /**************************************************************/  

/* media file output */   

int main(int argc, char **argv)  

{      const char *filename;  

    AVOutputFormat *fmt;  

    AVFormatContext *oc;  

    AVStream *audio_st, *video_st;  

    double audio_pts, video_pts;  

    int i;       /* initialize libavcodec, and register all codecs and formats */  

    av_register_all();    


#ifdef RTMP_STREAM  

    filename = "rtmp://192.168.0.239/live/livestream";  

#else   

    filename = "1.mp4";  

#endif    

    /* allocate the output media context */  

    avformat_alloc_output_context2(&oc, NULL, NULL, filename);  

    if (!oc){  

            printf("Could not deduce output format from file extension: using MPEG.\n");  

        avformat_alloc_output_context2(&oc, NULL, /*"mpeg"*/"flv", filename);  

    }    

    if (!oc)     {  

        return 1;  

    }        // 强制指定 264 编码  

    oc->oformat->video_codec = CODEC_ID_H264;  

    oc->oformat->audio_codec = CODEC_ID_AAC;    

    fmt = oc->oformat;    

    /* add the audio and video streams using the default format codecs 

    and initialize the codecs */  

    video_st = NULL;  

    audio_st = NULL;  

    if (fmt->video_codec != CODEC_ID_NONE) {  

        video_st = add_video_stream(oc, fmt->video_codec);  

    }  

    if (fmt->audio_codec != CODEC_ID_NONE) {  

        audio_st = add_audio_stream(oc, fmt->audio_codec);  

    }    

    av_dump_format(oc, 0, filename, 1);    

  

    if (video_st)  

        open_video(oc, video_st);  

    if (audio_st)  

        open_audio(oc, audio_st);   

    /* open the output file, if needed */  

    if (!(fmt->flags & AVFMT_NOFILE)) {  

        if (avio_open(&oc->pb, filename, AVIO_FLAG_WRITE) < 0) {  

            fprintf(stderr, "Could not open '%s'\n", filename);  

            return 1;  

        }      }        /* write the stream header, if any */  

    avformat_write_header(oc, NULL);  

    picture->pts = 0;  

    for(;;)  

    {   

        if (audio_st)  

            audio_pts = (double)audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;  

        else  

            audio_pts = 0.0;    

        if (video_st)  

            video_pts = (double)video_st->pts.val * video_st->time_base.num / video_st->time_base.den;  

        else  

            video_pts = 0.0;    

        if ((!audio_st || audio_pts >= STREAM_DURATION) &&  

            (!video_st || video_pts >= STREAM_DURATION))  

            break;            /* write interleaved audio and video frames */  

        if (!video_st || (video_st && audio_st && audio_pts < video_pts)) {  

            write_audio_frame(oc, audio_st);    

        } else {  

            write_video_frame(oc, video_st);    

            picture->pts++;  

        }     }   

    av_write_trailer(oc);       /* close each codec */  

    if (video_st)  

        close_video(oc, video_st);  

    if (audio_st)  

        close_audio(oc, audio_st);        /* free the streams */  

    for(i = 0; i < oc->nb_streams; i++) {  

        av_freep(&oc->streams[i]->codec);  

        av_freep(&oc->streams[i]);  

    }    

    if (!(fmt->flags & AVFMT_NOFILE)) {          /* close the output file */  

        avio_close(oc->pb);  

    }      /* free the stream */  

    av_free(oc);    

    return 0;  

}  http://blog.csdn.net/eightdegree/article/details/7425811 


xp5xp6
关注
专栏目录
运用ffmpeg生成MP4文件
tianyu的专栏 - Linux site:blog.csdn.net/wishfly
02-23 1299
生成的MP4文件，用播放器看见的视频如下，同时你可以听到一种呼叫的音频声音 生成的MP4文件音频为(aac)、视频为H264 由于生成的H264需要依赖x264开源库【因为需要将普通的原始数据编码成H264，而ffmpeg默认是按x264进行编码】，在生产x264库过程中，一般我们默认生成静态库即可。 编译ffmpeg并安装 代码如下：
13 - FFmpeg 封装 MP4
最新发布
weixin_44977283的博客
08-16 640
‌AV_SAMPLE_FMT_S16格式的PCM数据是两个声道交替存储，‌每个样点占用2个字节，‌而FFmpeg的AAC编码器需要PCM数据以平面存储格式（‌AV_SAMPLE_FMT_FLTP）‌提供，‌其中样点为float类型，‌且每个声道单独存储。‌这种格式转换（‌重采样）‌是为了适应编码器的输入要求，‌确保音频数据能够被正确编码成AAC格式。‌例如，‌有些声音设备只能播放特定采样率和采样格式的音频数据，‌如果音频数据的格式与设备要求不匹配，‌就需要进行重采样以适应设备的播放要求。
FFMpeg写MP4文件例子分析 .
dong_mingyi的专栏
02-19 1172
(转)FFMpeg写MP4文件例子分析 . 这段时间看了FFMpeg提供的例子muxing.c，我略微修改了下源代码，使其生成一个MP4文件，音频使用AAC编码，视频使用H.264编码。代码很简单，我就不做说明了，代码如下。 以后我们继续写如何将DirectShow中采集的音视频数据编码并生成MP4文件。 1 /* 5 seconds stream duration */
ffmpeg写mp4信息
evsqiezi
06-25 1405
如上图，ffmpeg转码完成后，会写文件信息。    while (!received_sigterm) {    。。。     ret = transcode_step();    for (i = 0; i &lt; nb_output_files; i++) {        os = output_files[i]-&gt;ctx;        if ((ret = av_write_...
python ffmpeg模块mp4岀错_利用ffmpeg+Python实现MP4格式音频与视频的合并的方法
weixin_36444661的博客
01-28 1228
利用ffmpeg+Python实现MP4格式音频与视频的合并的方法发布时间：2020-10-26 17:11:27来源：亿速云阅读：206作者：Leah本篇文章给大家分享的是有关利用ffmpeg+Python实现MP4格式音频与视频的合并的方法，小编觉得挺实用的，因此分享给大家学习，希望大家阅读完这篇文章后可以有所收获，话不多说，跟着小编一起来看看吧。环境变量此电脑--属性--高级系统设置--环境...
FFMPEG 3.4.2 - ffmpeg源代码分析 （二）
irainsa的博客
03-11 229
open_input_file()还调用avformat_find_stream_info()得到更准确的信息。有两种类型可选，一种是AV_CODEC_ID_MPEG4，是ffmpeg自己支持的，一种是AV_CODEC_ID_H264，需要外部的x264库的支持，后者优先。avfilter_get_by_name()用于查找指定名字的filter，avfilter_gragh_create_filter()用于创建filter实例，avfilter_link()用于连接两个filter。
FFmpeg开发入门：MP4文件封装协议解析与关键概念探索
"该文主要探讨了开发实例中的安全防御体系演进，特别是关于零信任最佳实践中的软件定义边界(SDP)技术，并结合了MP4文件封装协议的深入分析。文章详细介绍了MP4文件的结构，包括trak、sample、box等核心概念，以及...
FFmpeg：https：git.ffmpeg.orgffmpeg.git的镜像
01-31
FFmpeg自述文件 FFmpeg是用于处理多媒体内容（例如音频，视频，字幕和相关元数据）的库和工具的集合。 图书馆 libavcodec提供了更多编解码器的实现。 libavformat实现流协议，容器格式和基本I / O访问。 libavutil...
c++使用ffmpeg把h264/h265和mp3写入mp4文件
09-06
c++使用ffmpeg把h264/h265和mp3写入mp4文件,内含ffmpeg库、示例demo、视频素材。
opencv+ffmpeg图片序列写Mp4
06-30
本程序使用opencv3.2+ffmpeg3.4编译，实现Mat到mp4的无缓冲，并可以设置比特率、帧率，实现高质量图片与高质量视频的转换，说明请查看https://blog.csdn.net/weixin_39212021
利用ffmpeg将H264裸流文件封装为MP4文件并保存
06-29
利用ffmpeg库，将H264裸流文件读到内存，然后封装为MP4文件并保存到本地。转换效果亲测，流畅，无卡顿。
使用ffmepg解决mp4文件播放问题
11-13
按照使用说明即可解决mp4等影音文件无法以流方式播放的问题。
FFmpeg成功解码mp4为yuv
10-20
此工程通过FFmpeg成功把mp4文件解码为yuv：注意导入到eclipse之后要右键Android Tools-->add Native support把工程设置为支持本地代码编译的工程 把sintel.mp4放在根目录下
利用FFmpeg转码生成MP4文件
TopsLuo的专栏
06-24 7458
项目中，需要把一路音频流及一路视频流分别转码，生成指定格式（MP4）文件。在使用ffmpeg转码生成mp4文件的过程中，碰到了不少的问题，主要如下： 1. 生成的mp4文件无法正常播放 2. 生成的mp4，用ffmpeg分析，发现码率、帧率等参数不对（编码后的pkt结构体无pts，手动赋值错误，如果是mp4文件，不考虑B帧的情况下，pts是按512往上累加，如果是ts文件，则是按3600累加
FFmpeg支持多线程编码并保存mp4文件示例
网络资源是无限的
08-27 1769
FFmpeg支持多线程编码并保存mp4文件示例
ffmpeg解析mp4
lq496387202的博客
11-30 1922
#include <stdio.h> /*FFmpeg是用C语言编写的，所以如果主程序是用C++编写，则引用FFmpeg的头文件时必须加上extern "C"，否则编译会报错："无法解析的外部符号......"*/ extern "C" { #include "libavformat/avformat.h" } /** * @brief 将一个AVRational类型的分数转...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值