Ubuntu+FFmpeg源码+H264+RTMP推流

迈不过友情╰ 2022-09-07 15:58 451阅读 0赞

PC端通过FFmpeg源码实现将H264数据RTMP推流到Nginx服务器上，这个是用于PC端的测试demo，程序可以直接移植到ARM版本中，需要将库文件交叉编译，以及修改对应的交叉编译工具链即可。

因为实现这个功能的环境比较恶劣（没有摄像头），本人通过将开发板端摄像头实时数据保存成二进制文件（.bin），  
按规定格式\[NAL\_SIZE|NAL||NAL\_SIZE|NAL|…|NAL\_SIZE|NAL|NAL\_SIZE|NAL|\],现将一个完整的NAL帧数据大小写入文件，紧接是NAL数据，如此循环。当PC端读取文件时，先读取一帧数据的大小，再按照规定大小，读取一帧NAL数据，并将数据推送到Nginx服务器上。

[完整工程：https://download.csdn.net/download/weixin\_43793181/21481918][https_download.csdn.net_download_weixin_43793181_21481918]  
![在这里插入图片描述][741e85d73d564b31a1f82b80c4faba59.png]

[代码实现、库编译时遇到的问题][Link 1]

push\_stream.c完整代码：

#include <stdio.h> 
    #include "uvc_video_handler.h"
    #define __STDC_CONSTANT_MACROS
    
    #ifdef __cplusplus
    extern "C"
    { 
    #endif
    #include <libavformat/avformat.h>
    #include <libavcodec/codec_id.h>
    #include <libavutil/mathematics.h>
    #include <libavutil/time.h>
    
    #ifdef __cplusplus
    };
    #endif
    
    AVFormatContext *ofmt_ctx = NULL;
    int ptsInc = 0;
    
     int add_stream(AVFormatContext *ofmt_ctx,OutputStream *ost, AVCodec **codecder, enum AVCodecID codec_id)
    { 
    	AVCodecContext *codec = NULL;
    	AVRational a_time_base;
    	AVRational v_time_base;
    
    	// find the encoder
    	*codecder = avcodec_find_encoder(AV_CODEC_ID_H264);
    	if (!(*codecder)) 
    	{ 
    		printf("Could not find encoder for '%s'\n", avcodec_get_name(codec_id));
    		return -1;
    	}
    	
    	ost->st = avformat_new_stream(ofmt_ctx, NULL);
    	if (!ost->st) 
    	{ 
    		printf("Could not allocate stream\n");
    		return -1;
    	}
    
    	codec = avcodec_alloc_context3(*codecder);
    	if (!codec) { 
    		printf("Could not alloc an encoding context\n");
    		return -1;
    	}
    
    	ost->st->id = ofmt_ctx->nb_streams - 1;
    	ost->enc = codec;
    
    	switch ((*codecder)->type) { 
    		case AVMEDIA_TYPE_AUDIO:
    			codec->codec_id = codec_id;
    			codec->codec_type = AVMEDIA_TYPE_AUDIO;
    			codec->sample_fmt = AV_SAMPLE_FMT_FLTP;
    			codec->bit_rate = 64000;
    			codec->sample_rate = 8000;
    			codec->channel_layout = AV_CH_LAYOUT_MONO;
    			codec->channels = av_get_channel_layout_nb_channels(codec->channel_layout);
    			a_time_base.num = 1;
    			a_time_base.den = codec->sample_rate;
    			ost->st->time_base = a_time_base;
    			break;
    
    		case AVMEDIA_TYPE_VIDEO:
    			codec->codec_id = codec_id;
    			codec->codec_type = AVMEDIA_TYPE_VIDEO;
    			codec->pix_fmt = AV_PIX_FMT_YUV420P;
    			codec->bit_rate = 400000;
    			codec->width = 800;
    			codec->height = 640;
    			v_time_base.num = 1;
    			v_time_base.den = 50;
    			ost->st->time_base = v_time_base;
    			codec->time_base = ost->st->time_base;
    			codec->codec_tag = 0;
    			break;
    
    		default:
    			break;
    	}
    
    	if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
    		codec->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
    		
    	int ret = avcodec_open2(codec,*codecder,NULL);
    	if(ret < 0)
    	{ 
    		printf("open video codec failed !\n");
    	}
    
    	if(avcodec_parameters_from_context(ost->st->codecpar,codec) < 0)
    	{ 
    		printf("acvodec_parameters_from_context failed!\n");
    	}	
    	return 0;
    }
    
    int write_frame(AVFormatContext *fmt_ctx, const AVRational *time_base, AVStream *st, AVPacket *pkt)
    { 
    	// rescale output packet timestamp values from codec to stream timebase 
    	av_packet_rescale_ts(pkt, *time_base, st->time_base);
    	pkt->stream_index = st->index;
    
    	//Write the compressed frame to the media file. 
    	return av_interleaved_write_frame(fmt_ctx, pkt);
    }
    
    int write_video_frame(AVFormatContext *ofmt_ctx,OutputStream *ost, char* data, int datalen)
    { 
    	int ret = 0;
    	int isI = 0;
    	AVCodecContext *c = ost->enc;
    	AVPacket pkt = {  0 };
    
    	av_init_packet(&pkt);
    
    	isI = isIdrFrame1((uint8_t*)data, datalen);
    	pkt.flags |= isI ? AV_PKT_FLAG_KEY : 0;
    	pkt.data = (uint8_t*)data;
    	pkt.size = datalen;
    
    	AVRational time_base = {  1, 1000};
    	pkt.pts = av_rescale_q((ptsInc++) * 2, time_base, ost->st->time_base);
    	pkt.dts = av_rescale_q_rnd(pkt.dts, ost->st->time_base, ost->st->time_base, (AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
    	pkt.duration = av_rescale_q(pkt.duration, ost->st->time_base, ost->st->time_base);	
    	pkt.pos = -1;
    
    	ret = write_frame(ofmt_ctx, &c->time_base, ost->st, &pkt);
    	if (ret < 0)
    	 { 
    		printf("Error while writing video frame\n");
    		return -1;
    	}
    	return 0;
    }
     
    bool isIdrFrame2(uint8_t *buf, int len)
    { 
    	switch (buf[0] & 0x1f) { 
    	case 7: // SPS
    		return true;
    	case 8: // PPS
    		return true;
    	case 5:
    		return true;
    	case 1:
    		return false;
    
    	default:
    		return false;
    		break;
    	}
    	return false;
    }
    
    bool isIdrFrame1(uint8_t *buf, int size)
    { 
    	int last = 0;
    	for (int i = 2; i <= size; ++i) { 
    		if (i == size) { 
    			if (last) { 
    				bool ret = isIdrFrame2(buf + last, i - last);
    				if (ret) { 
    					return true;
    				}
    			}
    		}
    		else if (buf[i - 2] == 0x00 && buf[i - 1] == 0x00 && buf[i] == 0x01) { 
    			if (last) { 
    				int size = i - last - 3;
    				if (buf[i - 3]) ++size;
    				bool ret = isIdrFrame2(buf + last, size);
    				if (ret) { 
    					return true;
    				}
    			}
    			last = i + 1;
    		}
    	}
    	return false;
    }
    
    int main(int argc, char* argv[])
    { 
    	char buffer_size[6];				//每一帧数据的大小（字符串）
    	char nal_buf[100000];			//每一帧数据的内容
    	int nal_size = 0;						//每一帧数据的大小（整型）
    	int n,m = 0;
    
    	AVDictionary *opt;
    	AVPacket pkt;
    	AVCodec *audio_codec,*video_codec;
    	OutputStream audio_st,video_st;
    	AVOutputFormat *ofmt = NULL;
    	int ret,i,have_video,have_audio;
    	int videoindex=-1;
    	int frame_index=0;
    	int64_t start_time=0;
    	//输入对应一个AVFormatContext，输出对应一个AVFormatContext
    	AVFormatContext *ifmt_ctx = NULL, *ofmt_ctx = NULL;
    	const char *in_filename, *out_filename;
    
    	in_filename  = "uvc_enc_out.bin";//输入文件（内容结构:NAL_SIZE|NAL|NAL_SIZE|NAL|NAL_SIZE|NAL）
    	out_filename = "rtmp://10.1.40.34:1935/live/test";//输出 URL（Output URL）[RTMP]
     
    	av_register_all();
    	avformat_network_init();
    
    	avformat_alloc_output_context2(&ofmt_ctx, NULL, "flv", out_filename); 
    	if (!ofmt_ctx) 
    	{ 
    		printf( "Could not create output context\n");
    		ret = AVERROR_UNKNOWN;
    		return -1;
    	}
    
    	ofmt = ofmt_ctx->oformat;	
    	if(ofmt->video_codec != AV_CODEC_ID_NONE)
    	{ 
    		ofmt->video_codec = AV_CODEC_ID_H264;
    		
    		ret = add_stream(ofmt_ctx,&video_st, &video_codec,ofmt->video_codec);
    		if(ret < 0)
    		{ 
    			printf("Could not add video stream.\n");
    			return -1;
    		}
    	}
    /* if (ofmt->audio_codec != AV_CODEC_ID_NONE) { ofmt->audio_codec = AV_CODEC_ID_AAC; ret = add_stream(ofmt_ctx,&audio_st, &audio_codec, ofmt->audio_codec); if (ret < 0) { printf("Could not add audio stream.\n"); return -1; } } */
    	av_dump_format(ofmt_ctx, 0, out_filename, 1);
    
    	if (!(ofmt->flags & AVFMT_NOFILE)) 
    	{ 
    		ret = avio_open(&ofmt_ctx->pb, out_filename, AVIO_FLAG_READ_WRITE);
    		if (ret < 0) { 
    			printf("Could not open '%s' %d: %s\n", out_filename,ret, av_err2str(ret));
    			return -1;
    		}
    	}
    	
    	//ret = avformat_write_header(ofmt_ctx, &opt);
    	ret = avformat_write_header(ofmt_ctx, NULL);
    	if (ret < 0) { 
    		printf("Error occurred when opening output URL\n");
    		return -1;
    	}
    
    	FILE *dst= fopen(in_filename,"rb");
    	if(dst == NULL)		//打开失败返回NULL
    	{ 
    		perror("打开源文件失败！\n");
    		exit(0);
    	}
    	while(!feof(dst))
    	{ 
    		n = fread(buffer_size,1,5,dst);																						//前5个字节为NAL_SIZE
    		if(n == 5)
    		{ 
    			nal_size = atoi(buffer_size);																						//字符串转为整型
    			printf("nal_size == %d\n",nal_size);
    			memset(nal_buf,0,100000);																						//清空数组
    			n = fread(nal_buf,1,nal_size,dst);																			//读取一帧NAL数据
    			if(n == nal_size)
    			{ 
    				printf("这是%d帧数据！\n",++m);
    				ret = write_video_frame(ofmt_ctx,&video_st,  nal_buf, nal_size);	//写NAL数据，推流
    			}
    			else
    			{ 
    				printf("帧数据出不来n == %d\n",n);
    			}
    		}
    		else
    		{ 
    			printf("n不为5，n==%d\n",n);
    		}
    	}
    	return 0;
    }

推流＋拉流成功  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc5MzE4MQ_size_16_color_FFFFFF_t_70_pic_center]

[https_download.csdn.net_download_weixin_43793181_21481918]: https://download.csdn.net/download/weixin_43793181/21481918
[741e85d73d564b31a1f82b80c4faba59.png]: /images/20220829/53acf2baecce4b469255b9e68f3aa872.png
[Link 1]: https://blog.csdn.net/weixin_43793181/article/details/119874147?spm=1001.2014.3001.5501
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc5MzE4MQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/76541dbe304447b89941f692c36d2558.png