Header refactor (#2115)

* 优化MultiMediaSourceMuxer头文件包含

* 将MediaSinkDelegate和Demux移到MediaSink中

* MediaSource头文件重构, 独立出PacketCache.h
精简Frame和Track的头文件

* Rtmp头文件重构

* Rtsp头文件重构

* webrtc头文件重构

* 规范.h头文件包含，并将其移到.cpp中:
- 尽量不包含Common\config.h
- Util\File.h
- Rtsp/RtspPlayer.h
- Rtmp/RtmpPlayer.h

* 删除多余的Stamp.h和Base64包含

src/Common/Device.h

@@ -14,7 +14,6 @@
 #include <memory>
 #include <string>
 #include <functional>
-#include "Util/util.h"
 #include "Util/TimeTicker.h"
 #include "Common/MultiMediaSourceMuxer.h"
 

src/Common/MediaSink.cpp

@@ -10,6 +10,7 @@
 
 #include "MediaSink.h"
 #include "Extension/AAC.h"
+#include "Common/config.h"
 
 using namespace std;
 
@@ -271,4 +272,86 @@ void MediaSink::enableMuteAudio(bool flag) {
     _add_mute_audio = flag;
 }
 
+///////////////////////////DemuxerSink//////////////////////////////
+
+void MediaSinkDelegate::setTrackListener(TrackListener *listener) {
+    _listener = listener;
+}
+
+bool MediaSinkDelegate::onTrackReady(const Track::Ptr &track) {
+    if (_listener) {
+        _listener->addTrack(track);
+    }
+    return true;
+}
+
+void MediaSinkDelegate::onAllTrackReady() {
+    if (_listener) {
+        _listener->addTrackCompleted();
+    }
+}
+
+void MediaSinkDelegate::resetTracks() {
+    MediaSink::resetTracks();
+    if (_listener) {
+        _listener->resetTracks();
+    }
+}
+
+///////////////////////////Demuxer//////////////////////////////
+
+void Demuxer::setTrackListener(TrackListener *listener, bool wait_track_ready) {
+    if (wait_track_ready) {
+        auto sink = std::make_shared<MediaSinkDelegate>();
+        sink->setTrackListener(listener);
+        _sink = std::move(sink);
+    }
+    _listener = listener;
+}
+
+bool Demuxer::addTrack(const Track::Ptr &track) {
+    if (!_sink) {
+        _origin_track.emplace_back(track);
+        return _listener ? _listener->addTrack(track) : false;
+    }
+
+    if (_sink->addTrack(track)) {
+        track->addDelegate([this](const Frame::Ptr &frame) {
+            return _sink->inputFrame(frame);
+        });
+        return true;
+    }
+    return false;
+}
+
+void Demuxer::addTrackCompleted() {
+    if (_sink) {
+        _sink->addTrackCompleted();
+    } else if (_listener) {
+        _listener->addTrackCompleted();
+    }
+}
+
+void Demuxer::resetTracks() {
+    if (_sink) {
+        _sink->resetTracks();
+    } else if (_listener) {
+        _listener->resetTracks();
+    }
+}
+
+vector<Track::Ptr> Demuxer::getTracks(bool ready) const {
+    if (_sink) {
+        return _sink->getTracks(ready);
+    }
+
+    vector<Track::Ptr> ret;
+    for (auto &track : _origin_track) {
+        if (ready && !track->ready()) {
+            continue;
+        }
+        ret.emplace_back(track);
+    }
+    return ret;
+}
 }//namespace mediakit

src/Common/MediaSink.h

@@ -168,6 +168,44 @@ private:
 };
 
 
+class MediaSinkDelegate : public MediaSink {
+public:
+    MediaSinkDelegate() = default;
+    ~MediaSinkDelegate() override = default;
+
+    /**
+     * 设置track监听器
+     */
+    void setTrackListener(TrackListener *listener);
+
+protected:
+    void resetTracks() override;
+    bool onTrackReady(const Track::Ptr & track) override;
+    void onAllTrackReady() override;
+
+private:
+    TrackListener *_listener = nullptr;
+};
+
+class Demuxer : protected TrackListener, public TrackSource {
+public:
+    Demuxer() = default;
+    ~Demuxer() override = default;
+
+    void setTrackListener(TrackListener *listener, bool wait_track_ready = false);
+    std::vector<Track::Ptr> getTracks(bool trackReady = true) const override;
+
+protected:
+    bool addTrack(const Track::Ptr &track) override;
+    void addTrackCompleted() override;
+    void resetTracks() override;
+
+private:
+    MediaSink::Ptr _sink;
+    TrackListener *_listener = nullptr;
+    std::vector<Track::Ptr> _origin_track;
+};
+
 }//namespace mediakit
 
 #endif //ZLMEDIAKIT_MEDIASINK_H

src/Common/MediaSource.cpp

@@ -7,15 +7,16 @@
  * LICENSE file in the root of the source tree. All contributing project authors
  * may be found in the AUTHORS file in the root of the source tree.
  */
-
+#include <mutex>
 #include "Util/util.h"
 #include "Util/NoticeCenter.h"
 #include "Network/sockutil.h"
 #include "Network/Session.h"
 #include "MediaSource.h"
 #include "Common/config.h"
+#include "Common/Parser.h"
 #include "Record/MP4Reader.h"
-
+#include "PacketCache.h"
 using namespace std;
 using namespace toolkit;
 

src/Common/MediaSource.h

@@ -11,15 +11,10 @@
 #ifndef ZLMEDIAKIT_MEDIASOURCE_H
 #define ZLMEDIAKIT_MEDIASOURCE_H
 
-#include <mutex>
 #include <string>
 #include <atomic>
 #include <memory>
 #include <functional>
-#include <unordered_map>
-#include "Common/config.h"
-#include "Common/Parser.h"
-#include "Util/List.h"
 #include "Network/Socket.h"
 #include "Extension/Track.h"
 #include "Record/Recorder.h"
@@ -410,84 +405,5 @@ private:
     toolkit::ObjectStatistic<MediaSource> _statistic;
 };
 
-/// 缓存刷新策略类
-class FlushPolicy {
-public:
-    FlushPolicy() = default;
-    ~FlushPolicy() = default;
-
-    bool isFlushAble(bool is_video, bool is_key, uint64_t new_stamp, size_t cache_size);
-
-private:
-    // 音视频的最后时间戳
-    uint64_t _last_stamp[2] = { 0, 0 };
-};
-
-/// 合并写缓存模板
-/// \tparam packet 包类型
-/// \tparam policy 刷新缓存策略
-/// \tparam packet_list 包缓存类型
-template<typename packet, typename policy = FlushPolicy, typename packet_list = toolkit::List<std::shared_ptr<packet> > >
-class PacketCache {
-public:
-    PacketCache() { _cache = std::make_shared<packet_list>(); }
-
-    virtual ~PacketCache() = default;
-
-    void inputPacket(uint64_t stamp, bool is_video, std::shared_ptr<packet> pkt, bool key_pos) {
-        bool flag = flushImmediatelyWhenCloseMerge();
-        if (!flag && _policy.isFlushAble(is_video, key_pos, stamp, _cache->size())) {
-            flush();
-        }
-
-        //追加数据到最后
-        _cache->emplace_back(std::move(pkt));
-        if (key_pos) {
-            _key_pos = key_pos;
-        }
-
-        if (flag) {
-            flush();
-        }
-    }
-
-    void flush() {
-        if (_cache->empty()) {
-            return;
-        }
-        onFlush(std::move(_cache), _key_pos);
-        _cache = std::make_shared<packet_list>();
-        _key_pos = false;
-    }
-
-    virtual void clearCache() {
-        _cache->clear();
-    }
-
-    virtual void onFlush(std::shared_ptr<packet_list>, bool key_pos) = 0;
-
-private:
-    bool flushImmediatelyWhenCloseMerge() {
-        // 一般的协议关闭合并写时，立即刷新缓存，这样可以减少一帧的延时，但是rtp例外
-        // 因为rtp的包很小，一个RtpPacket包中也不是完整的一帧图像，所以在关闭合并写时，
-        // 还是有必要缓冲一帧的rtp(也就是时间戳相同的rtp)再输出，这样虽然会增加一帧的延时
-        // 但是却对性能提升很大，这样做还是比较划算的
-
-        GET_CONFIG(int, mergeWriteMS, General::kMergeWriteMS);
-
-        GET_CONFIG(int, rtspLowLatency, Rtsp::kLowLatency);
-        if (std::is_same<packet, RtpPacket>::value && rtspLowLatency) {
-            return true;
-        }
-
-        return std::is_same<packet, RtpPacket>::value ? false : (mergeWriteMS <= 0);
-    }
-
-private:
-    bool _key_pos = false;
-    policy _policy;
-    std::shared_ptr<packet_list> _cache;
-};
-
 } /* namespace mediakit */
 #endif //ZLMEDIAKIT_MEDIASOURCE_H

src/Common/MultiMediaSourceMuxer.cpp

@@ -11,6 +11,13 @@
 #include <math.h>
 #include "Common/config.h"
 #include "MultiMediaSourceMuxer.h"
+#include "Rtp/RtpSender.h"
+#include "Record/HlsRecorder.h"
+#include "Record/HlsMediaSource.h"
+#include "Rtsp/RtspMediaSourceMuxer.h"
+#include "Rtmp/RtmpMediaSourceMuxer.h"
+#include "TS/TSMediaSourceMuxer.h"
+#include "FMP4/FMP4MediaSourceMuxer.h"
 
 using namespace std;
 using namespace toolkit;

src/Common/MultiMediaSourceMuxer.h

@@ -12,16 +12,17 @@
 #define ZLMEDIAKIT_MULTIMEDIASOURCEMUXER_H
 
 #include "Common/Stamp.h"
-#include "Rtp/RtpSender.h"
+#include "Common/MediaSource.h"
+#include "Common/MediaSink.h"
 #include "Record/Recorder.h"
-#include "Record/HlsRecorder.h"
-#include "Record/HlsMediaSource.h"
-#include "Rtsp/RtspMediaSourceMuxer.h"
-#include "Rtmp/RtmpMediaSourceMuxer.h"
-#include "TS/TSMediaSourceMuxer.h"
-#include "FMP4/FMP4MediaSourceMuxer.h"
-
 namespace mediakit {
+class HlsRecorder;
+class RtspMediaSourceMuxer;
+class RtmpMediaSourceMuxer;
+class TSMediaSourceMuxer;
+class FMP4MediaSourceMuxer;
+class RtpSender;
+
 
 class MultiMediaSourceMuxer : public MediaSourceEventInterceptor, public MediaSink, public std::enable_shared_from_this<MultiMediaSourceMuxer>{
 public:
@@ -160,17 +161,17 @@ private:
     Stamp _stamp[2];
     std::weak_ptr<Listener> _track_listener;
 #if defined(ENABLE_RTPPROXY)
-    std::unordered_map<std::string, RtpSender::Ptr> _rtp_sender;
+    std::unordered_map<std::string, std::shared_ptr<RtpSender>> _rtp_sender;
 #endif //ENABLE_RTPPROXY
 
 #if defined(ENABLE_MP4)
-    FMP4MediaSourceMuxer::Ptr _fmp4;
+    std::shared_ptr<FMP4MediaSourceMuxer> _fmp4;
 #endif
-    RtmpMediaSourceMuxer::Ptr _rtmp;
-    RtspMediaSourceMuxer::Ptr _rtsp;
-    TSMediaSourceMuxer::Ptr _ts;
+    std::shared_ptr<RtmpMediaSourceMuxer> _rtmp;
+    std::shared_ptr<RtspMediaSourceMuxer> _rtsp;
+    std::shared_ptr<TSMediaSourceMuxer> _ts;
     MediaSinkInterface::Ptr _mp4;
-    HlsRecorder::Ptr _hls;
+    std::shared_ptr<HlsRecorder> _hls;
     toolkit::EventPoller::Ptr _poller;
 
     //对象个数统计

src/Common/PacketCache.h

@@ -0,0 +1,87 @@
+#ifndef _SRC_PACKET_CACHE_H_
+#define _SRC_PACKET_CACHE_H_
+#include "Common/config.h"
+#include "Util/List.h"
+
+#pragma once
+namespace mediakit {
+/// 缓存刷新策略类
+class FlushPolicy {
+public:
+    FlushPolicy() = default;
+    ~FlushPolicy() = default;
+
+    bool isFlushAble(bool is_video, bool is_key, uint64_t new_stamp, size_t cache_size);
+
+private:
+    // 音视频的最后时间戳
+    uint64_t _last_stamp[2] = { 0, 0 };
+};
+
+/// 合并写缓存模板
+/// \tparam packet 包类型
+/// \tparam policy 刷新缓存策略
+/// \tparam packet_list 包缓存类型
+template<typename packet, typename policy = FlushPolicy, typename packet_list = toolkit::List<std::shared_ptr<packet> > >
+class PacketCache {
+public:
+    PacketCache() { _cache = std::make_shared<packet_list>(); }
+
+    virtual ~PacketCache() = default;
+
+    void inputPacket(uint64_t stamp, bool is_video, std::shared_ptr<packet> pkt, bool key_pos) {
+        bool flag = flushImmediatelyWhenCloseMerge();
+        if (!flag && _policy.isFlushAble(is_video, key_pos, stamp, _cache->size())) {
+            flush();
+        }
+
+        //追加数据到最后
+        _cache->emplace_back(std::move(pkt));
+        if (key_pos) {
+            _key_pos = key_pos;
+        }
+
+        if (flag) {
+            flush();
+        }
+    }
+
+    void flush() {
+        if (_cache->empty()) {
+            return;
+        }
+        onFlush(std::move(_cache), _key_pos);
+        _cache = std::make_shared<packet_list>();
+        _key_pos = false;
+    }
+
+    virtual void clearCache() {
+        _cache->clear();
+    }
+
+    virtual void onFlush(std::shared_ptr<packet_list>, bool key_pos) = 0;
+
+private:
+    bool flushImmediatelyWhenCloseMerge() {
+        // 一般的协议关闭合并写时，立即刷新缓存，这样可以减少一帧的延时，但是rtp例外
+        // 因为rtp的包很小，一个RtpPacket包中也不是完整的一帧图像，所以在关闭合并写时，
+        // 还是有必要缓冲一帧的rtp(也就是时间戳相同的rtp)再输出，这样虽然会增加一帧的延时
+        // 但是却对性能提升很大，这样做还是比较划算的
+
+        GET_CONFIG(int, mergeWriteMS, General::kMergeWriteMS);
+
+        GET_CONFIG(int, rtspLowLatency, Rtsp::kLowLatency);
+        if (std::is_same<packet, RtpPacket>::value && rtspLowLatency) {
+            return true;
+        }
+
+        return std::is_same<packet, RtpPacket>::value ? false : (mergeWriteMS <= 0);
+    }
+
+private:
+    bool _key_pos = false;
+    policy _policy;
+    std::shared_ptr<packet_list> _cache;
+};
+}
+#endif