1. 是否可切片的检测
首先在调用 SrsHlsCache::reap_segment 函数进行切片时，针对音频或视频，都会有一个函数来进行检测当前片的时长是否符合所要求的时长。
对于音频，会调用 SrsHlsMuxer::is_segment_absolutely_overflow 函数进行检测，如下：
bool SrsHlsMuxer::is_segment_absolutely_overflow()
{
srs_assert(current);
/* 若当前片的时长小于 200 ms，则直接返回 false，即不允许切片 */
/* to prevent very small segment. */
if (current->duration * 1000 <
2 * SRS_AUTO_HLS_SEGMENT_MIN_DURATION_MS) {
return false;
}
/* 若没有配置 hls_ts_floor，则默认为 0 */
/* use N% deviation, to smoother. */
double deviation = hls_ts_floor ?
SRS_HLS_FLOOR_REAP_PERCENT * deviation_ts * hls_fragment : 0.0;
/* hls_aof_ratio 默认为 2.0， 而 hls_fragment 默认为 10s，
* 则需要当前片的时长大于 20s 时，才会进行切片 */
return current->duration >= hls_aof_ratio * hls_fragment + deviation;
}
对于视频，则会调用 SrsHlsMuxer::is_segment_overflow 函数进行检测，如下：
bool SrsHlsMuxer::is_segment_overflow()
{
srs_assert(current);
/* 同样，若小于 200ms，直接不允许切片 */
/* to prevent very small segment. */
if (current->duration * 1000 <
2 * SRS_AUTO_HLS_SEGMENT_MIN_DURATION_MS) {
return false;
}
/* use N% deviation, to smoother. */
double deviation = hls_ts_floor?
SRS_HLS_FLOOR_REAP_PERCENT * deviation_ts * hls_fragment : 0.0;
/* 假设 hls_fragment 配置为 10s，因此若当前片的时长
* 大于 10s 即可进行切片 */
return current->duration >= hls_fragment + deviation;
}
- 当调用以上两个函数，检测到满足其中一个时，则会调用 SrsHlsCache::reap_segment 函数对当前片进行切片。
2. SrsHlsCache::reap_segment
/*
* reopen the muxer for a new hls segment,
* close current segment, open a new segment,
* then write the key frame to the new segment.
* so, user must reap_segment then flush_video to hls muxer.
*/
int SrsHlsCache::reap_segment(string log_desc, SrsHlsMuxer* muxer,
int64_t segment_start_dts)
{
int ret = ERROR_SUCCESS;
/* TODO: flush audio before or after segment?
* TODO: fresh segment begin with audio or video? */
/* close current ts. */
/* 该函数会构造一个 M3u8 文件，将当前符合时长的所有 ts 文件
* 更新到该文件的 Playlist 列表中，以便客户端可以进行播放
* 同时会释放当前片（即 current）的所有资源 */
if ((ret = muxer->segment_close(log_desc)) != ERROR_SUCCESS) {
srs_error("m3u8 muxer close segment failed. ret=%d", ret);
return ret;
}
/* open new ts. */
if ((ret = muxer->segment_open(segment_start_dts)) != ERROR_SUCCESS) {
srs_error("m3u8 muxer open segment failed. ret=%d", ret);
return ret;
}
/* segment open, flush video first. */
if ((ret = muxer->flush_video(cache)) != ERROR_SUCCESS) {
srs_error("m3u8 muxer flush video failed. ret=%d", ret);
return ret;
}
/* segment open, flush the audio.
* @see: ngx_rtmp_hls_open_fragment
* start fragment with audio to make iPhone happy */
if ((ret = muxer->flush_audio(cache)) != ERROR_SUCCESS) {
srs_error("m3u8 muxer flush audio failed. ret=%d", ret);
return ret;
}
return ret;
}
- 首先调用 SrsHlsMuxer::segment_close 函数关闭当前的 ts。
3. SrsHlsMuxer::segment_close
/**
* close segment(ts).
* @param log_desc the description for log.
*/
int SrsHlsMuxer::segment_close(string log_desc)
{
int ret = ERROR_SUCCESS;
if (!current) {
srs_warn("ignore the segment close, for segment is not open.");
return ret;
}
/* when close current segment, the current segment
* must not be NULL. */
srs_assert(current);
/* assert segment duplicate. */
std::vector<SrsHlsSegment*>::iterator it;
it = std::find(segments.begin(), segments.end(), current);
srs_assert(it == segments.end());
/* valid, add to segments if segment duration is ok
* when too small, it maybe not enough data to play.
* when too large, it maybe timestamp corrupt.
* make the segment more acceptable, when in [min, max_td * 2], it's ok */
if (current->duration * 1000 >= SRS_AUTO_HLS_SEGMENT_MIN_DURATION_MS &&
(int)current->duration <= max_td * 2) {
/* 若当前片可以被切片时，将该片保存到 segments vector 容器中
* segments: m3u8 segments */
segments.push_back(current);
/* 这里两个调用暂时忽略 */
/* use async to call the http hooks, for it will cause thread switch. */
if ((ret = async->execute(new SrsDvrAsyncCallOnHls(
_srs_context->get_id(), req,
current->full_path, current->uri, m3u8, m3u8_url,
current->sequence_no, current->duration))) != ERROR_SUCCESS)
{
return ret;
}
/* use async to call the http hooks, for it will cause thread switch. */
if ((ret = async->execute(new SrsDvrAsyncCallOnHlsNotify(_srs_context->get_id(),
req, current->uri))) != ERROR_SUCCESS) {
return ret;
}
/* close the muxer of finished segment. */
srs_freep(current->muxer);
/* full_path: ./objs/nginx/html/live/livestream-0.ts */
std::string full_path = current->full_path;
current = NULL;
/* rename from tmp to real path */
std::string tmp_file = full_path + ".tmp";
/* 将 ./objs/nginx/html/live/livestream-0.ts.tmp 文件重命名为
* ./objs/nginx/html/live/livestream-0.ts */
if (should_write_file && rename(tmp_file.c_str(), full_path.c_str()) < 0) {
ret = ERROR_HLS_WRITE_FAILED;
srs_error("rename ts file failed, %s => %s. ret=%d",
tmp_file.c_str(), full_path.c_str(), ret);
return ret;
}
} else {
/* reuse current segment index. */
_sequence_no--;
/* rename from tmp to real path */
std::string tmp_file = current->full_path + ".tmp";
if (should_write_file) {
if (unlink(tmp_file.c_str()) < 0) {
srs_warn("ignore unlink path failed, file=%s.", tmp_file.c_str());
}
}
srs_freep(current);
}
/* the segments to remove */
std::vector<SrsHlsSegment*> segment_to_remove;
/* shrink the segments. */
double duration = 0;
int remove_index = -1;
for (int i = (int)segments.size() - 1; i >= 0; i--) {
SrsHlsSegment* segment = segments[i];
/* 统计 segmtns 容器保存的所有已经切片的片的总时长 */
duration += segment->duration;
/* 若所有片的总时长超过了 hls 窗口大小的限制，
* 则丢弃第一个 m3u8 中的第一个切片，直到 ts 的总时长
* 在这个配置项范围之内。 */
if ((int)duration > hls_window) {
/* 记录当前需要移除片的个数 */
remove_index = i;
break;
}
}
/* 遍历 segments 前 remove_index 个片，逐一将 segments 容器中
* 前 remove_index 个片移除 */
for (int i = 0; i < remove_index && !segments.empty(); i++) {
SrsHlsSegment* segment = *segments.begin();
segments.erase(segments.begin());
/* 将所有移除的片临时保存到该容器中 */
segment_ro_remove.push_back(segment);
}
/* refresh the m3u8, donot contains the removed ts */
ret = refresh_m3u8();
/* remove the ts file. */
for (int i = 0; i < (int)segment_to_remove.size(); i++) {
SrsHlsSegment* segment = segment_to_remove[i];
/* 从磁盘中删除该 ts 文件 */
if (hls_cleanup && should_write_file) {
if (unlink(segment->full_path.c_str()) < 0) {
srs_warn("cleanup unlink path failed, file=%s.", segment->full_path.c_str());
}
}
srs_freep(segment);
}
segment_to_remove.clear();
/* check ret of refresh m3u8 */
if (ret != ERROR_SUCCESS) {
srs_error("refresh m3u8 failed. ret=%d", ret);
return ret;
}
return ret;
}
- 该函数首先将满足时长的片保存到 segments vector 容器中，接着检查当前 segments 中所有片的总时长是否已经超过 hls_window 的限制，默认为 60s。若超过了其限制，则丢弃第一个 m3u8 中的第一个切片，直到 ts 的总时长在这个配置项范围之内。然后调用 SrsHlsMuxer::refresh_m3u8 函数刷新 m3u8，并且不再包含刚才已经删除的片。
3.1 SrsHlsMuxer::refresh_m3u8
int SrsHlsMuxer::refresh_m3u8()
{
int ret = ERROR_SUCCESS;
/* no segments, also no m3u8, return. */
if (segments.size() == 0) {
return ret;
}
std::string temp_m3u8 = m3u8 + ".temp";
if ((ret = _refresh_m3u8(temp_m3u8)) == ERROR_SUCCESS) {
/* 将该临时文件 livestream.m3u8.temp 重命名为 livestream.m3u8 */
if (should_write_file && rename(temp_m3u8.c_str(), m3u8.c_str()) < 0) {
ret = ERROR_HLS_WRITE_FAILED;
srs_error("rename m3u8 file failed. %s => %s, ret=%d", temp_m3u8.c_str(), m3u8.c_str(), ret);
}
}
/* remove the temp file. */
if (srs_path_exists(temp_m3u8)) {
/* 若该临时文件存在则删除该临时文件 */
if (unlink(temp_m3u8.c_str()) < 0) {
srs_warn("ignore remove m3u8 failed, %s", temp_m3u8.c_str());
}
}
return ret;
}
- 该函数首先会生成一个 m3u8 文件的绝对路径，然后根据该路径调用 SrsHlsMuxer::_refresh_m3u8 函数。
3.2 SrsHlsMuxer::_refresh_m3u8
int SrsHlsMuxer::_refresh_m3u8(string m3u8_file)
{
int ret = ERROR_SUCCESS;
/* no segments, return. */
if (segments.size() == 0) {
return ret;
}
SrsHlsCacheWriter writer(should_write_cache, should_write_file);
if ((ret = writer.open(m3u8_file)) != ERROR_SUCCESS) {
srs_error("open m3u8 file %s failed. ret=%d", m3u8_file.c_str(), ret);
return ret;
}
/* #EXTM3U
* #EXT-X-VERSION:3
* #EXT-X-ALLOW-CACHE:YES
*/
std::stringstream ss;
ss << "#EXTM3U" << SRS_CONSTS_LF
<< "#EXT-X-VERSION:3" << SRS_CONSTS_LF
<< "#EXT-X-ALLOW-CACHE:YES" << SRS_CONSTS_LF;
/* #EXT-X-MEDIA-SEQUENCE:4294967295
*/
SrsHlsSegment* first = *segments.begin();
ss << "#EXT-X-MEDIA-SEQUENCE:" << first->sequence_no << SRS_CONSTS_LF;
/* iterator shared for td generation and segments wrote. */
std::vector<SrsHlsSegment*>::iterator it;
/* #EXT-X-TARGETDURATION:4294967295
*/
/*
* @see hls-m3u8-draft-pantos-http-live-streaming-12.pdf, page 25
* The Media Playlist file MUST contain an EXT-X-TARGETDURATION tag.
* Its value MUST be equal to or greater than the EXTINF duration of any
* media segment that appears or will appear in the Playlist file,
* typical targer duration is 10 seconds.
*/
/* @see https://github.com/ossrs/srs/issues/304#issuecomment-74000081 */
int targer_duration = 0;
for (it = segments.begin(); it != segments.end(); ++it) {
SrsHlsSegment* segment = *it;
target_duration = srs_max(target_duration, (int)ceil(segment->duration));
}
target_duration = srs_max(target_duration, max_td);
ss << "#EXT-X-TARGETDURATION:" << target_duration << SRS_CONSTS_LF;
/* write all segments */
for (it = segments.begin(); it != segments.end(); ++it) {
SrsHlsSegment* segment = *it;
if (segment->is_sequence_header) {
/* #EXT-X-DISCONTINUITY
*/
ss << "#EXT-X-DISCONTINUITY" << SRS_CONSTS_LF;
srs_verbose("write m3u8 segment discontinuity success.");
}
/* "#EXTINF:4294967295.208,
" */
ss.precision(3);
ss.setf(std::ios::fixed, std::ios::floatfield);
ss << "#EXTINF:" << segment->duration << ", no desc" << SRS_CONSTS_LF;
/* {file name}
*/
ss << segment->uri << SRS_CONSTS_LF;
}
/* write m3u8 to writer. */
std::string m3u8 = ss.str();
if ((ret = writer.write((char*)m3u8.c_str(), (int)m3u8.length(), NULL))
!= ERROR_SUCCESS) {
srs_error("write m3u8 failed. ret=%d", ret);
return ret;
}
srs_info("write m3u8 %s success.", m3u8_file.c_str());
return ret;
}
-
该函数根据 segments 构建一个 m3u8 的 Playlist，并将构建的数据写入到 m3u8 文件中。关于 m3u8 的相关知识可参考 HLS协议解析。
-
回到 SrsHlsCache::reap_segment 函数中，当调用 SrsHlsMuxer::segment_close 成功返回后，接着调用 SrsHlsMuxer::segment_open 函数打开一个新的 片，即 ts 文件。
4. 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,
* 否则为当前接收到的音视频的 dts */
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-x.ts */
ts_file = srs_string_replace(ts_file, "[seq]", ss.str());
}
/* full_path: ./objs/nginx/html/live/livestream-x.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-x.ts,
* m3u8_dir: ./objs/nginx/html/live */
if (srs_string_starts_with(ts_url, m3u8_dir)) {
/* ts_url: /livestream-x.ts */
ts_url = ts_url.substr(m3u8_dir.length());
}
while (srs_string_starts_with(ts_url, "/")) {
/* ts_url: livestream-x.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-x.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-x.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;
}
- 该函数重新创建一个 SrsHlsSegment 类对象，并打开一个 ts 文件后。回到 SrsHlsCache::reap_segment 函数中，接着调用 SrsHlsMuxer::flush_video 和 SrsHlsMuxer::flush_audio 函数将 cache 中缓存的所有音视频封装为 ts，并写入到打开的 ts 文件中。这里两个函数的具体分析过程可参考 SRS之SrsHls::on_audio详解 和 SRS之SrsHls::on_video详解