当前位置:   article > 正文

三、RTMP推流的原理及实现_rtmp推流服务器

rtmp推流服务器

1、启动 SRS 服务器

sudo ./objs/srs -c conf/rtmp.conf
  • 1

2、启动 RTMP 客户端(rtmpdump)

./RTMP_DEMO
  • 1

注意:设置客户端请求的地址要和 SRS 服务启动的地址一样。
eg:客户端中设置的是:

#define RTMP_URL "rtmp://192.168.1.3/live/livestream"
  • 1

查看客户端的 log,发现连接成功:

在这里插入图片描述

打印 SRS 服务端的 log:发现 RTMP Client 连接成功,因为这个客户端也是在本机上启动的,所以地址也是 198.168.1.3。

在这里插入图片描述

3、 RTMP 客户端开始推流

  • 客户端会将设置好的 pcm 音频数据+ yuv 视频数据推到 SRS 服务端。
  • 拉流端会从SRS 服务端拉流播放。
    在这里插入图片描述

4、RTMP客户端实现原理

RTMP 客户端进行推流,下面简单说下实现原理。

  • 初始化 RTMP推流对象:RTMPPusher

  • 解析 RTMP URL,eg :“rtmp://192.168.1.3/live/livestream”

    (1) 对url做合法性的校验,不合法直接返回;
    (2) 解析url,解析出:protocol、host、path、port。
    protocol:16
    host:192.168.1.3/live/livestream
    path:live/livestream
    port:1935

  • RTMPPusher发起请求Connect

    (1) 构建 Socket

    	struct sockaddr_in service;
    	memset(&service, 0, sizeof(struct sockaddr_in));
    	service.sin_family = AF_INET; // 指定(TCP/IP – IPv4)
    	service->sin_addr.s_addr = inet_addr(hostname) //指定目的ip地址:192.168.1.3
    	service->sin_port = htons(port); //指定目的端口号port:1935
    
    • 1
    • 2
    • 3
    • 4
    • 5

    (2) 建立TCP连接

    	/*1、创建 Socket */
    	r->m_sb.sb_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    	/*2、开始3次握手,尝试建立 TCP 连接*/
    	connect(r->m_sb.sb_socket, service, sizeof(struct sockaddr));
    	/*3、成功建立连接*/
    	LogInfo("TCP Connect Success!!!");
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    (3) 建立 RTMP Connection

    	int ret;
    	/* 1、RTMP  Hand Shake*/
    	ret = HandShake(r, TRUE)
    	if(ret == 0){
            RTMP_LogInfo(RTMP_LOGERROR, "%s, RTMP handshake failed.", __FUNCTION__);
            RTMP_Close(r);
            return FALSE;
    	}
    	RTMP_LogInfo(RTMP_LOGINFO, "%s, RTMP handshaked success", __FUNCTION__);
    
    	/*2、发送 connect 命令消息(Command Message)
    	*  如果熟悉RTMP协议的话,就知道在RTMP握手完成之后,
    	*  就要发送⼀个connect命令消息,⽤于客户端向服务器发送连接请求,
    	*  如果服务端同意连接,会返回连接成功的消息。
    	*/
    	ret = SendConnectPacket(r,cp);
    	if(ret==0){
            RTMP_LogInfo(RTMP_LOGERROR, "%s,Setp 3  RTMP connect failed.", __FUNCTION__);
            RTMP_Close(r);
            return FALSE;
    	}
    	/*3、到这里 RTMP Connection 成功建立*/
    	RTMP_LogInfo(RTMP_LOGINFO, "Setp 3 connect. msg cmd (typeID=20) (Connect) ok");
    	return TRUE;
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    HandShake、SendConnectPacket都是 librtmp 里面函数,需要对 RTMP 协议熟悉才能看懂。

    • RTMP连接
      这里只是简要介绍一下RTMP 的连接过程,具体 RTMP 协议可以看Aodbe官方RTMP协议书。
      RTMP协议是应⽤层协议,是要靠底层可靠的传输层协议(通常是TCP)来保证信息传输的可靠性的。
      
      在传输层TCP协议的连接建⽴完成后,RTMP协议也要客户端和服务器通过“握⼿”来建⽴基于传输层
      链接之上的RTMP Connection链接。
      
      在握手完成后,先通过发送 connect 命令消息,来建立 NetConnection,才能进行会话。
      
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
    • RTMP Connection 握手(hand shake)
      要建⽴⼀个有效的RTMP Connection链接,⾸先要“握⼿”:客户端要向服务器发送C0,C1,C2(按序)三个 chunk,
      服务器向客户端发送S0,S1,S2(按序)三个chunk,然后才能进⾏有效的信息传输。
      本身并没有规定这6个Message的具体传输顺序,但RTMP协议的实现者需要保证这⼏点:
      1、客户端要等收到S1之后才能发送C2;
      2、客户端要等收到S2之后才能发送其他信息(控制信息和真实⾳视频等数据);
      3、服务端要等到收到C0之后发送S1;
      4、服务端必须等到收到C1之后才能发送S2;
      5、服务端必须等到收到C2之后才能发送其他信息(控制信息和真实⾳视频等数据)
      
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8

    (4) 建立 RTMP Stream
    通过发送 Create Stream 命令消息,来建立 NetStream 信息通道 。

    Netstream建⽴在NetConnection(第 3 步)之上,通过NetConnection的createStream命令创建,⽤于传输具体的⾳频、视频等信息。在传输层协议之上只能连接⼀个NetConnection,但⼀个NetConnection可以建⽴ 多个NetStream来建⽴不同的流通道传输数据。

    当发送完CreateStream消息后,解析服务器返回的消息会得到⼀个stream ID, 这个ID也就是以后和服 务器通信的 message stream ID, ⼀般返回的是1,不固定。

        if (!RTMP_ConnectStream(rtmp_, 0))
        {
            LogInfo("RTMP_ConnectStream failed");
            return FALSE;
        }
    
    • 1
    • 2
    • 3
    • 4
    • 5

    (5)音频编码、音频重采样、视频编码器初始化的过程

    	// 初始化publish  (推流起始时间 )
        AVPublishTime::GetInstance()->Rest();
    
    	// 设置音频编码器,并初始化
    	audio_encoder_ = new AACEncoder();
        Properties  aud_codec_properties;
        aud_codec_properties.SetProperty("sample_rate", audio_sample_rate_);
        aud_codec_properties.SetProperty("channels", audio_channels_);
        aud_codec_properties.SetProperty("bitrate", audio_bitrate_);
        if(audio_encoder_->Init(aud_codec_properties) != RET_OK)
        {
            LogError("AACEncoder Init failed");
            return RET_FAIL;
        }
        aac_fp_ = fopen("push_dump.aac", "wb");
        if(!aac_fp_)
        {
            LogError("fopen push_dump.aac failed");
            return RET_FAIL;
        }
    	
    	//设置音频重采样:将 s16 交错模式的 PCM 数据 ----> AV_SAMPLE_FMT_FLT 棋盘格式的数据
        audio_resampler_ = new AudioResampler();
        AudioResampleParams aud_params;
        aud_params.logtag = "[audio-resample]";
        aud_params.src_sample_fmt = (AVSampleFormat)mic_sample_fmt_;
        aud_params.dst_sample_fmt = (AVSampleFormat)audio_encoder_->get_sample_format();
        aud_params.src_sample_rate = mic_sample_rate_;
        aud_params.dst_sample_rate = audio_encoder_->get_sample_rate();
        aud_params.src_channel_layout = av_get_default_channel_layout(mic_channels_);
        aud_params.dst_channel_layout = audio_encoder_->get_channel_layout();
        aud_params.logtag = "audio-resample-encode";
        audio_resampler_->InitResampler(aud_params);
    	
    	//设置视频编码器
        video_encoder_ = new H264Encoder();
        Properties  vid_codec_properties;
        vid_codec_properties.SetProperty("width", video_width_);
        vid_codec_properties.SetProperty("height", video_height_);
        vid_codec_properties.SetProperty("fps", video_fps_);
        vid_codec_properties.SetProperty("b_frames", video_b_frames_);
        vid_codec_properties.SetProperty("bitrate", video_bitrate_);
        vid_codec_properties.SetProperty("gop", video_gop_);
        if(video_encoder_->Init(vid_codec_properties) != RET_OK)
        {
            LogError("H264Encoder Init failed");
            return RET_FAIL;
        }
        h264_fp_ = fopen("push_dump.h264", "wb");
        if(!h264_fp_)
        {
            LogError("fopen push_dump.h264 failed");
            return RET_FAIL;
        }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55

    (6)构造 FLV 格式,因为RTMP推流是以FLV的格式去发送
    FLV 格式中一个重要的字段:metaData
    在这里插入图片描述
    可以从上图看出 FLV 的 metaData 字段,保存着FLV 视频和音频的元信息。

        FLVMetadataMsg *metadata = new FLVMetadataMsg();
        // 设置视频相关
        metadata->has_video = true;
        metadata->width = video_encoder_->get_width();
        metadata->height = video_encoder_->get_height();
        metadata->framerate = video_encoder_->get_framerate();
        metadata->videodatarate = video_encoder_->get_bit_rate();
        // 设置音频相关
        metadata->has_audio = true;
        metadata->channles = audio_encoder_->get_channels();
        metadata->audiosamplerate = audio_encoder_->get_sample_rate();
        metadata->audiosamplesize = 16;
        metadata->audiodatarate = 64;
        metadata->pts = 0;
        
        /* metadata push到消息队列 */
        rtmp_pusher->Post(RTMP_BODY_METADATA, metadata, false);
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    (7) 设置音频捕获器
    音频捕获器的作用:
    1、打开要发送的pcm文件
    2、启动一个线程,循环发送pcm数据到pcm_buf
    3、执行回调消费pcm_buf
    4、将pcm_buf重采样后,进行编码。
    代码只看关键地方:

    	//音频捕获器初始化,在这个函数里面会打开pcm文件,得到fd:pcm_fp_
        audio_capturer_->Init(aud_cap_properties)
    
    	//Start里面会启动线程执行Loop操作
      	audio_capturer_->Start()
    
    	//Loop操作:会从打开的pcm文件中持续读取数据到pcm_buf中,然后传入回调callback_get_pcm_消费。
    	void AudioCapturer::Loop()
    	{		
    	    int nb_samples = 1024;
    	    pcm_total_duration_ = 0;
    	    pcm_start_time_ = TimesUtil::GetTimeMillisecond();
    	    while(true)
    	    {
    	        if(request_exit_)
    	            break;
    	         /* 每次读取1024个sample到pcm_buf中*/   
    	        if(readPcmFile(pcm_buf_, nb_samples) == 0)
    	        {
    	            if(!is_first_frame_) {
    	                is_first_frame_ = true;
    	                LogInfo("%s:t%u", AVPublishTime::GetInstance()->getAInTag(),
    	                        AVPublishTime::GetInstance()->getCurrenTime());
    	            }
    	            if(callback_get_pcm_)
    	            {    
    	                //执行回调,callback_get_pcm,将pcm_buf传入然后消费。
    	                callback_get_pcm_(pcm_buf_, nb_samples *4); // 2通道 s16格式
    	            }
    	        }
    	        std::this_thread::sleep_for(std::chrono::milliseconds(2));
    	    }
    	    closePcmFile();
    	}
    
    	
    	//执行callback_get_pcm_回调
    	/*
    	* pcm:就是pc_buf
    	* size:4096 ==> 1024个样本 * 2通道 * 16位采样格式
    	*/
    	void PushWork::PcmCallback(uint8_t *pcm, int32_t size){
    			
    		    if(need_send_audio_spec_config)
    		    {
    		        need_send_audio_spec_config = false;
    		        /* 生成 AudioSpecMsg 消息,推给服务端。
    		        */
    		        AudioSpecMsg *aud_spc_msg = new AudioSpecMsg(audio_encoder_->get_profile(),
    		                                                     audio_encoder_->get_channels(),
    		                                                     audio_encoder_->get_sample_rate());
    		        aud_spc_msg->pts_ = 0;
    		        /*
    		        * 对此大家可能很困惑?为什么要先把 Audio的配置信息(采样率、通道数...)先单独推送到服务端,
    		        * 为什么不和下面的数据一起推过去?其实在视频数据包推送哪里也会有类似的处理,它需要先把关键帧
    		        * 的 sps 和 pps 先单独推送到服务端。
    		        * 
    		        * 因为:假设sps和pps作为配置信息存放在关键帧的报文中推送到服务端,如果出现网络错误导致
    				* 这个关键帧没有到达服务端,缺少了 sps 和 pps,那后面推送的 B 帧、P 帧也无法播放了。
    		        * 
    		        * 针对上面问题:在推流的时候,sps 和 pps 不和关键帧放在一起往服务端推送,而是先把 sps+pps 数
    				* 据成功推到服务端后,才能推后面的帧。如果 sps、pps 推失败了,后面推多少都是白推。
    		        */
    		        rtmp_pusher->Post(RTMP_BODY_AUD_SPEC, aud_spc_msg);
    		    }
    		   
    		    // 1、创建一个AVFrame,参数(sample_rate、channel_layout、nb_samples、nb_channels)
    		    //   根据重采样后的pcm数据格式进行设置
    		    // 2、将pcm buf中的数据填充到AVFrame的data中
    		    // 3、取出AVFrame的data中的pcm数据,开始进行重采样
    		    // 4、将重采样后的数据写入AVAudioFifo
    		    auto ret = audio_resampler_->SendResampleFrame(pcm, size);
    			
    			// 1、构造一个AVFrame,参数根据重采样pcm后的格式进行设置
    			// 2、从AVAudioFifo中取出pcm数据,填充到这个AVFrame的data中(有点困惑,上面的重采样的AVFrame其实可以共用到这里,为什么要经过一手AVAudioFifo?)
    			// 3、resampled_frames.push_back(frame)
    			vector<shared_ptr<AVFrame>> resampled_frames;
    			ret = audio_resampler_->ReceiveResampledFrame(
                    resampled_frames,
                    audio_encoder_->GetFrameSampleSize());
    			
    			// 音频数据编码
    			// 1、将重采样后的pcm进行AAC编码
    	        int aac_size = audio_encoder_->Encode(resampled_frames[i].get(),
                                            aac_buf_, AAC_BUF_MAX_LENGTH);
    
    	}
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87

    AudioSpec是FLV Audio Tag区域的字段,当AACPacketType ==0,就代表是这个Audio Tag里面装的是音频的配置信息。
    当AACPacketType ==1 就代表Audio Tag区域里面是音频数据。
    在这里插入图片描述

    (8)构造ADTS流发送到服务端

    ADTS是AAC音频的传输流格式
    在这里插入图片描述
    在这里插入图片描述
    1、很显然,下面先构造ADTS的数据,然后写到aac_buf_
    2、然后构造AudioRawMsg,将aac_buf_的数据拷贝给AudioRawMsg中的data
    3、发送AudioRawMsg消息。

        int aac_size = audio_encoder_->Encode(resampled_frames[i].get(),
                                              aac_buf_, AAC_BUF_MAX_LENGTH);
        if(aac_size > 0)
        {
            if(aac_fp_)
            {
                uint8_t adts_header[7]; //ADTS Header占7个字节
                /* 构造ADTS Header*/
                audio_encoder_->GetAdtsHeader(adts_header, aac_size);
                fwrite(adts_header, 1, 7, aac_fp_);
                fwrite(aac_buf_, 1, aac_size, aac_fp_);
                fflush(aac_fp_);
            }
            AudioRawMsg *aud_raw_msg = new AudioRawMsg(aac_size + 2);
            // 打上时间戳
            aud_raw_msg->pts = AVPublishTime::GetInstance()->get_audio_pts();
            aud_raw_msg->data[0] = 0xaf;
            aud_raw_msg->data[1] = 0x01;    // 1 =  raw data数据
            memcpy(&aud_raw_msg->data[2], aac_buf_, aac_size);
            rtmp_pusher->Post(RTMP_BODY_AUD_RAW, aud_raw_msg);
            LogDebug("PcmCallback Post");
        }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    ADTS流 = ADTS Header(7字节) + Audio AAC Data(aac_size)
    ADTS Header:
    	1、sampling_frequency_index: 比如我设置pcm采样率是48khz,那么index就是3。
        2、syncword:同步头占12位,总是0xFFF
        3、ID: MPEG标示符,0表示MPEG-4 , 1表示MPEG-2,我这里是1
        4、Layer:总是0x00
        5、profile:表示使用那个级别的AAC
        6、protection_absent: 表示是否误码校验
        ...
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    (8) 设置视频捕获器

    初始化

        double video_frame_duration = 1000.0 / video_encoder_->get_framerate();
        LogInfo("video_frame_duration:%lf", video_frame_duration);
        AVPublishTime::GetInstance()->set_video_pts_strategy(AVPublishTime::PTS_RECTIFY);//帧间隔矫正
        video_capturer = new VideoCapturer();
        Properties  vid_cap_properties;
        vid_cap_properties.SetProperty("video_test", 1);
        vid_cap_properties.SetProperty("input_yuv_name", input_yuv_name_);
        vid_cap_properties.SetProperty("width", desktop_width_);
        vid_cap_properties.SetProperty("height", desktop_height_);
        if(video_capturer->Init(vid_cap_properties) != RET_OK)
        {
            LogError("VideoCapturer Init failed");
            return RET_FAIL;
        }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    启动Loop线程,循环读取yuv文件

        yuv_buf_size = width_ * height_ * 1.5;
    	yuv_buf_ = new uint8_t[yuv_buf_size];
        while(true)
        {
            if(request_exit_)
                break;
            if(readYuvFile(yuv_buf_, yuv_buf_size) == 0)
            {
                if(!is_first_frame_) {
                    is_first_frame_ = true;
                    LogInfo("%s:t%u", AVPublishTime::GetInstance()->getVInTag(),
                            AVPublishTime::GetInstance()->getCurrenTime());
                }
                if(callable_object_)
                {
                    callable_object_(yuv_buf_, yuv_buf_size);
                }
            }
    
            std::this_thread::sleep_for(std::chrono::milliseconds(2));
        }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    执行回调callable_object_:YuvCallback消费数据yuv_buf

        if(need_send_video_config)
        {	
        	/* 发送videoConfig Message */
            need_send_video_config = false;
            VideoSequenceHeaderMsg * vid_config_msg = new VideoSequenceHeaderMsg(
                        video_encoder_->get_sps_data(),
                        video_encoder_->get_sps_size(),
                        video_encoder_->get_pps_data(),
                        video_encoder_->get_pps_size()
                        );
            vid_config_msg->nWidth = video_width_;
            vid_config_msg->nHeight = video_height_;
            vid_config_msg->nFrameRate = video_fps_;
            vid_config_msg->nVideoDataRate = video_bitrate_;
            vid_config_msg->pts_ = 0;
            rtmp_pusher->Post(RTMP_BODY_VID_CONFIG, vid_config_msg);
        }	
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    FLV的Video Tag Data部分,如下:
    AVCPacketType ==0 时,data部分就是Specific,我打开这段flv文件,是h264编码(codecId = 7)
    可以在Specific里面看到,H264编码中关键的参数:sps、pps
    所以:Specific配置部分就是NALU的头
    在这里插入图片描述

    开始对视频yuv数据进行编码,编码好的packet存放到video_nalu_buf
    然后将video_nalu_buf中的packet封装成NALU,通过Video Message发送出去。

    if(video_encoder_->Encode(yuv, 0, video_nalu_buf, video_nalu_size_) == 0)
    {
        // 获取到编码数据
        NaluStruct *nalu = new NaluStruct(video_nalu_buf, video_nalu_size_);
        nalu->type = video_nalu_buf[0] & 0x1f;
        nalu->pts = AVPublishTime::GetInstance()->get_video_pts();
        rtmp_pusher->Post(RTMP_BODY_VID_RAW, nalu);
        LogDebug("YuvCallback Post");
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

5、WireShark分析

在这里插入图片描述
在这里插入图片描述

6、总结

本文简要介绍了RTMP推流的原理以及过程,只希望对RTMP的推流过程以及原理建立一个简单的认识而已,建议配合RTMP的协议规范和rtmpdump代码进行阅读。本文讲的比较简单,对FLV格式、ADTS、NALU、RTMP的Message机制都忽略不讲,这每一个都是长篇大论,不可能在一文中全部讲出,这也不是本文主要表达的东西。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/码创造者/article/detail/918171
推荐阅读
相关标签
  

闽ICP备14008679号