aunix/ZLMediaKit
1
0
Fork 0
mirror of https://gitee.com/xia-chu/ZLMediaKit.git synced 2026-05-23 01:57:50 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Pre Merge pull request !24 from yinxiang/hls_record

Browse Source
This commit is contained in:
yinxiang 2023-01-10 09:11:04 +00:00 committed by Gitee
commit 30f4a267c2
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
11 changed files with 784 additions and 572 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
conf/config.ini
View File

@ -94,6 +94,7 @@ maxStreamWaitMS=15000
#某个流无人观看时，触发hook.on_stream_none_reader事件的最大等待时间，单位毫秒 #某个流无人观看时，触发hook.on_stream_none_reader事件的最大等待时间，单位毫秒
#在配合hook.on_stream_none_reader事件时，可以做到无人观看自动停止拉流或停止接收推流 #在配合hook.on_stream_none_reader事件时，可以做到无人观看自动停止拉流或停止接收推流
streamNoneReaderDelayMS=20000 streamNoneReaderDelayMS=20000
noRecordStreamNoneReaderDelayMS=130000
#拉流代理时如果断流再重连成功是否删除前一次的媒体流数据，如果删除将重新开始， #拉流代理时如果断流再重连成功是否删除前一次的媒体流数据，如果删除将重新开始，
#如果不删除将会接着上一次的数据继续写(录制hls/mp4时会继续在前一个文件后面写) #如果不删除将会接着上一次的数据继续写(录制hls/mp4时会继续在前一个文件后面写)
resetWhenRePlay=1 resetWhenRePlay=1

81
src/Common/MediaSource.cpp
View File

@ -662,32 +662,73 @@ void MediaSourceEvent::onReaderChanged(MediaSource &sender, int size){
//没有任何人观看该视频源，表明该源可以关闭了 //没有任何人观看该视频源，表明该源可以关闭了
GET_CONFIG(string, record_app, Record::kAppName); GET_CONFIG(string, record_app, Record::kAppName);
GET_CONFIG(int, stream_none_reader_delay, General::kStreamNoneReaderDelayMS); GET_CONFIG(int, stream_none_reader_delay, General::kStreamNoneReaderDelayMS);
GET_CONFIG(int, no_record_stream_none_reader_delay, General::kNoRecordStreamNoneReaderDelayMS);
//如果mp4点播, 无人观看时我们强制关闭点播 //如果mp4点播, 无人观看时我们强制关闭点播
bool is_mp4_vod = sender.getApp() == record_app; bool is_mp4_vod = sender.getApp() == record_app;
weak_ptr<MediaSource> weak_sender = sender.shared_from_this(); weak_ptr<MediaSource> weak_sender = sender.shared_from_this();
_async_close_timer = std::make_shared<Timer>(stream_none_reader_delay / 1000.0f, [weak_sender, is_mp4_vod]() { if(sender.isRecording(Recorder::type_hls)) {//如果正在录像
auto strong_sender = weak_sender.lock(); WarnL << "************The stream is Recording.*************";
if (!strong_sender) { WarnL << sender.getUrl();
//对象已经销毁 _async_close_timer = std::make_shared<Timer>(
return false; stream_none_reader_delay / 1000.0f,
} [weak_sender, is_mp4_vod]() {
auto strong_sender = weak_sender.lock();
if (!strong_sender) {
//对象已经销毁
return false;
}
if (strong_sender->totalReaderCount()) { if (strong_sender->totalReaderCount()) {
//还有人观看该视频，不触发关闭事件 //还有人观看该视频，不触发关闭事件
return false; return false;
} }
if (!is_mp4_vod) { if (!is_mp4_vod) {
//直播时触发无人观看事件，让开发者自行选择是否关闭 //直播时触发无人观看事件，让开发者自行选择是否关闭
NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastStreamNoneReader, *strong_sender); NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastStreamNoneReader, *strong_sender);
} else { } else {
//这个是mp4点播，我们自动关闭 //这个是mp4点播，我们自动关闭
WarnL << "MP4点播无人观看,自动关闭:" << strong_sender->getUrl(); WarnL << "MP4点播无人观看,自动关闭:" << strong_sender->getUrl();
strong_sender->close(false); strong_sender->close(false);
} }
return false; return false;
}, nullptr); },
nullptr);
} else {//没有录像的话
WarnL << "************The stream is Not Recording.*************";
WarnL << sender.getUrl();
_async_close_timer = std::make_shared<Timer>(
no_record_stream_none_reader_delay / 1000.0f,
[weak_sender, is_mp4_vod]() {
auto strong_sender = weak_sender.lock();
if (strong_sender->isRecording(Recorder::type_hls)) {
return false;
}
if (!strong_sender) {
//对象已经销毁
return false;
}
if (strong_sender->totalReaderCount()) {
//还有人观看该视频，不触发关闭事件
return false;
}
if (!is_mp4_vod) {
//直播时触发无人观看事件，让开发者自行选择是否关闭
NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastStreamNoneReader, *strong_sender);
} else {
//这个是mp4点播，我们自动关闭
WarnL << "MP4点播无人观看,自动关闭:" << strong_sender->getUrl();
strong_sender->close(false);
}
return false;
},
nullptr);
}
} }
string MediaSourceEvent::getOriginUrl(MediaSource &sender) const { string MediaSourceEvent::getOriginUrl(MediaSource &sender) const {

18
src/Common/MultiMediaSourceMuxer.cpp
View File

@ -1,4 +1,4 @@
/* /*
* Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved. * Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved.
* *
* This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit). * This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit).
@ -192,8 +192,9 @@ bool MultiMediaSourceMuxer::setupRecord(MediaSource &sender, Recorder::type type
}); });
switch (type) { switch (type) {
case Recorder::type_hls : { case Recorder::type_hls : {
if (start && !_hls) { if (!_hls)
//开始录制 {
//创建hls对象
_option.hls_save_path = custom_path; _option.hls_save_path = custom_path;
auto hls = dynamic_pointer_cast<HlsRecorder>(makeRecorder(sender, getTracks(), type, _option)); auto hls = dynamic_pointer_cast<HlsRecorder>(makeRecorder(sender, getTracks(), type, _option));
if (hls) { if (hls) {
@ -201,10 +202,8 @@ bool MultiMediaSourceMuxer::setupRecord(MediaSource &sender, Recorder::type type
hls->setListener(shared_from_this()); hls->setListener(shared_from_this());
} }
_hls = hls; _hls = hls;
} else if (!start && _hls) {
//停止录制
_hls = nullptr;
} }
_hls->startRecord(start);
return true; return true;
} }
case Recorder::type_mp4 : { case Recorder::type_mp4 : {
@ -227,7 +226,12 @@ bool MultiMediaSourceMuxer::setupRecord(MediaSource &sender, Recorder::type type
bool MultiMediaSourceMuxer::isRecording(MediaSource &sender, Recorder::type type) { bool MultiMediaSourceMuxer::isRecording(MediaSource &sender, Recorder::type type) {
switch (type){ switch (type){
case Recorder::type_hls : case Recorder::type_hls :
return !!_hls; //return !!_hls;
if (_hls){
return _hls->getRecordFlag();
}else{
return false;
}
case Recorder::type_mp4 : case Recorder::type_mp4 :
return !!_mp4; return !!_mp4;
default: default:

2
src/Common/config.cpp
View File

@ -66,6 +66,7 @@ namespace General {
const string kMediaServerId = GENERAL_FIELD "mediaServerId"; const string kMediaServerId = GENERAL_FIELD "mediaServerId";
const string kFlowThreshold = GENERAL_FIELD "flowThreshold"; const string kFlowThreshold = GENERAL_FIELD "flowThreshold";
const string kStreamNoneReaderDelayMS = GENERAL_FIELD "streamNoneReaderDelayMS"; const string kStreamNoneReaderDelayMS = GENERAL_FIELD "streamNoneReaderDelayMS";
const string kNoRecordStreamNoneReaderDelayMS = GENERAL_FIELD "noRecordStreamNoneReaderDelayMS";
const string kMaxStreamWaitTimeMS = GENERAL_FIELD "maxStreamWaitMS"; const string kMaxStreamWaitTimeMS = GENERAL_FIELD "maxStreamWaitMS";
const string kEnableVhost = GENERAL_FIELD "enableVhost"; const string kEnableVhost = GENERAL_FIELD "enableVhost";
const string kResetWhenRePlay = GENERAL_FIELD "resetWhenRePlay"; const string kResetWhenRePlay = GENERAL_FIELD "resetWhenRePlay";
@ -79,6 +80,7 @@ const string kUnreadyFrameCache = GENERAL_FIELD "unready_frame_cache";
static onceToken token([]() { static onceToken token([]() {
mINI::Instance()[kFlowThreshold] = 1024; mINI::Instance()[kFlowThreshold] = 1024;
mINI::Instance()[kStreamNoneReaderDelayMS] = 20 * 1000; mINI::Instance()[kStreamNoneReaderDelayMS] = 20 * 1000;
mINI::Instance()[kNoRecordStreamNoneReaderDelayMS] = 130 * 1000;
mINI::Instance()[kMaxStreamWaitTimeMS] = 15 * 1000; mINI::Instance()[kMaxStreamWaitTimeMS] = 15 * 1000;
mINI::Instance()[kEnableVhost] = 0; mINI::Instance()[kEnableVhost] = 0;
mINI::Instance()[kResetWhenRePlay] = 1; mINI::Instance()[kResetWhenRePlay] = 1;

1
src/Common/config.h
View File

@ -158,6 +158,7 @@ extern const std::string kFlowThreshold;
// 流无人观看并且超过若干时间后才触发kBroadcastStreamNoneReader事件 // 流无人观看并且超过若干时间后才触发kBroadcastStreamNoneReader事件
// 默认连续5秒无人观看然后触发kBroadcastStreamNoneReader事件 // 默认连续5秒无人观看然后触发kBroadcastStreamNoneReader事件
extern const std::string kStreamNoneReaderDelayMS; extern const std::string kStreamNoneReaderDelayMS;
extern const std::string kNoRecordStreamNoneReaderDelayMS;
// 等待流注册超时时间，收到播放器后请求后，如果未找到相关流，服务器会等待一定时间， // 等待流注册超时时间，收到播放器后请求后，如果未找到相关流，服务器会等待一定时间，
// 如果在这个时间内，相关流注册上了，那么服务器会立即响应播放器播放成功， // 如果在这个时间内，相关流注册上了，那么服务器会立即响应播放器播放成功，
// 否则会最多等待kMaxStreamWaitTimeMS毫秒，然后响应播放器播放失败 // 否则会最多等待kMaxStreamWaitTimeMS毫秒，然后响应播放器播放失败

477
src/Record/HlsMaker.cpp
View File

@ -1,169 +1,308 @@
/* /*
* Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved. * Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved.
* *
* This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit). * This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit).
* *
* Use of this source code is governed by MIT license that can be found in the * Use of this source code is governed by MIT license that can be found in the
* LICENSE file in the root of the source tree. All contributing project authors * LICENSE file in the root of the source tree. All contributing project authors
* may be found in the AUTHORS file in the root of the source tree. * may be found in the AUTHORS file in the root of the source tree.
*/ */
#include "HlsMaker.h" #include "Util/File.h"
#include "Common/config.h" #include "HlsMaker.h"
#if defined(_WIN32)
using namespace std; #include <io.h>
#define _access access
namespace mediakit { #else
#include <unistd.h>
HlsMaker::HlsMaker(float seg_duration, uint32_t seg_number, bool seg_keep) { #include <dirent.h>
//最小允许设置为0，0个切片代表点播 #endif // WIN32
_seg_number = seg_number;
_seg_duration = seg_duration;
_seg_keep = seg_keep; using namespace std;
} using namespace toolkit;
HlsMaker::~HlsMaker() { namespace mediakit {
}
HlsMaker::HlsMaker(float seg_duration, uint32_t seg_number, bool seg_keep) {
//最小允许设置为0，0个切片代表点播
void HlsMaker::makeIndexFile(bool eof) { _seg_number = seg_number;
char file_content[1024]; _seg_duration = seg_duration;
int maxSegmentDuration = 0; _seg_keep = seg_keep;
_is_record = false;
for (auto &tp : _seg_dur_list) { }
int dur = std::get<0>(tp);
if (dur > maxSegmentDuration) { HlsMaker::~HlsMaker() {
maxSegmentDuration = dur;
} _is_close_stream = true;
} }
auto sequence = _seg_number ? (_file_index > _seg_number ? _file_index - _seg_number : 0LL) : 0LL; void HlsMaker::startRecord(bool isRecord) {
//本来已经在录像，再次点击录像，或者本来已经停止录像，再次点击停止录像，直接返回
string m3u8; if (isRecord == _is_record) {
if (_seg_number == 0) { return;
// 录像点播支持时移 }
snprintf(file_content, sizeof(file_content),
"#EXTM3U\n" if(isRecord) {
"#EXT-X-PLAYLIST-TYPE:EVENT\n" _seg_keep = true;
"#EXT-X-VERSION:4\n" }else{
"#EXT-X-TARGETDURATION:%u\n" _seg_keep = false;
"#EXT-X-MEDIA-SEQUENCE:%llu\n", _is_close_stream = true;
(maxSegmentDuration + 999) / 1000, }
sequence); _is_record = isRecord;
} else { }
snprintf(file_content, sizeof(file_content),
"#EXTM3U\n"
"#EXT-X-VERSION:3\n" void HlsMaker::makeIndexFile(bool eof) {
"#EXT-X-ALLOW-CACHE:NO\n" char file_content[1024];
"#EXT-X-TARGETDURATION:%u\n" int maxSegmentDuration = 0;
"#EXT-X-MEDIA-SEQUENCE:%llu\n",
(maxSegmentDuration + 999) / 1000, for (auto &tp : _seg_dur_list) {
sequence); int dur = std::get<0>(tp);
} if (dur > maxSegmentDuration) {
maxSegmentDuration = dur;
m3u8.assign(file_content); }
}
for (auto &tp : _seg_dur_list) {
snprintf(file_content, sizeof(file_content), "#EXTINF:%.3f,\n%s\n", std::get<0>(tp) / 1000.0, std::get<1>(tp).data()); auto sequence = _seg_number ? (_file_index > _seg_number ? _file_index - _seg_number : 0LL) : 0LL;
m3u8.append(file_content);
} string m3u8;
if (_seg_number == 0) {
if (eof) { // 录像点播支持时移
snprintf(file_content, sizeof(file_content), "#EXT-X-ENDLIST\n"); snprintf(file_content, sizeof(file_content),
m3u8.append(file_content); "#EXTM3U\n"
} "#EXT-X-PLAYLIST-TYPE:EVENT\n"
onWriteHls(m3u8); "#EXT-X-VERSION:4\n"
} "#EXT-X-TARGETDURATION:%u\n"
"#EXT-X-MEDIA-SEQUENCE:%llu\n",
(maxSegmentDuration + 999) / 1000,
void HlsMaker::inputData(void *data, size_t len, uint64_t timestamp, bool is_idr_fast_packet) { sequence);
if (data && len) { } else {
if (timestamp < _last_timestamp) { snprintf(file_content, sizeof(file_content),
//时间戳回退了，切片时长重新计时 "#EXTM3U\n"
WarnL << "stamp reduce: " << _last_timestamp << " -> " << timestamp; "#EXT-X-VERSION:3\n"
_last_seg_timestamp = _last_timestamp = timestamp; "#EXT-X-ALLOW-CACHE:NO\n"
} "#EXT-X-TARGETDURATION:%u\n"
if (is_idr_fast_packet) { "#EXT-X-MEDIA-SEQUENCE:%llu\n",
//尝试切片ts (maxSegmentDuration + 999) / 1000,
addNewSegment(timestamp); sequence);
} }
if (!_last_file_name.empty()) {
//存在切片才写入ts数据 m3u8.assign(file_content);
onWriteSegment((char *) data, len);
_last_timestamp = timestamp; for (auto &tp : _seg_dur_list) {
} snprintf(file_content, sizeof(file_content), "#EXTINF:%.3f,\n%s\n", std::get<0>(tp) / 1000.0, std::get<1>(tp).data());
} else { m3u8.append(file_content);
//resetTracks时触发此逻辑 }
flushLastSegment(false);
} if (eof) {
} snprintf(file_content, sizeof(file_content), "#EXT-X-ENDLIST\n");
m3u8.append(file_content);
void HlsMaker::delOldSegment() { }
if (_seg_number == 0) { onWriteHls(m3u8);
//如果设置为保留0个切片，则认为是保存为点播 }
return;
}
//在hls m3u8索引文件中,我们保存的切片个数跟_seg_number相关设置一致 void HlsMaker::inputData(void *data, size_t len, uint64_t timestamp, bool is_idr_fast_packet) {
if (_file_index > _seg_number) { if (data && len) {
_seg_dur_list.pop_front(); if (timestamp < _last_timestamp) {
} //时间戳回退了，切片时长重新计时
//如果设置为一直保存，就不删除 WarnL << "stamp reduce: " << _last_timestamp << " -> " << timestamp;
if (_seg_keep) { _last_seg_timestamp = _last_timestamp = timestamp;
return; }
} if (is_idr_fast_packet) {
GET_CONFIG(uint32_t, segRetain, Hls::kSegmentRetain); //尝试切片ts
//但是实际保存的切片个数比m3u8所述多若干个,这样做的目的是防止播放器在切片删除前能下载完毕 addNewSegment(timestamp);
if (_file_index > _seg_number + segRetain) { }
onDelSegment(_file_index - _seg_number - segRetain - 1); if (!_last_file_name.empty()) {
} //存在切片才写入ts数据
} onWriteSegment((char *) data, len);
_last_timestamp = timestamp;
void HlsMaker::addNewSegment(uint64_t stamp) { }
if (!_last_file_name.empty() && stamp - _last_seg_timestamp < _seg_duration * 1000) { } else {
//存在上个切片，并且未到分片时间 //resetTracks时触发此逻辑
return; flushLastSegment(false);
} }
}
//关闭并保存上一个切片，如果_seg_number==0,那么是点播。
flushLastSegment(false); void HlsMaker::delOldSegment() {
//新增切片 if (_seg_number == 0) {
_last_file_name = onOpenSegment(_file_index++); //如果设置为保留0个切片，则认为是保存为点播
//记录本次切片的起始时间戳 return;
_last_seg_timestamp = _last_timestamp ? _last_timestamp : stamp; }
} //在hls m3u8索引文件中,我们保存的切片个数跟_seg_number相关设置一致
if (_file_index > _seg_number) {
void HlsMaker::flushLastSegment(bool eof){ _seg_dur_list.pop_front();
if (_last_file_name.empty()) { }
//不存在上个切片 //如果设置为一直保存，就不删除
return; if (_seg_keep) {
} return;
//文件创建到最后一次数据写入的时间即为切片长度 }
auto seg_dur = _last_timestamp - _last_seg_timestamp; GET_CONFIG(uint32_t, segRetain, Hls::kSegmentRetain);
if (seg_dur <= 0) { //但是实际保存的切片个数比m3u8所述多若干个,这样做的目的是防止播放器在切片删除前能下载完毕
seg_dur = 100; if (_file_index > _seg_number + segRetain) {
} onDelSegment(_file_index - _seg_number - segRetain - 1);
_seg_dur_list.emplace_back(seg_dur, std::move(_last_file_name)); }
delOldSegment(); }
//先flush ts切片，否则可能存在ts文件未写入完毕就被访问的情况
onFlushLastSegment(seg_dur); void HlsMaker::addNewSegment(uint64_t stamp) {
//然后写m3u8文件 if (!_last_file_name.empty() && stamp - _last_seg_timestamp < _seg_duration * 1000) {
makeIndexFile(eof); //存在上个切片，并且未到分片时间
} return;
}
bool HlsMaker::isLive() {
return _seg_number != 0; //关闭并保存上一个切片，如果_seg_number==0,那么是点播。
} flushLastSegment(false);
bool HlsMaker::isKeep() { //新增切片
return _seg_keep; _last_file_name = onOpenSegment(_file_index++);
} //记录本次切片的起始时间戳
_last_seg_timestamp = _last_timestamp ? _last_timestamp : stamp;
void HlsMaker::clear() {
_file_index = 0; }
_last_timestamp = 0;
_last_seg_timestamp = 0; void HlsMaker::flushLastSegment(bool eof) {
_seg_dur_list.clear(); if (_last_file_name.empty()) {
_last_file_name.clear(); //不存在上个切片
} return;
}
}//namespace mediakit //文件创建到最后一次数据写入的时间即为切片长度
auto seg_dur = _last_timestamp - _last_seg_timestamp;
if (seg_dur <= 0) {
seg_dur = 100;
}
_seg_dur_list.emplace_back(seg_dur, std::move(_last_file_name));
delOldSegment();
//先flush ts切片，否则可能存在ts文件未写入完毕就被访问的情况
onFlushLastSegment(seg_dur);
//然后写m3u8文件
makeIndexFile(eof);
//判断当前是否在录像，正在录像的话，生成录像的m3u8文件
if (_is_record) {
createM3u8FileForRecord();
}
}
bool HlsMaker::isLive() {
return _seg_number != 0;
}
bool HlsMaker::isKeep() {
return _seg_keep;
}
void HlsMaker::clear() {
_file_index = 0;
_last_timestamp = 0;
_last_seg_timestamp = 0;
_seg_dur_list.clear();
_last_file_name.clear();
}
std::string HlsMaker::getM3u8TSBody(const std::string &file_content) {
string new_file = file_content;
if (file_content.find("#EXT-X-ENDLIST") != file_content.npos) {
//找到了，则去掉"#EXT-X-ENDLIST"
new_file = file_content.substr(0, file_content.length() - 15);
}
string body = new_file.substr(new_file.find_last_of("#"));
//此时的body为
//#EXTINF:4.534,
//2022-09-14/08/2022-09-14_08-35-16.ts
string extinf = body.substr(0, body.find(",")+2);
string tsFile = body.substr(body.find_last_of("/") + 1);
body.append("#EXT-X-ENDLIST\n");
return extinf + tsFile + "#EXT-X-ENDLIST\n";
}
std::string HlsMaker::getTsFile(const std::string &file_content) {
// 最后一个TS的body为
// 2022-09-13/13/58-13_43.ts
// #EXT-X-ENDLIST
string body = file_content.substr(file_content.find_last_of(",") + 2);
string ts_file_name = body.substr(body.find_last_of("/") + 1);
if (ts_file_name.find("#EXT-X-ENDLIST") == ts_file_name.npos ) {
ts_file_name = ts_file_name.substr(0, ts_file_name.length() - 4); //没找到，去掉“.ts\n”，只留名字
} else {
ts_file_name = ts_file_name.substr(0, ts_file_name.length() - 19); //找到的话，去掉“.ts\n#EXT-X-ENDLIST\n”，只留名字
}
return ts_file_name;
}
void HlsMaker::createM3u8FileForRecord() {
// 1.读取直播目录下的m3u8文件，获取当前的ts文件以及时长，并生成m3u8文件的路径
string live_file = File::loadFile((getPathPrefix() + "/hls.m3u8").data());
if (live_file.empty()) {
return;
}
string body = getM3u8TSBody(live_file);
string ts_file_name = getTsFile(live_file); // ts_file: 2022-09-14_11-06-03
string m3u8_file = getPathPrefix() + "/" + ts_file_name.substr(0, 10) + "/" + ts_file_name.substr(11, 2) + "/";
// 2.判断该目录下有没有m3u8文件，没有的话，生成第一个m3u8文件，有的话，重命名
int handle = -1;
DIR *dir_info = opendir(m3u8_file.data());
struct dirent *dir_entry;
if (dir_info) {
while ((dir_entry =readdir(dir_info)) != NULL) {
if (end_with(dir_entry->d_name, ".m3u8")) {
handle = 0;
break;
}
}
closedir(dir_info);
} else {
return;
}
if (-1 == handle) {//第一次播放流
_m3u8_file_path = m3u8_file + ts_file_name + ".m3u8";
_is_close_stream = false;
} else {//断流过，一次以上播放
if (_is_close_stream) {
_m3u8_file_path = m3u8_file + ts_file_name + ".m3u8";
_is_close_stream = false;
}
if (_m3u8_file_path.length() == 0) { //服务重启后，进来，_m3u8_file_path为空
_m3u8_file_path = m3u8_file + ts_file_name + ".m3u8";
}
}
if (_m3u8_file_path.empty()) {
WarnL << "create m3u8 file failed, _m3u8_file_path is empty." ;
return;
}
//3.写m3u8文件
string m3u8Header = "#EXTM3U\n"
"#EXT-X-PLAYLIST-TYPE:EVENT\n"
"#EXT-X-VERSION:4\n"
"#EXT-X-TARGETDURATION:2\n"
"#EXT-X-MEDIA-SEQUENCE:0\n";
if (access(_m3u8_file_path.data(), 0) != 0) { //文件不存在
auto file = File::create_file(_m3u8_file_path.data(), "wb");
if (file) {
fwrite(m3u8Header.data(), m3u8Header.size(), 1, file);
fwrite(body.data(), body.size(), 1, file);
fclose(file);
}
} else {
// 第二次进来，去掉 "#EXT-X-ENDLIST\n"，再重新追加file_content，保存文件
auto file = File::create_file(_m3u8_file_path.data(), "r+");
if (file) {
fseek(file, -15, SEEK_END);
fwrite(body.data(), body.size(), 1, file);
fclose(file);
}
}
}
}//namespace mediakit

262
src/Record/HlsMaker.h
View File

@ -1,122 +1,140 @@
/* /*
* Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved. * Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved.
* *
* This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit). * This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit).
* *
* Use of this source code is governed by MIT license that can be found in the * Use of this source code is governed by MIT license that can be found in the
* LICENSE file in the root of the source tree. All contributing project authors * LICENSE file in the root of the source tree. All contributing project authors
* may be found in the AUTHORS file in the root of the source tree. * may be found in the AUTHORS file in the root of the source tree.
*/ */
#ifndef HLSMAKER_H #ifndef HLSMAKERSUB_H
#define HLSMAKER_H #define HLSMAKERSUB_H
#include <string> #include <deque>
#include <deque> #include <tuple>
#include <tuple> #include "Common/config.h"
#include "Util/TimeTicker.h"
namespace mediakit { #include "Util/File.h"
#include "Util/util.h"
class HlsMaker { #include "Util/logger.h"
public:
/** namespace mediakit {
* @param seg_duration 切片文件长度
* @param seg_number 切片个数 class HlsMaker {
* @param seg_keep 是否保留切片文件 public:
*/ /**
HlsMaker(float seg_duration = 5, uint32_t seg_number = 3, bool seg_keep = false); * @param seg_duration 切片文件长度
virtual ~HlsMaker(); * @param seg_number 切片个数
* @param seg_keep 是否保留切片文件
/** */
* 写入ts数据 HlsMaker(float seg_duration = 5, uint32_t seg_number = 3, bool seg_keep = false);
* @param data 数据 virtual ~HlsMaker();
* @param len 数据长度
* @param timestamp 毫秒时间戳 /**
* @param is_idr_fast_packet 是否为关键帧第一个包 * 写入ts数据
*/ * @param data 数据
void inputData(void *data, size_t len, uint64_t timestamp, bool is_idr_fast_packet); * @param len 数据长度
* @param timestamp 毫秒时间戳
/** * @param is_idr_fast_packet 是否为关键帧第一个包
* 是否为直播 */
*/ void inputData(void *data, size_t len, uint64_t timestamp, bool is_idr_fast_packet);
bool isLive();
/**
/** * 是否为直播
* 是否保留切片文件 */
*/ bool isLive();
bool isKeep();
/**
/** * 是否保留切片文件
* 清空记录 */
*/ bool isKeep();
void clear();
/**
protected: * 清空记录
/** */
* 创建ts切片文件回调 void clear();
* @param index //设置是否录像标志
* @return void startRecord(bool isRecord);
*/
virtual std::string onOpenSegment(uint64_t index) = 0; protected:
/**
/** * 创建ts切片文件回调
* 删除ts切片文件回调 * @param index
* @param index * @return
*/ */
virtual void onDelSegment(uint64_t index) = 0; virtual std::string onOpenSegment(uint64_t index) = 0;
/** /**
* 写ts切片文件回调 * 删除ts切片文件回调
* @param data * @param index
* @param len */
*/ virtual void onDelSegment(uint64_t index) = 0;
virtual void onWriteSegment(const char *data, size_t len) = 0;
/**
/** * 写ts切片文件回调
* 写m3u8文件回调 * @param data
*/ * @param len
virtual void onWriteHls(const std::string &data) = 0; */
virtual void onWriteSegment(const char *data, size_t len) = 0;
/**
* 上一个 ts 切片写入完成, 可在这里进行通知处理 /**
* @param duration_ms 上一个 ts 切片的时长, 单位为毫秒 * 写m3u8文件回调
*/ */
virtual void onFlushLastSegment(uint64_t duration_ms) {}; virtual void onWriteHls(const std::string &data) = 0;
/** /**
* 关闭上个ts切片并且写入m3u8索引 * 上一个 ts 切片写入完成, 可在这里进行通知处理
* @param eof HLS直播是否已结束 * @param duration_ms 上一个 ts 切片的时长, 单位为毫秒
*/ */
void flushLastSegment(bool eof); virtual void onFlushLastSegment(uint64_t duration_ms) {};
virtual std::string getPathPrefix() = 0;
private:
/** /**
* 生成m3u8文件 * 关闭上个ts切片并且写入m3u8索引
* @param eof true代表点播 * @param eof HLS直播是否已结束
*/ */
void makeIndexFile(bool eof = false); void flushLastSegment(bool eof);
/** private:
* 删除旧的ts切片 /**
*/ * 生成m3u8文件
void delOldSegment(); * @param eof true代表点播
*/
/** void makeIndexFile(bool eof = false);
* 添加新的ts切片
* @param timestamp /**
*/ * 删除旧的ts切片
void addNewSegment(uint64_t timestamp); */
void delOldSegment();
private:
float _seg_duration = 0; /**
uint32_t _seg_number = 0; * 添加新的ts切片
bool _seg_keep = false; * @param timestamp
uint64_t _last_timestamp = 0; */
uint64_t _last_seg_timestamp = 0; void addNewSegment(uint64_t timestamp);
uint64_t _file_index = 0;
std::string _last_file_name; //新增函数，实现录像功能
std::deque<std::tuple<int,std::string> > _seg_dur_list; std::string getTsFile(const std::string &file_content);
}; std::string getM3u8TSBody(const std::string &file_content);
void createM3u8FileForRecord();
}//namespace mediakit
#endif //HLSMAKER_H private:
float _seg_duration = 0;
uint32_t _seg_number = 0;
bool _seg_keep = false;
uint64_t _last_timestamp = 0;
uint64_t _last_seg_timestamp = 0;
uint64_t _file_index = 0;
std::string _last_file_name;
std::deque<std::tuple<int,std::string> > _seg_dur_list;
bool _is_record = false;
bool _is_close_stream = false;
std::string _m3u8_file_path;
public:
std::map<uint64_t /*index*/, std::string /*file_path*/> _segment_file_paths;
};
}//namespace mediakit
#endif //HLSMAKERSUB_H

339
src/Record/HlsMakerImp.cpp
View File

@ -1,171 +1,170 @@
/* /*
* Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved. * Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved.
* *
* This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit). * This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit).
* *
* Use of this source code is governed by MIT license that can be found in the * Use of this source code is governed by MIT license that can be found in the
* LICENSE file in the root of the source tree. All contributing project authors * LICENSE file in the root of the source tree. All contributing project authors
* may be found in the AUTHORS file in the root of the source tree. * may be found in the AUTHORS file in the root of the source tree.
*/ */
#include <ctime> #include <ctime>
#include <sys/stat.h> #include <sys/stat.h>
#include "HlsMakerImp.h" #include "HlsMakerImp.h"
#include "Util/util.h" #include "Util/util.h"
#include "Util/uv_errno.h" #include "Util/uv_errno.h"
#include "Util/File.h"
#include "Common/config.h" using namespace std;
using namespace toolkit;
using namespace std;
using namespace toolkit; namespace mediakit {
namespace mediakit { HlsMakerImp::HlsMakerImp(
const string &m3u8_file,
HlsMakerImp::HlsMakerImp(const string &m3u8_file, const string &params,
const string &params, uint32_t bufSize,
uint32_t bufSize, float seg_duration,
float seg_duration, uint32_t seg_number,
uint32_t seg_number, bool seg_keep):HlsMaker(seg_duration, seg_number, seg_keep) {
bool seg_keep):HlsMaker(seg_duration, seg_number, seg_keep) { _path_prefix = m3u8_file.substr(0, m3u8_file.rfind('/'));
_poller = EventPollerPool::Instance().getPoller(); _path_hls = m3u8_file;
_path_prefix = m3u8_file.substr(0, m3u8_file.rfind('/')); _params = params;
_path_hls = m3u8_file; _buf_size = bufSize;
_params = params; _file_buf.reset(new char[bufSize], [](char *ptr) {
_buf_size = bufSize; delete[] ptr;
_file_buf.reset(new char[bufSize], [](char *ptr) { });
delete[] ptr;
}); _info.folder = _path_prefix;
}
_info.folder = _path_prefix;
} HlsMakerImp::~HlsMakerImp() {
clearCache(false, true);
HlsMakerImp::~HlsMakerImp() { }
clearCache(false, true);
} void HlsMakerImp::clearCache() {
clearCache(true, false);
void HlsMakerImp::clearCache() { }
clearCache(true, false);
} void HlsMakerImp::clearCache(bool immediately, bool eof) {
//录制完了
void HlsMakerImp::clearCache(bool immediately, bool eof) { flushLastSegment(eof);
//录制完了 if (!isLive()||isKeep()) {
flushLastSegment(eof); return;
if (!isLive()||isKeep()) { }
return;
} clear();
_file = nullptr;
clear(); //删除_segment_file_paths路径对应的直播文件
_file = nullptr; for (auto it : _segment_file_paths) {
_segment_file_paths.clear(); auto ts_path = it.second;
File::delete_file(ts_path.data());
//hls直播才删除文件 }
GET_CONFIG(uint32_t, delay, Hls::kDeleteDelaySec); _segment_file_paths.clear();
if (!delay || immediately) {
File::delete_file(_path_prefix.data()); //删除缓存的m3u8文件
} else { File::delete_file((_path_prefix + "/hls.m3u8").data());
auto path_prefix = _path_prefix; }
_poller->doDelayTask(delay * 1000, [path_prefix]() {
File::delete_file(path_prefix.data()); string HlsMakerImp::onOpenSegment(uint64_t index) {
return 0; string segment_name, segment_path;
});
} auto strDate = getTimeStr("%Y-%m-%d");
} auto strHour = getTimeStr("%H");
auto strTime = getTimeStr("%M-%S");
string HlsMakerImp::onOpenSegment(uint64_t index) { segment_name = StrPrinter << strDate + "_" + strHour + "-" + strTime << ".ts";
string segment_name, segment_path; segment_path = _path_prefix + "/" + strDate + "/" + strHour + "/" + segment_name;
{ if ((!isKeep())) {
auto strDate = getTimeStr("%Y-%m-%d"); _segment_file_paths.emplace(index, segment_path);
auto strHour = getTimeStr("%H"); }
auto strTime = getTimeStr("%M-%S");
segment_name = StrPrinter << strDate + "/" + strHour + "/" + strTime << "_" << index << ".ts"; _file = makeFile(segment_path, true);
segment_path = _path_prefix + "/" + segment_name;
if (isLive()) { //保存本切片的元数据
_segment_file_paths.emplace(index, segment_path); _info.start_time = ::time(NULL);
} _info.file_name = segment_name;
} _info.file_path = segment_path;
_file = makeFile(segment_path, true); _info.url = _info.app + "/" + _info.stream + "/" + segment_name;
//保存本切片的元数据 if (!_file) {
_info.start_time = ::time(NULL); WarnL << "create file failed," << segment_path << " " << get_uv_errmsg();
_info.file_name = segment_name; return "";
_info.file_path = segment_path; }
_info.url = _info.app + "/" + _info.stream + "/" + segment_name; if (_params.empty()) {
return strDate + "/" + strHour + "/" + segment_name;
if (!_file) { }
WarnL << "create file failed," << segment_path << " " << get_uv_errmsg(); return strDate + "/" + strHour + "/" + segment_name + "?" + _params;
} }
if (_params.empty()) {
return segment_name; void HlsMakerImp::onDelSegment(uint64_t index) {
} auto it = _segment_file_paths.find(index);
return segment_name + "?" + _params; if (it == _segment_file_paths.end()) {
} return;
}
void HlsMakerImp::onDelSegment(uint64_t index) { File::delete_file(it->second.data());
auto it = _segment_file_paths.find(index); _segment_file_paths.erase(it);
if (it == _segment_file_paths.end()) { }
return;
} void HlsMakerImp::onWriteSegment(const char *data, size_t len) {
File::delete_file(it->second.data()); if (_file) {
_segment_file_paths.erase(it); fwrite(data, len, 1, _file.get());
} }
if (_media_src) {
void HlsMakerImp::onWriteSegment(const char *data, size_t len) { _media_src->onSegmentSize(len);
if (_file) { }
fwrite(data, len, 1, _file.get()); }
}
if (_media_src) { void HlsMakerImp::onWriteHls(const std::string &data) {
_media_src->onSegmentSize(len); auto hls = makeFile(_path_hls);
} if (hls) {
} fwrite(data.data(), data.size(), 1, hls.get());
hls.reset();
void HlsMakerImp::onWriteHls(const std::string &data) { if (_media_src) {
auto hls = makeFile(_path_hls); _media_src->setIndexFile(data);
if (hls) { }
fwrite(data.data(), data.size(), 1, hls.get()); } else {
hls.reset(); WarnL << "create hls file failed," << _path_hls << " " << get_uv_errmsg();
if (_media_src) { }
_media_src->setIndexFile(data); //DebugL << "\r\n" << string(data,len);
} }
} else {
WarnL << "create hls file failed," << _path_hls << " " << get_uv_errmsg(); void HlsMakerImp::onFlushLastSegment(uint64_t duration_ms) {
} //关闭并flush文件到磁盘
//DebugL << "\r\n" << string(data,len); _file = nullptr;
}
GET_CONFIG(bool, broadcastRecordTs, Hls::kBroadcastRecordTs);
void HlsMakerImp::onFlushLastSegment(uint64_t duration_ms) { if (broadcastRecordTs) {
//关闭并flush文件到磁盘 _info.time_len = duration_ms / 1000.0f;
_file = nullptr; _info.file_size = File::fileSize(_info.file_path.data());
NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastRecordTs, _info);
GET_CONFIG(bool, broadcastRecordTs, Hls::kBroadcastRecordTs); }
if (broadcastRecordTs) { }
_info.time_len = duration_ms / 1000.0f;
_info.file_size = File::fileSize(_info.file_path.data()); std::shared_ptr<FILE> HlsMakerImp::makeFile(const string &file, bool setbuf) {
NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastRecordTs, _info); auto file_buf = _file_buf;
} auto ret = shared_ptr<FILE>(File::create_file(file.data(), "wb"), [file_buf](FILE *fp) {
} if (fp) {
fclose(fp);
std::shared_ptr<FILE> HlsMakerImp::makeFile(const string &file, bool setbuf) { }
auto file_buf = _file_buf; });
auto ret = shared_ptr<FILE>(File::create_file(file.data(), "wb"), [file_buf](FILE *fp) { if (ret && setbuf) {
if (fp) { setvbuf(ret.get(), _file_buf.get(), _IOFBF, _buf_size);
fclose(fp); }
} return ret;
}); }
if (ret && setbuf) {
setvbuf(ret.get(), _file_buf.get(), _IOFBF, _buf_size); void HlsMakerImp::setMediaSource(const string &vhost, const string &app, const string &stream_id) {
} _media_src = std::make_shared<HlsMediaSource>(vhost, app, stream_id);
return ret; _info.app = app;
} _info.stream = stream_id;
_info.vhost = vhost;
void HlsMakerImp::setMediaSource(const string &vhost, const string &app, const string &stream_id) { }
_media_src = std::make_shared<HlsMediaSource>(vhost, app, stream_id);
_info.app = app; HlsMediaSource::Ptr HlsMakerImp::getMediaSource() const {
_info.stream = stream_id; return _media_src;
_info.vhost = vhost; }
}
std::string HlsMakerImp::getPathPrefix() {
HlsMediaSource::Ptr HlsMakerImp::getMediaSource() const { return _path_prefix;
return _media_src; }
}
}//namespace mediakit }//namespace mediakit

155
src/Record/HlsMakerImp.h
View File

@ -1,77 +1,78 @@
/* /*
* Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved. * Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved.
* *
* This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit). * This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit).
* *
* Use of this source code is governed by MIT license that can be found in the * Use of this source code is governed by MIT license that can be found in the
* LICENSE file in the root of the source tree. All contributing project authors * LICENSE file in the root of the source tree. All contributing project authors
* may be found in the AUTHORS file in the root of the source tree. * may be found in the AUTHORS file in the root of the source tree.
*/ */
#ifndef HLSMAKERIMP_H #ifndef HLSMAKERIMPSUB_H
#define HLSMAKERIMP_H #define HLSMAKERIMPSUB_H
#include <memory> #include <memory>
#include <string> #include <string>
#include <stdlib.h> #include <stdlib.h>
#include "HlsMaker.h" #include "HlsMaker.h"
#include "HlsMediaSource.h" #include "HlsMediaSource.h"
namespace mediakit { namespace mediakit {
class HlsMakerImp : public HlsMaker{ class HlsMakerImp : public HlsMaker{
public: public:
HlsMakerImp(const std::string &m3u8_file, HlsMakerImp(
const std::string &params, const std::string &m3u8_file,
uint32_t bufSize = 64 * 1024, const std::string &params,
float seg_duration = 5, uint32_t bufSize = 64 * 1024,
uint32_t seg_number = 3, float seg_duration = 5,
bool seg_keep = false); uint32_t seg_number = 3,
bool seg_keep = false);
~HlsMakerImp() override;
~HlsMakerImp() override;
/**
* 设置媒体信息 /**
* @param vhost 虚拟主机 * 设置媒体信息
* @param app 应用名 * @param vhost 虚拟主机
* @param stream_id 流id * @param app 应用名
*/ * @param stream_id 流id
void setMediaSource(const std::string &vhost, const std::string &app, const std::string &stream_id); */
void setMediaSource(const std::string &vhost, const std::string &app, const std::string &stream_id);
/**
* 获取MediaSource /**
* @return * 获取MediaSource
*/ * @return
HlsMediaSource::Ptr getMediaSource() const; */
HlsMediaSource::Ptr getMediaSource() const;
/**
* 清空缓存 /**
*/ * 清空缓存
void clearCache(); */
void clearCache();
protected:
std::string onOpenSegment(uint64_t index) override ; protected:
void onDelSegment(uint64_t index) override; std::string onOpenSegment(uint64_t index) override ;
void onWriteSegment(const char *data, size_t len) override; void onDelSegment(uint64_t index) override;
void onWriteHls(const std::string &data) override; void onWriteSegment(const char *data, size_t len) override;
void onFlushLastSegment(uint64_t duration_ms) override; void onWriteHls(const std::string &data) override;
void onFlushLastSegment(uint64_t duration_ms) override;
private: std::string getPathPrefix() override;
std::shared_ptr<FILE> makeFile(const std::string &file,bool setbuf = false);
void clearCache(bool immediately, bool eof); private:
std::shared_ptr<FILE> makeFile(const std::string &file,bool setbuf = false);
private: void clearCache(bool immediately, bool eof);
int _buf_size;
std::string _params; private:
std::string _path_hls; int _buf_size;
std::string _path_prefix; std::string _params;
RecordInfo _info; std::string _path_hls;
std::shared_ptr<FILE> _file; std::string _path_prefix;
std::shared_ptr<char> _file_buf; RecordInfo _info;
HlsMediaSource::Ptr _media_src; std::shared_ptr<FILE> _file;
toolkit::EventPoller::Ptr _poller; std::shared_ptr<char> _file_buf;
std::map<uint64_t/*index*/,std::string/*file_path*/> _segment_file_paths; HlsMediaSource::Ptr _media_src;
};
};
}//namespace mediakit
#endif //HLSMAKERIMP_H }//namespace mediakit
#endif //HLSMAKERIMPSUB_H

10
src/Record/HlsRecorder.h
View File

@ -1,4 +1,4 @@
/* /*
* Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved. * Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved.
* *
* This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit). * This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit).
@ -26,7 +26,6 @@ public:
GET_CONFIG(bool, hlsKeep, Hls::kSegmentKeep); GET_CONFIG(bool, hlsKeep, Hls::kSegmentKeep);
GET_CONFIG(uint32_t, hlsBufSize, Hls::kFileBufSize); GET_CONFIG(uint32_t, hlsBufSize, Hls::kFileBufSize);
GET_CONFIG(float, hlsDuration, Hls::kSegmentDuration); GET_CONFIG(float, hlsDuration, Hls::kSegmentDuration);
_option = option; _option = option;
_hls = std::make_shared<HlsMakerImp>(m3u8_file, params, hlsBufSize, hlsDuration, hlsNum, hlsKeep); _hls = std::make_shared<HlsMakerImp>(m3u8_file, params, hlsBufSize, hlsDuration, hlsNum, hlsKeep);
//清空上次的残余文件 //清空上次的残余文件
@ -73,6 +72,12 @@ public:
//缓存尚未清空时，还允许触发inputFrame函数，以便及时清空缓存 //缓存尚未清空时，还允许触发inputFrame函数，以便及时清空缓存
return _option.hls_demand ? (_clear_cache ? true : _enabled) : true; return _option.hls_demand ? (_clear_cache ? true : _enabled) : true;
} }
void startRecord(bool flag) {
_hls->startRecord(flag);
_is_record = flag;
}
bool getRecordFlag() { return _is_record; }
private: private:
void onWrite(std::shared_ptr<toolkit::Buffer> buffer, uint64_t timestamp, bool key_pos) override { void onWrite(std::shared_ptr<toolkit::Buffer> buffer, uint64_t timestamp, bool key_pos) override {
@ -88,6 +93,7 @@ private:
bool _clear_cache = false; bool _clear_cache = false;
ProtocolOption _option; ProtocolOption _option;
std::shared_ptr<HlsMakerImp> _hls; std::shared_ptr<HlsMakerImp> _hls;
bool _is_record = false;
}; };
}//namespace mediakit }//namespace mediakit
#endif //HLSRECORDER_H #endif //HLSRECORDER_H

10
src/Record/MP4Recorder.cpp
View File

@ -1,4 +1,4 @@
/* /*
* Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved. * Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved.
* *
* This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit). * This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit).
@ -39,7 +39,7 @@ MP4Recorder::~MP4Recorder() {
} }
void MP4Recorder::createFile() { void MP4Recorder::createFile() {
closeFile(); //closeFile();
auto date = getTimeStr("%Y-%m-%d"); auto date = getTimeStr("%Y-%m-%d");
auto time = getTimeStr("%H-%M-%S"); auto time = getTimeStr("%H-%M-%S");
auto full_path_tmp = _folder_path + date + "/." + time + ".mp4"; auto full_path_tmp = _folder_path + date + "/." + time + ".mp4";
@ -93,7 +93,7 @@ void MP4Recorder::asyncClose() {
void MP4Recorder::closeFile() { void MP4Recorder::closeFile() {
if (_muxer) { if (_muxer) {
asyncClose(); //asyncClose();
_muxer = nullptr; _muxer = nullptr;
} }
} }
@ -119,7 +119,7 @@ bool MP4Recorder::inputFrame(const Frame::Ptr &frame) {
// 2、到了切片时间，并且只有音频 // 2、到了切片时间，并且只有音频
// 3、到了切片时间，有视频并且遇到视频的关键帧 // 3、到了切片时间，有视频并且遇到视频的关键帧
_last_dts = 0; _last_dts = 0;
createFile(); //createFile();
} }
} }
@ -140,7 +140,7 @@ bool MP4Recorder::addTrack(const Track::Ptr &track) {
} }
void MP4Recorder::resetTracks() { void MP4Recorder::resetTracks() {
closeFile(); //closeFile();
_tracks.clear(); _tracks.clear();
_have_video = false; _have_video = false;
} }