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

AI automatically translates all comments in the code into English (#3917)

Browse Source
This commit is contained in:
alex
2024-09-19 14:53:50 +08:00
committed by GitHub
parent 046de691cb
commit 4152dcd409
279 changed files with 10602 additions and 3038 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/Player/MediaPlayer.cpp
View File

@@ -26,7 +26,8 @@ static void setOnCreateSocket_l(const std::shared_ptr<PlayerBase> &delegate, con
if (cb) {
helper->setOnCreateSocket(cb);
} else {
//客户端，确保开启互斥锁
// 客户端，确保开启互斥锁 [AUTO-TRANSLATED:a75e6e36]
// Client, ensure mutual exclusion lock is enabled
helper->setOnCreateSocket([](const EventPoller::Ptr &poller) {
return Socket::createSocket(poller, true);
});

3
src/Player/PlayerBase.cpp
View File

@@ -38,7 +38,8 @@ PlayerBase::Ptr PlayerBase::createPlayer(const EventPoller::Ptr &in_poller, cons
string prefix = findSubString(url.data(), NULL, "://");
auto pos = url.find('?');
if (pos != string::npos) {
//去除？后面的字符串
// 去除？后面的字符串 [AUTO-TRANSLATED:0ccb41c2]
// Remove the string after the question mark
url = url.substr(0, pos);
}

52
src/Player/PlayerBase.h
View File

@@ -36,81 +36,133 @@ public:
/**
* 开始播放
* @param url 视频url，支持rtsp/rtmp
* Start playback
* @param url Video url, supports rtsp/rtmp
* [AUTO-TRANSLATED:3871cbee]
*/
virtual void play(const std::string &url) {};
/**
* 暂停或恢复
* @param flag true:暂停，false:恢复
* Pause or resume
* @param flag true: pause, false: resume
* [AUTO-TRANSLATED:2a17eab2]
*/
virtual void pause(bool flag) {};
/**
* 获取节目总时长，单位秒
* Get the total duration of the program, in seconds
* [AUTO-TRANSLATED:f3de1631]
*/
virtual float getDuration() const { return 0; };
/**
* 倍数播放
* @param speed 1.0 2.0 0.5
* Playback at a multiple
* @param speed 1.0 2.0 0.5
* [AUTO-TRANSLATED:46bf057e]
*/
virtual void speed(float speed) {};
/**
* 中断播放
* Interrupt playback
* [AUTO-TRANSLATED:d962e9bc]
*/
virtual void teardown() {};
/**
* 获取播放进度，取值 0.0 ~ 1.0
* Get playback progress, value 0.0 ~ 1.0
* [AUTO-TRANSLATED:ba24f450]
*/
virtual float getProgress() const { return 0; };
/**
* 获取播放进度pos，取值 相对开始时间增量 单位秒
* Get playback progress pos, value relative to the start time increment, unit seconds
* [AUTO-TRANSLATED:1eb148ad]
*/
virtual uint32_t getProgressPos() const { return 0; };
/**
* 拖动进度条
* @param progress 进度，取值 0.0 ~ 1.0
* Drag the progress bar
* @param progress Progress, value 0.0 ~ 1.0
* [AUTO-TRANSLATED:c4907336]
*/
virtual void seekTo(float progress) {};
/**
* 拖动进度条
* @param pos 进度，取值 相对于开始时间的增量 单位秒
* Drag the progress bar
* @param pos Progress, value relative to the start time increment, unit seconds
* [AUTO-TRANSLATED:77dab991]
*/
virtual void seekTo(uint32_t pos) {};
/**
* 获取丢包率，只支持rtsp
* @param type 音频或视频，TrackInvalid时为总丢包率
* Get packet loss rate, only supports rtsp
* @param type Audio or video, TrackInvalid for total packet loss rate
* [AUTO-TRANSLATED:aac7f19c]
*/
virtual float getPacketLossRate(TrackType type) const { return -1; };
/**
* 获取所有track
* Get all tracks
* [AUTO-TRANSLATED:5860aed6]
*/
std::vector<Track::Ptr> getTracks(bool ready = true) const override { return std::vector<Track::Ptr>(); };
/**
* 设置一个MediaSource，直接生产rtsp/rtmp代理
* Set a MediaSource, directly produce rtsp/rtmp proxy
* [AUTO-TRANSLATED:dda602c4]
*/
virtual void setMediaSource(const MediaSource::Ptr &src) = 0;
/**
* 设置异常中断回调
* Set exception interrupt callback
* [AUTO-TRANSLATED:d931e70d]
*/
virtual void setOnShutdown(const Event &cb) = 0;
/**
* 设置播放结果回调
* Set playback result callback
* [AUTO-TRANSLATED:f6d73f89]
*/
virtual void setOnPlayResult(const Event &cb) = 0;
/**
* 设置播放恢复回调
* Set playback resume callback
* [AUTO-TRANSLATED:8fb31d43]
*/
virtual void setOnResume(const std::function<void()> &cb) = 0;

69
src/Player/PlayerProxy.cpp
View File

@@ -94,7 +94,8 @@ void PlayerProxy::setTranslationInfo()
static int getMaxTrackSize(const std::string &url) {
if (url.find(".m3u8") != std::string::npos || url.find(".ts") != std::string::npos) {
// hls和ts协议才开放多track支持
// hls和ts协议才开放多track支持 [AUTO-TRANSLATED:6c5f8f04]
// Only hls and ts protocols support multiple tracks
return 16;
}
return 2;
@@ -116,11 +117,13 @@ void PlayerProxy::play(const string &strUrlTmp) {
}
if (!err) {
// 取消定时器,避免hls拉流索引文件因为网络波动失败重连成功后出现循环重试的情况
// 取消定时器,避免hls拉流索引文件因为网络波动失败重连成功后出现循环重试的情况 [AUTO-TRANSLATED:91e5f0c8]
// Cancel the timer to avoid the situation where the hls stream index file fails to reconnect due to network fluctuations and then retries in a loop after successful reconnection
strongSelf->_timer.reset();
strongSelf->_live_ticker.resetTime();
strongSelf->_live_status = 0;
// 播放成功
// 播放成功 [AUTO-TRANSLATED:e43f9fb8]
// Play successfully
*piFailedCnt = 0; // 连续播放失败次数清0
strongSelf->onPlaySuccess();
strongSelf->setTranslationInfo();
@@ -128,11 +131,13 @@ void PlayerProxy::play(const string &strUrlTmp) {
InfoL << "play " << strUrlTmp << " success";
} else if (*piFailedCnt < strongSelf->_retry_count || strongSelf->_retry_count < 0) {
// 播放失败，延时重试播放
// 播放失败，延时重试播放 [AUTO-TRANSLATED:d7537c9c]
// Play failed, retry playing with delay
strongSelf->_on_disconnect();
strongSelf->rePlay(strUrlTmp, (*piFailedCnt)++);
} else {
// 达到了最大重试次数，回调关闭
// 达到了最大重试次数，回调关闭 [AUTO-TRANSLATED:610f31f3]
// Reached the maximum number of retries, callback to close
strongSelf->_on_close(err);
}
});
@@ -142,7 +147,8 @@ void PlayerProxy::play(const string &strUrlTmp) {
return;
}
// 注销直接拉流代理产生的流：#532
// 注销直接拉流代理产生的流：#532 [AUTO-TRANSLATED:c6343a3b]
// Unregister the stream generated by the direct stream proxy: #532
strongSelf->setMediaSource(nullptr);
if (strongSelf->_muxer) {
@@ -160,18 +166,21 @@ void PlayerProxy::play(const string &strUrlTmp) {
}
if (*piFailedCnt == 0) {
// 第一次重拉更新时长
// 第一次重拉更新时长 [AUTO-TRANSLATED:3c414b08]
// Update the duration for the first time
strongSelf->_live_secs += strongSelf->_live_ticker.elapsedTime() / 1000;
strongSelf->_live_ticker.resetTime();
TraceL << " live secs " << strongSelf->_live_secs;
}
// 播放异常中断，延时重试播放
// 播放异常中断，延时重试播放 [AUTO-TRANSLATED:fee316b2]
// Play interrupted abnormally, retry playing with delay
if (*piFailedCnt < strongSelf->_retry_count || strongSelf->_retry_count < 0) {
strongSelf->_repull_count++;
strongSelf->rePlay(strUrlTmp, (*piFailedCnt)++);
} else {
// 达到了最大重试次数，回调关闭
// 达到了最大重试次数，回调关闭 [AUTO-TRANSLATED:610f31f3]
// Reached the maximum number of retries, callback to close
strongSelf->_on_close(err);
}
});
@@ -189,13 +198,15 @@ void PlayerProxy::play(const string &strUrlTmp) {
void PlayerProxy::setDirectProxy() {
MediaSource::Ptr mediaSource;
if (dynamic_pointer_cast<RtspPlayer>(_delegate)) {
// rtsp拉流
// rtsp拉流 [AUTO-TRANSLATED:189cf691]
// Rtsp stream
GET_CONFIG(bool, directProxy, Rtsp::kDirectProxy);
if (directProxy && _option.enable_rtsp) {
mediaSource = std::make_shared<RtspMediaSource>(_tuple);
}
} else if (dynamic_pointer_cast<RtmpPlayer>(_delegate)) {
// rtmp拉流
// rtmp拉流 [AUTO-TRANSLATED:f70a142c]
// Rtmp stream
GET_CONFIG(bool, directProxy, Rtmp::kDirectProxy);
if (directProxy && _option.enable_rtmp) {
mediaSource = std::make_shared<RtmpMediaSource>(_tuple);
@@ -208,7 +219,8 @@ void PlayerProxy::setDirectProxy() {
PlayerProxy::~PlayerProxy() {
_timer.reset();
// 避免析构时, 忘记回调api请求
// 避免析构时, 忘记回调api请求 [AUTO-TRANSLATED:1ad9ad52]
// Avoid forgetting to callback api request when destructing
if (_on_play) {
try {
_on_play(SockException(Err_shutdown, "player proxy close"));
@@ -225,7 +237,8 @@ void PlayerProxy::rePlay(const string &strUrl, int iFailedCnt) {
_timer = std::make_shared<Timer>(
iDelay / 1000.0f,
[weakSelf, strUrl, iFailedCnt]() {
// 播放失败次数越多，则延时越长
// 播放失败次数越多，则延时越长 [AUTO-TRANSLATED:5af39264]
// The more times the playback fails, the longer the delay
auto strongPlayer = weakSelf.lock();
if (!strongPlayer) {
return false;
@@ -239,7 +252,8 @@ void PlayerProxy::rePlay(const string &strUrl, int iFailedCnt) {
}
bool PlayerProxy::close(MediaSource &sender) {
// 通知其停止推流
// 通知其停止推流 [AUTO-TRANSLATED:d69d10d8]
// Notify it to stop pushing the stream
weak_ptr<PlayerProxy> weakSelf = dynamic_pointer_cast<PlayerProxy>(shared_from_this());
getPoller()->async_first([weakSelf]() {
auto strongSelf = weakSelf.lock();
@@ -286,7 +300,8 @@ TranslationInfo PlayerProxy::getTranslationInfo() {
void PlayerProxy::onPlaySuccess() {
GET_CONFIG(bool, reset_when_replay, General::kResetWhenRePlay);
if (dynamic_pointer_cast<RtspMediaSource>(_media_src)) {
// rtsp拉流代理
// rtsp拉流代理 [AUTO-TRANSLATED:3935cf68]
// Rtsp stream proxy
if (reset_when_replay || !_muxer) {
auto old = _option.enable_rtsp;
_option.enable_rtsp = false;
@@ -294,7 +309,8 @@ void PlayerProxy::onPlaySuccess() {
_option.enable_rtsp = old;
}
} else if (dynamic_pointer_cast<RtmpMediaSource>(_media_src)) {
// rtmp拉流代理
// rtmp拉流代理 [AUTO-TRANSLATED:21173335]
// Rtmp stream proxy
if (reset_when_replay || !_muxer) {
auto old = _option.enable_rtmp;
_option.enable_rtmp = false;
@@ -302,7 +318,8 @@ void PlayerProxy::onPlaySuccess() {
_option.enable_rtmp = old;
}
} else {
// 其他拉流代理
// 其他拉流代理 [AUTO-TRANSLATED:e5f2e45d]
// Other stream proxies
if (reset_when_replay || !_muxer) {
_muxer = std::make_shared<MultiMediaSourceMuxer>(_tuple, getDuration(), _option);
}
@@ -311,25 +328,31 @@ void PlayerProxy::onPlaySuccess() {
auto videoTrack = getTrack(TrackVideo, false);
if (videoTrack) {
// 添加视频
// 添加视频 [AUTO-TRANSLATED:afc7e0f7]
// Add video
_muxer->addTrack(videoTrack);
// 视频数据写入_mediaMuxer
// 视频数据写入_mediaMuxer [AUTO-TRANSLATED:fc07e1c9]
// Write video data to _mediaMuxer
videoTrack->addDelegate(_muxer);
}
auto audioTrack = getTrack(TrackAudio, false);
if (audioTrack) {
// 添加音频
// 添加音频 [AUTO-TRANSLATED:e08e79ce]
// Add audio
_muxer->addTrack(audioTrack);
// 音频数据写入_mediaMuxer
// 音频数据写入_mediaMuxer [AUTO-TRANSLATED:69911524]
// Write audio data to _mediaMuxer
audioTrack->addDelegate(_muxer);
}
// 添加完毕所有track，防止单track情况下最大等待3秒
// 添加完毕所有track，防止单track情况下最大等待3秒 [AUTO-TRANSLATED:8908bc01]
// After adding all tracks, prevent the maximum waiting time of 3 seconds in the case of a single track
_muxer->addTrackCompleted();
if (_media_src) {
// 让_muxer对象拦截一部分事件(比如说录像相关事件)
// 让_muxer对象拦截一部分事件(比如说录像相关事件) [AUTO-TRANSLATED:7d27c400]
// Let the _muxer object intercept some events (such as recording related events)
_media_src->setListener(_muxer);
}
}

32
src/Player/PlayerProxy.h
View File

@@ -64,8 +64,10 @@ class PlayerProxy
public:
using Ptr = std::shared_ptr<PlayerProxy>;
// 如果retry_count<0,则一直重试播放；否则重试retry_count次数
// 默认一直重试
// 如果retry_count<0,则一直重试播放；否则重试retry_count次数 [AUTO-TRANSLATED:5582d53c]
// If retry_count < 0, then retry playing indefinitely; otherwise, retry retry_count times
// 默认一直重试 [AUTO-TRANSLATED:779d3c46]
// Default to retrying indefinitely
PlayerProxy(const MediaTuple &tuple, const ProtocolOption &option, int retry_count = -1,
const toolkit::EventPoller::Ptr &poller = nullptr,
int reconnect_delay_min = 2, int reconnect_delay_max = 60, int reconnect_delay_step = 3);
@@ -75,35 +77,58 @@ public:
/**
* 设置play结果回调，只触发一次；在play执行之前有效
* @param cb 回调对象
* Set a callback for the play result, triggered only once; effective before play execution
* @param cb Callback object
* [AUTO-TRANSLATED:f34625f6]
*/
void setPlayCallbackOnce(std::function<void(const toolkit::SockException &ex)> cb);
/**
* 设置主动关闭回调
* @param cb 回调对象
* Set a callback for active closure
* @param cb Callback object
* [AUTO-TRANSLATED:83b7700a]
*/
void setOnClose(std::function<void(const toolkit::SockException &ex)> cb);
/**
* Set a callback for failed server connection
* @param cb 回调对象
* Set a callback for failed server connection
* @param cb Callback object
* [AUTO-TRANSLATED:e7f5e7cc]
*/
void setOnDisconnect(std::function<void()> cb);
/**
* Set a callback for a successful connection to the server
* @param cb 回调对象
* Set a callback for a successful connection to the server
* @param cb Callback object
* [AUTO-TRANSLATED:b88e0d4c]
*/
void setOnConnect(std::function<void(const TranslationInfo&)> cb);
/**
* 开始拉流播放
* @param strUrl
* Start streaming playback
* @param strUrl
* [AUTO-TRANSLATED:a2f0e859]
*/
void play(const std::string &strUrl) override;
/**
* 获取观看总人数
* Get the total number of viewers
* [AUTO-TRANSLATED:6c1b8bf1]
*/
int totalReaderCount();
@@ -145,7 +170,8 @@ private:
MultiMediaSourceMuxer::Ptr _muxer;
toolkit::Ticker _live_ticker;
// 0 表示正常 1 表示正在尝试拉流
// 0 表示正常 1 表示正在尝试拉流 [AUTO-TRANSLATED:2080bedf]
// 0 indicates normal, 1 indicates attempting to stream
std::atomic<int> _live_status;
std::atomic<uint64_t> _live_secs;