基于Ubuntu+FFmepg源码通过Nginx+Live555服务器完成RTMP+RTSP推H264流

落日映苍穹つ 2022-09-09 01:51 467阅读 0赞

最近项目需要支持RTMP+RTSP推流功能，最终版本是在RK平台上显示，这里提供一个ubuntu系统上的简单实现demo(主要C实现)。  
实现方式：  
RTMP:将完整H264帧数据发布到Nginx服务器，通过VLC播放器拉流显示。  
RTSP:将完整H264帧数据发布到Live555服务器，通过VLC播放器拉流显示。  
Nginx:服务器是通过网络读取数据流  
Live555:服务器是通过文件读取数据流（此demo用到fifo有名管道）

[完整DEMO工程：https://download.csdn.net/download/weixin\_43793181/21653704?spm=1001.2014.3001.5501][DEMO_https_download.csdn.net_download_weixin_43793181_21653704_spm_1001.2014.3001.5501]

上源码：  
RTSP头文件：

#ifndef _RTSP_STREAM_H_
    #define _RTSP_STREAM_H_
    
    #include <stdio.h>
    #include <fcntl.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <pthread.h>
    
    struct val
    { 
        char buffer[100000];
        int 	length;
    };
    
    void rtsp_fifo_init();
    void rtsp_push(void *arg);
    #endif

RTSP源文件：

#include "rtsp_stream.h"
    
    int fifo1;
    void rtsp_fifo_init()
    { 
    	const char *fifo_filename = "/opt/test.264";
    	int ret;
    	if(access(fifo_filename,F_OK))					//判断文件是否存在，固定参数F_OK
    	{ 
    		ret = mkfifo(fifo_filename,0777);					//不存在则创建
    		if(ret == -1)
    		{ 
    			perror("创建有名管道失败！\n");
    			return -1;
    		}
    	}
    	
    	fifo1 = open(fifo_filename,O_RDWR);			//存在就直接打开
    	if(fifo1 == -1)
    	{ 
    		perror("打开有名管道1失败！\n");
    		return -1;
    	}
    }
    
    void rtsp_push(void *arg)
    { 
    	struct val *v = (struct val *)arg;
    	write(fifo1, v->buffer ,v->length);	
    	pthread_exit(NULL);
    }

RTMP头文件

#ifndef _RTMP_STREAM_H_
    #define _RTMP_STREAM_H_
    
    #include <pthread.h>
    #include <libavformat/avformat.h>
    #include <libavutil/timestamp.h>
    #include <libavutil/time.h>
    #include <libavcodec/avcodec.h>
    #include <libavformat/avformat.h>
    #include <libavutil/opt.h>
    #include <libswresample/swresample.h>
    #include <libavcodec/codec_id.h>
    #ifdef __cplusplus
    extern "C" { 
    #endif
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <stdbool.h>
    
    typedef struct OutputStream { 
    	AVStream *st;
    	AVCodecContext *enc;
    	
    	int64_t next_pts;
    	long long samples_count;
    
    	AVFrame *frame;
    	AVFrame *tmp_frame;
    
    	struct SwrContext *swr_ctx;
    } OutputStream;
    
    int add_stream(AVFormatContext *ofmt_ctx,OutputStream *ost, AVCodec **codecder, enum AVCodecID codec_id);
    int write_frame(AVFormatContext *fmt_ctx, const AVRational *time_base, AVStream *st, AVPacket *pkt);
    int write_video_frame(AVFormatContext *ofmt_ctx,OutputStream *ost, char* data, int datalen);
    bool isIdrFrame2(uint8_t *buf, int len);
    bool isIdrFrame1(uint8_t *buf, int size);
    
    #ifdef __cplusplus
    }
    #endif
    
    #endif

RTMP源文件

#include "rtmp_stream.h"
    #include <stdio.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
    
    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;
    }

main函数实现：

#include <stdio.h> 
    #include "rtsp_stream.h"
    #include "rtmp_stream.h"
    
    #include "uvc_video_handler.h"
    #define __STDC_CONSTANT_MACROS
    
    int main(int argc, char* argv[])
    { 
    	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]
    	
    	rtsp_fifo_init();
    	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, 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);
    				write_video_frame(ofmt_ctx,&video_st,  nal_buf, nal_size);				//写NAL数据，RTMP推流 
    
    				struct val nal;
    				memcpy(nal.buffer,nal_buf,nal_size);
    				nal.length = nal_size;
    				pthread_create(&rtsp_id, NULL, rtsp_push,(void *)&nal);							//RTSP推流
    			    pthread_join(rtsp_id, NULL);
    			}
    			else
    			{ 
    				printf("帧数据出不来n == %d\n",n);
    			}
    		}
    		else
    		{ 
    			printf("n不为5，n==%d\n",n);
    		}
    	}
    	return 0;
    }

Makefile内容：

#!/bin/sh
    INCLUDE = /home/jiajia/FFmpeg_push_H264/include
    LIB_DIR = /home/jiajia/FFmpeg_push_H264/lib
    LDFLAGS = -lavformat -lavutil -lavcodec -lswresample  -lm -lpthread
    
    SRC=push_stream.c rtsp_stream.c  rtmp_stream.c
    
    all:$(SRC)
    	gcc -g -Wall $(SRC) -o send -I $(INCLUDE) -L $(LIB_DIR)  $(LDFLAGS)

[完整DEMO工程：https://download.csdn.net/download/weixin\_43793181/21653704?spm=1001.2014.3001.5501][DEMO_https_download.csdn.net_download_weixin_43793181_21653704_spm_1001.2014.3001.5501]

[DEMO_https_download.csdn.net_download_weixin_43793181_21653704_spm_1001.2014.3001.5501]: https://download.csdn.net/download/weixin_43793181/21653704?spm=1001.2014.3001.5501