mp4v2再学习 -- H264视频编码成MP4文件

标签：int -- MP4Encoder char H264 MP4 nalu size

一、H264视频编码成MP4文件

参看：H264视频编码成MP4文件

参看：mp4v2在VS2010下的编译与在项目中的使用

最近做项目需要将H264文件封装为mp4文件，从网上找到了MP4V2库，下载下来后不知道从何下手，官方网站https://code.google.com/p/mp4v2/在windows下的编译过程介绍的很简短，对刚刚开始使用VS2010做大型项目的人来说，实在是有些无力。于是从网上找到了下面几篇博客文章，亲测可用，留下来以备查看。

（1）mp4v2 库在VS2017下的编译过程

注：此段内容参考：编译MP4v2

Mp4v2 一开始是与 mpeg4ip 这个开源项目捆绑在一起的，现在已经脱离mpeg4ip以一个单独的库存在着。Mp4v2 库提供了一些 API 用来创建修改 MP4 文件。

源码在 http://mp4v2.googlecode.com/svn/trunk/，首先新建一个文件夹用来导入源码，创建文件夹后右键 SVN checkout（需要预先在电脑上安装 TortoiseSVN 客户端），在 URL of repository 中填入http://mp4v2.googlecode.com/svn/trunk/ 这个网址，点击ok后导入代码，再把vstudio9.0\libmp4v2\Version.rc 放入 src 文件夹下。

上面的内容其实就是获取 MP4V2 源码。上面两个谷歌网站没有进入，原因你懂的。可从 CSDN 下载。

下载：mp4v2最新源码

mp4v2再学习 -- H264视频编码成MP4文件_ide

然后在进入 vs2013 目录下，用 vs2017 打开 mp4v2.sln 。选择配置为 release win32，成功后，编译 libmp4v2。

在 mp4v2-master\buildwin\lib.vs2013\Win32\Release 下会生成 4 个文件，lbmp4v2.lib、libmp4v2.dll、libmp4v2.pdb、libmp4v2.exp。这样就完成了。

mp4v2再学习 -- H264视频编码成MP4文件_封装_02

mp4v2再学习 -- H264视频编码成MP4文件_封装_03

备注：

1. mp4v2 的源码下载需要用到 SVN 客户端 TortoiseSVN，官方网站上能下载的是 Linux 平台下的代码。

Linux下安装编译之前有讲，参看：mp4v2再学习 -- mp4v2 安装说明
2. 此过程在 VS2017 下打开没有问题。
3. 以后在你的项目中会用到 lbmp4v2.lib、libmp4v2.dll 这两个文件。

上面的操作有几处需要注意的：

（1）首先选择配置为 release win32，这个该如何配置？

配置方法：生成->配置管理器，然后将 libmp4v2 配置改为 Release

mp4v2再学习 -- H264视频编码成MP4文件_封装_04

mp4v2再学习 -- H264视频编码成MP4文件_#include_05

（2）问题分析

出现无法打开包括文件: “corecrt.h”

mp4v2再学习 -- H264视频编码成MP4文件_封装_06

解决方法，参看：VS2015无法打开包括文件corecrt.h

简单来说就是按如下图，把里面的 10.0.15063.0 文件复制一份，重命名成 10.0.10240.0

mp4v2再学习 -- H264视频编码成MP4文件_封装_07

mp4v2再学习 -- H264视频编码成MP4文件_ide_08

（2）mp4v2库在VS2010中的使用

注：此处测试代码参考：H264视频编码成MP4文件，作者代码写的很好，赞一个。此处只是把配置过程再详讲一下。

原文如下：
最近需要将H264视频编码成MP4格式。研究了一下，一种方法是采用ffmpeg库，可以先将H264文件解码，再编码生成MP4文件，但这种方式效率较低，10M的视频可能需要几秒钟才能完成。另一种方式根据MP4文件协议直接将H264包封装成MP4格式，由于是直接基于MP4的封装，因而效率很高。H264可以很方便的封装成FLV文件，但MP4格式格式相对比较复杂，封装起来会比较麻烦。由于没时间研究MP4协议，在Google Code上找到一个开源的MP4编解码库Mp4v2（https://code.google.com/p/mp4v2/），通过Mp4v2可以很方便的将H264编码成MP4格式文件。为了方便使用，基于该库封装了一个MP4Encoder类，MP4Encoder封装的接口如下。目前仅支持将H264文件或数据帧编码成MP4文件。

[cpp] view plain copy

class MP4Encoder
{
public:
void);
void);
public:
// open or creat a mp4 file.
const char *fileName,int width,int height,int timeScale = 90000,int frameRate = 25);
// wirte 264 metadata in mp4 file.
bool Write264Metadata(MP4FileHandle hMp4File,LPMP4ENC_Metadata lpMetadata);
// wirte 264 data, data can contain multiple frame.
int WriteH264Data(MP4FileHandle hMp4File,const unsigned char* pData,int size);
// close mp4 file.
void CloseMP4File(MP4FileHandle hMp4File);
// convert H264 file to mp4 file.
// no need to call CreateMP4File and CloseMP4File,it will create/close mp4 file automaticly.
bool WriteH264File(const char* pFile264,const char* pFileMp4);
// Prase H264 metamata from H264 data frame
static bool PraseMetadata(const unsigned char* pData,int size,MP4ENC_Metadata &metadata);
};

客户端调用示例代码：

[cpp] view plain copy

#include <stdio.h>
#include "MP4Encoder.h"
int main(int argc, char** argv)
{
MP4Encoder mp4Encoder;
// convert H264 file to mp4 file
"test.264","test.mp4");
}

MP4Encoder的完整代码如下：

[cpp] view plain copy

/********************************************************************
filename: MP4Encoder.h
created: 2013-04-16
author: firehood
purpose: MP4编码器，基于开源库mp4v2实现（https://code.google.com/p/mp4v2/）。
*********************************************************************/
#pragma once
#include "mp4v2\mp4v2.h"
// NALU单元
typedef struct _MP4ENC_NaluUnit
{
int type;
int size;
char *data;
}MP4ENC_NaluUnit;
typedef struct _MP4ENC_Metadata
{
// video, must be h264 type
int nSpsLen;
char Sps[1024];
int nPpsLen;
char Pps[1024];
} MP4ENC_Metadata,*LPMP4ENC_Metadata;
class MP4Encoder
{
public:
void);
void);
public:
// open or creat a mp4 file.
const char *fileName,int width,int height,int timeScale = 90000,int frameRate = 25);
// wirte 264 metadata in mp4 file.
bool Write264Metadata(MP4FileHandle hMp4File,LPMP4ENC_Metadata lpMetadata);
// wirte 264 data, data can contain multiple frame.
int WriteH264Data(MP4FileHandle hMp4File,const unsigned char* pData,int size);
// close mp4 file.
void CloseMP4File(MP4FileHandle hMp4File);
// convert H264 file to mp4 file.
// no need to call CreateMP4File and CloseMP4File,it will create/close mp4 file automaticly.
bool WriteH264File(const char* pFile264,const char* pFileMp4);
// Prase H264 metamata from H264 data frame
static bool PraseMetadata(const unsigned char* pData,int size,MP4ENC_Metadata &metadata);
private:
// read one nalu from H264 data buffer
static int ReadOneNaluFromBuf(const unsigned char *buffer,unsigned int nBufferSize,unsigned int offSet,MP4ENC_NaluUnit &nalu);
private:
int m_nWidth;
int m_nHeight;
int m_nFrameRate;
int m_nTimeScale;
MP4TrackId m_videoId;
};

MP4Encoder.cpp

[cpp] view plain copy

/********************************************************************
filename: MP4Encoder.cpp
created: 2013-04-16
author: firehood
purpose: MP4编码器，基于开源库mp4v2实现（https://code.google.com/p/mp4v2/）。
*********************************************************************/
#include "MP4Encoder.h"
#include <string.h>
#define BUFFER_SIZE (1024*1024)
MP4Encoder::MP4Encoder(void):
m_videoId(NULL),
m_nWidth(0),
m_nHeight(0),
m_nTimeScale(0),
m_nFrameRate(0)
{
}
MP4Encoder::~MP4Encoder(void)
{
}
MP4FileHandle MP4Encoder::CreateMP4File(const char *pFileName,int width,int height,int timeScale/* = 90000*/,int frameRate/* = 25*/)
{
if(pFileName == NULL)
{
return false;
}
// create mp4 file
MP4FileHandle hMp4file = MP4Create(pFileName);
if (hMp4file == MP4_INVALID_FILE_HANDLE)
{
"ERROR:Open file fialed.\n");
return false;
}
m_nWidth = width;
m_nHeight = height;
m_nTimeScale = 90000;
m_nFrameRate = 25;
MP4SetTimeScale(hMp4file, m_nTimeScale);
return hMp4file;
}
bool MP4Encoder::Write264Metadata(MP4FileHandle hMp4File,LPMP4ENC_Metadata lpMetadata)
{
m_videoId = MP4AddH264VideoTrack
(hMp4File,
m_nTimeScale,
m_nTimeScale / m_nFrameRate,
// width
// height
// sps[1] AVCProfileIndication
// sps[2] profile_compat
// sps[3] AVCLevelIndication
// 4 bytes length before each NAL unit
if (m_videoId == MP4_INVALID_TRACK_ID)
{
"add video track failed.\n");
return false;
}
// Simple Profile @ Level 3
// write sps
MP4AddH264SequenceParameterSet(hMp4File,m_videoId,lpMetadata->Sps,lpMetadata->nSpsLen);
// write pps
MP4AddH264PictureParameterSet(hMp4File,m_videoId,lpMetadata->Pps,lpMetadata->nPpsLen);
return true;
}
int MP4Encoder::WriteH264Data(MP4FileHandle hMp4File,const unsigned char* pData,int size)
{
if(hMp4File == NULL)
{
return -1;
}
if(pData == NULL)
{
return -1;
}
MP4ENC_NaluUnit nalu;
int pos = 0, len = 0;
while (len = ReadOneNaluFromBuf(pData,size,pos,nalu))
{
if(nalu.type == 0x07) // sps
{
// 添加h264 track
m_videoId = MP4AddH264VideoTrack
(hMp4File,
m_nTimeScale,
m_nTimeScale / m_nFrameRate,
// width
// height
// sps[1] AVCProfileIndication
// sps[2] profile_compat
// sps[3] AVCLevelIndication
// 4 bytes length before each NAL unit
if (m_videoId == MP4_INVALID_TRACK_ID)
{
"add video track failed.\n");
return 0;
}
// Simple Profile @ Level 3
MP4AddH264SequenceParameterSet(hMp4File,m_videoId,nalu.data,nalu.size);
}
else if(nalu.type == 0x08) // pps
{
MP4AddH264PictureParameterSet(hMp4File,m_videoId,nalu.data,nalu.size);
}
else
{
int datalen = nalu.size+4;
char *data = new unsigned char[datalen];
// MP4 Nalu前四个字节表示Nalu长度
data[0] = nalu.size>>24;
data[1] = nalu.size>>16;
data[2] = nalu.size>>8;
data[3] = nalu.size&0xff;
memcpy(data+4,nalu.data,nalu.size);
if(!MP4WriteSample(hMp4File, m_videoId, data, datalen,MP4_INVALID_DURATION, 0, 1))
{
return 0;
}
delete[] data;
}
pos += len;
}
return pos;
}
int MP4Encoder::ReadOneNaluFromBuf(const unsigned char *buffer,unsigned int nBufferSize,unsigned int offSet,MP4ENC_NaluUnit &nalu)
{
int i = offSet;
while(i<nBufferSize)
{
if(buffer[i++] == 0x00 &&
buffer[i++] == 0x00 &&
buffer[i++] == 0x00 &&
buffer[i++] == 0x01
)
{
int pos = i;
while (pos<nBufferSize)
{
if(buffer[pos++] == 0x00 &&
buffer[pos++] == 0x00 &&
buffer[pos++] == 0x00 &&
buffer[pos++] == 0x01
)
{
break;
}
}
if(pos == nBufferSize)
{
nalu.size = pos-i;
}
else
{
nalu.size = (pos-4)-i;
}
nalu.type = buffer[i]&0x1f;
char*)&buffer[i];
return (nalu.size+i-offSet);
}
}
return 0;
}
void MP4Encoder::CloseMP4File(MP4FileHandle hMp4File)
{
if(hMp4File)
{
MP4Close(hMp4File);
hMp4File = NULL;
}
}
bool MP4Encoder::WriteH264File(const char* pFile264,const char* pFileMp4)
{
if(pFile264 == NULL || pFileMp4 == NULL)
{
return false;
}
MP4FileHandle hMp4File = CreateMP4File(pFileMp4,352,288);
if(hMp4File == NULL)
{
"ERROR:Create file failed!");
return false;
}
FILE *fp = fopen(pFile264, "rb");
if(!fp)
{
"ERROR:open file failed!");
return false;
}
fseek(fp, 0, SEEK_SET);
char *buffer = new unsigned char[BUFFER_SIZE];
int pos = 0;
while(1)
{
int readlen = fread(buffer+pos, sizeof(unsigned char), BUFFER_SIZE-pos, fp);
if(readlen<=0)
{
break;
}
readlen += pos;
int writelen = 0;
for(int i = readlen-1; i>=0; i--)
{
if(buffer[i--] == 0x01 &&
buffer[i--] == 0x00 &&
buffer[i--] == 0x00 &&
buffer[i--] == 0x00
)
{
writelen = i+5;
break;
}
}
writelen = WriteH264Data(hMp4File,buffer,writelen);
if(writelen<=0)
{
break;
}
memcpy(buffer,buffer+writelen,readlen-writelen+1);
pos = readlen-writelen+1;
}
fclose(fp);
delete[] buffer;
CloseMP4File(hMp4File);
return true;
}
bool MP4Encoder:: PraseMetadata(const unsigned char* pData,int size,MP4ENC_Metadata &metadata)
{
if(pData == NULL || size<4)
{
return false;
}
MP4ENC_NaluUnit nalu;
int pos = 0;
bool bRet1 = false,bRet2 = false;
while (int len = ReadOneNaluFromBuf(pData,size,pos,nalu))
{
if(nalu.type == 0x07)
{
memcpy(metadata.Sps,nalu.data,nalu.size);
metadata.nSpsLen = nalu.size;
true;
}
else if((nalu.type == 0x08))
{
memcpy(metadata.Pps,nalu.data,nalu.size);
metadata.nPpsLen = nalu.size;
true;
}
pos += len;
}
if(bRet1 && bRet2)
{
return true;
}
return false;
}