diff --git a/server/FFmpegSource.cpp b/server/FFmpegSource.cpp
index 53b481bc..848a9f01 100644
--- a/server/FFmpegSource.cpp
+++ b/server/FFmpegSource.cpp
@@ -245,30 +245,6 @@ bool FFmpegSource::close(MediaSource &sender, bool force) {
     return true;
 }
 
-int FFmpegSource::totalReaderCount(MediaSource &sender) {
-    auto listener = _listener.lock();
-    if(listener){
-        return listener->totalReaderCount(sender);
-    }
-    return sender.readerCount();
-}
-
-void FFmpegSource::onNoneReader(MediaSource &sender){
-    auto listener = _listener.lock();
-    if(listener){
-        listener->onNoneReader(sender);
-        return;
-    }
-    MediaSourceEvent::onNoneReader(sender);
-}
-
-void FFmpegSource::onRegist(MediaSource &sender, bool regist){
-    auto listener = _listener.lock();
-    if(listener){
-        listener->onRegist(sender, regist);
-    }
-}
-
 void FFmpegSource::onGetMediaSource(const MediaSource::Ptr &src) {
     auto listener = src->getListener();
     if (listener.lock().get() != this) {
diff --git a/server/FFmpegSource.h b/server/FFmpegSource.h
index 00635ac5..02fc288c 100644
--- a/server/FFmpegSource.h
+++ b/server/FFmpegSource.h
@@ -40,7 +40,7 @@ private:
     ~FFmpegSnap() = delete;
 };
 
-class FFmpegSource : public std::enable_shared_from_this<FFmpegSource> , public MediaSourceEvent{
+class FFmpegSource : public std::enable_shared_from_this<FFmpegSource> , public MediaSourceEventInterceptor{
 public:
     typedef shared_ptr<FFmpegSource> Ptr;
     typedef function<void(const SockException &ex)> onPlay;
@@ -60,9 +60,6 @@ private:
 
     //MediaSourceEvent override
     bool close(MediaSource &sender,bool force) override;
-    int totalReaderCount(MediaSource &sender) override;
-    void onNoneReader(MediaSource &sender) override;
-    void onRegist(MediaSource &sender, bool regist) override;
 
 private:
     Process _process;
@@ -72,7 +69,6 @@ private:
     string _src_url;
     string _dst_url;
     function<void()> _onClose;
-    std::weak_ptr<MediaSourceEvent> _listener;
     Ticker _replay_ticker;
 };
 
diff --git a/src/Common/MediaSink.h b/src/Common/MediaSink.h
index ea7e3408..45afe88d 100644
--- a/src/Common/MediaSink.h
+++ b/src/Common/MediaSink.h
@@ -36,6 +36,11 @@ public:
      */
     virtual void addTrack(const Track::Ptr & track) = 0;
 
+    /**
+     * 添加所有Track完毕
+     */
+    virtual void addTrackCompleted() {}
+
     /**
      * 重置track
      */
@@ -70,7 +75,7 @@ public:
      * 这样会增加生成流的延时，如果添加了音视频双Track，那么可以不调用此方法
      * 否则为了降低流注册延时，请手动调用此方法
      */
-    void addTrackCompleted();
+    void addTrackCompleted() override;
 
     /**
      * 重置track
diff --git a/src/Common/MediaSource.cpp b/src/Common/MediaSource.cpp
index d203034f..1cf04a2a 100644
--- a/src/Common/MediaSource.cpp
+++ b/src/Common/MediaSource.cpp
@@ -17,16 +17,19 @@
 using namespace toolkit;
 namespace mediakit {
 
-recursive_mutex MediaSource::g_mtxMediaSrc;
-MediaSource::SchemaVhostAppStreamMap MediaSource::g_mapMediaSrc;
+recursive_mutex s_media_source_mtx;
+MediaSource::SchemaVhostAppStreamMap s_media_source_map;
 
-MediaSource::MediaSource(const string &strSchema, const string &strVhost, const string &strApp, const string &strId) :
-        _strSchema(strSchema), _strApp(strApp), _strId(strId) {
-    if (strVhost.empty()) {
-        _strVhost = DEFAULT_VHOST;
+MediaSource::MediaSource(const string &schema, const string &vhost, const string &app, const string &stream_id){
+    GET_CONFIG(bool, enableVhost, General::kEnableVhost);
+    if (!enableVhost) {
+        _vhost = DEFAULT_VHOST;
     } else {
-        _strVhost = strVhost;
+        _vhost = vhost.empty() ? DEFAULT_VHOST : vhost;
     }
+    _schema = schema;
+    _app = app;
+    _stream_id = stream_id;
 }
 
 MediaSource::~MediaSource() {
@@ -34,26 +37,26 @@ MediaSource::~MediaSource() {
 }
 
 const string& MediaSource::getSchema() const {
-    return _strSchema;
+    return _schema;
 }
 
 const string& MediaSource::getVhost() const {
-    return _strVhost;
+    return _vhost;
 }
 
 const string& MediaSource::getApp() const {
     //获取该源的id
-    return _strApp;
+    return _app;
 }
 
 const string& MediaSource::getId() const {
-    return _strId;
+    return _stream_id;
 }
 
-vector<Track::Ptr> MediaSource::getTracks(bool trackReady) const {
+vector<Track::Ptr> MediaSource::getTracks(bool ready) const {
     auto strongPtr = _track_source.lock();
     if(strongPtr){
-        return strongPtr->getTracks(trackReady);
+        return strongPtr->getTracks(ready);
     }
     return vector<Track::Ptr>();
 }
@@ -77,12 +80,13 @@ int MediaSource::totalReaderCount(){
     }
     return listener->totalReaderCount(*this);
 }
-bool MediaSource::seekTo(uint32_t ui32Stamp) {
+
+bool MediaSource::seekTo(uint32_t stamp) {
     auto listener = _listener.lock();
     if(!listener){
         return false;
     }
-    return listener->seekTo(*this,ui32Stamp);
+    return listener->seekTo(*this, stamp);
 }
 
 bool MediaSource::close(bool force) {
@@ -121,12 +125,12 @@ bool MediaSource::isRecording(Recorder::type type){
 }
 
 void MediaSource::for_each_media(const function<void(const MediaSource::Ptr &src)> &cb) {
-    decltype(g_mapMediaSrc) copy;
+    decltype(s_media_source_map) copy;
     {
-        //拷贝g_mapMediaSrc后再遍历，考虑到是高频使用的全局单例锁，并且在上锁时会执行回调代码
+        //拷贝s_media_source_map后再遍历，考虑到是高频使用的全局单例锁，并且在上锁时会执行回调代码
         //很容易导致多个锁交叉死锁的情况，而且该函数使用频率不高，拷贝开销相对来说是可以接受的
-        lock_guard<recursive_mutex> lock(g_mtxMediaSrc);
-        copy = g_mapMediaSrc;
+        lock_guard<recursive_mutex> lock(s_media_source_mtx);
+        copy = s_media_source_map;
     }
 
     for (auto &pr0 : copy) {
@@ -181,42 +185,75 @@ static void eraseIfEmpty(MAP &map, IT0 it0, IT1 it1, IT2 it2) {
     }
 }
 
-void MediaSource::findAsync_l(const MediaInfo &info, const std::shared_ptr<TcpSession> &session, bool retry, const function<void(const MediaSource::Ptr &src)> &cb){
-    auto src = MediaSource::find_l(info._schema, info._vhost, info._app, info._streamid, true);
+static MediaSource::Ptr find_l(const string &schema, const string &vhost_in, const string &app, const string &id, bool create_new) {
+    string vhost = vhost_in;
+    GET_CONFIG(bool,enableVhost,General::kEnableVhost);
+    if(vhost.empty() || !enableVhost){
+        vhost = DEFAULT_VHOST;
+    }
+
+    MediaSource::Ptr ret;
+    {
+        lock_guard<recursive_mutex> lock(s_media_source_mtx);
+        //查找某一媒体源，找到后返回
+        searchMedia(s_media_source_map, schema, vhost, app, id,
+                    [&](MediaSource::SchemaVhostAppStreamMap::iterator &it0, MediaSource::VhostAppStreamMap::iterator &it1,
+                        MediaSource::AppStreamMap::iterator &it2, MediaSource::StreamMap::iterator &it3) {
+            ret = it3->second.lock();
+            if (!ret) {
+                //该对象已经销毁
+                it2->second.erase(it3);
+                eraseIfEmpty(s_media_source_map, it0, it1, it2);
+                return false;
+            }
+            return true;
+        });
+    }
+
+    if(!ret && create_new){
+        //未查找媒体源，则创建一个
+        ret = MediaSource::createFromMP4(schema, vhost, app, id);
+    }
+    return ret;
+}
+
+static void findAsync_l(const MediaInfo &info, const std::shared_ptr<TcpSession> &session, bool retry,
+                        const function<void(const MediaSource::Ptr &src)> &cb){
+    auto src = find_l(info._schema, info._vhost, info._app, info._streamid, true);
     if (src || !retry) {
         cb(src);
         return;
     }
 
     void *listener_tag = session.get();
-    weak_ptr<TcpSession> weakSession = session;
+    weak_ptr<TcpSession> weak_session = session;
 
     GET_CONFIG(int, maxWaitMS, General::kMaxStreamWaitTimeMS);
-    auto onTimeout = session->getPoller()->doDelayTask(maxWaitMS, [cb, listener_tag]() {
+    auto on_timeout = session->getPoller()->doDelayTask(maxWaitMS, [cb, listener_tag]() {
         //最多等待一定时间，如果这个时间内，流未注册上，那么返回未找到流
         NoticeCenter::Instance().delListener(listener_tag, Broadcast::kBroadcastMediaChanged);
         cb(nullptr);
         return 0;
     });
 
-    auto cancelAll = [onTimeout, listener_tag]() {
+    auto cancel_all = [on_timeout, listener_tag]() {
         //取消延时任务，防止多次回调
-        onTimeout->cancel();
+        on_timeout->cancel();
         //取消媒体注册事件监听
         NoticeCenter::Instance().delListener(listener_tag, Broadcast::kBroadcastMediaChanged);
     };
 
-    function<void()> closePlayer = [cb, cancelAll]() {
-        cancelAll();
+    function<void()> close_player = [cb, cancel_all]() {
+        cancel_all();
         //告诉播放器，流不存在，这样会立即断开播放器
         cb(nullptr);
     };
 
-    auto onRegist = [weakSession, info, cb, cancelAll](BroadcastMediaChangedArgs) {
-        auto strongSession = weakSession.lock();
-        if (!strongSession) {
+    auto on_regist = [weak_session, info, cb, cancel_all](BroadcastMediaChangedArgs) {
+        auto strong_session = weak_session.lock();
+        if (!strong_session) {
             //自己已经销毁
-            cancelAll();
+            cancel_all();
             return;
         }
 
@@ -229,11 +266,11 @@ void MediaSource::findAsync_l(const MediaInfo &info, const std::shared_ptr<TcpSe
             return;
         }
 
-        cancelAll();
+        cancel_all();
 
         //播发器请求的流终于注册上了，切换到自己的线程再回复
-        strongSession->async([weakSession, info, cb]() {
-            auto strongSession = weakSession.lock();
+        strong_session->async([weak_session, info, cb]() {
+            auto strongSession = weak_session.lock();
             if (!strongSession) {
                 return;
             }
@@ -244,9 +281,9 @@ void MediaSource::findAsync_l(const MediaInfo &info, const std::shared_ptr<TcpSe
     };
 
     //监听媒体注册事件
-    NoticeCenter::Instance().addListener(listener_tag, Broadcast::kBroadcastMediaChanged, onRegist);
+    NoticeCenter::Instance().addListener(listener_tag, Broadcast::kBroadcastMediaChanged, on_regist);
     //广播未找到流,此时可以立即去拉流，这样还来得及
-    NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastNotFoundStream, info, static_cast<SockInfo &>(*session), closePlayer);
+    NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastNotFoundStream, info, static_cast<SockInfo &>(*session), close_player);
 }
 
 void MediaSource::findAsync(const MediaInfo &info, const std::shared_ptr<TcpSession> &session,const function<void(const Ptr &src)> &cb){
@@ -257,55 +294,10 @@ MediaSource::Ptr MediaSource::find(const string &schema, const string &vhost, co
     return find_l(schema, vhost, app, id, false);
 }
 
-MediaSource::Ptr MediaSource::find_l(const string &schema, const string &vhost_tmp, const string &app, const string &id, bool bMake) {
-    string vhost = vhost_tmp;
-    if(vhost.empty()){
-        vhost = DEFAULT_VHOST;
-    }
-
-    GET_CONFIG(bool,enableVhost,General::kEnableVhost);
-    if(!enableVhost){
-        vhost = DEFAULT_VHOST;
-    }
-
-    MediaSource::Ptr ret;
-    {
-        lock_guard<recursive_mutex> lock(g_mtxMediaSrc);
-        //查找某一媒体源，找到后返回
-        searchMedia(g_mapMediaSrc, schema, vhost, app, id, [&](SchemaVhostAppStreamMap::iterator &it0,
-                                                               VhostAppStreamMap::iterator &it1,
-                                                               AppStreamMap::iterator &it2,
-                                                               StreamMap::iterator &it3) {
-            ret = it3->second.lock();
-            if (!ret) {
-                //该对象已经销毁
-                it2->second.erase(it3);
-                eraseIfEmpty(g_mapMediaSrc, it0, it1, it2);
-                return false;
-            }
-            return true;
-        });
-    }
-
-    if(!ret && bMake){
-        //未查找媒体源，则创建一个
-        ret = createFromMP4(schema, vhost, app, id);
-    }
-    return ret;
-}
-void MediaSource::regist() {
-    GET_CONFIG(bool,enableVhost,General::kEnableVhost);
-    if(!enableVhost){
-        _strVhost = DEFAULT_VHOST;
-    }
-    //注册该源，注册后服务器才能找到该源
-    {
-        lock_guard<recursive_mutex> lock(g_mtxMediaSrc);
-        g_mapMediaSrc[_strSchema][_strVhost][_strApp][_strId] = shared_from_this();
-    }
+static string getTrackInfoStr(const TrackSource *track_src){
     _StrPrinter codec_info;
-    auto tracks = getTracks(true);
-    for(auto &track : tracks) {
+    auto tracks = track_src->getTracks(true);
+    for (auto &track : tracks) {
         auto codec_type = track->getTrackType();
         codec_info << track->getCodecName();
         switch (codec_type) {
@@ -329,45 +321,51 @@ void MediaSource::regist() {
                 break;
         }
     }
+    return codec_info;
+}
 
-    InfoL << _strSchema << " " << _strVhost << " " << _strApp << " " << _strId << " " << codec_info;
-    NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastMediaChanged, true, *this);
-
+void MediaSource::emitEvent(bool regist){
     auto listener = _listener.lock();
     if (listener) {
-        listener->onRegist(*this, true);
+        //触发回调
+        listener->onRegist(*this, regist);
     }
+    //触发广播
+    NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastMediaChanged, regist, *this);
+    InfoL << (regist ? "媒体注册:" : "媒体注销:") << _schema << " " << _vhost << " " << _app << " " << _stream_id << " " << getTrackInfoStr(this);
+}
+
+void MediaSource::regist() {
+    {
+        //减小互斥锁临界区
+        lock_guard<recursive_mutex> lock(s_media_source_mtx);
+        s_media_source_map[_schema][_vhost][_app][_stream_id] = shared_from_this();
+    }
+    emitEvent(true);
 }
 
 //反注册该源
 bool MediaSource::unregist() {
     bool ret;
     {
-        lock_guard<recursive_mutex> lock(g_mtxMediaSrc);
-        ret = searchMedia(g_mapMediaSrc, _strSchema, _strVhost, _strApp, _strId,
-                          [&](SchemaVhostAppStreamMap::iterator &it0,
-                              VhostAppStreamMap::iterator &it1,
-                              AppStreamMap::iterator &it2,
-                              StreamMap::iterator &it3) {
-                              auto strongMedia = it3->second.lock();
-                              if (strongMedia && this != strongMedia.get()) {
-                                  //不是自己,不允许反注册
-                                  return false;
-                              }
-                              it2->second.erase(it3);
-                              eraseIfEmpty(g_mapMediaSrc, it0, it1, it2);
-                              return true;
-                          });
+        //减小互斥锁临界区
+        lock_guard<recursive_mutex> lock(s_media_source_mtx);
+        ret = searchMedia(s_media_source_map, _schema, _vhost, _app, _stream_id,
+                          [&](SchemaVhostAppStreamMap::iterator &it0, VhostAppStreamMap::iterator &it1,
+                              AppStreamMap::iterator &it2, StreamMap::iterator &it3) {
+          auto strong_self = it3->second.lock();
+          if (strong_self && this != strong_self.get()) {
+              //不是自己,不允许反注册
+              return false;
+          }
+          it2->second.erase(it3);
+          eraseIfEmpty(s_media_source_map, it0, it1, it2);
+          return true;
+      });
     }
 
-    if(ret){
-        InfoL <<  _strSchema << " " << _strVhost << " " << _strApp << " " << _strId;
-        NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastMediaChanged, false, *this);
-
-        auto listener = _listener.lock();
-        if (listener) {
-            listener->onRegist(*this, false);
-        }
+    if (ret) {
+        emitEvent(false);
     }
     return ret;
 }
@@ -377,67 +375,87 @@ bool MediaSource::unregist() {
 void MediaInfo::parse(const string &url){
     //string url = "rtsp://127.0.0.1:8554/live/id?key=val&a=1&&b=2&vhost=vhost.com";
     auto schema_pos = url.find("://");
-    if(schema_pos != string::npos){
-        _schema = url.substr(0,schema_pos);
-    }else{
+    if (schema_pos != string::npos) {
+        _schema = url.substr(0, schema_pos);
+    } else {
         schema_pos = -3;
     }
-    auto split_vec = split(url.substr(schema_pos + 3),"/");
-    if(split_vec.size() > 0){
+    auto split_vec = split(url.substr(schema_pos + 3), "/");
+    if (split_vec.size() > 0) {
         auto vhost = split_vec[0];
         auto pos = vhost.find(":");
-        if(pos != string::npos){
-            _host = _vhost = vhost.substr(0,pos);
+        if (pos != string::npos) {
+            _host = _vhost = vhost.substr(0, pos);
             _port = vhost.substr(pos + 1);
-        } else{
+        } else {
             _host = _vhost = vhost;
         }
 
-        if(_vhost == "localhost" || INADDR_NONE != inet_addr(_vhost.data())){
+        if (_vhost == "localhost" || INADDR_NONE != inet_addr(_vhost.data())) {
             //如果访问的是localhost或ip，那么则为默认虚拟主机
             _vhost = DEFAULT_VHOST;
         }
 
     }
-    if(split_vec.size() > 1){
+    if (split_vec.size() > 1) {
         _app = split_vec[1];
     }
-    if(split_vec.size() > 2){
-        string steamid;
-        for(int i = 2 ; i < split_vec.size() ; ++i){
-            steamid.append(split_vec[i] + "/");
+    if (split_vec.size() > 2) {
+        string stream_id;
+        for (int i = 2; i < split_vec.size(); ++i) {
+            stream_id.append(split_vec[i] + "/");
         }
-        if(steamid.back() == '/'){
-            steamid.pop_back();
+        if (stream_id.back() == '/') {
+            stream_id.pop_back();
         }
-        auto pos = steamid.find("?");
-        if(pos != string::npos){
-            _streamid = steamid.substr(0,pos);
-            _param_strs = steamid.substr(pos + 1);
+        auto pos = stream_id.find("?");
+        if (pos != string::npos) {
+            _streamid = stream_id.substr(0, pos);
+            _param_strs = stream_id.substr(pos + 1);
             auto params = Parser::parseArgs(_param_strs);
-            if(params.find(VHOST_KEY) != params.end()){
+            if (params.find(VHOST_KEY) != params.end()) {
                 _vhost = params[VHOST_KEY];
             }
-        } else{
-            _streamid = steamid;
+        } else {
+            _streamid = stream_id;
         }
     }
 
-    GET_CONFIG(bool,enableVhost,General::kEnableVhost);
-    if(!enableVhost || _vhost.empty()){
+    GET_CONFIG(bool, enableVhost, General::kEnableVhost);
+    if (!enableVhost || _vhost.empty()) {
         //如果关闭虚拟主机或者虚拟主机为空，则设置虚拟主机为默认
         _vhost = DEFAULT_VHOST;
     }
 }
 
+MediaSource::Ptr MediaSource::createFromMP4(const string &schema, const string &vhost, const string &app, const string &stream, const string &file_path , bool check_app){
+    GET_CONFIG(string, appName, Record::kAppName);
+    if (check_app && app != appName) {
+        return nullptr;
+    }
+#ifdef ENABLE_MP4
+    try {
+        MP4Reader::Ptr pReader(new MP4Reader(vhost, app, stream, file_path));
+        pReader->startReadMP4();
+        return MediaSource::find(schema, vhost, app, stream);
+    } catch (std::exception &ex) {
+        WarnL << ex.what();
+        return nullptr;
+    }
+#else
+    WarnL << "创建MP4点播失败，请编译时打开\"ENABLE_MP4\"选项";
+    return nullptr;
+#endif //ENABLE_MP4
+}
+
 /////////////////////////////////////MediaSourceEvent//////////////////////////////////////
 
 void MediaSourceEvent::onNoneReader(MediaSource &sender){
-    GET_CONFIG(string, recordApp, Record::kAppName);
+    GET_CONFIG(string, record_app, Record::kAppName);
     GET_CONFIG(int, stream_none_reader_delay, General::kStreamNoneReaderDelayMS);
 
     //如果mp4点播, 无人观看时我们强制关闭点播
-    bool is_mp4_vod = sender.getApp() == recordApp;
+    bool is_mp4_vod = sender.getApp() == record_app;
 
     //没有任何人观看该视频源，表明该源可以关闭了
     weak_ptr<MediaSource> weakSender = sender.shared_from_this();
@@ -475,26 +493,64 @@ void MediaSourceEvent::onNoneReader(MediaSource &sender){
     }, nullptr);
 }
 
-MediaSource::Ptr MediaSource::createFromMP4(const string &schema, const string &vhost, const string &app, const string &stream, const string &filePath , bool checkApp){
-    GET_CONFIG(string, appName, Record::kAppName);
-    if (checkApp && app != appName) {
-        return nullptr;
+bool MediaSourceEventInterceptor::seekTo(MediaSource &sender, uint32_t stamp) {
+    auto listener = _listener.lock();
+    if (!listener) {
+        return false;
     }
-#ifdef ENABLE_MP4
-    try {
-        MP4Reader::Ptr pReader(new MP4Reader(vhost, app, stream, filePath));
-        pReader->startReadMP4();
-        return MediaSource::find(schema, vhost, app, stream);
-    } catch (std::exception &ex) {
-        WarnL << ex.what();
-        return nullptr;
-    }
-#else
-    WarnL << "创建MP4点播失败，请编译时打开\"ENABLE_MP4\"选项";
-    return nullptr;
-#endif //ENABLE_MP4
+    return listener->seekTo(sender, stamp);
 }
 
+bool MediaSourceEventInterceptor::close(MediaSource &sender, bool force) {
+    auto listener = _listener.lock();
+    if (!listener) {
+        return false;
+    }
+    return listener->close(sender, force);
+}
+
+int MediaSourceEventInterceptor::totalReaderCount(MediaSource &sender) {
+    auto listener = _listener.lock();
+    if (!listener) {
+        return sender.readerCount();
+    }
+    return listener->totalReaderCount(sender);
+}
+
+void MediaSourceEventInterceptor::onNoneReader(MediaSource &sender) {
+    auto listener = _listener.lock();
+    if (!listener) {
+        MediaSourceEvent::onNoneReader(sender);
+        return;
+    }
+    listener->onNoneReader(sender);
+}
+
+void MediaSourceEventInterceptor::onRegist(MediaSource &sender, bool regist) {
+    auto listener = _listener.lock();
+    if (listener) {
+        listener->onRegist(sender, regist);
+    }
+}
+
+bool MediaSourceEventInterceptor::setupRecord(MediaSource &sender, Recorder::type type, bool start, const string &custom_path) {
+    auto listener = _listener.lock();
+    if (!listener) {
+        return false;
+    }
+    return listener->setupRecord(sender, type, start, custom_path);
+}
+
+bool MediaSourceEventInterceptor::isRecording(MediaSource &sender, Recorder::type type) {
+    auto listener = _listener.lock();
+    if (!listener) {
+        return false;
+    }
+    return listener->isRecording(sender, type);
+}
+
+/////////////////////////////////////FlushPolicy//////////////////////////////////////
+
 static bool isFlushAble_default(bool is_video, uint32_t last_stamp, uint32_t new_stamp, int cache_size) {
     if (new_stamp + 500 < last_stamp) {
         //时间戳回退比较大(可能seek中)，由于rtp中时间戳是pts，是可能存在一定程度的回退的
diff --git a/src/Common/MediaSource.h b/src/Common/MediaSource.h
index 9dcab1ff..9d4bd0e9 100644
--- a/src/Common/MediaSource.h
+++ b/src/Common/MediaSource.h
@@ -44,33 +44,54 @@ public:
     virtual ~MediaSourceEvent(){};
 
     // 通知拖动进度条
-    virtual bool seekTo(MediaSource &sender,uint32_t ui32Stamp){ return false; }
-    // 通知其停止推流
-    virtual bool close(MediaSource &sender,bool force) { return false;}
-    // 观看总人数
+    virtual bool seekTo(MediaSource &sender, uint32_t stamp) { return false; }
+    // 通知其停止产生流
+    virtual bool close(MediaSource &sender, bool force) { return false; }
+    // 获取观看总人数
     virtual int totalReaderCount(MediaSource &sender) = 0;
-    // 开启或关闭录制
-    virtual bool setupRecord(MediaSource &sender, Recorder::type type, bool start, const string &custom_path) { return false; };
-    // 获取录制状态
-    virtual bool isRecording(MediaSource &sender, Recorder::type type) { return false; };
     // 通知无人观看
     virtual void onNoneReader(MediaSource &sender);
     //流注册或注销事件
     virtual void onRegist(MediaSource &sender, bool regist) {};
 
+    ////////////////////////仅供MultiMediaSourceMuxer对象继承////////////////////////
+    // 开启或关闭录制
+    virtual bool setupRecord(MediaSource &sender, Recorder::type type, bool start, const string &custom_path) { return false; };
+    // 获取录制状态
+    virtual bool isRecording(MediaSource &sender, Recorder::type type) { return false; };
+
 private:
     Timer::Ptr _async_close_timer;
 };
 
+//该对象用于拦截感兴趣的MediaSourceEvent事件
+class MediaSourceEventInterceptor : public MediaSourceEvent{
+public:
+    MediaSourceEventInterceptor(){}
+    ~MediaSourceEventInterceptor() override {}
+
+    bool seekTo(MediaSource &sender, uint32_t stamp) override;
+    bool close(MediaSource &sender, bool force) override;
+    int totalReaderCount(MediaSource &sender) override;
+    void onNoneReader(MediaSource &sender) override;
+    void onRegist(MediaSource &sender, bool regist) override;;
+    bool setupRecord(MediaSource &sender, Recorder::type type, bool start, const string &custom_path) override;
+    bool isRecording(MediaSource &sender, Recorder::type type) override;
+
+protected:
+    std::weak_ptr<MediaSourceEvent> _listener;
+};
+
 /**
  * 解析url获取媒体相关信息
  */
 class MediaInfo{
 public:
-    MediaInfo(){}
-    ~MediaInfo(){}
-    MediaInfo(const string &url){ parse(url); }
+    ~MediaInfo() {}
+    MediaInfo() {}
+    MediaInfo(const string &url) { parse(url); }
     void parse(const string &url);
+
 public:
     string _schema;
     string _host;
@@ -92,7 +113,7 @@ public:
     typedef unordered_map<string, AppStreamMap > VhostAppStreamMap;
     typedef unordered_map<string, VhostAppStreamMap > SchemaVhostAppStreamMap;
 
-    MediaSource(const string &strSchema, const string &strVhost, const string &strApp, const string &strId) ;
+    MediaSource(const string &schema, const string &vhost, const string &app, const string &stream_id) ;
     virtual ~MediaSource() ;
 
     // 获取协议类型
@@ -107,7 +128,7 @@ public:
     // 设置TrackSource
     void setTrackSource(const std::weak_ptr<TrackSource> &track_src);
     // 获取所有Track
-    vector<Track::Ptr> getTracks(bool trackReady = true) const override;
+    vector<Track::Ptr> getTracks(bool ready = true) const override;
 
     // 设置监听者
     virtual void setListener(const std::weak_ptr<MediaSourceEvent> &listener);
@@ -120,12 +141,12 @@ public:
     virtual int totalReaderCount();
 
     // 获取流当前时间戳
-    virtual uint32_t getTimeStamp(TrackType trackType) { return 0; };
+    virtual uint32_t getTimeStamp(TrackType type) { return 0; };
     // 设置时间戳
-    virtual void setTimeStamp(uint32_t uiStamp) {};
+    virtual void setTimeStamp(uint32_t stamp) {};
 
     // 拖动进度条
-    bool seekTo(uint32_t ui32Stamp);
+    bool seekTo(uint32_t stamp);
     // 关闭该流
     bool close(bool force);
     // 该流无人观看
@@ -141,26 +162,26 @@ public:
     static void findAsync(const MediaInfo &info, const std::shared_ptr<TcpSession> &session, const function<void(const Ptr &src)> &cb);
     // 遍历所有流
     static void for_each_media(const function<void(const Ptr &src)> &cb);
-
     // 从mp4文件生成MediaSource
-    static MediaSource::Ptr createFromMP4(const string &schema, const string &vhost, const string &app, const string &stream, const string &filePath = "", bool checkApp = true);
+    static MediaSource::Ptr createFromMP4(const string &schema, const string &vhost, const string &app, const string &stream, const string &file_path = "", bool check_app = true);
 
 protected:
-    void regist() ;
-    bool unregist();
+    //媒体注册
+    void regist();
 
 private:
-    static Ptr find_l(const string &schema, const string &vhost, const string &app, const string &id, bool bMake);
-    static void findAsync_l(const MediaInfo &info, const std::shared_ptr<TcpSession> &session, bool retry, const function<void(const MediaSource::Ptr &src)> &cb);
+    //媒体注销
+    bool unregist();
+    //触发媒体事件
+    void emitEvent(bool regist);
+
 private:
-    string _strSchema;
-    string _strVhost;
-    string _strApp;
-    string _strId;
-    std::weak_ptr<MediaSourceEvent> _listener;
+    string _schema;
+    string _vhost;
+    string _app;
+    string _stream_id;
     weak_ptr<TrackSource> _track_source;
-    static SchemaVhostAppStreamMap g_mapMediaSrc;
-    static recursive_mutex g_mtxMediaSrc;
+    std::weak_ptr<MediaSourceEvent> _listener;
 };
 
 ///缓存刷新策略类
@@ -221,9 +242,9 @@ private:
     }
 
 private:
+    bool _key_pos = false;
     policy _policy;
     std::shared_ptr<packet_list> _cache;
-    bool _key_pos = false;
 };
 
 } /* namespace mediakit */
diff --git a/src/Common/MultiMediaSourceMuxer.cpp b/src/Common/MultiMediaSourceMuxer.cpp
index e9322224..868f7173 100644
--- a/src/Common/MultiMediaSourceMuxer.cpp
+++ b/src/Common/MultiMediaSourceMuxer.cpp
@@ -11,15 +11,11 @@
 #include "MultiMediaSourceMuxer.h"
 namespace mediakit {
 
+///////////////////////////////MultiMuxerPrivate//////////////////////////////////
+
 MultiMuxerPrivate::~MultiMuxerPrivate() {}
-MultiMuxerPrivate::MultiMuxerPrivate(const string &vhost,
-                                     const string &app,
-                                     const string &stream,
-                                     float dur_sec,
-                                     bool enable_rtsp,
-                                     bool enable_rtmp,
-                                     bool enable_hls,
-                                     bool enable_mp4) {
+MultiMuxerPrivate::MultiMuxerPrivate(const string &vhost, const string &app, const string &stream, float dur_sec,
+                                     bool enable_rtsp, bool enable_rtmp, bool enable_hls, bool enable_mp4) {
     if (enable_rtmp) {
         _rtmp = std::make_shared<RtmpMediaSourceMuxer>(vhost, app, stream, std::make_shared<TitleMeta>(dur_sec));
         _enable_rtxp = true;
@@ -73,7 +69,7 @@ void MultiMuxerPrivate::setMediaListener(const std::weak_ptr<MediaSourceEvent> &
     if (hls_src) {
         hls_src->setListener(listener);
     }
-    _meida_listener = listener;
+    _listener = listener;
 }
 
 int MultiMuxerPrivate::totalReaderCount() const {
@@ -99,7 +95,7 @@ bool MultiMuxerPrivate::setupRecord(MediaSource &sender, Recorder::type type, bo
                 auto hls_src = getHlsMediaSource();
                 if (hls_src) {
                     //设置HlsMediaSource的事件监听器
-                    hls_src->setListener(_meida_listener);
+                    hls_src->setListener(_listener);
                     hls_src->setTrackSource(shared_from_this());
                 }
             } else if (!start && _hls) {
@@ -146,7 +142,7 @@ void MultiMuxerPrivate::setTimeStamp(uint32_t stamp) {
 }
 
 void MultiMuxerPrivate::setTrackListener(Listener *listener) {
-    _listener = listener;
+    _track_listener = listener;
 }
 
 void MultiMuxerPrivate::onTrackReady(const Track::Ptr &track) {
@@ -206,8 +202,8 @@ void MultiMuxerPrivate::onAllTrackReady() {
         hls_src->setTrackSource(shared_from_this());
     }
 
-    if (_listener) {
-        _listener->onAllTrackReady();
+    if (_track_listener) {
+        _track_listener->onAllTrackReady();
     }
 }
 
@@ -219,22 +215,18 @@ MediaSource::Ptr MultiMuxerPrivate::getHlsMediaSource() const {
     return nullptr;
 }
 
-/////////////////////////////////////////////////////////////////
+///////////////////////////////MultiMediaSourceMuxer//////////////////////////////////
 
 MultiMediaSourceMuxer::~MultiMediaSourceMuxer() {}
-MultiMediaSourceMuxer::MultiMediaSourceMuxer(const string &vhost,
-                                             const string &app,
-                                             const string &stream,
-                                             float dur_sec,
-                                             bool enable_rtsp,
-                                             bool enable_rtmp,
-                                             bool enable_hls,
-                                             bool enable_mp4) {
+
+MultiMediaSourceMuxer::MultiMediaSourceMuxer(const string &vhost, const string &app, const string &stream, float dur_sec,
+                                             bool enable_rtsp, bool enable_rtmp, bool enable_hls, bool enable_mp4) {
     _muxer.reset(new MultiMuxerPrivate(vhost, app, stream, dur_sec, enable_rtsp, enable_rtmp, enable_hls, enable_mp4));
     _muxer->setTrackListener(this);
 }
 
 void MultiMediaSourceMuxer::setMediaListener(const std::weak_ptr<MediaSourceEvent> &listener) {
+    //拦截事件
     _muxer->setMediaListener(shared_from_this());
     _listener = listener;
 }
@@ -255,46 +247,14 @@ vector<Track::Ptr> MultiMediaSourceMuxer::getTracks(bool trackReady) const {
     return _muxer->getTracks(trackReady);
 }
 
-bool MultiMediaSourceMuxer::seekTo(MediaSource &sender, uint32_t ui32Stamp) {
-    auto listener = _listener.lock();
-    if (!listener) {
-        return false;
-    }
-    return listener->seekTo(sender, ui32Stamp);
-}
-
-bool MultiMediaSourceMuxer::close(MediaSource &sender, bool force) {
-    auto listener = _listener.lock();
-    if (!listener) {
-        return false;
-    }
-    return listener->close(sender, force);
-}
-
 int MultiMediaSourceMuxer::totalReaderCount(MediaSource &sender) {
     auto listener = _listener.lock();
     if (!listener) {
-        return _muxer->totalReaderCount();
+        return totalReaderCount();
     }
     return listener->totalReaderCount(sender);
 }
 
-void MultiMediaSourceMuxer::onNoneReader(MediaSource &sender){
-    auto listener = _listener.lock();
-    if (!listener) {
-        MediaSourceEvent::onNoneReader(sender);
-        return;
-    }
-    listener->onNoneReader(sender);
-}
-
-void MultiMediaSourceMuxer::onRegist(MediaSource &sender, bool regist){
-    auto listener = _listener.lock();
-    if (listener) {
-        listener->onRegist(sender, regist);
-    }
-}
-
 bool MultiMediaSourceMuxer::setupRecord(MediaSource &sender, Recorder::type type, bool start, const string &custom_path) {
     return _muxer->setupRecord(sender,type,start,custom_path);
 }
@@ -313,9 +273,9 @@ void MultiMediaSourceMuxer::addTrackCompleted() {
 
 void MultiMediaSourceMuxer::onAllTrackReady(){
     _muxer->setMediaListener(shared_from_this());
-    auto track_listener = _track_listener.lock();
-    if(track_listener){
-        track_listener->onAllTrackReady();
+    auto listener = _track_listener.lock();
+    if(listener){
+        listener->onAllTrackReady();
     }
 }
 
@@ -370,19 +330,19 @@ public:
         return _frame->getCodecId();
     }
 private:
-    Frame::Ptr _frame;
     int64_t _dts;
     int64_t _pts;
+    Frame::Ptr _frame;
 };
 
 void MultiMediaSourceMuxer::inputFrame(const Frame::Ptr &frame) {
-    GET_CONFIG(bool,modify_stamp,General::kModifyStamp);
-    if(!modify_stamp){
+    GET_CONFIG(bool, modify_stamp, General::kModifyStamp);
+    if (!modify_stamp) {
         //未开启时间戳覆盖
         _muxer->inputFrame(frame);
-    }else{
+    } else {
         //开启了时间戳覆盖
-        FrameModifyStamp::Ptr new_frame = std::make_shared<FrameModifyStamp>(frame,_stamp[frame->getTrackType()]);
+        FrameModifyStamp::Ptr new_frame = std::make_shared<FrameModifyStamp>(frame, _stamp[frame->getTrackType()]);
         //输入时间戳覆盖后的帧
         _muxer->inputFrame(new_frame);
     }
diff --git a/src/Common/MultiMediaSourceMuxer.h b/src/Common/MultiMediaSourceMuxer.h
index b6588bc3..0e443956 100644
--- a/src/Common/MultiMediaSourceMuxer.h
+++ b/src/Common/MultiMediaSourceMuxer.h
@@ -17,7 +17,7 @@
 #include "Record/HlsRecorder.h"
 namespace mediakit{
 
-class MultiMuxerPrivate : public MediaSink , public std::enable_shared_from_this<MultiMuxerPrivate>{
+class MultiMuxerPrivate : public MediaSink, public std::enable_shared_from_this<MultiMuxerPrivate>{
 public:
     friend class MultiMediaSourceMuxer;
     typedef std::shared_ptr<MultiMuxerPrivate> Ptr;
@@ -47,17 +47,17 @@ private:
     MediaSource::Ptr getHlsMediaSource() const;
 
 private:
+    bool _enable_rtxp = false;
+    bool _enable_record = false;
+    Listener *_track_listener = nullptr;
     RtmpMediaSourceMuxer::Ptr _rtmp;
     RtspMediaSourceMuxer::Ptr _rtsp;
     MediaSinkInterface::Ptr _hls;
     MediaSinkInterface::Ptr _mp4;
-    Listener *_listener = nullptr;
-    std::weak_ptr<MediaSourceEvent> _meida_listener;
-    bool _enable_rtxp = false;
-    bool _enable_record = false;
+    std::weak_ptr<MediaSourceEvent> _listener;
 };
 
-class MultiMediaSourceMuxer : public MediaSourceEvent, public MediaSinkInterface, public TrackSource, public MultiMuxerPrivate::Listener, public std::enable_shared_from_this<MultiMediaSourceMuxer>{
+class MultiMediaSourceMuxer : public MediaSourceEventInterceptor, public MediaSinkInterface, public TrackSource, public MultiMuxerPrivate::Listener, public std::enable_shared_from_this<MultiMediaSourceMuxer>{
 public:
     typedef MultiMuxerPrivate::Listener Listener;
     typedef std::shared_ptr<MultiMediaSourceMuxer> Ptr;
@@ -83,12 +83,19 @@ public:
      */
     int totalReaderCount() const;
 
+    /**
+     * 判断是否生效(是否正在转其他协议)
+     */
+    bool isEnabled();
+
     /**
      * 设置MediaSource时间戳
      * @param stamp 时间戳
      */
     void setTimeStamp(uint32_t stamp);
 
+    /////////////////////////////////TrackSource override/////////////////////////////////
+
     /**
      * 获取所有Track
      * @param trackReady 是否筛选过滤未就绪的track
@@ -96,21 +103,7 @@ public:
      */
     vector<Track::Ptr> getTracks(bool trackReady = true) const override;
 
-    /**
-     * 通知拖动进度条
-     * @param sender 事件发送者
-     * @param ui32Stamp 目标时间戳
-     * @return 是否成功
-     */
-    bool seekTo(MediaSource &sender,uint32_t ui32Stamp) override;
-
-    /**
-     * 通知停止流生成
-     * @param sender 事件发送者
-     * @param force 是否强制关闭
-     * @return 成功与否
-     */
-    bool close(MediaSource &sender,bool force) override;
+    /////////////////////////////////MediaSourceEvent override/////////////////////////////////
 
     /**
      * 观看总人数
@@ -119,19 +112,6 @@ public:
      */
     int totalReaderCount(MediaSource &sender) override;
 
-    /**
-     * 触发无人观看事件
-     * @param sender 触发者
-     */
-    void onNoneReader(MediaSource &sender) override;
-
-    /**
-     * 媒体注册注销事件
-     * @param sender 触发者
-     * @param regist 是否为注册事件
-     */
-    void onRegist(MediaSource &sender, bool regist) override;
-
     /**
      * 设置录制状态
      * @param type 录制类型
@@ -148,6 +128,8 @@ public:
      */
     bool isRecording(MediaSource &sender, Recorder::type type) override;
 
+    /////////////////////////////////MediaSinkInterface override/////////////////////////////////
+
     /**
     * 添加track，内部会调用Track的clone方法
     * 只会克隆sps pps这些信息 ，而不会克隆Delegate相关关系
@@ -158,12 +140,7 @@ public:
     /**
      * 添加track完毕
      */
-    void addTrackCompleted();
-
-    /**
-     * 所有track全部就绪
-     */
-    void onAllTrackReady() override;
+    void addTrackCompleted() override;
 
     /**
      * 重置track
@@ -176,16 +153,17 @@ public:
      */
     void inputFrame(const Frame::Ptr &frame) override;
 
+    /////////////////////////////////MultiMuxerPrivate::Listener override/////////////////////////////////
+
     /**
-     * 判断是否生效(是否正在转其他协议)
+     * 所有track全部就绪
      */
-    bool isEnabled();
+    void onAllTrackReady() override;
 
 private:
-    MultiMuxerPrivate::Ptr _muxer;
-    std::weak_ptr<MediaSourceEvent> _listener;
-    std::weak_ptr<MultiMuxerPrivate::Listener> _track_listener;
     Stamp _stamp[2];
+    MultiMuxerPrivate::Ptr _muxer;
+    std::weak_ptr<MultiMuxerPrivate::Listener> _track_listener;
 };
 
 }//namespace mediakit