SRS之HLS部署实例源码分析

1. 综述

SRS 关于 HLS 的具体配置可见： HLS部署实例

SRS 关于 hls 的配置文件内容如下：

listen              1935;
max_connections     1000;
daemon              off;
srs_log_tank        console;
vhost __defaultVhost__ {
    hls {
        enabled         on;
        hls_fragment    10;
        hls_window      60;
        hls_path        ./objs/nginx/html;
        hls_m3u8_file   [app]/[stream].m3u8;
        hls_ts_file     [app]/[stream]-[seq].ts;
    }
}

SRS 端具体流程分析如下：

1. SRS 建立对 1935 端口的监听： SRS之监听端口的管理：RTMP
2. 在建立对 1935 端口监听的过程中创建了针对该端口的 tcp 监听线程，在该线程中 accept 客户端的连接请求，接着针对该客户端创建一个 conn 线程，以便为该客户端提供服务： SRS之RTMP连接处理线程conn：接收客户端推流
3. 在 conn 线程的循环开始时，首先服务器会与客户端进行 handshake 过程： SRS之RTMP handshake
4. handshake 成功后，会接收客户端 handshake 后的第一个命令，一般为 connect('xxx')： SRS之SrsRtmpServer::connect_app详解
5. 接着进入 SrsRtmpConn::service_cycle 函数： SRS之SrsRtmpConn::service_cycle详解
6. 在 SrsRtmpConn::service_cycle 函数开始向客户端发送 应答窗口大小（5）、设置流带宽（6）、设置块大小（1）、response connect 的响应等消息后，开始进入循环，此时，调用 stream_service_cycle 函数

对于 hls 的分析，下面开始从 stream_service_cycle 开始分析。

2. SrsRtmpConn::stream_service_cycle

int SrsRtmpConn::stream_service_cycle()
{
    int ret = ERROR_SUCCESS;

    SrsRtmpConnType type;
    /* 接收一些消息，然后根据该消息的内容识别该客户端接下来是 publish 还是 play */
    if ((ret = rtmp->identify_client(res->stream_id, type, req->stream, req->duration))
        != ERROR_SUCCESS) {
        if (!srs_is_client_gracefully_close(ret)) {
            srs_error("identify client failed. ret=%d", ret);
        }
        return ret;
    }
    req->strip();

    /* security check: 若 vhost 中没有配置 security，则默认返回 false  */
    if ((ret = security->check(type, ip, req)) != ERROR_SUCCESS) {
        srs_error("security check failed. ret=%d", ret);
        return ret;
    }

    /* SRS 不支持流名称为空的请求，因为对于 HLS 需要通过流名称写入到文件中 */
    if (req->stream.empty()) {
        ret = ERROR_RTMP_STREAM_NAME_EMPTY;
        srs_error("RTMP: Empty stream name not allowed, ret=%d", ret);
        return ret;
    }

    /* client is identified, set the timeout to service timeout. */
    rtmp->set_recv_timeout(SRS_CONSTS_RTMP_RECV_TIMEOUT_US);
    rtmp->set_send_timeout(SRS_CONSTS_RTMP_SEND_TIMEOUT_US);

    /* find a source to serve. */
    SrsSource* source = NULL;
    if ((ret = SrsSource::fetch_or_create(req, server, &source)) != ERROR_SUCCESS)
    {
        return ret;
    }
    srs_assert(source != NULL);

    /* update the statistic when source disconveried. */
    SrsStatistic* stat = SrsStatistic::instance();
    if ((ret = stat->on_client(_srs_context->get_id(), req, this, type)) != ERROR_SUCCESS)
    {
        srs_error("stat client failed. ret=%d", ret);
        return ret;
    }

    /* 若 vhost 没有配置 mode，则默认返回 false */
    bool vhost_is_edge = _srs_config->get_vhost_is_edge(req->vhost);
    /* 默认开启 gop_cache */
    bool enabled_cache = _srs_config->get_gop_cache(req->vhost);
    source->set_cache(enabled_cache);

    client_type = type;
    switch (type) {
        ...

        case SrsRtmpConnFMLEPublish: {
            srs_verbose("FMLE start to publish stream %s.", req->stream.c_str());

            if ((ret = rtmp->start_fmle_publish(res->stream_id)) != ERROR_SUCCESS) {
                srs_error("start to publish stream failed. ret=%d", ret);
                return ret;
            }

            return publishing(source);
        }

        ...

        default: {
            ret = ERROR_SYSTEM_CLIENT_INVALID;
            srs_info("invalid client type=%d. ret=%d", type, ret);
            return ret;
        }
    }

    return ret;
}

2.1 SrsSource::fetch_or_create

/* 该全局变量 pool 用于保存创建的 SrsSource 类对象，
 * key： vhost/app/stream
 * value: SrsSource* */
std::map<std::string, SrsSource*> SrsSource::pool;

/*
 * create source when fetch from cache failed.
 * @param r, the client request.
 * @param h, the event handlr for source.
 * @param pps, the matched source, if success never be NULL.
 */
int SrsSource::fetch_or_create(SrsRequest* r, ISrsSourceHandler* h, SrsSource** pps)
{
    int ret = ERROR_SUCCESS;

    SrsSource* source = NULL;
    /* 检测 pool 中是否有 key（如vhost/live/livestream）对应的 SrsSource*，
     * 若有则返回该 SrsSource* */
    if ((source = fetch(r)) != NULL) {
        *pps = source;
        return ret;
    }

    string stream_url = r->get_stream_url();
    string vhost = r->vhost;

    /* should always not exists for create a source. */
    srs_assert (pool.find(stream_url) == pool.end());

    /* 获取或构建一个新的 SrsSource */
    source = new SrsSource();
    if ((ret = source->initialize(r, h)) != ERROR_SUCCESS) {
        srs_freep(source);
        return ret;
    }

    /* 将创建成功并初始化后 source 放入到 pool 中 */
    pool[stream_url] = source;

    *pps = source;

    return ret;
}

下面主要分析 SrsSource 的构造。

2.1.1 SrsSource 构造

/* live streaming source. */
SrsSource::SrsSource()
{
    /* deep copy of client request. */
    _req = NULL;
    /* the time jitter algorithm for vhost. 这里初始化关闭 */
    jitter_algorithm = SrsRtmpJitterAlgorithmOFF;

    mix_correct = false;
    mix_queue = new SrsMixQueue();

#ifdef SRS_AUTO_HLS
    /* 构造 SrsHls 类 */
    hls = new SrsHls();
#endif
...

    cache_metadata = cache_sh_video = cache_sh_audio = NULL;

    /* can publish, true when is not streaming */
    _can_publish = true;
    _pre_source_id = _source_id = -1;
    /* last die time, when all consumers quit and no publisher,
     * we will remove the source when source die. */
    die_at = -1;

    /* edge control service */
    play_edge = new SrsPlayEdge();
    publish_edge = new SrsPublishEdge();
    /* gop cache for client fast startup. */
    gop_cache = new SrsGopCache();
    /* for aggregate message */
    aggregate_stream = new SrsStream();

    is_monotonically_increase = false;
    last_packet_time = 0;

    _srs_config->subscribe(this);
    atc = false;
}

2.1.2 SrsHls 构造

/*
 * delivery RTMP stream to HLS(m3u8 and ts),
 * SrsHls provides interface with SrsSource.
 */
SrsHls::SrsHls()
{
    _req = NULL;
    source = NULL;

    /* hls 使能标志 */
    hls_enabled = false;
    /* hls 清理的过期时间，系统重启或者超过这个时间时，清理 hls 所有文件，
     * 包括 m3u8 文件和 ts。默认为 0，不清理 */
    hls_can_dispose = false;
    last_update_time = 0;

    /* the h264/avc and aac codec, for media stream. */
    codec = new SrsAvcAacCodec();
    /* the samples in the flv audio/video packet. */
    sample = new SrsCodecSample();
    /* time jitter detect and correct, to ensure the rtmp stream is monotonically. */
    jitter = new SrsRtmpJitter();

    /* muxer the HLS stream(m3u8 and ts files). */
    muxer = new SrsHlsMuxer();
    /* hls stream cache, use to cache hls stream and flush to hls muxer. */
    hls_cache = new SrsHlsCache();

    pprint = SrsPithyPrint::create_hls();
    /*
     * we store the stream dts,
     * for when we notice the hls cache to publish,
     * it need to know the segment start dts.
     *
     * for example. when republish, the stream dts will
     * monotonically increase, and the ts dts should start
     * from current dts.
     *
     * or, simply because the HlsCache never free when unpublish,
     * so when publish or republish it must start at stream dts,
     * not zero dts.
     */
    stream_dts = 0;
}

2.1.3 SrsAvcAacCodec 构造

/**
* the h264/avc and aac codec, for media stream.
*
* to demux the FLV/RTMP video/audio packet to sample,
* add each NALUs of h.264 as a sample unit to sample,
* while the entire aac raw data as a sample unit.
*
* for sequence header,
* demux it and save it in the avc_extra_data and aac_extra_data,
*
* for the codec info, such as audio sample rate,
* decode from FLV/RTMP header, then use codec info in sequence
* header to override it.
*/
SrsAvcAacCodec::SrsAvcAacCodec()
{
    /* for sequence header, whether parse the h.264 sps. */
    avc_parse_sps               = true;

    width                       = 0;
    height                      = 0;
    duration                    = 0;
    NAL_unit_length             = 0;
    frame_rate                  = 0;

    video_data_rate             = 0;
    video_codec_id              = 0;

    audio_data_rate             = 0;
    audio_codec_id              = 0;

    avc_profile                 = SrsAvcProfileReserved;
    avc_level                   = SrsAvcLevelReserved;
    aac_object                  = SrsAacObjectTypeReserved;
    aac_sample_rate             = SRS_AAC_SAMPLE_RATE_UNSET; // sample rate ignored
    aac_channels                = 0;
    avc_extra_size              = 0;
    avc_extra_data              = NULL;
    aac_extra_size              = 0;
    aac_extra_data              = NULL;

    sequenceParameterSetLength  = 0;
    sequenceParameterSetNALUnit = NULL;
    pictureParameterSetLength   = 0;
    pictureParameterSetNALUnit  = NULL;

    /* the avc payload format. */
    payload_format = SrsAvcPayloadFormatGuess;
    stream = new SrsStream();
}

2.1.4 SrsCodecSample 构造

/**
* the samples in the flv audio/video packet.
* the sample used to analysis a video/audio packet,
* split the h.264 NALUs to buffers, or aac raw data to a buffer,
* and decode the video/audio specified infos.
*
* the sample unit:
*       a video packet codec in h.264 contains many NALUs, each is a sample unit.
*       a audio packet codec in aac is a sample unit.
* @remark, the video/audio sequence header is not sample unit,
*       all sequence header stores as extra data,
*       @see SrsAvcAacCodec.avc_extra_data and SrsAvcAacCodec.aac_extra_data
* @remark, user must clear all samples before decode a new video/audio packet.
*/
SrsCodecSample::SrsCodecSample()
{
    clear();
}

/**
 * clear all samples.
 * the sample units never copy the bytes, it directly use the ptr,
 * so when video/audio packet is destroyed, the sample must be clear.
 * in a word, user must clear sample before demux it.
 * @remark demux sample use SrsAvcAacCodec.audio_aac_demux or video_avc_demux.
 */
void SrsCodecSample::clear()
{
    /* whether the sample is video sample which demux from video packet. */
    is_video = false;
    /*
     * each audio/video raw data packet will dumps to one or multiple buffers,
     * the buffers will write to hls and clear to reset.
     * generally, aac audio packet corresponding to one buffer,
     * where avc/h264 video packet may contains multiple buffer.
     */
    nb_sample_units = 0;

    /*
     * CompositionTime, video_file_format_spec_v10_1.pdf, page 78.
     * cts = pts - dts, where dts = flvheader->timestamp.
     */
    cts = 0;
    frame_type = SrsCodecVideoAVCFrameReserved;
    avc_packet_type = SrsCodecVideoAVCTypeReserved;
    has_sps_pps = has_aud = has_idr = false;
    first_nalu_type = SrsAvcNaluTypeReserved;

    acodec = SrsCodecAudioReserved1;
    sound_rate = SrsCodecAudioSampleRateReserved;
    sound_size = SrsCodecAudioSampleSizeReserved;
    sound_type = SrsCodecAudioSoundTypeReserved;
    aac_packet_type = SrsCodecAudioTypeReserved;
}

2.1.5 SrsHlsMuxer 构造

/**
* muxer the HLS stream(m3u8 and ts files).
* generally, the m3u8 muxer only provides methods to open/close segments,
* to flush video/audio, without any mechenisms.
*
* that is, user must use HlsCache, which will control the methods of muxer,
* and provides HLS mechenisms.
*/
SrsHlsMuxer::SrsHlsMuxer()
{
    req = NULL;
    hls_fragment = hls_window = 0;
    hls_aof_ratio = 1.0;
    /*
     * the deviation in piece to adjust the fragment to be more
     * bigger or smaller.
     */
    deviation_ts = 0;
    /* 是否删除过期的 ts 切片，不在 hls_window 中就是过期。
     * 可以关闭清除 ts 切片，实现时移和存储，使用自己的切片管理系统。
     * 这里默认为开启 */
    hls_cleanup = true;
    /* 是否按 gop 切片，即等待到关键帧后开始切片。这里默认开启 */
    hls_wait_keyframe = true;
    previous_floor_ts = 0;
    /*
     * the previous reap floor timestamp,
     * used to detect the dup or jmp or ts.
     */
    accept_floor_ts = 0;
    /* whether use floor algorithm for timestamp. */
    hls_ts_floor = false;
    /* 切片时长的最大值 */
    max_td = 0;
    /* ts 的序列号，每开始写一个新的 ts，该值加 1 */
    _sequence_no = 0;
    /* current writing segment. */
    current = NULL;
    /*
     * the current audio codec, when open new muxer,
     * set the muxer audio codec.
     * @see https://github.com/ossrs/srs/issues/301
     */
    acodec = SrsCodecAudioReserved1;
    /* 默认不支持写入到 cache 中 */
    should_write_cache = false;
    /* 默认开启将 video/audio 写入到文件中，即 ts 文件 */
    should_write_file = true;
    /* 构建了一个可重复使用（SrsReusableThread）的线程：async */
    async = new SrsAsyncCallWorker();
    /* the ts context, to keep cc continous between ts. */
    context = new SrsTsContext();
}

2.1.6 SrsAsyncCallWorker 构造

/**
 * the async callback for dvr.
 * when worker call with the task, the worker will do it in isolate thread.
 * that is, the task is execute/call in async mode.
 */
SrsAsyncCallWorker::SrsAsyncCallWorker()
{
    /* 创建一个可重复使用的线程：async */
    pthread = new SrsReusableThread("async", this, SRS_AUTO_ASYNC_CALLBACL_SLEEP_US);
}

2.1.6.1 SrsReusableThread 构造

SrsReusableThread::SrsReusableThread(const char* n, ISrsReusableThreadHandler* h,
    int64_t interval_us)
{
    handler = h;
    pthread = new internal::SrsThread(n, this, interval_us, true);
}

2.1.6.2 SrsThread 构造

SrsThread::SrsThread(const char* name, ISrsThreadHandler* thread_handler, int64_t interval_us, bool joinable)
{
    _name = name;
    handler = thread_handler;
    cycle_interval_us = interval_us;

    tid = NULL;
    loop = false;
    really_terminated = true;
    _cid = -1;
    _joinable = joinable;
    disposed = false;

    // in start(), the thread cycle method maybe stop and remove the thread itself,
    // and the thread start() is waiting for the _cid, and segment fault then.
    // @see https://github.com/ossrs/srs/issues/110
    // thread will set _cid, callback on_thread_start(), then wait for the can_run signal.
    can_run = false;
}

2.1.7 SrsHlsCache 构造

/**
* hls stream cache,
* use to cache hls stream and flush to hls muxer.
*
* when write stream to ts file:
* video frame will directly flush to M3u8Muxer,
* audio frame need to cache, because it's small and flv tbn problem.
*
* whatever, the Hls cache used to cache video/audio,
* and flush video/audio to m3u8 muxer if needed.
*
* about the flv tbn problem:
*   flv tbn is 1/1000, ts tbn is 1/90000,
*   when timestamp convert to flv tbn, it will loose precise,
*   so we must gather audio frame together, and recalc the timestamp @see SrsTsAacJitter,
*   we use a aac jitter to correct the audio pts.
*/
SrsHlsCache::SrsHlsCache()
{
    cache = new SrsTsCache();
}

2.1.8 SrsTsCache 构造

/**
* ts stream cache,
* use to cache ts stream.
*
* about the flv tbn problem:
*   flv tbn is 1/1000, ts tbn is 1/90000,
*   when timestamp convert to flv tbn, it will loose precise,
*   so we must gather audio frame together, and recalc the timestamp @see SrsTsAacJitter,
*   we use a aac jitter to correct the audio pts.
*/
SrsTsCache::SrsTsCache()
{
    /* current ts message. */
    audio = NULL;
    video = NULL;
}

上面构造好 SrsSource 后，接着调用 SrsSource 的 initialize 函数进行初始化。

2.1.9 SrsSource::initialize

int SrsSource::initialize(SrsRequest* r, ISrsSourceHandler* h)
{
    int ret = ERROR_SUCCESS;

    srs_assert(h);
    srs_assert(!_req);

    /* the event handler. */
    handler = h;
    /* deep copy of client request. */
    _req = r->copy();
    /* 若 vhost 中没有配置 atc，默认返回 false */
    atc = _srs_config->get_atc(_req->vhost);

#ifdef SRS_AUTO_HLS
    if ((ret = hls->initialize(this)) != ERROR_SUCCESS) {
        return ret;
    }
#endif

..

    if ((ret = play_edge->initialize(this, _req)) != ERROR_SUCCESS) {
        return ret;
    }
    if ((ret = publish_edge->initialize(this, _req)) != ERROR_SUCCESS) {
        return ret;
    }

    /* 若 vhost 中没有配置 queue_length，则默认播放队列的大小为 30s
     *
     * in seconds, the live queue length
     * #define SRS_PERF_PLAY_QUEUE 30
     */
    double queue_size = _srs_config->get_queue_length(_req->vhost);
    publish_edge->set_queue_size(queue_size);

    /* the time jitter algorithm for vhost.
     * 若 vhost 中没有配置 time_jitter，则默认返回值为 SrsRtmpJitterAlgorithmFULL */
    jitter_algorithm = (SrsRtmpJitterAlgorithm)_srs_config->get_time_jitter(_req->vhost);
    /* 若 vhost 中没有配置 mix_correct，则默认返回 false，
     * 即禁止使用 interlaved/mixed algorithm 去校正 timstamp */
    mix_correct = _srs_config->get_mix_correct(_req->vhost);

    return ret;
}

2.1.10 SrsHls::initialize

/*
 * initialize the hls by handler and source.
 */
int SrsHls::initialize(SrsSource* s)
{
    int ret = ERROR_SUCCESS;

    source = s;

    /* 初始化 hls muxer */
    if ((ret = muxer->initialize()) != ERROR_SUCCESS) {
        return ret;
    }

    return ret;
}

2.1.11 SrsHlsMuxer::initialize

/* initialize the hls muxer. */
int SrsHlsMuxer::initialize()
{
    int ret = ERROR_SUCCESS;

    /* 启动 async 线程 */
    if ((ret = async->start()) != ERROR_SUCCESS) {
        return ret;
    }

    return ret;
}

2.1.12 SrsAsyncCallWorker::start

int SrsAsyncCallWorker::start()
{
    return pthread->start();
}

2.1.13 SrsReusableThread::start

int SrsReusableThread::start()
{
    return pthread->start();
}

2.1.14 SrsThread::start

int SrsThread::start()
{
    int ret = ERROR_SUCCESS;

    if(tid) {
        srs_info("thread %s already running.", _name);
        return ret;
    }

    /* 创建线程 */
    if((tid = st_thread_create(thread_fun, this, (_joinable? 1:0), 0)) == NULL){
        ret = ERROR_ST_CREATE_CYCLE_THREAD;
        srs_error("st_thread_create failed. ret=%d", ret);
        return ret;
    }

    disposed = false;
    // we set to loop to true for thread to run.
    loop = true;

    // wait for cid to ready, for parent thread to get the cid.
    while (_cid < 0) {
        st_usleep(10 * 1000);
    }

    // now, cycle thread can run.
    can_run = true;

    return ret;
}

3. SrsRtmpConn::publishing

int SrsRtmpConn::publishing(SrsSource* source)
{
    int ret = ERROR_SUCCESS;

    /* vhost 中没有配置 refer_publish，忽略 */
    if ((ret = refer->check(req->pageUrl, _srs_config->get_refer_publish(req->vhost)))
        != ERROR_SUCCESS) {
        srs_error("check publish_refer failed. ret=%d", ret);
        return ret;
    }

    /* vhost 中没有配置 http_hooks，ignore */
    if ((ret = http_hooks_on_publish()) != ERROR_SUCCESS) {
        srs_error("http hook on_publish failed. ret=%d", ret);
        return ret;
    }

    /* 这里返回 false */
    bool vhost_is_edge = _srs_config->get_vhost_is_edge(req->vhost);
    if ((ret = acquire_publish(source, vhost_is_edge)) == ERROR_SUCCESS) {
        SrsPublishRecvThread tcp(rtmp, req,
            st_netfd_fileno(stfd), 0, this, source,
            client_type != SrsRtmpConnFlashPublish,
            vhost_is_edge);

        ret = do_publishing(source, &trd);

        /* stop isolate recv thread */
        trd.stop();
    }

    /*
     * whatever the acquire publish, always release publish.
     * when the acquire error in the middle-way, the publish state changed,
     * but failed, so we must cleanup it.
     * @remark, when stream is busy, should never release it.
     */
    if (ret != ERROR_SYSTEM_STREAM_BUSY) {
        release_publish(source, vhost_is_edge);
    }

    http_hooks_on_unpublish();

    return ret;
}

3.1 SrsRtmpConn::acquire_publish

int SrsRtmpConn::acquire_publish(SrsSource* source, bool is_edge)
{
    int ret = ERROR_SUCCESS;

    /* 这里直接返回 _can_publish 的值，source  构建时初始化为 true */
    if (!source->can_publish(is_edge)) {
        ret = ERROR_SYSTEM_STREAM_BUSY;
        srs_warn("stream %s is already publishing. ret=%d",
            req->get_stream_url().c_str(), ret);
        return ret;
    }

    /* vhost 中没有配置 mode，因此 is_edge 为 false */
    /* when edge, ignore the publish event, directly proxy it. */
    if (is_edge) {
        if ((ret = source->on_edge_start_publish()) != ERROR_SUCCESS) {
            srs_error("notice edge start publish stream failed. ret=%d", ret);
            return ret;
        }
    } else {
        /* publish stream event notify. */
        if ((ret = source->on_publish()) != ERROR_SUCCESS) {
            srs_error("notify publish failed. ret=%d", ret);
            return ret;
        }
    }

    return ret;
}

3.1.1 SrsSource::on_publish

/*
 * publish stream event notify.
 * @param _req, the request from client, the source will deep copy it,
 *     for when reload the request of client maybe invalid.
 */
int SrsSource::on_publish()
{
    int ret = ERROR_SUCCESS;

    /* update the request object. */
    srs_assert(_req);

    _can_publish = false;

    /* whatever, the publish thread is the source or edge source,
     * save its id to srouce id. */
    on_source_id_changed(_srs_context->get_id());

    /* reset the mix queue. */
    mix_queue->clear();

    /* detect the monotonically again. */
    is_monotonically_increase = true;
    last_packet_time = 0;

    /* create forwarders */
    /* vhost 没有配置 forward，ignore */
    if ((ret = create_forwarders()) != ERROR_SUCCESS) {
        srs_error("create forwarders failed. ret=%d", ret);
        return ret;
    }

    /* TODO: FIXME: use initialize to set req. */
#ifdef SRS_AUTO_TRANSCODE
    ...
#endif

    /* TODO: FIXME: use initialize to set req. */
#ifdef SRS_AUTO_HLS
    if ((ret = hls->on_publish(_req, false)) != ERROR_SUCCESS) {
        srs_error("start hls failed. ret=%d", ret);
        return ret;
    }
#endif

    /* TODO: FIXME: use initialize to set req. */
#ifdef SRS_AUTO_DVR
    ...
#endif

#ifdef SRS_AUTO_HDS
    ...
#endif

    /* notify the handler. */
    srs_assert(handler);
    /* 调用子类 SrsServer 实现的 on_publish 函数，没有开启相关功能，ignore */
    if ((ret = handler->on_publish(this, _req)) != ERROR_SUCCESS) {
        srs_error("handle on publish failed. ret=%d", ret);
        return ret;
    }
    SrsStatistic* stat = SrsStatistic::instance();
    stat->on_stream_publish(_req, _source_id);

    return ret;
}

3.1.2 SrsSource::on_source_id_changed

int SrsSource::on_source_id_changed(int id)
{
    int ret = ERROR_SUCCESS;

    if (_source_id == id) {
        return ret;
    }

    if (_pre_source_id == -1) {
        _pre_source_id = id;
    } else if (_pre_source_id != _source_id) {
        _pre_source_id = _source_id;
    }

    _source_id = id;

    /* notice all consumer */
    std::vector<SrsConsumer*>::iterator it;
    for (it = consumers.begin(); it != consumers.end(); ++it) {
        SrsConsumer* consumer = *it;
        /* 该函数将 should_update_source_id 置为 true */
        consumer->update_source_id();
    }

    return ret;
}

3.1.3 SrsHls::on_publish

/*
 * publish stream event, continue to write the m3u8,
 * for the muxer object not destroyed.
 * @param fetch_sequence_header, whether fetch sequence from source.
 */
int SrsHls::on_publish(SrsRequest* req, bool fetch_sequence_header)
{
    int ret = ERROR_SUCCESS;

    srs_freep(_req);
    _req = req->copy();

    /* update the hls time, for hls_dispose. */
    last_update_time = srs_get_system_time_ms();

    /* SrsHls 构建时初始化为 false，因此不支持多次 publish */
    /* support multiple publish. */
    if (hls_enabled) {
        return ret;
    }

    /* vhost 中使能了 hls */
    std::string vhost = req->vhost;
    if (!_srs_config->get_hls_enabled(vhost)) {
        return ret;
    }

    /* 初始化 muxer，创建 m3u8 目录和文件等等 */
    if ((ret = hls_cache->on_publish(muxer, req, stream_dts)) != ERROR_SUCCESS) {
        return ret;
    }

    /* if enabled, open the muxer. */
    hls_enabled = true;

    /* ok, the hls can be dispose, or need to be dispose. */
    hls_can_dispose = true;

    /* 由上面调用知，传入的值为 false */
    /* when publish, don't need to fetch sequence header, which is old and maybe corrupt.
     * when reload, we must fetch the sequence header from source cache. */
    if (fetch_sequence_header) {
        /* notice the source to get the cached sequence header.
         * when reload to start hls, hls will never get the sequence header in stream,
         * use the SrsSource.on_hls_start to push the sequence header to HLS. */
        if ((ret = source->on_hls_start()) != ERROR_SUCCESS) {
            srs_error("callback source hls start failed. ret=%d", ret);
            return ret;
        }
    }

    return ret;
}

3.1.4 SrsHlsCache::on_publish

int SrsHlsCache::on_publish(SrsHlsMuxer* muxer, SrsRequest* req,
    int64_t segment_start_dts)
{
    int ret = ERROR_SUCCESS;

    std::string vhost = req->vhost;
    std::string stream = req->stream;
    std::string app = req->app;

    /* get the hls fragment time, in seconds.
     * 配置文件中设置 hls_fragment 为 10，即切片时长的最小值为 10s */
    double hls_fragment = _srs_config->get_hls_fragment(vhost);

    /* get the hls window time, in seconds.
     * a window is a set of ts, the ts collection in m3u8.
     * @remark SRS will delete the ts exceed the window.
     * 配置文件中设置 hls_window 为 60，即所有切片加起来的最大时长为 60s */
    double hls_window = _srs_config->get_hls_window(vhost);

    /* get the hls m3u8 ts list entry prefix config */
    /* get the HLS m3u8 list ts segment entry prefix info.
     * vhost 中没有配置 hls_entry_prefix，因此返回 "" */
    std::string entry_prefix = _srs_config->get_hls_entry_prefix(vhost);

    /* get the HLS ts/m3u8 file store path.
     * 配置文件中 hls_path 为 ./objs/nginx/html  */
    std::string path = _srs_config->get_hls_path(vhost);

    /* get the HLS m3u8 file path template.
     * 配置文件中 hls_m3u8_file 为 [app]/[stream].m3u8 */
    std::string m3u8_file = _srs_config->get_hls_m3u8_file(vhost);

    /* get the HLS ts file path template.
     * 配置文件中 hls_ts_file 为 [app]/[stream]-[seq].ts */
    std::string ts_file = _srs_config->get_hls_ts_file(vhost);

    /* whether cleanup the old ts files.
     * hls 中没有配置 hls_cleanup，因此默认返回 true
     * 即开启删除过期的 ts 切片功能，不在 hls_window 中就是过期 */
    bool cleanup = _srs_config->get_hls_cleanup(vhost);

    /* whether reap the ts when got keyframe.
     * hls 中没有配置 hls_wait_keyframe，默认返回 true，即表示等待 I帧
     * 因此需要该切片时长超过 10s，且获取到 I帧的情况下才开始切片 */
    bool wait_keyframe = _srs_config->get_hls_wait_keyframe(vhost);

    /* get the hls aof(audio overflow) ratio.
     * hls 没有配置 hls_aof_ratio，默认返回 2.0，
     * 纯音频下音频时长的倍数 */
    double hls_aof_ratio = _srs_config->get_hls_aof_ratio(vhost);

    /* whether use floor(timestamp/hls_fragment) for variable timestamp
     * hls 中没有配置 hls_ts_floor，默认返回 false*/
    bool ts_floor = _srs_config->get_hls_ts_floor(vhost);

    /* the seconds to dispose the hls.
     * hls 中没有配置 hls_dispose，默认返回 0 */
    int hls_dispose = _srs_config->get_hls_dispose(vhost);

    /* TODO: FIXME: support load exists m3u8, to continue publish stream.
     * for the HLS donot requires the EXT-X-MEDIA-SEQUENCE be monotonically increase */

    /* open muxer, when publish, update the config for muxer */
    if ((ret = muxer->update_config(req, entry_prefix,
        path, m3u8_file, ts_file, hls_fragment, hls_window, ts_floor, hls_aof_ratio,
        cleanup, wait_keyframe)) != ERROR_SUCCESS
    ) {
        srs_error("m3u8 muxer update config failed. ret=%d", ret);
        return ret;
    }

    /* open a new segment(a new ts file) */
    if ((ret = muxer->segment_open(segment_start_dts)) != ERROR_SUCCESS) {
        srs_error("m3u8 muxer open segment failed. ret=%d", ret);
        return ret;
    }

    return ret;
}

3.1.5 SrsHlsMuxer::update_config

/* when publish, update the config for muxer. */
int SrsHlsMuxer::update_config(SrsRequest* r, string entry_prefix,
    string path, string m3u8_file, string ts_file, double fragment, double window,
    bool ts_floor, double aof_ratio, bool cleanup, bool wait_keyframe
) {
    int ret = ERROR_SUCCESS;

    srs_freep(req);
    /* 深度拷贝一个副本给 req */
    req = r->copy();

    /* "" */
    hls_entry_prefix = entry_prefix;
    /* hls_path: ./objs/nginx/html */
    hls_path = path;
    /* hls_ts_file: "[app]/[stream]-[seq].ts" */
    hls_ts_file = ts_file;
    /* hls_fragment: 10s */
    hls_fragment = fragment;
    /* hls_aof_ratio: 2.0 */
    hls_aof_ratio = aof_ratio;
    /* hls_ts_floor: false */
    hls_ts_floor = ts_floor;
    /* hls_cleanup: true */
    hls_cleanup = cleanup;
    /* hls_wait_keyframe: true */
    hls_wait_keyframe = wait_keyframe;
    previous_floor_ts = 0;
    accept_floor_ts = 0;
    /* hls_window: 60s */
    hls_window = window;
    deviation_ts = 0;

    /* generate the m3u8 dir and path. *
    /* m3u8_url: "live/livestream.m3u8" */
    m3u8_url = srs_path_build_stream(m3u8_file, req->vhost, req->app, req->stream);
    /* m3u8: ./objs/nginx/html/live/livestream.m3u8 */
    m3u8 = path + "/" + m3u8_url;

    /* when update config, reset the history target duration. */
    /* get_hls_td_ratio： get the hls td(target duration) ratio.
     * hls 没有配置 hls_td_ratio，默认返回 1.5，而 fragment 配置为 10，
     * 因此 max_td 为 15 */
    max_td = (int)(fragment * _srs_config->get_hls_td_ratio(r->vhost));

    /* TODO: FIXME: refine better for SRS2 only support disk. */
    should_write_cache = false;
    should_write_file = true;

    /* create m3u8 dir once. */
    /* 返回 m3u8 的目录路径，即 ./objs/nginx/html/live */
    m3u8_dir = srs_path_dirname(m3u8);
    if (should_write_file && (ret = srs_create_dir_recursively(m3u8_dir)) != ERROR_SUCCESS)
    {
        srs_error("create app dir %s failed. ret=%d", m3u8_dir.c_str(), ret);
        return ret;
    }
    srs_info("create m3u8 dir %s ok", m3u8_dir.c_str());

    return ret;
}

3.1.6 srs_path_build_stream

/*
 * build the path according to vhost/app/stream, where replace variables:
 *     [vhost], the vhost of stream.
 *     [app], the app of stream.
 *     [stream], the stream name of stream.
 * @return the replaced path.
 */
string srs_path_build_stream(string template_path, string vhost, string app, string stream)
{
    std::string path = template_path;

    /* variable [vhost] */
    path = srs_string_replace(path, "[vhost]", vhost);
    /* variable [app] */
    path = srs_string_replace(path, "[app]", app);
    /* variable [stream] */
    path = srs_string_replace(path, "[stream]", stream);

    return path;
}

3.1.7 SrsHlsMuxer::segment_open

/*
 * open a new segment(a new ts file),
 * @param segment_start_dts, use to calc the segment duration,
 *    use 0 for the first segment of HLS.
 */
int SrsHlsMuxer::segment_open(int64_t segment_start_dts)
{
    int ret = ERROR_SUCCESS;

    /* current: current writing segment. 初始化时为 NULL */
    if (current) {
        srs_warn("ignore the segment open, for segment is already open.");
        return ret;
    }

    /* when segment open, the current segment must be NULL. */
    srs_assert(!current);

    /* load the default acodec from config. */
    SrsCodecAudio default_acodec = SrsCodecAudioAAC;
    if (true) {
        /* hls 没有配置 hls_acodec，默认返回 "aac" */
        std::string default_acodec_str = _srs_config->get_hls_acodec(req->vhost);
        if (default_acodec_str == "mp3") {
            default_acodec = SrsCodecAudioMP3;
            srs_info("hls: use default mp3 acodec");
        } else if (default_acodec_str == "aac") {
            default_acodec = SrsCodecAudioAAC;
            srs_info("hls: use default aac acodec");
        } else if (default_acodec_str == "an") {
            default_acodec = SrsCodecAudioDisabled;
            srs_info("hls: use default an acodec for pure video");
        } else {
            srs_warn("hls: use aac for other codec=%s", default_acodec_str.c_str());
        }
    }

    /* load the default vcodec from config. */
    SrsCodecVideo default_vcodec = SrsCodecVideoAVC;
    if (true) {
        /* hls 中没有配置 hls_vcodec，默认返回 "h264" */
        std::string default_vcodec_str = _srs_config->get_hls_vcodec(req->vhost);
        if (default_vcodec_str == "h264") {
            default_vcodec = SrsCodecVideoAVC;
            srs_info("hls: use default h264 vcodec");
        } else if (default_vcodec_str == "vn") {
            default_vcodec = SrsCodecVideoDisabled;
            srs_info("hls: use default vn vcodec for pure audio");
        } else {
            srs_warn("hls: use h264 for other codec=%s", default_vcodec_str.c_str());
        }
    }

    /* new segment. */
    current = new SrsHlsSegment(context, should_write_cache, should_write_file,
                                default_acodec, default_vcodec);
    /* _sequence_no: sequence number in m3u8. */
    current->sequence_no = _sequence_no++;
    /* 若为 HLS 的 first segment，则 segment_start_dts 为 0 */
    current->segment_start_dts = segment_start_dts;

    /* generate filename. */
    /* ts_file: "[app]/[stream]-[seq].ts" */
    std::string ts_file = hls_ts_file;
    /* ts_file: "live/livestream-[seq].ts" */
    ts_file = srs_path_build_stream(ts_file, req->vhost, req->app, req->stream);
    /* SrsHlsMuxer 构造时，初始化该值为 false */
    if (hls_ts_floor) {
        ...

    } else {
        ts_file = srs_path_build_timestamp(ts_file);
    }
    if (true) {
        std::stringstream ss;
        ss << current->sequence_no;
        /* ts_file: live/livestream-0.ts */
        ts_file = srs_string_replace(ts_file, "[seq]", ss.str());
    }
    /* full_path: ./objs/nginx/html/live/livestream-0.ts */
    current->full_path = hls_path + "/" + ts_file;

    /* the ts url, relative or absolute url. */
    std::string ts_url = current->full_path;
    /* ts_url: ./objs/nginx/html/live/livestream-0.ts,
     * m3u8_dir: ./objs/nginx/html/live */
    if (srs_string_starts_with(ts_url, m3u8_dir)) {
        /* ts_url: /livestream-0.ts */
        ts_url = ts_url.substr(m3u8_dir.length());
    }
    while (srs_string_starts_with(ts_url, "/")) {
        /* ts_url: livestream-0.ts */
        ts_url = ts_url.substr(1);
    }
    /* current->uri: "" */
    current->uri += hls_entry_prefix;
    if (!hls_entry_prefix.empty() && !srs_string_ends_with(hls_entry_prefix, "/"))
    {
        current->uri += "/";

        /* add the http dir to uri. */
        string http_dir = srs_path_dirname(m3u8_url);
        if (!http_dir.empty()) {
            current->uri += http_dir + "/";
        }
    }
    /* current->uri: livestream-0.ts */
    current->uri += ts_url;

    /* create dir recursively for hls. */
    /* ts_dir: ./objs/nginx/html/live */
    std::string ts_dir = srs_path_dirname(current->full_path);
    if (should_write_file && (ret = srs_create_dir_recursively(ts_dir))
        != ERROR_SUCCESS) {
        srs_error("create app dir %s failed. ret=%d", ts_dir.c_str(), ret);
        return ret;
    }

    /* open temp ts file. */
    /* tmp_file: ./objs/nginx/html/live/livestream-0.ts.tmp */
    std::string tmp_file = current->full_path + ".tmp";
    if ((ret = current->muxer->open(tmp_file.c_str())) != ERROR_SUCCESS) {
        srs_error("open hls muxer failed. ret=%d", ret);
        return ret;
    }

    /* set the segment muxer audio codec. */
    if (acodec != SrsCodecAudioReserved1) {
        current->muxer->update_acodec(acodec);
    }

    return ret;
}

3.1.8 SrsHlsSegment 构造

/*
 * the wrapper of m3u8 segment from specification:
 * EXTINF: The EXTINF tag specifies the duration of a media segment.
 */
SrsHlsSegment::SrsHlsSegment(SrsTsContext* c, bool write_cache,
    bool write_file, SrsCodecAudio ac, SrsCodecVideo vc)
{
    /* duration in seconds in m3u8. */
    duration = 0;
    /* sequence number in m3u8. */
    sequence_no = 0;
    /* current segment start dts for m3u8 */
    segment_start_dts = 0;
    /* whether current segement is sequence header. */
    is_sequence_header = false;
    /* 由前知 write_cache 为 false，write_file 为 true */
    writer = new SrsHlsCacheWriter(write_cache, write_file);
    muxer = new SrsTSMuxer(writer, c, ac, vc);
}

3.1.9 SrsHlsCacheWriter 构造

/*
 * write to file and cache.
 */
SrsHlsCacheWriter::SrsHlsCacheWriter(bool write_cache, bool write_file)
{
    should_write_cache = write_cache;
    should_write_file = write_file;
}

3.1.10 SrsTSMuxer 构造

/*
 * write data from frame(header info) and buffer(data) to ts file.
 * it's a simple object wrapper for utility from nginx-rtmp: SrsMpegtsWriter
 */
SrsTSMuxer::SrsTSMuxer(SrsFileWriter* w, SrsTsContext* c, SrsCodecAudio ac,
    SrsCodecVideo vc)
{
    writer = w;
    context = c;

    acodec = ac;
    vcodec = vc;
}

3.1.11 srs_path_build_timestamp

/*
 * build the path according to timestamp, where replace variables:
 *       [2006], replace this const to current year.
 *       [01], replace this const to current month.
 *       [02], replace this const to current date.
 *       [15], replace this const to current hour.
 *       [04], repleace this const to current minute.
 *       [05], repleace this const to current second.
 *       [999], repleace this const to current millisecond.
 *       [timestamp],replace this const to current UNIX timestamp in ms.
 * @return the replace path.
 */
string srs_path_build_timestamp(string template_path)
{
    std::string path = template_path;

    /* data and time substitude
     * clock time */
    timeval tv;
    if (gettimeofday(&tv, NULL) == -1) {
        return path;
    }

    /* to calendar time */
    struct tm* tm;
    /* 若没有配置 utc_time，则默认返回 false，即不使用 utc 时间 */
    if (_srs_config->get_utc_time()) {
        if ((tm = gmtime(&tv.tv_sec)) == NULL) {
            return path;
        }
    } else {
        if ((tm = localtime(&tv.tv_sec)) == NULL) {
            return path;
        }
    }

    /* the buffer to format the date and time. */
    char buf[64];

    /* [2006], replace with current year. */
    if (true) {
        snprintf(buf, sizeof(buf), "%04d", 1900 + tm->tm_year);
        path = srs_string_replace(path, "[2006]", buf);
    }
    /* [01], replace this const to current month. */
    if (true) {
        snprintf(buf, sizeof(buf), "%02d", 1 + tm->tm_mon);
        path = srs_string_replace(path, "[01]", buf);
    }
    /* [02], replace this const to current date. */
    if (true) {
        snprintf(buf, sizeof(buf), "%02d", tm->tm_mday);
        path = srs_string_replace(path, "[02]", buf);
    }
    /* [15], replace this const to current hour. */
    if (true) {
        snprintf(buf, sizeof(buf), "%02d", tm->tm_hour);
        path = srs_string_replace(path, "[15]", buf);
    }
    /* [04], repleace this const to current minute. */
    if (true) {
        snprintf(buf, sizeof(buf), "%02d", tm->tm_min);
        path = srs_string_replace(path, "[04]", buf);
    }
    /* [05], repleace this const to current second. */
    if (true) {
        snprintf(buf, sizeof(buf), "%02d", tm->tm_sec);
        path = srs_string_replace(path, "[05]", buf);
    }
    /* [999], repleace this const to current millisecond. */
    if (true) {
        snprintf(buf, sizeof(buf), "%03d", (int)(tv.tv_usec / 1000));
        path = srs_string_replace(path, "[999]", buf);
    }
    /* [timestamp],replace this const to current UNIX timestamp in ms. */
    if (true) {
        int64_t now_us = ((int64_t)tv.tv_sec) * 1000 * 1000 + (int64_t)tv.tv_usec;
        snprintf(buf, sizeof(buf), "%"PRId64, now_us / 1000);
        path = srs_string_replace(path, "[timestamp]", buf);
    }

    return path;
}

3.1.12 SrsTSMuxer::open

/*
 * open the writer, donot write the PSI of ts.
 * @param p, a string indicates the path of ts file to mux to.
 */
int SrsTSMuxer::open(string p)
{
    int ret = ERROR_SUCCESS;

    path = p;

    close();

    /* reset the context for a new ts start. */
    context->reset();

    /* 调用子类 SrsHlsCacheWriter 实现的 open 函数 */
    if ((ret = writer->open(path)) != ERROR_SUCCESS) {
        return ret;
    }

    return ret;
}

3.1.13 SrsHlsCacheWriter::open

int SrsHlsCacheWriter::open(string file)
{
    if (!should_write_file) {
        return ERROR_SUCCESS;
    }

    return impl.open(file);
}

3.1.14 SrsFileWriter::open

/*
 * open file writer, in truncate mode.
 * @param p, a string indicates the path of file to open.
 */
int SrsFileWriter::open(string p)
{
    int ret = ERROR_SUCCESS;

    if (fd > 0) {
        ret = ERROR_SYSTEM_FILE_ALREADY_OPENED;
        srs_error("file %s already opened. ret=%d", path.c_str(), ret);
        return ret;
    }

    int flags = O_CREAT|O_WRONLY|O_TRUNC;
    mode_t mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH;

    /* 打开 ./objs/nginx/html/live/livestream-0.ts.tmp 文件 */
    if ((fd = ::open(p.c_str(), flags, mode)) < 0) {
        ret = ERROR_SYSTEM_FILE_OPENE;
        srs_error("open file %s failed. ret=%d", p.c_str(), ret);
        return ret;
    }

    path = p;

    return ret;
}

上面分析完 acquire_publish 函数，下面接着分析 SrsPublishRecvThread 线程的构建。

3.2 SrsPublishRecvThread 构造

在该构造函数中，创建了一个可重复使用的 recv 线程，专门用于接收客户端推流的音视频数据。

• the publish recv thread got message and callback the source method to process message.

SrsPublishRecvThread::SrsPublishRecvThread(
    SrsRtmpServer* rtmp_sdk,
    SrsRequest* _req, int mr_sock_fd, int timeout_ms,
    SrsRtmpConn* conn, SrsSource* source, bool is_fmle, bool is_edge
): trd(this, rtmp_sdk, timeout_ms)
{
    rtmp = rtmp_sdk;

    _conn = conn;
    /* the params for conn callback. */
    _source = source;
    /* 由前知，为 true */
    _is_fmle = is_fmle;
    /* false */
    _is_edge = is_edge;

    recv_error_code = ERROR_SUCCESS;
    /* the msgs already got. */
    _nb_msgs = 0;
    /* The video frames we got. */
    video_frames = 0;
    /* the error timeout cond */
    error = st_cond_new();
    ncid = cid = 0;

    req = _req;
    mr_fd = mr_sock_fd;

    /* the mr settings,
     * @see https://github.com/ossrs/srs/issues/241 */
    /* 没有配置 mr，默认返回 false */
    mr = _srs_config->get_mr_enabled(req->vhost);
    /* 默认返回 350 */
    mr_sleep = _srs_config->get_mr_sleep_ms(req->vhost);

    /* 没有配置 min_latency，默认返回 false */
    realtime = _srs_config->get_realtime_enabled(req->vhost);

    _srs_config->subscribe(this);
}

调用该 SrsPublishRecvThread 的构造函数前，先调用 SrsRecvThread 类的构造函数。

3.2.1 SrsRecvThread 构造

• the recv thread, use message handler to handle each received message.

SrsRecvThread::SrsRecvThread(ISrsMessageHandler* msg_handler,
    SrsRtmpServer* rtmp_sdk, int timeout_ms)
{
    timeout = timeout_ms;
    handler = msg_handler;
    rtmp = rtmp_sdk;
    trd = new SrsReusableThread2("recv", this);
}

3.2.2 SrsReusableThread2 构造

SrsReusableThread2::SrsReusableThread2(const char* n, ISrsReusableThread2Handler* h,
    int64_t interval_us)
{
    handler = h;
    pthread = new internal::SrsThread(n, this, interval_us, true);
}

3.2.3 SrsThread 构造

SrsThread::SrsThread(const char* name, ISrsThreadHandler* thread_handler,
    int64_t interval_us, bool joinable)
{
    _name = name;
    handler = thread_handler;
    cycle_interval_us = interval_us;

    tid = NULL;
    loop = false;
    really_terminated = true;
    _cid = -1;
    _joinable = joinable;
    disposed = false;

    // in start(), the thread cycle method maybe stop and remove the thread itself,
    // and the thread start() is waiting for the _cid, and segment fault then.
    // @see https://github.com/ossrs/srs/issues/110
    // thread will set _cid, callback on_thread_start(), then wait for the can_run signal.
    can_run = false;
}

4. SrsRtmpConn::do_publishing

int SrsRtmpConn::do_publishing(SrsSource* source, SrsPublishRecvThread* trd)
{
    int ret = ERROR_SUCCESS;

    SrsPithyPrint* pprint = SrsPithyPrint::create_rtmp_publish();
    SrsAutoFree(SrsPithyPrint, pprint);

    /* start isolate recv thread. */
    if ((ret = trd->start()) != ERROR_SUCCESS) {
        srs_error("start isolate recv thread failed. ret=%d", ret);
        return ret;
    }

    /* change the isolate recv thread context id,
     * merge its log to current thread. */
    int receive_thread_cid = trd->get_cid();
    trd->set_cid(_srs_context->get_id());

    /* initialize the publish timeout. */
    publish_1stpkt_timeout = _srs_config->get_publish_1stpkt_timeout(req->vhost);
    publish_normal_timeout = _srs_config->get_publish_normal_timeout(req->vhost);

    /* set the sock options. */
    set_sock_options();

    if (true) {
        /* 没有启用 mr 功能，为 false */
        bool mr = _srs_config->get_mr_enabled(req->vhost);
        int mr_sleep = _srs_config->get_mr_sleep_ms(req->vhost);
    }

    int64_t nb_msgs = 0;
    uint64_t nb_frames = 0;
    while (!disposed) {
        pprint->elapse();

        /* when source is set to expired, disconnect it. */
        if (expired) {
            ret = ERROR_USER_DISCONNECT;
            srs_error("connection expired. ret=%d", ret);
            return ret;
        }

        /* conn wait for timeout */
        if (nb_msgs == 0) {
            /* when not got msgs, wait for a larger timeout. */
            trd->wait(publish_1stpkt_timeout);
        } else {
            trd->wait(publish_normal_timeout);
        }

        /* check the thread error code */
        if ((ret = trd->error_code()) != ERROR_SUCCESS) {
            if (!srs_is_system_control_error(ret) &&
                !srs_is_client_gracefully_close(ret)) {
                srs_error("recv thread failed. ret=%d", ret);
            }
            return ret;
        }

        /* when not any messages, timeout */
        if (trd->nb_msgs() <= nb_msgs) {
            ret = ERROR_SOCKET_TIMEOUT;
            srs_warn("publish timeout %dms, nb_msgs=%"PRId64", ret=%d",
                nb_msgs? publish_normal_timeout : publish_1stpkt_timeout, nb_msgs, ret);
            break;
        }
        nb_msgs = trd->nb_msgs();

        /* update the stat for video fps. */
        SrsStatistic* stat = SrsStatistic::instance();
        if ((ret = stat->on_video_frames(req, (int)(trd->nb_video_frames() - nb_frames)))
            != ERROR_SUCCESS) {
            return ret;
        }
        nb_frames = trd->nb_video_frames();

        /* reportable */
        if (pprint->can_print()) {
            kbps->sample();
            bool mr = _srs_config->get_mr_enabled(req->vhost);
            int mr_sleep = _srs_config->get_mr_sleep_ms(req->vhost);
            );
        }
    }

    return ret;
}

该 while 循环主要是循环进行 error 条件变量上进入休眠状态，等待该条件变量成立（即若 recv 线程发生错误，则会通过 error 条件变量唤醒在该条件变量上等待的线程，以便该线程进行处理 recv error），或者等待的超时时间到了才唤醒。

5. recv 线程

该线程具体分析可见： SRS之接收推流线程：recv