format code style for pusher and player

ffed4b3b · xiongguangjie · 7c89c165 · ffed4b3b · ffed4b3b · ffed4b3b
Commit ffed4b3b authored May 03, 2023 by xiongguangjie
--- a/src/Player/PlayerProxy.cpp
+++ b/src/Player/PlayerProxy.cpp
@@ -8,29 +8,31 @@
 * may be found in the AUTHORS file in the root of the source tree.
 */
-#include "Common/config.h"
 #include "PlayerProxy.h"
-#include "Util/mini.h"
+#include "Common/config.h"
-#include "Util/MD5.h"
-#include "Util/logger.h"
 #include "Extension/AAC.h"
 #include "Rtmp/RtmpMediaSource.h"
-#include "Rtsp/RtspMediaSource.h"
 #include "Rtmp/RtmpPlayer.h"
+#include "Rtsp/RtspMediaSource.h"
 #include "Rtsp/RtspPlayer.h"
+#include "Util/MD5.h"
+#include "Util/logger.h"
+#include "Util/mini.h"
 using namespace toolkit;
 using namespace std;
 namespace mediakit {
-PlayerProxy::PlayerProxy(const string &vhost, const string &app, const string &stream_id, const ProtocolOption &option,
+PlayerProxy::PlayerProxy(
-                         int retry_count, const EventPoller::Ptr &poller) : MediaPlayer(poller) , _option(option) {
+    const string &vhost, const string &app, const string &stream_id, const ProtocolOption &option, int retry_count, const EventPoller::Ptr &poller)
+    : MediaPlayer(poller)
+    , _option(option) {
    _vhost = vhost;
    _app = app;
    _stream_id = stream_id;
    _retry_count = retry_count;
    _live_secs = 0;
    _live_status = 1;
    _repull_count = 0;
@@ -48,7 +50,7 @@ void PlayerProxy::setOnClose(const function<void(const SockException &ex)> &cb) 
 void PlayerProxy::play(const string &strUrlTmp) {
    weak_ptr<PlayerProxy> weakSelf = shared_from_this();
-    std::shared_ptr<int> piFailedCnt(new int(0)); //连续播放失败次数
+    std::shared_ptr<int> piFailedCnt(new int(0)); // 连续播放失败次数
    setOnPlayResult([weakSelf, strUrlTmp, piFailedCnt](const SockException &err) {
        auto strongSelf = weakSelf.lock();
        if (!strongSelf) {
@@ -66,7 +68,7 @@ void PlayerProxy::play(const string &strUrlTmp) {
            strongSelf->_live_ticker.resetTime();
            strongSelf->_live_status = 0;
            // 播放成功
-            *piFailedCnt = 0;//连续播放失败次数清0
+            *piFailedCnt = 0; // 连续播放失败次数清0
            strongSelf->onPlaySuccess();
            InfoL << "play " << strUrlTmp << " success";
@@ -74,7 +76,7 @@ void PlayerProxy::play(const string &strUrlTmp) {
            // 播放失败，延时重试播放
            strongSelf->rePlay(strUrlTmp, (*piFailedCnt)++);
        } else {
-            //达到了最大重试次数，回调关闭
+            // 达到了最大重试次数，回调关闭
            strongSelf->_on_close(err);
        }
    });
@@ -84,7 +86,7 @@ void PlayerProxy::play(const string &strUrlTmp) {
            return;
        }
-        //注销直接拉流代理产生的流：#532
+        // 注销直接拉流代理产生的流：#532
        strongSelf->setMediaSource(nullptr);
        if (strongSelf->_muxer) {
@@ -101,19 +103,19 @@ void PlayerProxy::play(const string &strUrlTmp) {
            }
        }
-        if(*piFailedCnt == 0){
+        if (*piFailedCnt == 0) {
            // 第一次重拉更新时长
-            strongSelf->_live_secs += strongSelf->_live_ticker.elapsedTime()/1000;
+            strongSelf->_live_secs += strongSelf->_live_ticker.elapsedTime() / 1000;
            strongSelf->_live_ticker.resetTime();
-            TraceL<<" live secs "<<strongSelf->_live_secs;
+            TraceL << " live secs " << strongSelf->_live_secs;
        }
-        //播放异常中断，延时重试播放
+        // 播放异常中断，延时重试播放
        if (*piFailedCnt < strongSelf->_retry_count || strongSelf->_retry_count < 0) {
            strongSelf->_repull_count++;
            strongSelf->rePlay(strUrlTmp, (*piFailedCnt)++);
        } else {
-            //达到了最大重试次数，回调关闭
+            // 达到了最大重试次数，回调关闭
            strongSelf->_on_close(err);
        }
    });
@@ -131,13 +133,13 @@ void PlayerProxy::play(const string &strUrlTmp) {
 void PlayerProxy::setDirectProxy() {
    MediaSource::Ptr mediaSource;
    if (dynamic_pointer_cast<RtspPlayer>(_delegate)) {
-        //rtsp拉流
+        // rtsp拉流
        GET_CONFIG(bool, directProxy, Rtsp::kDirectProxy);
        if (directProxy) {
            mediaSource = std::make_shared<RtspMediaSource>(_vhost, _app, _stream_id);
        }
    } else if (dynamic_pointer_cast<RtmpPlayer>(_delegate)) {
-        //rtmp拉流,rtmp强制直接代理
+        // rtmp拉流,rtmp强制直接代理
        mediaSource = std::make_shared<RtmpMediaSource>(_vhost, _app, _stream_id);
    }
    if (mediaSource) {
@@ -148,7 +150,7 @@ void PlayerProxy::setDirectProxy() {
 PlayerProxy::~PlayerProxy() {
    _timer.reset();
    // 避免析构时, 忘记回调api请求
-     if(_on_play) {
+    if (_on_play) {
        _on_play(SockException(Err_shutdown, "player proxy close"));
        _on_play = nullptr;
    }
@@ -157,21 +159,24 @@ PlayerProxy::~PlayerProxy() {
 void PlayerProxy::rePlay(const string &strUrl, int iFailedCnt) {
    auto iDelay = MAX(2 * 1000, MIN(iFailedCnt * 3000, 60 * 1000));
    weak_ptr<PlayerProxy> weakSelf = shared_from_this();
-    _timer = std::make_shared<Timer>(iDelay / 1000.0f, [weakSelf, strUrl, iFailedCnt]() {
+    _timer = std::make_shared<Timer>(
-        //播放失败次数越多，则延时越长
+        iDelay / 1000.0f,
-        auto strongPlayer = weakSelf.lock();
+        [weakSelf, strUrl, iFailedCnt]() {
-        if (!strongPlayer) {
+            // 播放失败次数越多，则延时越长
+            auto strongPlayer = weakSelf.lock();
+            if (!strongPlayer) {
+                return false;
+            }
+            WarnL << "重试播放[" << iFailedCnt << "]:" << strUrl;
+            strongPlayer->MediaPlayer::play(strUrl);
+            strongPlayer->setDirectProxy();
            return false;
-        }
+        },
-        WarnL << "重试播放[" << iFailedCnt << "]:" << strUrl;
+        getPoller());
-        strongPlayer->MediaPlayer::play(strUrl);
-        strongPlayer->setDirectProxy();
-        return false;
-    }, getPoller());
 }
 bool PlayerProxy::close(MediaSource &sender) {
-    //通知其停止推流
+    // 通知其停止推流
    weak_ptr<PlayerProxy> weakSelf = dynamic_pointer_cast<PlayerProxy>(shared_from_this());
    getPoller()->async_first([weakSelf]() {
        auto strongSelf = weakSelf.lock();
@@ -214,19 +219,19 @@ float PlayerProxy::getLossRate(MediaSource &sender, TrackType type) {
 void PlayerProxy::onPlaySuccess() {
    GET_CONFIG(bool, reset_when_replay, General::kResetWhenRePlay);
    if (dynamic_pointer_cast<RtspMediaSource>(_media_src)) {
-        //rtsp拉流代理
+        // rtsp拉流代理
        if (reset_when_replay || !_muxer) {
            _option.enable_rtsp = false;
            _muxer = std::make_shared<MultiMediaSourceMuxer>(_vhost, _app, _stream_id, getDuration(), _option);
        }
    } else if (dynamic_pointer_cast<RtmpMediaSource>(_media_src)) {
-        //rtmp拉流代理
+        // rtmp拉流代理
        if (reset_when_replay || !_muxer) {
            _option.enable_rtmp = false;
            _muxer = std::make_shared<MultiMediaSourceMuxer>(_vhost, _app, _stream_id, getDuration(), _option);
        }
    } else {
-        //其他拉流代理
+        // 其他拉流代理
        if (reset_when_replay || !_muxer) {
            _muxer = std::make_shared<MultiMediaSourceMuxer>(_vhost, _app, _stream_id, getDuration(), _option);
        }
@@ -235,25 +240,25 @@ void PlayerProxy::onPlaySuccess() {
    auto videoTrack = getTrack(TrackVideo, false);
    if (videoTrack) {
-        //添加视频
+        // 添加视频
        _muxer->addTrack(videoTrack);
-        //视频数据写入_mediaMuxer
+        // 视频数据写入_mediaMuxer
        videoTrack->addDelegate(_muxer);
    }
    auto audioTrack = getTrack(TrackAudio, false);
    if (audioTrack) {
-        //添加音频
+        // 添加音频
        _muxer->addTrack(audioTrack);
-        //音频数据写入_mediaMuxer
+        // 音频数据写入_mediaMuxer
        audioTrack->addDelegate(_muxer);
    }
-    //添加完毕所有track，防止单track情况下最大等待3秒
+    // 添加完毕所有track，防止单track情况下最大等待3秒
    _muxer->addTrackCompleted();
    if (_media_src) {
-        //让_muxer对象拦截一部分事件(比如说录像相关事件)
+        // 让_muxer对象拦截一部分事件(比如说录像相关事件)
        _media_src->setListener(_muxer);
    }
 }
@@ -262,14 +267,14 @@ int PlayerProxy::getStatus() {
    return _live_status.load();
 }
 uint64_t PlayerProxy::getLiveSecs() {
-    if(_live_status == 0){
+    if (_live_status == 0) {
-        return _live_secs + _live_ticker.elapsedTime()/1000;
+        return _live_secs + _live_ticker.elapsedTime() / 1000;
-    }else{
+    } else {
        return _live_secs;
    }
 }
-uint64_t PlayerProxy::getRePullCount(){
+uint64_t PlayerProxy::getRePullCount() {
    return _repull_count;
 }

--- a/src/Player/PlayerProxy.h
+++ b/src/Player/PlayerProxy.h
@@ -11,21 +11,25 @@
 #ifndef SRC_DEVICE_PLAYERPROXY_H_
 #define SRC_DEVICE_PLAYERPROXY_H_
-#include <memory>
 #include "Common/MultiMediaSourceMuxer.h"
 #include "Player/MediaPlayer.h"
 #include "Util/TimeTicker.h"
+#include <memory>
 namespace mediakit {
-class PlayerProxy : public MediaPlayer, public MediaSourceEvent, public std::enable_shared_from_this<PlayerProxy> {
+class PlayerProxy
+    : public MediaPlayer
+    , public MediaSourceEvent
+    , public std::enable_shared_from_this<PlayerProxy> {
 public:
    using Ptr = std::shared_ptr<PlayerProxy>;
-    //如果retry_count<0,则一直重试播放；否则重试retry_count次数
+    // 如果retry_count<0,则一直重试播放；否则重试retry_count次数
-    //默认一直重试
+    // 默认一直重试
-    PlayerProxy(const std::string &vhost, const std::string &app, const std::string &stream_id,
+    PlayerProxy(
-                const ProtocolOption &option, int retry_count = -1, const toolkit::EventPoller::Ptr &poller = nullptr);
+        const std::string &vhost, const std::string &app, const std::string &stream_id, const ProtocolOption &option, int retry_count = -1,
+        const toolkit::EventPoller::Ptr &poller = nullptr);
    ~PlayerProxy() override;
@@ -50,15 +54,14 @@ public:
    /**
     * 获取观看总人数
     */
-    int totalReaderCount() ;
+    int totalReaderCount();
    int getStatus();
    uint64_t getLiveSecs();
    uint64_t getRePullCount();
 private:
-    //MediaSourceEvent override
+    // MediaSourceEvent override
    bool close(MediaSource &sender) override;
    int totalReaderCount(MediaSource &sender) override;
    MediaOriginType getOriginType(MediaSource &sender) const override;
@@ -66,7 +69,7 @@ private:
    std::shared_ptr<toolkit::SockInfo> getOriginSock(MediaSource &sender) const override;
    float getLossRate(MediaSource &sender, TrackType type) override;
-    void rePlay(const std::string &strUrl,int iFailedCnt);
+    void rePlay(const std::string &strUrl, int iFailedCnt);
    void onPlaySuccess();
    void setDirectProxy();
@@ -83,8 +86,8 @@ private:
    MultiMediaSourceMuxer::Ptr _muxer;
    toolkit::Ticker _live_ticker;
-    //0 表示正常 1 表示正在尝试拉流
+    // 0 表示正常 1 表示正在尝试拉流
-    std::atomic<int> _live_status; 
+    std::atomic<int> _live_status;
    std::atomic<uint64_t> _live_secs;
    std::atomic<uint64_t> _repull_count;

--- a/src/Pusher/PusherProxy.cpp
+++ b/src/Pusher/PusherProxy.cpp
@@ -16,7 +16,7 @@ using namespace std;
 namespace mediakit {
 PusherProxy::PusherProxy(const MediaSource::Ptr &src, int retry_count, const EventPoller::Ptr &poller)
-            : MediaPusher(src, poller){
+    : MediaPusher(src, poller) {
    _retry_count = retry_count;
    _on_close = [](const SockException &) {};
    _weak_src = src;
@@ -65,7 +65,7 @@ void PusherProxy::publish(const string &dst_url) {
            strong_self->_live_status = 1;
            strong_self->rePublish(dst_url, (*failed_cnt)++);
        } else {
-            //如果媒体源已经注销, 或达到了最大重试次数，回调关闭
+            // 如果媒体源已经注销, 或达到了最大重试次数，回调关闭
            strong_self->_on_close(err);
        }
    });
@@ -76,20 +76,20 @@ void PusherProxy::publish(const string &dst_url) {
            return;
        }
-        if(*failed_cnt == 0){
+        if (*failed_cnt == 0) {
            // 第一次重推更新时长
-            strong_self->_live_secs += strong_self->_live_ticker.elapsedTime()/1000;
+            strong_self->_live_secs += strong_self->_live_ticker.elapsedTime() / 1000;
            strong_self->_live_ticker.resetTime();
-            TraceL<<" live secs "<<strong_self->_live_secs;
+            TraceL << " live secs " << strong_self->_live_secs;
        }
        auto src = strong_self->_weak_src.lock();
-        //推流异常中断，延时重试播放
+        // 推流异常中断，延时重试播放
        if (src && (*failed_cnt < strong_self->_retry_count || strong_self->_retry_count < 0)) {
            strong_self->_republish_count++;
            strong_self->rePublish(dst_url, (*failed_cnt)++);
        } else {
-            //如果媒体源已经注销, 或达到了最大重试次数，回调关闭
+            // 如果媒体源已经注销, 或达到了最大重试次数，回调关闭
            strong_self->_on_close(err);
        }
    });
@@ -100,30 +100,33 @@ void PusherProxy::publish(const string &dst_url) {
 void PusherProxy::rePublish(const string &dst_url, int failed_cnt) {
    auto delay = MAX(2 * 1000, MIN(failed_cnt * 3000, 60 * 1000));
    weak_ptr<PusherProxy> weak_self = shared_from_this();
-    _timer = std::make_shared<Timer>(delay / 1000.0f, [weak_self, dst_url, failed_cnt]() {
+    _timer = std::make_shared<Timer>(
-        //推流失败次数越多，则延时越长
+        delay / 1000.0f,
-        auto strong_self = weak_self.lock();
+        [weak_self, dst_url, failed_cnt]() {
-        if (!strong_self) {
+            // 推流失败次数越多，则延时越长
+            auto strong_self = weak_self.lock();
+            if (!strong_self) {
+                return false;
+            }
+            WarnL << "推流重试[" << failed_cnt << "]:" << dst_url;
+            strong_self->MediaPusher::publish(dst_url);
            return false;
-        }
+        },
-        WarnL << "推流重试[" << failed_cnt << "]:" << dst_url;
+        getPoller());
-        strong_self->MediaPusher::publish(dst_url);
-        return false;
-    }, getPoller());
 }
 int PusherProxy::getStatus() {
    return _live_status.load();
 }
 uint64_t PusherProxy::getLiveSecs() {
-    if(_live_status == 0){
+    if (_live_status == 0) {
-        return _live_secs + _live_ticker.elapsedTime()/1000;
+        return _live_secs + _live_ticker.elapsedTime() / 1000;
-    }else{
+    } else {
        return _live_secs;
    }
 }
-uint64_t PusherProxy::getRePublishCount(){
+uint64_t PusherProxy::getRePublishCount() {
    return _republish_count;
 }

--- a/src/Pusher/PusherProxy.h
+++ b/src/Pusher/PusherProxy.h
@@ -16,7 +16,9 @@
 namespace mediakit {
-class PusherProxy : public MediaPusher, public std::enable_shared_from_this<PusherProxy> {
+class PusherProxy
+    : public MediaPusher
+    , public std::enable_shared_from_this<PusherProxy> {
 public:
    using Ptr = std::shared_ptr<PusherProxy>;
@@ -41,7 +43,7 @@ public:
     * 开始拉流播放
     * @param dstUrl 目标推流地址
     */
-    void publish(const std::string& dstUrl) override;
+    void publish(const std::string &dstUrl) override;
    int getStatus();
    uint64_t getLiveSecs();
@@ -55,8 +57,8 @@ private:
    int _retry_count;
    toolkit::Timer::Ptr _timer;
    toolkit::Ticker _live_ticker;
-    //0 表示正常 1 表示正在尝试推流
+    // 0 表示正常 1 表示正在尝试推流
-    std::atomic<int> _live_status; 
+    std::atomic<int> _live_status;
    std::atomic<uint64_t> _live_secs;
    std::atomic<uint64_t> _republish_count;
    std::weak_ptr<MediaSource> _weak_src;
@@ -66,4 +68,4 @@ private:
 } /* namespace mediakit */
-#endif //SRC_DEVICE_PUSHERPROXY_H
+#endif // SRC_DEVICE_PUSHERPROXY_H