Mirror/ZLMediaKit
1
0
Fork 0
mirror of https://github.com/ZLMediaKit/ZLMediaKit.git synced 2026-06-27 04:22:20 +08:00
Code Issues Packages Projects Releases Wiki Activity

整理命名空间 (#1409)

Browse Source 
* feat: remove using namespace mediakit in header files.

(cherry picked from commit d44aeb339a8a0e1f0455be82b21fe4b1b536299f)

* feat: remove using namespace mediakit in FFmpegSource.h

* feat: remove using namespace mediakit in RtpExt.h

* feat: remove using namespace mediakit in header files.

* feat: remove using namespace std in header files.

* feat: remove using namespace std in header files when zltoolkit remove std in header

* 补充命名空间

* 整理命名空间

* 整理命名空间2

* 修复macos ci

* 修复编译问题

* 修复编译问题2

* 修复编译问题3

Co-authored-by: Johnny <hellojinqiang@gmail.com>
Co-authored-by: Xiaofeng Wang <wasphin@gmail.com>
This commit is contained in:
夏楚
2022-02-02 20:34:50 +08:00
committed by GitHub
parent 80a0e27d8c
commit c72cf4cbcc
239 changed files with 1887 additions and 1766 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/Common/Device.cpp
View File

@@ -24,6 +24,7 @@
#include "Codec/H264Encoder.h"
#endif //ENABLE_X264
using namespace toolkit;
using namespace std;
namespace mediakit {

6
src/Common/Device.h
View File

@@ -17,8 +17,6 @@
#include "Util/util.h"
#include "Util/TimeTicker.h"
#include "Common/MultiMediaSourceMuxer.h"
using namespace std;
using namespace toolkit;
namespace mediakit {
@@ -48,7 +46,7 @@ class DevChannel : public MultiMediaSourceMuxer{
public:
typedef std::shared_ptr<DevChannel> Ptr;
//fDuration<=0为直播，否则为点播
DevChannel(const string &vhost, const string &app, const string &stream_id,
DevChannel(const std::string &vhost, const std::string &app, const std::string &stream_id,
float duration = 0, bool enable_hls = true, bool enable_mp4 = false);
~DevChannel() override ;
@@ -126,7 +124,7 @@ private:
std::shared_ptr<AACEncoder> _pAacEnc;
std::shared_ptr<VideoInfo> _video;
std::shared_ptr<AudioInfo> _audio;
SmoothTicker _aTicker[2];
toolkit::SmoothTicker _aTicker[2];
};
} /* namespace mediakit */

2
src/Common/MediaSink.cpp
View File

@@ -11,6 +11,8 @@
#include "MediaSink.h"
#include "Extension/AAC.h"
using namespace std;
namespace mediakit{
bool MediaSink::addTrack(const Track::Ptr &track_in) {

13
src/Common/MediaSink.h
View File

@@ -17,9 +17,6 @@
#include "Extension/Frame.h"
#include "Extension/Track.h"
using namespace std;
using namespace toolkit;
namespace mediakit{
class TrackListener {
@@ -106,7 +103,7 @@ public:
* 获取所有Track
* @param trackReady 是否获取已经准备好的Track
*/
vector<Track::Ptr> getTracks(bool trackReady = true) const override;
std::vector<Track::Ptr> getTracks(bool trackReady = true) const override;
/**
* 返回是否所有track已经准备完成
@@ -154,10 +151,10 @@ private:
private:
bool _all_track_ready = false;
size_t _max_track_size = 2;
unordered_map<int, pair<Track::Ptr, bool/*got frame*/> > _track_map;
unordered_map<int, List<Frame::Ptr> > _frame_unread;
unordered_map<int, function<void()> > _track_ready_callback;
Ticker _ticker;
std::unordered_map<int, std::pair<Track::Ptr, bool/*got frame*/> > _track_map;
std::unordered_map<int, toolkit::List<Frame::Ptr> > _frame_unread;
std::unordered_map<int, std::function<void()> > _track_ready_callback;
toolkit::Ticker _ticker;
MuteAudioMaker::Ptr _mute_audio_maker;
};

2
src/Common/MediaSource.cpp
View File

@@ -13,6 +13,8 @@
#include "Util/util.h"
#include "Network/sockutil.h"
#include "Network/TcpSession.h"
using namespace std;
using namespace toolkit;
namespace toolkit {

111
src/Common/MediaSource.h
View File

@@ -29,9 +29,6 @@
#include "Extension/Track.h"
#include "Record/Recorder.h"
using namespace std;
using namespace toolkit;
namespace toolkit{
class Session;
}// namespace toolkit
@@ -50,7 +47,7 @@ enum class MediaOriginType : uint8_t {
rtc_push,
};
string getOriginTypeString(MediaOriginType type);
std::string getOriginTypeString(MediaOriginType type);
class MediaSource;
class MediaSourceEvent{
@@ -62,9 +59,9 @@ public:
// 获取媒体源类型
virtual MediaOriginType getOriginType(MediaSource &sender) const { return MediaOriginType::unknown; }
// 获取媒体源url或者文件路径
virtual string getOriginUrl(MediaSource &sender) const;
virtual std::string getOriginUrl(MediaSource &sender) const;
// 获取媒体源客户端相关信息
virtual std::shared_ptr<SockInfo> getOriginSock(MediaSource &sender) const { return nullptr; }
virtual std::shared_ptr<toolkit::SockInfo> getOriginSock(MediaSource &sender) const { return nullptr; }
// 通知拖动进度条
virtual bool seekTo(MediaSource &sender, uint32_t stamp) { return false; }
@@ -83,18 +80,18 @@ public:
////////////////////////仅供MultiMediaSourceMuxer对象继承////////////////////////
// 开启或关闭录制
virtual bool setupRecord(MediaSource &sender, Recorder::type type, bool start, const string &custom_path, size_t max_second) { return false; };
virtual bool setupRecord(MediaSource &sender, Recorder::type type, bool start, const std::string &custom_path, size_t max_second) { return false; };
// 获取录制状态
virtual bool isRecording(MediaSource &sender, Recorder::type type) { return false; };
// 获取所有track相关信息
virtual vector<Track::Ptr> getMediaTracks(MediaSource &sender, bool trackReady = true) const { return vector<Track::Ptr>(); };
virtual std::vector<Track::Ptr> getMediaTracks(MediaSource &sender, bool trackReady = true) const { return std::vector<Track::Ptr>(); };
// 开始发送ps-rtp
virtual void startSendRtp(MediaSource &sender, const string &dst_url, uint16_t dst_port, const string &ssrc, bool is_udp, uint16_t src_port, const function<void(uint16_t local_port, const SockException &ex)> &cb) { cb(0, SockException(Err_other, "not implemented"));};
virtual void startSendRtp(MediaSource &sender, const std::string &dst_url, uint16_t dst_port, const std::string &ssrc, bool is_udp, uint16_t src_port, const std::function<void(uint16_t local_port, const toolkit::SockException &ex)> &cb) { cb(0, toolkit::SockException(toolkit::Err_other, "not implemented"));};
// 停止发送ps-rtp
virtual bool stopSendRtp(MediaSource &sender, const string &ssrc) {return false; }
virtual bool stopSendRtp(MediaSource &sender, const std::string &ssrc) {return false; }
private:
Timer::Ptr _async_close_timer;
toolkit::Timer::Ptr _async_close_timer;
};
//该对象用于拦截感兴趣的MediaSourceEvent事件
@@ -107,8 +104,8 @@ public:
std::shared_ptr<MediaSourceEvent> getDelegate() const;
MediaOriginType getOriginType(MediaSource &sender) const override;
string getOriginUrl(MediaSource &sender) const override;
std::shared_ptr<SockInfo> getOriginSock(MediaSource &sender) const override;
std::string getOriginUrl(MediaSource &sender) const override;
std::shared_ptr<toolkit::SockInfo> getOriginSock(MediaSource &sender) const override;
bool seekTo(MediaSource &sender, uint32_t stamp) override;
bool pause(MediaSource &sender, bool pause) override;
@@ -117,11 +114,11 @@ public:
int totalReaderCount(MediaSource &sender) override;
void onReaderChanged(MediaSource &sender, int size) override;
void onRegist(MediaSource &sender, bool regist) override;
bool setupRecord(MediaSource &sender, Recorder::type type, bool start, const string &custom_path, size_t max_second) override;
bool setupRecord(MediaSource &sender, Recorder::type type, bool start, const std::string &custom_path, size_t max_second) override;
bool isRecording(MediaSource &sender, Recorder::type type) override;
vector<Track::Ptr> getMediaTracks(MediaSource &sender, bool trackReady = true) const override;
void startSendRtp(MediaSource &sender, const string &dst_url, uint16_t dst_port, const string &ssrc, bool is_udp, uint16_t src_port, const function<void(uint16_t local_port, const SockException &ex)> &cb) override;
bool stopSendRtp(MediaSource &sender, const string &ssrc) override;
std::vector<Track::Ptr> getMediaTracks(MediaSource &sender, bool trackReady = true) const override;
void startSendRtp(MediaSource &sender, const std::string &dst_url, uint16_t dst_port, const std::string &ssrc, bool is_udp, uint16_t src_port, const std::function<void(uint16_t local_port, const toolkit::SockException &ex)> &cb) override;
bool stopSendRtp(MediaSource &sender, const std::string &ssrc) override;
private:
std::weak_ptr<MediaSourceEvent> _listener;
@@ -134,18 +131,18 @@ class MediaInfo{
public:
~MediaInfo() {}
MediaInfo() {}
MediaInfo(const string &url) { parse(url); }
void parse(const string &url);
MediaInfo(const std::string &url) { parse(url); }
void parse(const std::string &url);
public:
string _full_url;
string _schema;
string _host;
string _port;
string _vhost;
string _app;
string _streamid;
string _param_strs;
std::string _full_url;
std::string _schema;
std::string _host;
std::string _port;
std::string _vhost;
std::string _app;
std::string _streamid;
std::string _param_strs;
};
class BytesSpeed {
@@ -191,40 +188,40 @@ private:
private:
int _speed = 0;
size_t _bytes = 0;
Ticker _ticker;
toolkit::Ticker _ticker;
};
/**
* 媒体源，任何rtsp/rtmp的直播流都源自该对象
*/
class MediaSource: public TrackSource, public enable_shared_from_this<MediaSource> {
class MediaSource: public TrackSource, public std::enable_shared_from_this<MediaSource> {
public:
static MediaSource * const NullMediaSource;
using Ptr = std::shared_ptr<MediaSource>;
using StreamMap = unordered_map<string/*strema_id*/, weak_ptr<MediaSource> >;
using AppStreamMap = unordered_map<string/*app*/, StreamMap>;
using VhostAppStreamMap = unordered_map<string/*vhost*/, AppStreamMap>;
using SchemaVhostAppStreamMap = unordered_map<string/*schema*/, VhostAppStreamMap>;
using StreamMap = std::unordered_map<std::string/*strema_id*/, std::weak_ptr<MediaSource> >;
using AppStreamMap = std::unordered_map<std::string/*app*/, StreamMap>;
using VhostAppStreamMap = std::unordered_map<std::string/*vhost*/, AppStreamMap>;
using SchemaVhostAppStreamMap = std::unordered_map<std::string/*schema*/, VhostAppStreamMap>;
MediaSource(const string &schema, const string &vhost, const string &app, const string &stream_id) ;
MediaSource(const std::string &schema, const std::string &vhost, const std::string &app, const std::string &stream_id) ;
virtual ~MediaSource();
////////////////获取MediaSource相关信息////////////////
// 获取协议类型
const string& getSchema() const;
const std::string& getSchema() const;
// 虚拟主机
const string& getVhost() const;
const std::string& getVhost() const;
// 应用名
const string& getApp() const;
const std::string& getApp() const;
// 流id
const string& getId() const;
const std::string& getId() const;
//获取对象所有权
std::shared_ptr<void> getOwnership();
// 获取所有Track
vector<Track::Ptr> getTracks(bool ready = true) const override;
std::vector<Track::Ptr> getTracks(bool ready = true) const override;
// 获取流当前时间戳
virtual uint32_t getTimeStamp(TrackType type) { return 0; };
@@ -253,9 +250,9 @@ public:
// 获取媒体源类型
MediaOriginType getOriginType() const;
// 获取媒体源url或者文件路径
string getOriginUrl() const;
std::string getOriginUrl() const;
// 获取媒体源客户端相关信息
std::shared_ptr<SockInfo> getOriginSock() const;
std::shared_ptr<toolkit::SockInfo> getOriginSock() const;
// 拖动进度条
bool seekTo(uint32_t stamp);
@@ -268,28 +265,28 @@ public:
// 该流观看人数变化
void onReaderChanged(int size);
// 开启或关闭录制
bool setupRecord(Recorder::type type, bool start, const string &custom_path, size_t max_second);
bool setupRecord(Recorder::type type, bool start, const std::string &custom_path, size_t max_second);
// 获取录制状态
bool isRecording(Recorder::type type);
// 开始发送ps-rtp
void startSendRtp(const string &dst_url, uint16_t dst_port, const string &ssrc, bool is_udp, uint16_t src_port, const function<void(uint16_t local_port, const SockException &ex)> &cb);
void startSendRtp(const std::string &dst_url, uint16_t dst_port, const std::string &ssrc, bool is_udp, uint16_t src_port, const std::function<void(uint16_t local_port, const toolkit::SockException &ex)> &cb);
// 停止发送ps-rtp
bool stopSendRtp(const string &ssrc);
bool stopSendRtp(const std::string &ssrc);
////////////////static方法，查找或生成MediaSource////////////////
// 同步查找流
static Ptr find(const string &schema, const string &vhost, const string &app, const string &id, bool from_mp4 = false);
static Ptr find(const std::string &schema, const std::string &vhost, const std::string &app, const std::string &id, bool from_mp4 = false);
// 忽略类型，同步查找流，可能返回rtmp/rtsp/hls类型
static Ptr find(const string &vhost, const string &app, const string &stream_id, bool from_mp4 = false);
static Ptr find(const std::string &vhost, const std::string &app, const std::string &stream_id, bool from_mp4 = false);
// 异步查找流
static void findAsync(const MediaInfo &info, const std::shared_ptr<Session> &session, const function<void(const Ptr &src)> &cb);
static void findAsync(const MediaInfo &info, const std::shared_ptr<toolkit::Session> &session, const std::function<void(const Ptr &src)> &cb);
// 遍历所有流
static void for_each_media(const function<void(const Ptr &src)> &cb, const string &schema = "", const string &vhost = "", const string &app = "", const string &stream = "");
static void for_each_media(const std::function<void(const Ptr &src)> &cb, const std::string &schema = "", const std::string &vhost = "", const std::string &app = "", const std::string &stream = "");
// 从mp4文件生成MediaSource
static MediaSource::Ptr createFromMP4(const string &schema, const string &vhost, const string &app, const string &stream, const string &file_path = "", bool check_app = true);
static MediaSource::Ptr createFromMP4(const std::string &schema, const std::string &vhost, const std::string &app, const std::string &stream, const std::string &file_path = "", bool check_app = true);
protected:
//媒体注册
@@ -305,16 +302,16 @@ protected:
BytesSpeed _speed[TrackMax];
private:
atomic_flag _owned { false };
std::atomic_flag _owned { false };
time_t _create_stamp;
Ticker _ticker;
string _schema;
string _vhost;
string _app;
string _stream_id;
toolkit::Ticker _ticker;
std::string _schema;
std::string _vhost;
std::string _app;
std::string _stream_id;
std::weak_ptr<MediaSourceEvent> _listener;
//对象个数统计
ObjectStatistic<MediaSource> _statistic;
toolkit::ObjectStatistic<MediaSource> _statistic;
};
///缓存刷新策略类
@@ -333,7 +330,7 @@ private:
/// \tparam packet 包类型
/// \tparam policy 刷新缓存策略
/// \tparam packet_list 包缓存类型
template<typename packet, typename policy = FlushPolicy, typename packet_list = List<std::shared_ptr<packet> > >
template<typename packet, typename policy = FlushPolicy, typename packet_list = toolkit::List<std::shared_ptr<packet> > >
class PacketCache {
public:
PacketCache(){

3
src/Common/MultiMediaSourceMuxer.cpp
View File

@@ -12,6 +12,9 @@
#include "Common/config.h"
#include "MultiMediaSourceMuxer.h"
using namespace std;
using namespace toolkit;
namespace toolkit {
StatisticImp(mediakit::MultiMediaSourceMuxer);
}

20
src/Common/MultiMediaSourceMuxer.h
View File

@@ -35,7 +35,7 @@ public:
};
~MultiMediaSourceMuxer() override = default;
MultiMediaSourceMuxer(const string &vhost, const string &app, const string &stream, float dur_sec = 0.0,
MultiMediaSourceMuxer(const std::string &vhost, const std::string &app, const std::string &stream, float dur_sec = 0.0,
bool enable_rtsp = true, bool enable_rtmp = true, bool enable_hls = true, bool enable_mp4 = false);
/**
@@ -87,7 +87,7 @@ public:
* @param custom_path 开启录制时，指定自定义路径
* @return 是否设置成功
*/
bool setupRecord(MediaSource &sender, Recorder::type type, bool start, const string &custom_path, size_t max_second) override;
bool setupRecord(MediaSource &sender, Recorder::type type, bool start, const std::string &custom_path, size_t max_second) override;
/**
* 获取录制状态
@@ -104,20 +104,20 @@ public:
* @param is_udp 是否为udp
* @param cb 启动成功或失败回调
*/
void startSendRtp(MediaSource &sender, const string &dst_url, uint16_t dst_port, const string &ssrc, bool is_udp, uint16_t src_port, const function<void(uint16_t local_port, const SockException &ex)> &cb) override;
void startSendRtp(MediaSource &sender, const std::string &dst_url, uint16_t dst_port, const std::string &ssrc, bool is_udp, uint16_t src_port, const std::function<void(uint16_t local_port, const toolkit::SockException &ex)> &cb) override;
/**
* 停止ps-rtp发送
* @return 是否成功
*/
bool stopSendRtp(MediaSource &sender, const string &ssrc) override;
bool stopSendRtp(MediaSource &sender, const std::string &ssrc) override;
/**
* 获取所有Track
* @param trackReady 是否筛选过滤未就绪的track
* @return 所有Track
*/
vector<Track::Ptr> getMediaTracks(MediaSource &sender, bool trackReady = true) const override;
std::vector<Track::Ptr> getMediaTracks(MediaSource &sender, bool trackReady = true) const override;
protected:
/////////////////////////////////MediaSink override/////////////////////////////////
@@ -142,13 +142,13 @@ protected:
private:
bool _is_enable = false;
Ticker _last_check;
toolkit::Ticker _last_check;
Stamp _stamp[2];
std::weak_ptr<Listener> _track_listener;
function<string()> _get_origin_url;
std::function<std::string()> _get_origin_url;
#if defined(ENABLE_RTPPROXY)
mutex _rtp_sender_mtx;
unordered_map<string, RtpSender::Ptr> _rtp_sender;
std::mutex _rtp_sender_mtx;
std::unordered_map<std::string, RtpSender::Ptr> _rtp_sender;
#endif //ENABLE_RTPPROXY
#if defined(ENABLE_MP4)
@@ -161,7 +161,7 @@ private:
HlsRecorder::Ptr _hls;
//对象个数统计
ObjectStatistic<MultiMediaSourceMuxer> _statistic;
toolkit::ObjectStatistic<MultiMediaSourceMuxer> _statistic;
};
}//namespace mediakit

3
src/Common/Parser.cpp
View File

@@ -10,6 +10,9 @@
#include "Parser.h"
using namespace std;
using namespace toolkit;
namespace mediakit{
string FindField(const char* buf, const char* start, const char *end ,size_t bufSize) {

49
src/Common/Parser.h
View File

@@ -15,26 +15,23 @@
#include <string>
#include "Util/util.h"
using namespace std;
using namespace toolkit;
namespace mediakit {
string FindField(const char *buf, const char *start, const char *end, size_t bufSize = 0);
std::string FindField(const char *buf, const char *start, const char *end, size_t bufSize = 0);
struct StrCaseCompare {
bool operator()(const string &__x, const string &__y) const {
bool operator()(const std::string &__x, const std::string &__y) const {
return strcasecmp(__x.data(), __y.data()) < 0;
}
};
class StrCaseMap : public multimap<string, string, StrCaseCompare> {
class StrCaseMap : public std::multimap<std::string, std::string, StrCaseCompare> {
public:
using Super = multimap<string, string, StrCaseCompare>;
using Super = multimap<std::string, std::string, StrCaseCompare>;
StrCaseMap() = default;
~StrCaseMap() = default;
string &operator[](const string &k) {
std::string &operator[](const std::string &k) {
auto it = find(k);
if (it == end()) {
it = Super::emplace(k, "");
@@ -43,7 +40,7 @@ public:
}
template<typename V>
void emplace(const string &k, V &&v) {
void emplace(const std::string &k, V &&v) {
auto it = find(k);
if (it != end()) {
return;
@@ -52,7 +49,7 @@ public:
}
template<typename V>
void emplace_force(const string k, V &&v) {
void emplace_force(const std::string k, V &&v) {
Super::emplace(k, std::forward<V>(v));
}
};
@@ -67,34 +64,34 @@ public:
void Parse(const char *buf);
//获取命令字
const string &Method() const;
const std::string &Method() const;
//获取中间url，不包含?后面的参数
const string &Url() const;
const std::string &Url() const;
//获取中间url，包含?后面的参数
string FullUrl() const;
std::string FullUrl() const;
//获取命令协议名
const string &Tail() const;
const std::string &Tail() const;
//根据header key名，获取请求header value值
const string &operator[](const char *name) const;
const std::string &operator[](const char *name) const;
//获取http body或sdp
const string &Content() const;
const std::string &Content() const;
//清空，为了重用
void Clear();
//获取?后面的参数
const string &Params() const;
const std::string &Params() const;
//重新设置url
void setUrl(string url);
void setUrl(std::string url);
//重新设置content
void setContent(string content);
void setContent(std::string content);
//获取header列表
StrCaseMap &getHeader() const;
@@ -103,15 +100,15 @@ public:
StrCaseMap &getUrlArgs() const;
//解析?后面的参数
static StrCaseMap parseArgs(const string &str, const char *pair_delim = "&", const char *key_delim = "=");
static StrCaseMap parseArgs(const std::string &str, const char *pair_delim = "&", const char *key_delim = "=");
private:
string _strMethod;
string _strUrl;
string _strTail;
string _strContent;
string _strNull;
string _params;
std::string _strMethod;
std::string _strUrl;
std::string _strTail;
std::string _strContent;
std::string _strNull;
std::string _params;
mutable StrCaseMap _mapHeaders;
mutable StrCaseMap _mapUrlArgs;
};

2
src/Common/Stamp.cpp
View File

@@ -16,6 +16,8 @@
#define MAX_CTS 500
#define ABS(x) ((x) > 0 ? (x) : (-x))
using namespace toolkit;
namespace mediakit {
int64_t DeltaStamp::deltaStamp(int64_t stamp) {

5
src/Common/Stamp.h
View File

@@ -14,7 +14,6 @@
#include <set>
#include <cstdint>
#include "Util/TimeTicker.h"
using namespace toolkit;
namespace mediakit {
@@ -87,7 +86,7 @@ private:
int64_t _last_dts_in = 0;
int64_t _last_dts_out = 0;
int64_t _last_pts_out = 0;
SmoothTicker _ticker;
toolkit::SmoothTicker _ticker;
bool _playback = false;
Stamp *_sync_master = nullptr;
};
@@ -111,7 +110,7 @@ private:
size_t _frames_since_last_max_pts = 0;
size_t _sorter_max_size = 0;
size_t _count_sorter_max_size = 0;
set<uint32_t> _pts_sorter;
std::set<uint32_t> _pts_sorter;
};
class NtpStamp {

1
src/Common/config.cpp
View File

@@ -15,6 +15,7 @@
#include "Util/onceToken.h"
#include "Util/NoticeCenter.h"
using namespace std;
using namespace toolkit;
namespace mediakit {

231
src/Common/config.h
View File

@@ -18,9 +18,6 @@
#include "Util/NoticeCenter.h"
#include "macros.h"
using namespace std;
using namespace toolkit;
namespace mediakit {
//加载配置文件，如果配置文件不存在，那么会导出默认配置并生成配置文件
@@ -34,93 +31,93 @@ bool loadIniConfig(const char *ini_path = nullptr);
namespace Broadcast {
//注册或反注册MediaSource事件广播
extern const string kBroadcastMediaChanged;
extern const std::string kBroadcastMediaChanged;
#define BroadcastMediaChangedArgs const bool &bRegist, MediaSource &sender
//录制mp4文件成功后广播
extern const string kBroadcastRecordMP4;
extern const std::string kBroadcastRecordMP4;
#define BroadcastRecordMP4Args const RecordInfo &info
// 录制 ts 文件后广播
extern const string kBroadcastRecordTs;
extern const std::string kBroadcastRecordTs;
#define BroadcastRecordTsArgs const RecordInfo &info
//收到http api请求广播
extern const string kBroadcastHttpRequest;
extern const std::string kBroadcastHttpRequest;
#define BroadcastHttpRequestArgs const Parser &parser,const HttpSession::HttpResponseInvoker &invoker,bool &consumed,SockInfo &sender
//在http文件服务器中,收到http访问文件或目录的广播,通过该事件控制访问http目录的权限
extern const string kBroadcastHttpAccess;
#define BroadcastHttpAccessArgs const Parser &parser,const string &path,const bool &is_dir,const HttpSession::HttpAccessPathInvoker &invoker,SockInfo &sender
extern const std::string kBroadcastHttpAccess;
#define BroadcastHttpAccessArgs const Parser &parser,const std::string &path,const bool &is_dir,const HttpSession::HttpAccessPathInvoker &invoker,SockInfo &sender
//在http文件服务器中,收到http访问文件或目录前的广播,通过该事件可以控制http url到文件路径的映射
//在该事件中通过自行覆盖path参数，可以做到譬如根据虚拟主机或者app选择不同http根目录的目的
extern const string kBroadcastHttpBeforeAccess;
#define BroadcastHttpBeforeAccessArgs const Parser &parser,string &path,SockInfo &sender
extern const std::string kBroadcastHttpBeforeAccess;
#define BroadcastHttpBeforeAccessArgs const Parser &parser, std::string &path, SockInfo &sender
//该流是否需要认证？是的话调用invoker并传入realm,否则传入空的realm.如果该事件不监听则不认证
extern const string kBroadcastOnGetRtspRealm;
extern const std::string kBroadcastOnGetRtspRealm;
#define BroadcastOnGetRtspRealmArgs const MediaInfo &args,const RtspSession::onGetRealm &invoker,SockInfo &sender
//请求认证用户密码事件，user_name为用户名，must_no_encrypt如果为true，则必须提供明文密码(因为此时是base64认证方式),否则会导致认证失败
//获取到密码后请调用invoker并输入对应类型的密码和密码类型，invoker执行时会匹配密码
extern const string kBroadcastOnRtspAuth;
#define BroadcastOnRtspAuthArgs const MediaInfo &args,const string &realm,const string &user_name,const bool &must_no_encrypt,const RtspSession::onAuth &invoker,SockInfo &sender
extern const std::string kBroadcastOnRtspAuth;
#define BroadcastOnRtspAuthArgs const MediaInfo &args,const std::string &realm,const std::string &user_name,const bool &must_no_encrypt,const RtspSession::onAuth &invoker,SockInfo &sender
//推流鉴权结果回调对象
//如果errMessage为空则代表鉴权成功
//enableHls: 是否允许转换hls
//enableMP4: 是否运行MP4录制
typedef std::function<void(const string &errMessage, bool enableHls, bool enableMP4)> PublishAuthInvoker;
typedef std::function<void(const std::string &errMessage, bool enableHls, bool enableMP4)> PublishAuthInvoker;
//收到rtsp/rtmp推流事件广播，通过该事件控制推流鉴权
extern const string kBroadcastMediaPublish;
extern const std::string kBroadcastMediaPublish;
#define BroadcastMediaPublishArgs const MediaInfo &args,const Broadcast::PublishAuthInvoker &invoker,SockInfo &sender
//播放鉴权结果回调对象
//如果errMessage为空则代表鉴权成功
typedef std::function<void(const string &errMessage)> AuthInvoker;
typedef std::function<void(const std::string &errMessage)> AuthInvoker;
//播放rtsp/rtmp/http-flv事件广播，通过该事件控制播放鉴权
extern const string kBroadcastMediaPlayed;
extern const std::string kBroadcastMediaPlayed;
#define BroadcastMediaPlayedArgs const MediaInfo &args,const Broadcast::AuthInvoker &invoker,SockInfo &sender
//shell登录鉴权
extern const string kBroadcastShellLogin;
#define BroadcastShellLoginArgs const string &user_name,const string &passwd,const Broadcast::AuthInvoker &invoker,SockInfo &sender
extern const std::string kBroadcastShellLogin;
#define BroadcastShellLoginArgs const std::string &user_name,const std::string &passwd,const Broadcast::AuthInvoker &invoker,SockInfo &sender
//停止rtsp/rtmp/http-flv会话后流量汇报事件广播
extern const string kBroadcastFlowReport;
extern const std::string kBroadcastFlowReport;
#define BroadcastFlowReportArgs const MediaInfo &args,const uint64_t &totalBytes,const uint64_t &totalDuration,const bool &isPlayer, SockInfo &sender
//未找到流后会广播该事件，请在监听该事件后去拉流或其他方式产生流，这样就能按需拉流了
extern const string kBroadcastNotFoundStream;
#define BroadcastNotFoundStreamArgs const MediaInfo &args,SockInfo &sender, const function<void()> &closePlayer
extern const std::string kBroadcastNotFoundStream;
#define BroadcastNotFoundStreamArgs const MediaInfo &args, SockInfo &sender, const std::function<void()> &closePlayer
//某个流无人消费时触发，目的为了实现无人观看时主动断开拉流等业务逻辑
extern const string kBroadcastStreamNoneReader;
extern const std::string kBroadcastStreamNoneReader;
#define BroadcastStreamNoneReaderArgs MediaSource &sender
//更新配置文件事件广播,执行loadIniConfig函数加载配置文件成功后会触发该广播
extern const string kBroadcastReloadConfig;
extern const std::string kBroadcastReloadConfig;
#define BroadcastReloadConfigArgs void
#define ReloadConfigTag ((void *)(0xFF))
#define RELOAD_KEY(arg,key) \
do { \
decltype(arg) arg##_tmp = mINI::Instance()[key]; \
if (arg == arg##_tmp) { \
return; \
} \
arg = arg##_tmp; \
InfoL << "reload config:" << key << "=" << arg; \
#define RELOAD_KEY(arg,key) \
do { \
decltype(arg) arg##_tmp = toolkit::mINI::Instance()[key]; \
if (arg == arg##_tmp) { \
return; \
} \
arg = arg##_tmp; \
InfoL << "reload config:" << key << "=" << arg; \
} while(0)
//监听某个配置发送变更
#define LISTEN_RELOAD_KEY(arg, key, ...) \
do { \
static onceToken s_token_listen([](){ \
NoticeCenter::Instance().addListener(ReloadConfigTag, \
static toolkit::onceToken s_token_listen([](){ \
toolkit::NoticeCenter::Instance().addListener(ReloadConfigTag, \
Broadcast::kBroadcastReloadConfig,[](BroadcastReloadConfigArgs) { \
__VA_ARGS__; \
}); \
@@ -128,23 +125,23 @@ extern const string kBroadcastReloadConfig;
} while(0)
#define GET_CONFIG(type, arg, key) \
static type arg = mINI::Instance()[key]; \
static type arg = toolkit::mINI::Instance()[key]; \
LISTEN_RELOAD_KEY(arg, key, { \
RELOAD_KEY(arg, key); \
});
#define GET_CONFIG_FUNC(type, arg, key, ...) \
static type arg; \
do { \
static onceToken s_token_set([](){ \
static auto lam = __VA_ARGS__ ; \
static auto arg##_str = mINI::Instance()[key]; \
arg = lam(arg##_str); \
LISTEN_RELOAD_KEY(arg, key, { \
RELOAD_KEY(arg##_str, key); \
arg = lam(arg##_str); \
}); \
}); \
#define GET_CONFIG_FUNC(type, arg, key, ...) \
static type arg; \
do { \
static toolkit::onceToken s_token_set([](){ \
static auto lam = __VA_ARGS__ ; \
static auto arg##_str = toolkit::mINI::Instance()[key]; \
arg = lam(arg##_str); \
LISTEN_RELOAD_KEY(arg, key, { \
RELOAD_KEY(arg##_str, key); \
arg = lam(arg##_str); \
}); \
}); \
} while(0)
} //namespace Broadcast
@@ -152,168 +149,168 @@ extern const string kBroadcastReloadConfig;
////////////通用配置///////////
namespace General{
//每个流媒体服务器的ID（GUID）
extern const string kMediaServerId;
extern const std::string kMediaServerId;
//流量汇报事件流量阈值,单位KB，默认1MB
extern const string kFlowThreshold;
extern const std::string kFlowThreshold;
//流无人观看并且超过若干时间后才触发kBroadcastStreamNoneReader事件
//默认连续5秒无人观看然后触发kBroadcastStreamNoneReader事件
extern const string kStreamNoneReaderDelayMS;
extern const std::string kStreamNoneReaderDelayMS;
//等待流注册超时时间，收到播放器后请求后，如果未找到相关流，服务器会等待一定时间，
//如果在这个时间内，相关流注册上了，那么服务器会立即响应播放器播放成功，
//否则会最多等待kMaxStreamWaitTimeMS毫秒，然后响应播放器播放失败
extern const string kMaxStreamWaitTimeMS;
extern const std::string kMaxStreamWaitTimeMS;
//是否启动虚拟主机
extern const string kEnableVhost;
extern const std::string kEnableVhost;
//拉流代理时是否添加静音音频
extern const string kAddMuteAudio;
extern const std::string kAddMuteAudio;
//拉流代理时如果断流再重连成功是否删除前一次的媒体流数据，如果删除将重新开始，
//如果不删除将会接着上一次的数据继续写(录制hls/mp4时会继续在前一个文件后面写)
extern const string kResetWhenRePlay;
extern const std::string kResetWhenRePlay;
//是否默认推流时转换成hls，hook接口(on_publish)中可以覆盖该设置
extern const string kPublishToHls ;
extern const std::string kPublishToHls ;
//是否默认推流时mp4录像，hook接口(on_publish)中可以覆盖该设置
extern const string kPublishToMP4 ;
extern const std::string kPublishToMP4 ;
//合并写缓存大小(单位毫秒)，合并写指服务器缓存一定的数据后才会一次性写入socket，这样能提高性能，但是会提高延时
//开启后会同时关闭TCP_NODELAY并开启MSG_MORE
extern const string kMergeWriteMS ;
extern const std::string kMergeWriteMS ;
//全局的时间戳覆盖开关，在转协议时，对frame进行时间戳覆盖
extern const string kModifyStamp;
extern const std::string kModifyStamp;
//按需转协议的开关
extern const string kHlsDemand;
extern const string kRtspDemand;
extern const string kRtmpDemand;
extern const string kTSDemand;
extern const string kFMP4Demand;
extern const std::string kHlsDemand;
extern const std::string kRtspDemand;
extern const std::string kRtmpDemand;
extern const std::string kTSDemand;
extern const std::string kFMP4Demand;
//转协议是否全局开启或忽略音频
extern const string kEnableAudio;
extern const std::string kEnableAudio;
//最多等待未初始化的Track 10秒，超时之后会忽略未初始化的Track
extern const string kWaitTrackReadyMS;
extern const std::string kWaitTrackReadyMS;
//如果直播流只有单Track，最多等待3秒，超时后未收到其他Track的数据，则认为是单Track
//如果协议元数据有声明特定track数，那么无此等待时间
extern const string kWaitAddTrackMS;
extern const std::string kWaitAddTrackMS;
//如果track未就绪，我们先缓存帧数据，但是有最大个数限制(100帧时大约4秒)，防止内存溢出
extern const string kUnreadyFrameCache;
extern const std::string kUnreadyFrameCache;
//推流断开后可以在超时时间内重新连接上继续推流，这样播放器会接着播放。
//置0关闭此特性(推流断开会导致立即断开播放器)
extern const string kContinuePushMS;
extern const std::string kContinuePushMS;
}//namespace General
////////////HTTP配置///////////
namespace Http {
//http 文件发送缓存大小
extern const string kSendBufSize;
extern const std::string kSendBufSize;
//http 最大请求字节数
extern const string kMaxReqSize;
extern const std::string kMaxReqSize;
//http keep-alive秒数
extern const string kKeepAliveSecond;
extern const std::string kKeepAliveSecond;
//http 字符编码
extern const string kCharSet;
extern const std::string kCharSet;
//http 服务器根目录
extern const string kRootPath;
extern const std::string kRootPath;
//http 服务器虚拟目录 虚拟目录名和文件路径使用","隔开，多个配置路径间用";"隔开，例如 path_d,d:/record;path_e,e:/record
extern const string kVirtualPath;
extern const std::string kVirtualPath;
//http 404错误提示内容
extern const string kNotFound;
extern const std::string kNotFound;
//是否显示文件夹菜单
extern const string kDirMenu;
extern const std::string kDirMenu;
}//namespace Http
////////////SHELL配置///////////
namespace Shell {
extern const string kMaxReqSize;
extern const std::string kMaxReqSize;
} //namespace Shell
////////////RTSP服务器配置///////////
namespace Rtsp {
//是否优先base64方式认证？默认Md5方式认证
extern const string kAuthBasic;
extern const std::string kAuthBasic;
//握手超时时间，默认15秒
extern const string kHandshakeSecond;
extern const std::string kHandshakeSecond;
//维持链接超时时间，默认15秒
extern const string kKeepAliveSecond;
extern const std::string kKeepAliveSecond;
//rtsp拉流代理是否直接代理
//直接代理后支持任意编码格式，但是会导致GOP缓存无法定位到I帧，可能会导致开播花屏
//并且如果是tcp方式拉流，如果rtp大于mtu会导致无法使用udp方式代理
//假定您的拉流源地址不是264或265或AAC，那么你可以使用直接代理的方式来支持rtsp代理
//默认开启rtsp直接代理，rtmp由于没有这些问题，是强制开启直接代理的
extern const string kDirectProxy;
extern const std::string kDirectProxy;
} //namespace Rtsp
////////////RTMP服务器配置///////////
namespace Rtmp {
//rtmp推流时间戳覆盖开关
extern const string kModifyStamp;
extern const std::string kModifyStamp;
//握手超时时间，默认15秒
extern const string kHandshakeSecond;
extern const std::string kHandshakeSecond;
//维持链接超时时间，默认15秒
extern const string kKeepAliveSecond;
extern const std::string kKeepAliveSecond;
} //namespace RTMP
////////////RTP配置///////////
namespace Rtp {
//RTP打包最大MTU,公网情况下更小
extern const string kVideoMtuSize;
extern const std::string kVideoMtuSize;
//RTP打包最大MTU,公网情况下更小
extern const string kAudioMtuSize;
extern const std::string kAudioMtuSize;
//rtp包最大长度限制, 单位KB
extern const string kRtpMaxSize;
extern const std::string kRtpMaxSize;
} //namespace Rtsp
////////////组播配置///////////
namespace MultiCast {
//组播分配起始地址
extern const string kAddrMin;
extern const std::string kAddrMin;
//组播分配截止地址
extern const string kAddrMax;
extern const std::string kAddrMax;
//组播TTL
extern const string kUdpTTL;
extern const std::string kUdpTTL;
} //namespace MultiCast
////////////录像配置///////////
namespace Record {
//查看录像的应用名称
extern const string kAppName;
extern const std::string kAppName;
//每次流化MP4文件的时长,单位毫秒
extern const string kSampleMS;
extern const std::string kSampleMS;
//MP4文件录制大小,默认一个小时
extern const string kFileSecond;
extern const std::string kFileSecond;
//录制文件路径
extern const string kFilePath;
extern const std::string kFilePath;
//mp4文件写缓存大小
extern const string kFileBufSize;
extern const std::string kFileBufSize;
//mp4录制完成后是否进行二次关键帧索引写入头部
extern const string kFastStart;
extern const std::string kFastStart;
//mp4文件是否重头循环读取
extern const string kFileRepeat;
extern const std::string kFileRepeat;
} //namespace Record
////////////HLS相关配置///////////
namespace Hls {
//HLS切片时长,单位秒
extern const string kSegmentDuration;
extern const std::string kSegmentDuration;
//m3u8文件中HLS切片个数，如果设置为0，则不删除切片，而是保存为点播
extern const string kSegmentNum;
extern const std::string kSegmentNum;
//HLS切片从m3u8文件中移除后，继续保留在磁盘上的个数
extern const string kSegmentRetain;
extern const std::string kSegmentRetain;
//HLS文件写缓存大小
extern const string kFileBufSize;
extern const std::string kFileBufSize;
//录制文件路径
extern const string kFilePath;
extern const std::string kFilePath;
// 是否广播 ts 切片完成通知
extern const string kBroadcastRecordTs;
extern const std::string kBroadcastRecordTs;
//hls直播文件删除延时，单位秒
extern const string kDeleteDelaySec;
extern const std::string kDeleteDelaySec;
} //namespace Hls
////////////Rtp代理相关配置///////////
namespace RtpProxy {
//rtp调试数据保存目录,置空则不生成
extern const string kDumpDir;
extern const std::string kDumpDir;
//rtp接收超时时间
extern const string kTimeoutSec;
extern const std::string kTimeoutSec;
} //namespace RtpProxy
/**
@@ -323,26 +320,26 @@ extern const string kTimeoutSec;
*/
namespace Client {
//指定网卡ip
extern const string kNetAdapter;
extern const std::string kNetAdapter;
//设置rtp传输类型，可选项有0(tcp，默认)、1(udp)、2(组播)
//设置方法:player[PlayerBase::kRtpType] = 0/1/2;
extern const string kRtpType;
extern const std::string kRtpType;
//rtsp认证用户名
extern const string kRtspUser;
extern const std::string kRtspUser;
//rtsp认证用用户密码，可以是明文也可以是md5,md5密码生成方式 md5(username:realm:password)
extern const string kRtspPwd;
extern const std::string kRtspPwd;
//rtsp认证用用户密码是否为md5类型
extern const string kRtspPwdIsMD5;
extern const std::string kRtspPwdIsMD5;
//握手超时时间，默认10,000 毫秒
extern const string kTimeoutMS;
extern const std::string kTimeoutMS;
//rtp/rtmp包接收超时时间，默认5000秒
extern const string kMediaTimeoutMS;
extern const std::string kMediaTimeoutMS;
//rtsp/rtmp心跳时间,默认5000毫秒
extern const string kBeatIntervalMS;
extern const std::string kBeatIntervalMS;
//是否为性能测试模式，性能测试模式开启后不会解析rtp或rtmp包
extern const string kBenchmarkMode;
extern const std::string kBenchmarkMode;
//播放器在触发播放成功事件时，是否等待所有track ready时再回调
extern const string kWaitTrackReady;
extern const std::string kWaitTrackReady;
}
} // namespace mediakit