使用ffmpeg开源库将h264封装为mp4格式

最新推荐文章于 2024-08-16 15:39:20 发布
最新推荐文章于 2024-08-16 15:39:20 发布
阅读量2.9k 收藏 6
点赞数
分类专栏： FFmpeg 文章标签： ffmpeg

--------------------- 
作者：Jons伯恩特 
来源：CSDN 
原文：https://blog.csdn.net/huangyifei_1111/article/details/46955021 
版权声明：本文为博主原创文章，转载请附上博文链接！

最近一直在做使用ffmpeg关于读取标准h264格式内存如何封装为mp4格式文件，在经过一周的持续奋战之后在网上找了一些代码，特别的雷神的博客让我获益匪浅，开始不知道如何持续读取发送来的内存块，如何边接受内存边封装为mp4格式文件，找了很多代码也没想出来，后来发现ffmpeg注册的读取拷贝内存的回调函数是自己控制的人为无法控制，经过一番折腾，找了一个比较容易的方法，如果代码有错误的地方希望大家指导，想写一篇博客把自己的代码贴出来。

#include "StdAfx.h"
#include "format.h"


ITAVFormat::ITAVFormat(void)
{
    m_ifmt_ctx = NULL;
    m_ofmt_ctx = NULL;
    m_ofmt       = NULL;
    m_bufAvalloc = NULL;
    m_fileName = NULL;
    for(int i=0; i<BUF_UNIT_NUM; i++)
    {
        m_bufDeq.data[i].ptr = new unsigned char[UNIT_SIZE];
        memset(m_bufDeq.data[i].ptr,0,UNIT_SIZE);
        m_bufDeq.data[i].size = 0;
        m_bufDeq.data[i].readsize = 0;
    }
    m_bufDeq.head = 0;
    m_bufDeq.tail = 0;
    m_countFill = 0;
    m_frame_index = 0;
    m_startCode = 0;
}


ITAVFormat::~ITAVFormat(void)
{
    for(int i=0; i<BUF_UNIT_NUM; i++)
    {
        delete []m_bufDeq.data[i].ptr;
        m_bufDeq.data[i].size = 0;
        m_bufDeq.data[i].readsize = 0;
    }
    m_bufDeq.head = 0;
    m_bufDeq.tail = 0;
}

int ITAVFormat::read_data(void *opaque, uint8_t *buf, int buf_size)
{
    //printf("readData!!!!!!!!!!!!\n");
    ITAVFormat* pThis = (ITAVFormat*)opaque;
    if(pThis->m_bufDeq.head == pThis->m_bufDeq.tail)
    {
        //printf("*********head==tail********buf_size=%ld\n",buf_size);
        return 0;
    }
    else
    {
        int head = pThis->m_bufDeq.head;
        buf_size = FFMIN(buf_size, pThis->m_bufDeq.data[head].size);
        printf("ptr:%p,size:%u,buf_size=%u\n",pThis->m_bufDeq.data[head].ptr, pThis->m_bufDeq.data[head].size,buf_size);

        /* copy internal buffer data to buf */
        memcpy(buf, pThis->m_bufDeq.data[head].ptr+pThis->m_bufDeq.data[head].readsize, buf_size);

        pThis->m_bufDeq.data[head].readsize  += buf_size;
        pThis->m_bufDeq.data[head].size -= buf_size;

        if(pThis->m_bufDeq.data[head].size <= 0)
        {
            pThis->m_bufDeq.data[head].readsize = 0;
            pThis->m_bufDeq.head = (pThis->m_bufDeq.head+1)%BUF_UNIT_NUM;

        }
        return buf_size;
    }
    
}
void ITAVFormat::init()
{
    av_register_all();
}

int ITAVFormat::fillBuffer(unsigned char* buff,int len)
{
    //buffer_data b
    if(buff == NULL)
        return TRUE;
    if(len > UNIT_SIZE)
        return FALSE;
    int tail = m_bufDeq.tail;
    memcpy(m_bufDeq.data[tail].ptr,buff,len);
    m_bufDeq.data[tail].size = len;
    m_bufDeq.data[tail].readsize = 0;
    m_bufDeq.tail = (m_bufDeq.tail+1)%BUF_UNIT_NUM;
    
    if(m_countFill == 0)
    {
    
        m_startCode = start();
        if(m_startCode < 0)
            return FALSE;
        m_countFill++;    
    }
    else
        writeFrame();
    
    return TRUE;
}

int ITAVFormat::writeFrame()
{
    int ret = -1;
    AVPacket pkt;
    while(1) 
    {
        AVStream *in_stream, *out_stream;
        //Get an AVPacket
        ret = av_read_frame(m_ifmt_ctx, &pkt);
        //printf("ret=%d\n",ret);
        if (ret < 0)
        {
            printf("ret = %d\n",ret);
            break;
        }
        in_stream  = m_ifmt_ctx->streams[pkt.stream_index];
        out_stream = m_ofmt_ctx->streams[pkt.stream_index];

        ///如果没有显示时间戳自己加上时间戳并且将显示时间戳赋值给解码时间戳
        if(pkt.pts==AV_NOPTS_VALUE){
            //Write PTS
            AVRational time_base1=in_stream->time_base;
            //Duration between 2 frames (us)
            int64_t calc_duration=(double)AV_TIME_BASE/av_q2d(in_stream->r_frame_rate);
            //Parameters
            pkt.pts=(double)(m_frame_index*calc_duration)/(double)(av_q2d(time_base1)*AV_TIME_BASE);
            pkt.dts=pkt.pts;
            pkt.duration=(double)calc_duration/(double)(av_q2d(time_base1)*AV_TIME_BASE);
            m_frame_index++;
        }

        //Convert PTS/DTS
        pkt.pts = av_rescale_q_rnd(pkt.pts, in_stream->time_base, out_stream->time_base, (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
        pkt.dts = av_rescale_q_rnd(pkt.dts, in_stream->time_base, out_stream->time_base, (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
        pkt.duration = av_rescale_q(pkt.duration, in_stream->time_base, out_stream->time_base);

        pkt.pos = -1;
        //Write
        if (av_interleaved_write_frame(m_ofmt_ctx, &pkt) < 0) {
            printf( "Error muxing packet\n");
            break;
        }
        //printf("Write %8d frames to output file\n",frame_index);
        av_free_packet(&pkt);
        m_frame_index++;
    }
     return TRUE;
}
// av_probe_input_buffer2
//     AVPROBE_SCORE_MAX
int ITAVFormat::start()
{
    int ret,i;
    AVIOContext* pb = NULL;
    AVInputFormat* piFmt = NULL;
    m_bufAvalloc = (unsigned char*)av_malloc(32768);
    pb = avio_alloc_context(m_bufAvalloc, 32768, 0, (void*)this, ITAVFormat::read_data, NULL, NULL);

    if (av_probe_input_buffer(pb, &piFmt, "", NULL, 0, 0) < 0)
        return -1;
    else{
        printf("format:%s[%s]\n", piFmt->name, piFmt->long_name);
    }
    m_ifmt_ctx = avformat_alloc_context();
    m_ifmt_ctx->pb = pb;

    //Input
    if (avformat_open_input(&m_ifmt_ctx, "", piFmt, NULL) != 0){//iformat，priv_data赋值，pb, nbstreams,streams为null
        printf("Couldn't open input stream.（无法打开输入流）\n");
        return -2;
    }

    if ((ret = avformat_find_stream_info(m_ifmt_ctx, 0)) < 0) {
        printf( "Failed to retrieve input stream information");
        return -3;
    }
    //Output
    avformat_alloc_output_context2(&m_ofmt_ctx, NULL, NULL, m_fileName);
    if (!m_ofmt_ctx) {
        printf( "Could not create output context\n");
        return -4;
        //goto end;
    }
    m_ofmt = m_ofmt_ctx->oformat;
    for (i = 0; i < m_ifmt_ctx->nb_streams; i++) {
        //Create output AVStream according to input AVStream
        AVStream *in_stream = m_ifmt_ctx->streams[i];
        AVStream *out_stream = avformat_new_stream(m_ofmt_ctx, in_stream->codec->codec);
        if (!out_stream) {
            printf( "Failed allocating output stream\n");
            return -5;
        }
        //Copy the settings of AVCodecContext
        if (avcodec_copy_context(out_stream->codec, in_stream->codec) < 0) {
            printf( "Failed to copy context from input to output stream codec context\n");
            return -6;
        }
        out_stream->codec->codec_tag = 0;
        if (m_ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
        {
            out_stream->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
        }
    }
    //Output information------------------
    av_dump_format(m_ofmt_ctx, 0, m_fileName, 1);
    //Open output file
    if (!(m_ofmt->flags & AVFMT_NOFILE)) {
        ret = avio_open(&m_ofmt_ctx->pb, m_fileName, AVIO_FLAG_WRITE);
        if (ret < 0) {
            printf( "Could not open output file '%s'", m_fileName);
            return -7;
        }
    }
    //Write file header
    if (avformat_write_header(m_ofmt_ctx, NULL) < 0) { 
        printf( "Error occurred when opening output file\n");
        return -8;
    }
    return TRUE;
}

void ITAVFormat::setFileName(char* fileName)
{
    m_fileName = fileName;
}

void ITAVFormat::finish()
{
    if(m_startCode < 0)
        return;
    //Write file trailer
    av_write_trailer(m_ofmt_ctx);
    //av_free(m_bufAvalloc);
    avformat_close_input(&m_ifmt_ctx);
    /* close output */
    if (m_ofmt_ctx && !(m_ofmt->flags & AVFMT_NOFILE))
        avio_close(m_ofmt_ctx->pb);
    avformat_free_context(m_ofmt_ctx);
    //av_free(m_bufAvalloc);
}

 

mr_xuliang
关注
专栏目录
基于FFMPEG封装aac及h264为FargmentMP4
venice0708的博客
07-26 1257
FargmentMP4是一种特殊的MP4，这边他的特点及格式，不再详细说明 ，网上资料不少可以进行参考。 这边说下基于FFMPEG封装aac及h264为FargmentMP4的步骤： 关键代码： 1、创建两个输入对象和一个输出对象并打开。 AVFormatContext *ifmt_ctx_v = NULL, *ifmt_ctx_a = NULL, *ofmt_ctx = NULL; if ...
利用ffmpeg将H264裸流文件封装为MP4文件并保存
06-29
利用ffmpeg库，将H264裸流文件读到内存，然后封装为MP4文件并保存到本地。转换效果亲测，流畅，无卡顿。
13 - FFmpeg 封装 MP4
最新发布
weixin_44977283的博客
08-16 561
‌AV_SAMPLE_FMT_S16格式的PCM数据是两个声道交替存储，‌每个样点占用2个字节，‌而FFmpeg的AAC编码器需要PCM数据以平面存储格式（‌AV_SAMPLE_FMT_FLTP）‌提供，‌其中样点为float类型，‌且每个声道单独存储。‌这种格式转换（‌重采样）‌是为了适应编码器的输入要求，‌确保音频数据能够被正确编码成AAC格式。‌例如，‌有些声音设备只能播放特定采样率和采样格式的音频数据，‌如果音频数据的格式与设备要求不匹配，‌就需要进行重采样以适应设备的播放要求。
使用ffmpeg封装h264裸流为MP4文件
11-21
使用ffmpeg封装h264裸流为MP4文件，亲测，可修改时间戳实现输出视频的速度控制，附使用说明。
ffmpeg封装H264成MP4、AVI视频格式，及提取出png、jpg格式图片
08-15
Qt工程，ffmpeg库和h264测试文件。纯原创，仅供交流学习。
ffmpeg学习（二） 通过rtsp获取H264裸流并保存到mp4文件
weixin_30847939的博客
09-24 1453
本篇将使用上节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、工程属...
c++使用ffmpeg把h264/h265和mp3写入mp4文件
09-06
本主题聚焦于如何使用C++与FFmpeg库来将H264、H265编码的视频流和MP3音频流合并并写入到MP4文件中。H264和H265是两种高效的视频编码标准，而MP3是一种广泛接受的音频编码格式。MP4文件格式则允许同时存储视频和音频...
封装的使用FFMPEG的DXVA2解码显示H264和H265码流的库
05-13
总的来说，封装的FFmpeg DXVA2解码库提供了一个高效的解决方案，帮助开发者充分利用硬件资源，优化H264和H265视频的解码过程，从而提升用户体验，特别是在资源有限的设备上。通过学习和使用这类库，开发者可以构建出...
ffmpeg摄像头数据h264编码并封装avi
05-18
在这个特定的场景中，我们要探讨的是如何使用FFmpeg将摄像头捕获的数据进行H.264编码，并封装成AVI格式的视频文件。 H.264，也称为MPEG-4 Part 10或AVC（Advanced Video Coding），是一种高效的视频编码标准，广泛...
ffmpeg封装H246为MP4
爱自在的专栏
09-27 2556
转载格式实在不好看，看原文链接吧！ 前言 文章主要对H264视频流封装为MP4格式文件的讲述，有实时H264视频流的封装和h264文件的封装，本文主要针对飞思卡尔I.MX6Q-vpu视频编码后的视频封装，所以没涉及到音频， 一、h264视频文件的封装 这部分代码主要是从雷博那里借鉴过来的，雷博的文章是音频和视频封装，我这里只实现视频的封装，雷博的文章网站：http://blog...
使用ffmpeg 将纯H264保存为mp4
tpyangqingyuan的专栏
12-31 6689
(未验证，先保留着) http://doc.okbase.net/wenjingu/archive/101505.html
ffmpeg实现将H264裸流封装成.mp4或.avi文件
Qiuoooooo的博客
07-17 7851
由于我是移植到arm-linux环境（海思HI3521A），H264裸流直接从海思的编码模块VENC获取。 H264数据流序列: SPS, PPS, SEI, I, P, P, ... P, P, SPS, PPS, SEI, I, P, P, ... P, P, ... 源码如下： #include <stdio.h> #include "mpi_venc.h" #ifndef __STDC_CONSTANT_MACROS #define __STDC_CONSTANT_MA...
FFMPEG 封装H264->MP4
技术联盟
05-24 2799
#define USE_H264BSF 1 #define USE_AACBSF 1 #define CODEC_FLAG_GLOBAL_HEADER (1 << 22) static int open_input_file(const char *filename) { FILE *fp; fp=fopen(filename,"rb");// localf...
实现用FFmpeg接收RTSP，把H264视频和AAC音频录制成MP4文件（附完整代码）
热门推荐
toshiba689的专栏
03-02 1万+
FFmpeg支持Rtsp流接收功能，协议实现已经较为完善，利用FFmpeg还可以将RTSP收到的流录制为某种容器格式。这里我向大家介绍怎么用它的API来实现RTSP接收和录制这两个功能。 我把接收RTSP和录制文件的逻辑都用一个类RtspStreamMuxTask来处理，下面给出这个类的头文件和源文件。 RtspStreamMuxTask.h文件: #ifndef RtspS...
Hi3531D调试手记（四）：使用ffmpeg实时封装H264视频为MP4
qq_38940316的博客
04-12 2139
Ubuntu系统版本：Ubuntu 16.04.7 LTS 目录零、杂记一、 零、杂记 参考博客 最简单的基于FFmpeg的封装格式处理：视音频复用器（muxer）、博客 海思HI3531D使用ffmpeg实时封装多路H264视频+AAC音频为MP4 以及博客 hisi3559A平台VENC获取H264裸流封装成mp4，完美贴合项目需求，确实有被帮助到，感谢几位博主的无私分享。 本文记录的代码实现仅为实时视频封装，无视频编码需求以及音频封装需求。 ffmpeg使用的版本为 3.4.8，移植过程记录在 Hi
利用ffmpeg0.6.1把.h264纯码流打包成.mp4 .avi等格式 （转载）
weixin_30530939的博客
05-08 341
转自：http://cache2.weidaohang.org/h/index.php?q=aHR0cDovL2Jsb2cuY3Nkbi5uZXQvemh1cWluZ183MzkvYXJ0aWNsZS9kZXRhaWxzLzY2MzY4NTc= 一直比较困惑一个问题，都说ffmpeg功能很强大，但是自己一直没有去研究一下，今天终于见识了一下它的强大之处了！ 首先当然是在linux下编译和...
关于ffmpeg封装h264为mp4的问题
u010289908的专栏
06-15 7438
照着ffmpeg里的例子封装h264为mp4的答题思路是对的，但是，还是要加一些东西才行~ 下面是之前查东西的一些收获：     对于h264文件来说，h264有两种封装，     一种是annexb模式，传统模式，有startcode，SPS和PPS是在ES中      一种是mp4模式，一般mp4 mkv会有，没有startcode，SPS和PPS以及其它信息被封装在container
H.264 封装mp4 源码
05-10
H.264 封装为 MP4 的源码可以比较复杂，需要涉及到视频编码、封装格式等多个方面的知识。以下是一个简单的示例代码，可以实现将 H.264 裸流封装为 MP4 文件的功能： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #define FRAME_RATE 25 #define BIT_RATE 4800000 typedef struct { FILE *fp; int width; int height; int frame_rate; int bit_rate; int gop_size; int frame_count; } MP4File; typedef struct { unsigned char *data; int size; int key_frame; int pts; } H264Frame; static void write_int(FILE *fp, int value) { unsigned char buf[4]; buf[0] = value >> 24; buf[1] = value >> 16; buf[2] = value >> 8; buf[3] = value; fwrite(buf, 1, 4, fp); } static void write_short(FILE *fp, short value) { unsigned char buf[2]; buf[0] = value >> 8; buf[1] = value; fwrite(buf, 1, 2, fp); } static void write_data(FILE *fp, unsigned char *data, int size) { fwrite(data, 1, size, fp); } MP4File *mp4_create(const char *filename, int width, int height, int frame_rate, int bit_rate) { MP4File *mp4 = (MP4File *)malloc(sizeof(MP4File)); memset(mp4, 0, sizeof(MP4File)); mp4->fp = fopen(filename, "wb"); if (!mp4->fp) { printf("failed to create mp4 file\n"); free(mp4); return NULL; } mp4->width = width; mp4->height = height; mp4->frame_rate = frame_rate; mp4->bit_rate = bit_rate; mp4->gop_size = frame_rate * 2; write_data(mp4->fp, (unsigned char *)"ftypisom", 8); write_int(mp4->fp, 0); write_data(mp4->fp, (unsigned char *)"isom", 4); write_data(mp4->fp, (unsigned char *)"mp42", 4); return mp4; } void mp4_destroy(MP4File *mp4) { if (mp4) { fclose(mp4->fp); free(mp4); } } void mp4_write_frame(MP4File *mp4, H264Frame *frame) { if (!mp4 || !frame) { return; } if (frame->key_frame) { write_data(mp4->fp, (unsigned char *)"mdat", 4); write_int(mp4->fp, 0); } int size = frame->size + 4; write_int(mp4->fp, size); if (frame->key_frame) { write_data(mp4->fp, (unsigned char *)"avc1", 4); write_short(mp4->fp, 0); write_short(mp4->fp, 0); write_short(mp4->fp, mp4->width); write_short(mp4->fp, mp4->height); write_int(mp4->fp, mp4->bit_rate); write_int(mp4->fp, mp4->frame_rate); write_short(mp4->fp, 1); write_short(mp4->fp, 12); write_data(mp4->fp, (unsigned char *)"avcC", 4); write_int(mp4->fp, 0x01); write_data(mp4->fp, frame->data + 4, 3); write_short(mp4->fp, 0xffe1); write_short(mp4->fp, 16); write_data(mp4->fp, (unsigned char *)"avcC", 4); write_data(mp4->fp, frame->data + 7, frame->size - 7); } else { write_data(mp4->fp, frame->data, frame->size); } mp4->frame_count++; } int main() { MP4File *mp4 = mp4_create("test.mp4", 1280, 720, FRAME_RATE, BIT_RATE); if (!mp4) { return 0; } FILE *h264 = fopen("test.h264", "rb"); if (!h264) { mp4_destroy(mp4); return 0; } H264Frame frame; memset(&frame, 0, sizeof(H264Frame)); frame.data = (unsigned char *)malloc(1024 * 1024); while (!feof(h264)) { size_t size = fread(frame.data, 1, 1024 * 1024, h264); frame.size = size; frame.key_frame = 1; frame.pts = mp4->frame_count * 90000 / mp4->frame_rate; mp4_write_frame(mp4, &frame); } free(frame.data); fclose(h264); mp4_destroy(mp4); return 0; } ``` 在这个示例中，我们首先定义了一个 MP4File 结构体，用于保存 MP4 文件的相关信息，比如宽高、帧率、码率等。mp4_create 函数用于创建 MP4 文件，它会写入 MP4 文件的头信息。mp4_write_frame 函数用于写入 H.264 数据帧，它会根据帧类型（关键帧或非关键帧）来写入相应的 MP4 Box。最后，在主函数中我们读入 H.264 裸流，并将其封装为 MP4 文件。 需要注意的是，这里只是一个简单的示例，实际的 MP4 封装格式可能比这个复杂得多，还需要考虑音频、时间戳等问题。如果需要进行更加复杂的封装，建议使用现有的一些开源封装库，比如 FFmpeg 等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值