ZLMediaKit中RTSP的创建过程

• 首先是初始化_rtsp，在 publish消息中的setProtocolTranslation，在_muxer（MultiMediaSourceMuxer）里面的_muxer（MultiMuxerPrivate）的构造函数中，创建了_rtsp（RtspMediaSourceMuxer），在_rtsp的构造函数中，创建了_media_src （RtspMediaSource），并将RtpRing的delegate设置为_media_src

   RtspMediaSourceMuxer(const string &vhost,
                         const string &strApp,
                         const string &strId,
                         const TitleSdp::Ptr &title = nullptr) : RtspMuxer(title){
        _media_src = std::make_shared<RtspMediaSource>(vhost,strApp,strId);
        getRtpRing()->setDelegate(_media_src);
    }

• 后面就是接收音视频数据后，对应 _rtsp 相应的处理过程了，在接收音视频的过程中，会创建track并检测track是否ready，如果track已经ready的话，会调用以下函数，对于 _rtsp来说就是初始化其对象 _encoder，根据打印表名，_rtsp 会添加的两个code分别为 H264RtpEncoder和AACRtpEncoder，并且 _encoder 会设置 rtpRing为_rtpRing

void MultiMuxerPrivate::onTrackReady(const Track::Ptr &track) {
    if (_rtmp) {
        _rtmp->addTrack(track);
    }
    if (_rtsp) {
        _rtsp->addTrack(track);
    }
    if (_ts) {
        _ts->addTrack(track);
    }
#if defined(ENABLE_MP4)
    if (_fmp4) {
        _fmp4->addTrack(track);
    }
#endif

    //拷贝智能指针，目的是为了防止跨线程调用设置录像相关api导致的线程竞争问题
    auto hls = _hls;
    if (hls) {
        hls->addTrack(track);
    }
    auto mp4 = _mp4;
    if (mp4) {
        mp4->addTrack(track);
    }
}
rtsp的AddTrack：
void RtspMuxer::addTrack(const Track::Ptr &track) {
    InfoL<<"enter RtspMuxer::addTrack";
    //根据track生成sdp
    Sdp::Ptr sdp = track->getSdp();
    if (!sdp) {
        return;
    }

    InfoL<<"enter RtspMuxer::addTrack trackType: "<<track->getTrackType();
    auto &encoder = _encoder[track->getTrackType()];
    encoder = Factory::getRtpEncoderBySdp(sdp);
    if (!encoder) {
        return;
    }

    //设置rtp输出环形缓存
    encoder->setRtpRing(_rtpRing);

    //添加其sdp
    _sdp.append(sdp->getSdp());
}

• 在track回调AllTrackAready之后，收到的音视频数据会进入 _rtsp的流程中，具体流程是先进入 _rtsp中，然后再进入 H264RtpEncoder 最后再回到 _media_src 的onWrite 中

    void inputFrame(const Frame::Ptr &frame) override {
        InfoL<<"enter RtspMediaSourceMuxer inputFrame";
        GET_CONFIG(bool, rtsp_demand, General::kRtspDemand);
        if (_clear_cache && rtsp_demand) {
            InfoL<<"rtsp inputFrame _clear_cache && rtsp_demand";
            _clear_cache = false;
            _media_src->clearCache();
        }
        if (_enabled || !rtsp_demand) {
            InfoL<<"rtsp inputFrame _enabled || !rtsp_demand";
            RtspMuxer::inputFrame(frame);
        }
    }
void RtspMuxer::inputFrame(const Frame::Ptr &frame) {
    auto &encoder = _encoder[frame->getTrackType()];
    if(encoder){
        InfoL<<"RtspMuxer::inputFrame encoder";
        encoder->inputFrame(frame);
    }
}

void H264RtpEncoder::inputFrame(const Frame::Ptr &frame) {
    auto ptr = frame->data() + frame->prefixSize();
    auto len = frame->size() - frame->prefixSize();
    auto pts = frame->pts();
    auto nal_type = H264_TYPE(ptr[0]);
    auto packet_size = getMaxSize() - 2;

    //末尾5bit为nalu type，固定为28(FU-A)
    auto fu_char_0 = (ptr[0] & (~0x1F)) | 28;
    auto fu_char_1 = nal_type;
    FuFlags *fu_flags = (FuFlags *) (&fu_char_1);
    fu_flags->start_bit = 1;

    //超过MTU则按照FU-A模式打包
    if (len > packet_size + 1) {
        InfoL<<"H264RtpEncoder::inputFrame if";
        size_t offset = 1;
        while (!fu_flags->end_bit) {
            if (!fu_flags->start_bit && len <= offset + packet_size) {
                //FU-A end
                packet_size = len - offset;
                fu_flags->end_bit = 1;
            }

            //传入nullptr先不做payload的内存拷贝
            auto rtp = makeRtp(getTrackType(), nullptr, packet_size + 2, fu_flags->end_bit, pts);
            //rtp payload 负载部分
            uint8_t *payload = rtp->getPayload();
            //FU-A 第1个字节
            payload[0] = fu_char_0;
            //FU-A 第2个字节
            payload[1] = fu_char_1;
            //H264 数据
            memcpy(payload + 2, (uint8_t *) ptr + offset, packet_size);
            //输入到rtp环形缓存
            RtpCodec::inputRtp(rtp, fu_flags->start_bit && nal_type == H264Frame::NAL_IDR);

            offset += packet_size;
            fu_flags->start_bit = 0;
        }
    } else {
        InfoL<<"H264RtpEncoder::inputFrame else";
        //如果帧长度不超过mtu, 则按照Single NAL unit packet per H.264 方式打包
        makeH264Rtp(ptr, len, false, false, pts);
    }
}

virtual bool inputRtp(const RtpPacket::Ptr &rtp, bool key_pos){
        if(_rtpRing){
            _rtpRing->write(rtp,key_pos);
        }
        return key_pos;
    }

void write(T in, bool is_key = true) {
        if (_delegate) {
            _delegate->onWrite(std::move(in), is_key);
            return;
        }

        LOCK_GUARD(_mtx_map);
        for (auto &pr : _dispatcher_map) {
            auto &second = pr.second;
            //切换线程后触发onRead事件
            pr.first->async([second, in, is_key]() {
                second->write(std::move(const_cast<T &>(in)), is_key);
            }, false);
        }

        _storage->write(std::move(in), is_key);
    }

void onWrite(RtpPacket::Ptr rtp, bool keyPos) override {
        _speed[rtp->type] += rtp->size();
        assert(rtp->type >= 0 && rtp->type < TrackMax);
        auto &track = _tracks[rtp->type];
        auto stamp = rtp->getStampMS();
        if (track) {
            track->_seq = rtp->getSeq();
            track->_time_stamp = stamp;
            track->_ssrc = rtp->getSSRC();
        }
        if (!_ring) {
            weak_ptr<RtspMediaSource> weakSelf = dynamic_pointer_cast<RtspMediaSource>(shared_from_this());
            auto lam = [weakSelf](int size) {
                auto strongSelf = weakSelf.lock();
                if (!strongSelf) {
                    return;
                }
                strongSelf->onReaderChanged(size);
            };
            //GOP默认缓冲512组RTP包，每组RTP包时间戳相同(如果开启合并写了，那么每组为合并写时间内的RTP包),
            //每次遇到关键帧第一个RTP包，则会清空GOP缓存(因为有新的关键帧了，同样可以实现秒开)
            _ring = std::make_shared<RingType>(_ring_size, std::move(lam));
            onReaderChanged(0);
            if (!_sdp.empty()) {
            //根据打印，最后会进入此处进行resist
                InfoL<<"RtspMediaSource onWrite regist";
                regist();
            }
        }
        bool is_video = rtp->type == TrackVideo;
        PacketCache<RtpPacket>::inputPacket(stamp, is_video, std::move(rtp), keyPos);
    }

• 最后梳理一下，便于自己理解， _rtsp 是类（RtspMediaSourceMuxer） 的对象，其中有 RtpRing 、 _encoder 和 _media_src，其中 RtpRing的代理是 _media_src ，_encoder中的rtpRing就是上述的RtpRing， _rtsp 收到数据之后，会把数据回调给 _encoder ,encoder会回调给 RtpRing，至此就是回调到了 _rtsp中的 RtpRing ，然后RtpRing再次将数据回调给代理_media_src，最终数据就是在上面的函数中最后调用PacketCache<RtpPacket>::inputPacket，其中RtpRing就是一个缓存数据的环形队列