H264码流封装MP4

最新推荐文章于 2024-08-29 22:05:19 发布

qq_28086637

最新推荐文章于 2024-08-29 22:05:19 发布

阅读量6.7k

点赞数 4

分类专栏： ffmpeg H.264 MP4

本文链接：https://blog.csdn.net/qq_28086637/article/details/51201594

版权

ffmpeg H.264 MP4 专栏收录该内容

0 篇文章 0 订阅

订阅专栏

码流封装使用开源库ffmpeg

通过函数h264buff_write() 向H264 buffer中写入H264码流，mux_thread 会把收到的码流封装进MP4 文件，

这里我采用单独的线程封装码流是为了解决录制过程中周期卡顿的问题，也可以不单独拉线程。

类型声明

/*---------------for muxing--------------*/
#ifndef INT64_C
#define INT64_C(c) (c ## LL)
#define UINT64_C(c) (c ## ULL)
#endif

#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"

#define STREAM_FRAME_RATE 30
#define STREAM_PIX_FMT    PIX_FMT_YUV420P    /* AV_PIX_FMT_YUV420P */ /* default pix_fmt */


static int
h264buff_write(char *buf, int n, int instns);

全局变量声明

static int H264buff_flag = 0;
sem_t sem_f;
static char H264BUFA[5242880];/*5MB*///[54857600];   /*50MB*/
static char H264BUFB[5242880];//[54857600];

static int A_size;
static int B_size;

函数声明

/*------------------------muxing---------------------------------*/
/*-----------------
< 0 = error
   0 = I-Frame
   1 = P-Frame
   2 = B-Frame
   3 = S-Frame
--------------------*/
static int getVopType( const void *p, int len )
{   
	if ( !p || 6 >= len )
		return -1;

	unsigned char *b = (unsigned char*)p;
	/* Verify NAL marker */
	if (b[0] ||b[1] || 0x01 != b[2]){   
		b++;
		if (b[0] || b[1] || 0x01 != b[2])
			return -1;
	} 

	b += 3;
	/* Verify VOP id */
	if (0xb6 == *b){
		b++;
		return (*b & 0xc0) >> 6;
	} 

	switch(*b){   
		case 0x65 : return 0;
		case 0x61 : return 1;
		case 0x01 : return 2;
	}

	return -1;
}
 
static int get_nal_type( void *p, int len )
{
	if ( !p || 5 >= len )
		return -1;

	unsigned char *b = (unsigned char*)p;

	/* Verify NAL marker */
	if ( b[0] || b[1] || 0x01 != b[2] ){   
		b++;
		if ( b[0] || b[1] || 0x01 != b[2] )
			return -1;
	}

	b += 3;
	return (*b & 0x1f);
}
 
 
/* Add an output stream */
static AVStream *add_stream(AVFormatContext *oc, AVCodec **codec, struct mux_priv *mux_p, void *p, int len)
{
	AVCodecContext *pcc;
	AVStream *pst;
	AVBitStreamFilterContext * avFilter;
	enum CodecID codec_id = CODEC_ID_H264;

	pst = av_new_stream(oc, 0);
	if (!pst){
		printf("could not allocate stream \n");
		return NULL;
	}
	pst->id = oc->nb_streams-1;
	pcc = pst->codec;
	mux_p->vi = pst->index;
	//avcodec_get_context_defaults2(pcc, NULL);

	pcc->codec_id = codec_id;
	pcc->codec_type = CODEC_TYPE_VIDEO;
	pcc->bit_rate = 3000000;
	pcc->width = 720;
	pcc->height = 480;
	pcc->time_base.den = 30;
	pcc->time_base.num = 1;
	pcc->frame_number = 1;
	//pcc->gop_size = 12;
	pcc->pix_fmt = STREAM_PIX_FMT;

	avFilter = av_bitstream_filter_init("h264_mp4toannexb");
	pcc->extradata_size = len;
	pcc->extradata = (uint8_t*)p;      /*set the PPS SPS of H264 */
	printf("\n\nzorro, pcc->codec_id =   %d. \n",(int)pcc->codec_id);


	if (oc->oformat->flags & AVFMT_GLOBALHEADER){
		pcc->flags |= CODEC_FLAG_GLOBAL_HEADER;
	}

	return pst;
}
 
 
static int
CreateMp4(AVFormatContext **pm_pOc, char *pszFileName, struct mux_priv *mux_p, void *p, int len)
{
	int ret; // 成功返回0，失败返回1
	//const char* pszFileName = "output002.mp4";
	AVOutputFormat *fmt;
	AVCodec *video_codec;
	AVStream *m_pVideoSt;
	AVFormatContext *m_pOc;

	/*0x67 or 0x27*/
	if (0x07 != get_nal_type(p, len)){
		printf("can not detect nal type");
		return -1;
	}
	av_register_all();


	/* auto detect the output format from the name. default is
	mpeg. */
	fmt = guess_format(NULL, pszFileName, NULL);
	if (!fmt) {
		printf("Could not deduce output format from file extension: using MPEG.\n");
		fmt = guess_format("mpeg", pszFileName, NULL);
	}
	if (!fmt) {
		fprintf(stderr, "Could not find suitable output format\n");
		return -1;//
	}

	/* allocate the output media context */
	m_pOc = av_alloc_format_context();
	*pm_pOc = m_pOc;
	if (!m_pOc) {
		fprintf(stderr, "Memory error\n");
		return -1;
	}
	m_pOc->oformat = fmt;	

	snprintf(m_pOc->filename, sizeof(m_pOc->filename), "%s", pszFileName);
	if (fmt->video_codec != CODEC_ID_NONE){
		if (m_pVideoSt = add_stream(m_pOc, &video_codec, mux_p, p, len) == NULL){
			return -1;
		}
	}


	/* set the output parameters (must be done even if no
	parameters). */
	if (av_set_parameters(m_pOc, NULL) < 0) {
		printf("Invalid output format parameters\n");
		return -1;
	}

	dump_format(m_pOc, 0, pszFileName, 1);

	/* open the output file, if needed */
	if (!(fmt->flags & AVFMT_NOFILE)) {
		if (url_fopen(&m_pOc->pb, pszFileName, URL_WRONLY) < 0) {
			printf("Could not open '%s'\n", pszFileName);
			return -1;
		}
	}

	/* Write the stream header, if any */
	ret = av_write_header(m_pOc);
	if (ret < 0){
		printf("Error occurred when opening output file");
		return -1;
	}

	return 0;
}
 
 
/* write h264 data to mp4 file */
static int
WriteVideo(AVFormatContext *m_pOc, struct mux_priv *mux_p, void* data, int nLen)
{
	int ret;

	if ( 0 > mux_p->vi ){
		printf("vi less than 0");
		return -1;
	}
	AVStream *pst = m_pOc->streams[mux_p->vi];

	// Init packet
	AVPacket pkt;

	// 我的添加，为了计算pts
	AVCodecContext *c = pst->codec;

	av_init_packet( &pkt );
	pkt.flags |= ( 0 >= getVopType( data, nLen ) ) ? PKT_FLAG_KEY : 0;   

	pkt.stream_index = pst->index;
	pkt.data = (uint8_t*)data;
	pkt.size = nLen;

	// Wait for key frame
	if (mux_p->waitkey)
		if ( 0 == ( pkt.flags & PKT_FLAG_KEY ) )
		return 0;
	else
		mux_p->waitkey = 0;


	pkt.dts = AV_NOPTS_VALUE;
	pkt.pts = AV_NOPTS_VALUE;
	//pkt.pts = (ptsInc++) * (180000/STREAM_FRAME_RATE);
	//pkt.dts = (ptsInc++) * (90000/STREAM_FRAME_RATE);

	ret = av_interleaved_write_frame( m_pOc, &pkt );
	if (ret < 0){
		printf("cannot write frame");
	}

	av_free_packet(&pkt);
	return 0;
}
 
static void
CloseMp4(AVFormatContext *m_pOc)
{
	/* no need zorro
	waitkey = -1;
	vi = -1; */
	
	if (m_pOc)
		av_write_trailer(m_pOc);

	if (m_pOc && !(m_pOc->oformat->flags & AVFMT_NOFILE))
		url_fclose(m_pOc->pb);/* for new : avio_close(m_pOc->pb); */


	if (m_pOc){
		av_free(m_pOc);
		m_pOc = NULL;
   	 }
 
}

/*==============get_H264NAL================
*Function: get a NAL from H264buff,when we find the next NAL, 
		   return 0, or return -1,
*Author: zorro
*Date :6/3/2015
*======================================*/
static int
get_H264NAL(void *pbuff, int plen, int *NAL_len, int *NAL_type)
{
	unsigned char *H264Data =  (unsigned char*)pbuff;
	int H264Len = plen;
           int next_type;

	if (plen <4){
		*NAL_len = plen;
		return -1;
	}

	// check this NAL type
	if (H264Data[1] || H264Data[2] || 0x01 != H264Data[3]){
		*NAL_type = 0;
	}else{
		*NAL_type = H264Data[4] & 0x1f;
		H264Data+=4;
		H264Len-=4;
	}

	
	while(H264Len){
		if(H264Data[0] == 0x00 && H264Data[1] == 0x00 && H264Data[2] == 0x01){
			next_type = H264Data[3] & 0x1f;
		
		    	if(next_type == 0x01 ||next_type == 0x05){
				if(H264Data[-1] == 0x00) H264Data--;
				*NAL_len = H264Data - (unsigned char *)pbuff;
				return 0;
			}

		}

		H264Data+=1;
		H264Len-=1;
		
	}
	*NAL_len = H264Data -  (unsigned char *)pbuff;
	return -1;
}


/*==============mux_thread====================
*Function: read H264Data from h264 file, and packet it to MP4 file
*Author: zorro
*Date :6/3/2015
*======================================*/
void
mux_thread(void *arg)
{	
	struct encode *enc = (struct encode *)arg;
	int instns = enc->cmdl->instns;
	struct mux_priv mux_p = {0, -1, 1};
	char *H264head;
	int H264len;

	unsigned char NALbuf[512 * 1024];
	int NAL_Len;
	int read_len;
	int NAL_type;

	int rs;
	
	AVFormatContext * pFormatCtx = NULL;
	

waitenc:

	sem_wait(& sem_f);
	if (H264buff_flag == 1){
		H264head = H264BUFA;
		H264len = A_size;
		A_size = 0;
	}else{
		H264head = H264BUFB;
		H264len = B_size;
		B_size = 0;
	}

	do{

		/* reach the next NAL or H264buf end*/
		rs = get_H264NAL(H264head, H264len, &read_len, &NAL_type);
		
		if ((H264len - read_len) < 0){
			printf("\n\n\nzorro, get_H264NAL err.\n\n");
		}
		/* no data to read, break out*/
		if (read_len <= 0) break;
		/*	new NAL*/
		if (NAL_type > 0){
			memcpy(NALbuf, H264head, read_len);
			NAL_Len = read_len; 
			if (NAL_type == 0x05)  mux_p.waitkey = 1;	   /*check key frame*/
		}else{ /* last NAL*/
			memcpy(&NALbuf[NAL_Len], H264head, read_len);
			NAL_Len += read_len;
		}

		H264head += read_len; 
		H264len -= read_len;

		/* reach the H264buf end */
		if (rs < 0){
			if (! enc_end)
					goto waitenc;
			printf("reach the H264 buff end, H264len = %d, NAL_Len = %d, NAL_type = %d\n", H264len, NAL_Len, NAL_type);
		}
		

		if (0 < NAL_Len)
		{
			memset(&NALbuf[NAL_Len], 0, FF_INPUT_BUFFER_PADDING_SIZE);

		
		if (!pFormatCtx){
			if (CreateMp4(&pFormatCtx, enc->cmdl->output, &mux_p, NALbuf, NAL_Len) < 0){
				break;
			}
		}
		if (pFormatCtx)
			if (WriteVideo(pFormatCtx, &mux_p, NALbuf, NAL_Len) < 0)
				break;

		} /* end if (0 < NAL_Len) */

		if (quitflag)
		break;

	}while(0 < NAL_Len);
	CloseMp4(pFormatCtx);
	ins_priv[instns].A_size = 0;
	ins_priv[instns].B_size = 0;
	printf("\nmuxing end\n");
}

/*==============h264buff_write================
*Function: copy the encoded data frome vpu to H264buff,
*Author: zorro
*Date :6/3/2015
*======================================*/
static int
h264buff_write(char *buf, int n, int instns)
{
	//if (fwrite_thread_err < 0)
		//return -1;
	
	if (! H264buff_flag){
		if ( A_size >= 5000000){
			printf("zorro,memory err ,out of H264BUFA range..\n" );
			return -1;
		}
		memcpy((void *)(& H264BUFA[ A_size]), (void *)buf, n);
		A_size+=n;
		if ( A_size >= 5000000){
			 H264buff_flag = 1;
			 sem_post(& sem_f);
		}
	}else{
		if (B_size >= 5000000){
			printf("zorro,memory err ,out of H264BUFB range..\n" );
			return -1;
		}
		memcpy((void *)(& H264BUFB[ B_size]), (void *)buf, n);
		B_size+=n;
		if ( B_size >= 5000000){
			H264buff_flag = 0;
			sem_post(& sem_f);
		}
	}

	return 0;
}
/*------------------------muxing---------------------------------*/