Merge 7141759d78 into aa56576b0e

修复默认音频参数相关bug
完善rtp服务器对各编码类型es流的支持
2024-12-05 01:11:52 +08:00 · 2024-11-30 13:36:02 +00:00 · 2024-11-30 10:54:45 +08:00 · 2024-11-30 08:50:07 +08:00 · 2024-11-30 08:23:10 +08:00 · 2024-11-29 23:51:34 +08:00
35 changed files with 335 additions and 399 deletions
--- a/3rdpart/media-server
+++ b/3rdpart/media-server
@ -1 +1 @@
-Subproject commit cf83ebc62e65ae6f3b73bc5ebd06cb0b2da49fa5
+Subproject commit 0658496d5fc7d238f41e10ea4d0a10113a8eed84
--- a/README.md
+++ b/README.md
@ -37,6 +37,7 @@
 - [谁在使用zlmediakit?](https://github.com/ZLMediaKit/ZLMediaKit/issues/511)
 - 全面支持ipv6网络
 - 支持多轨道模式(一个流中多个视频/音频)
+- 全协议支持H264/H265/AAC/G711/OPUS，部分支持VP8/VP9/AV1/JPEG/MP3/H266/ADPCM/SVAC/G722/G723/G729

 ## 项目定位

--- a/api/source/mk_util.cpp
+++ b/api/source/mk_util.cpp
@ -196,7 +196,7 @@ API_EXPORT void API_CALL mk_get_statistic(on_mk_get_statistic_cb func, void *use
 #ifdef ENABLE_MEM_DEBUG
    auto bytes = getTotalMemUsage();
    val["memory.memUsage"] = bytes;
-    val["memory.memUsageMB"] = (int)(bytes / 1024 / 1024);
+    val["memory.memUsageMB"] = (int)(bytes >> 20);
    val["memory.memBlock"] = getTotalMemBlock();
    static auto block_type_size = getBlockTypeSize();
    {
@ -240,7 +240,7 @@ API_EXPORT void API_CALL mk_get_statistic(on_mk_get_statistic_cb func, void *use
 #ifdef ENABLE_MEM_DEBUG
            auto bytes = getThisThreadMemUsage();
            val["memUsage"] = bytes;
-            val["memUsageMB"] = bytes / 1024 / 1024;
+            val["memUsageMB"] = bytes >> 20;
            val["memBlock"] = getThisThreadMemBlock();
            {
                int i = 0;
--- a/ext-codec/AAC.cpp
+++ b/ext-codec/AAC.cpp
@ -373,11 +373,7 @@ Track::Ptr AACTrack::clone() const {
 }

 Sdp::Ptr AACTrack::getSdp(uint8_t payload_type) const {
-    if (!ready()) {
-        WarnL << getCodecName() << " Track未准备好";
-        return nullptr;
-    }
-    return std::make_shared<AACSdp>(getExtraData()->toString(), payload_type, getAudioSampleRate(), getAudioChannel(), getBitRate() / 1024);
+    return std::make_shared<AACSdp>(getExtraData()->toString(), payload_type, getAudioSampleRate(), getAudioChannel(), getBitRate() >> 10);
 }

 namespace {
--- a/ext-codec/G711.cpp
+++ b/ext-codec/G711.cpp
@ -19,70 +19,14 @@ using namespace toolkit;

 namespace mediakit {

-/**
- * G711类型SDP
- * G711 type SDP
- 
- * [AUTO-TRANSLATED:ea72d60a]
- */
-class G711Sdp : public Sdp {
-public:
-    /**
-     * G711采样率固定为8000
-     * @param codecId G711A G711U
-     * @param payload_type rtp payload type
-     * @param sample_rate 音频采样率
-     * @param channels 通道数
-     * @param bitrate 比特率
-     * G711 sampling rate is fixed at 8000
-     * @param codecId G711A G711U
-     * @param payload_type rtp payload type
-     * @param sample_rate audio sampling rate
-     * @param channels number of channels
-     * @param bitrate bitrate
-     
-     * [AUTO-TRANSLATED:5ea4b771]
-     */
-    G711Sdp(CodecId codecId, int payload_type, int sample_rate, int channels, int bitrate)
-        : Sdp(sample_rate, payload_type) {
-        _printer << "m=audio 0 RTP/AVP " << payload_type << "\r\n";
-        if (bitrate) {
-            _printer << "b=AS:" << bitrate << "\r\n";
-        }
-        _printer << "a=rtpmap:" << payload_type << " " << getCodecName(codecId) << "/" << sample_rate  << "/" << channels << "\r\n";
-    }
-
-    string getSdp() const override {
-        return _printer;
-    }
-
-private:
-    _StrPrinter _printer;
-};
-
 Track::Ptr G711Track::clone() const {
    return std::make_shared<G711Track>(*this);
 }

 Sdp::Ptr G711Track::getSdp(uint8_t payload_type) const {
-    if (!ready()) {
-        WarnL << getCodecName() << " Track未准备好";
-        return nullptr;
-    }
-
-    const auto codec = getCodecId();
-    const auto sample_rate = getAudioSampleRate();
-    const auto audio_channel = getAudioChannel();
-    const auto bitrate = getBitRate() >> 10;
-    if (sample_rate == 8000 && audio_channel == 1) {
-        // https://datatracker.ietf.org/doc/html/rfc3551#section-6
-        payload_type = (codec == CodecG711U) ? Rtsp::PT_PCMU : Rtsp::PT_PCMA;
-    }
-
-    return std::make_shared<G711Sdp>(codec, payload_type, sample_rate, audio_channel, bitrate);
+    return std::make_shared<DefaultSdp>(payload_type, *this);
 }

-
 namespace {

 CodecId getCodecA() {
@ -94,7 +38,7 @@ CodecId getCodecU() {
 }

 Track::Ptr getTrackByCodecId_l(CodecId codec, int sample_rate, int channels, int sample_bit) {
-    return (sample_rate && channels && sample_bit) ? std::make_shared<G711Track>(codec, sample_rate, channels, sample_bit) : nullptr;
+    return std::make_shared<G711Track>(codec, sample_rate, 1, 16);
 }

 Track::Ptr getTrackByCodecIdA(int sample_rate, int channels, int sample_bit) {
@ -119,7 +63,7 @@ Track::Ptr getTrackBySdpU(const SdpTrack::Ptr &track) {

 RtpCodec::Ptr getRtpEncoderByCodecId_l(CodecId codec, uint8_t pt) {
    if (pt == Rtsp::PT_PCMA || pt == Rtsp::PT_PCMU) {
-        return std::make_shared<G711RtpEncoder>(codec, 1);
+        return std::make_shared<G711RtpEncoder>(8000, 1);
    }
    return std::make_shared<CommonRtpEncoder>();
 }
--- a/ext-codec/G711Rtp.cpp
+++ b/ext-codec/G711Rtp.cpp
@ -2,10 +2,10 @@

 namespace mediakit {

-G711RtpEncoder::G711RtpEncoder(CodecId codec, uint32_t channels){
-    _cache_frame = FrameImp::create();
-    _cache_frame->_codec_id = codec;
+G711RtpEncoder::G711RtpEncoder(int sample_rate, int channels, int sample_bit) {
+    _sample_rate = sample_rate;
    _channels = channels;
+    _sample_bit = sample_bit;
 }

 void G711RtpEncoder::setOpt(int opt, const toolkit::Any &param) {
@ -24,36 +24,24 @@ void G711RtpEncoder::setOpt(int opt, const toolkit::Any &param) {
 }

 bool G711RtpEncoder::inputFrame(const Frame::Ptr &frame) {
-    auto dur = (_cache_frame->size() - _cache_frame->prefixSize()) / (8 * _channels);
-    auto next_pts = _cache_frame->pts() + dur;
-    if (next_pts == 0) {
-        _cache_frame->_pts = frame->pts();
-    } else {
-        if ((next_pts + _pkt_dur_ms) < frame->pts()) { // 有丢包超过20ms
-            _cache_frame->_pts = frame->pts() - dur;
-        }
-    }
-    _cache_frame->_buffer.append(frame->data() + frame->prefixSize(), frame->size() - frame->prefixSize());
+    auto ptr = frame->data() + frame->prefixSize();
+    auto size = frame->size() - frame->prefixSize();
+    _buffer.append(ptr, size);
+    _in_size += size;
+    _in_pts = frame->pts();

-    auto stamp = _cache_frame->pts();
-    auto ptr = _cache_frame->data() + _cache_frame->prefixSize();
-    auto len = _cache_frame->size() - _cache_frame->prefixSize();
-    auto remain_size = len;
-    size_t max_size = 160 * _channels * _pkt_dur_ms / 20; // 20 ms per 160 byte
-    size_t n = 0;
-    bool mark = false;
-    while (remain_size >= max_size) {
-        assert(remain_size >= max_size);
-        const size_t rtp_size = max_size;
-        n++;
-        stamp += _pkt_dur_ms;
-        RtpCodec::inputRtp(getRtpInfo().makeRtp(TrackAudio, ptr, rtp_size, mark, stamp), false);
-        ptr += rtp_size;
-        remain_size -= rtp_size;
+    if (!_pkt_bytes) {
+        // G711压缩率固定是2倍
+        _pkt_bytes = _pkt_dur_ms * _channels * (_sample_bit / 8) * _sample_rate / 1000 / 2;
    }
-    _cache_frame->_buffer.erase(0, n * max_size);
-    _cache_frame->_pts += (uint64_t)_pkt_dur_ms * n;
-    return len > 0;
+
+    while (_buffer.size() >= _pkt_bytes) {
+        _out_size += _pkt_bytes;
+        auto pts = _in_pts - (_in_size - _out_size) * (_pkt_dur_ms / (float)_pkt_bytes);
+        RtpCodec::inputRtp(getRtpInfo().makeRtp(TrackAudio, _buffer.data(), _pkt_bytes, false, pts), false);
+        _buffer.erase(0, _pkt_bytes);
+    }
+    return true;
 }

 } // namespace mediakit
--- a/ext-codec/G711Rtp.h
+++ b/ext-codec/G711Rtp.h
@ -29,15 +29,17 @@ public:

    /**
     * 构造函数
-     * @param codec 编码类型
+     * @param sample_rate 音频采样率
     * @param channels 通道数
+     * @param sample_bit 音频采样位数
     * Constructor
-     * @param codec Encoding type
+     * @param sample_rate audio sample rate
     * @param channels Number of channels
-     
+     * @param sample_bit audio sample bits
+
     * [AUTO-TRANSLATED:dbbd593e]
     */
-    G711RtpEncoder(CodecId codec, uint32_t channels);
+    G711RtpEncoder(int sample_rate = 8000, int channels = 1, int sample_bit = 16);

    /**
     * 输入帧数据并编码成rtp
@ -51,9 +53,16 @@ public:
    void setOpt(int opt, const toolkit::Any &param) override;

 private:
-    uint32_t _channels = 1;
+    int _channels;
+    int _sample_rate;
+    int _sample_bit;
+
    uint32_t _pkt_dur_ms = 20;
-    FrameImp::Ptr _cache_frame;
+    uint32_t _pkt_bytes = 0;
+    uint64_t _in_size = 0;
+    uint64_t _out_size = 0;
+    int64_t _in_pts = 0;
+    toolkit::BufferLikeString _buffer;
 };

 }//namespace mediakit
--- a/ext-codec/H264.cpp
+++ b/ext-codec/H264.cpp
@ -357,11 +357,7 @@ private:
 };

 Sdp::Ptr H264Track::getSdp(uint8_t payload_type) const {
-    if (!ready()) {
-        WarnL << getCodecName() << " Track未准备好";
-        return nullptr;
-    }
-    return std::make_shared<H264Sdp>(_sps, _pps, payload_type, getBitRate() / 1024);
+    return std::make_shared<H264Sdp>(_sps, _pps, payload_type, getBitRate() >> 10);
 }

 namespace {
--- a/ext-codec/H265.cpp
+++ b/ext-codec/H265.cpp
@ -263,11 +263,7 @@ private:
 };

 Sdp::Ptr H265Track::getSdp(uint8_t payload_type) const {
-    if (!ready()) {
-        WarnL << getCodecName() << " Track未准备好";
-        return nullptr;
-    }
-    return std::make_shared<H265Sdp>(_vps, _sps, _pps, payload_type, getBitRate() / 1024);
+    return std::make_shared<H265Sdp>(_vps, _sps, _pps, payload_type, getBitRate() >> 10);
 }

 namespace {
--- a/ext-codec/JPEG.cpp
+++ b/ext-codec/JPEG.cpp
@ -31,26 +31,10 @@ void JPEGTrack::getVideoResolution(const uint8_t *buf, int len) {
    }
 }

-class JPEGSdp : public Sdp {
-public:
-    JPEGSdp(int bitrate) : Sdp(90000, Rtsp::PT_JPEG) {
-        _printer << "m=video 0 RTP/AVP " << (int)getPayloadType() << "\r\n";
-        if (bitrate) {
-            _printer << "b=AS:" << bitrate << "\r\n";
-        }
-    }
-
-    std::string getSdp() const { return _printer; }
-
-private:
-    _StrPrinter _printer;
-};
-
-Sdp::Ptr JPEGTrack::getSdp(uint8_t) const {
-    return std::make_shared<JPEGSdp>(getBitRate() / 1024);
+Sdp::Ptr JPEGTrack::getSdp(uint8_t pt) const {
+    return std::make_shared<DefaultSdp>(pt, *this);
 }

-
 namespace {

 CodecId getCodec() {
--- a/ext-codec/L16.cpp
+++ b/ext-codec/L16.cpp
@ -18,50 +18,8 @@ using namespace toolkit;

 namespace mediakit {

-/**
- * L16类型SDP
- * L16 type SDP
- 
- * [AUTO-TRANSLATED:11b1196d]
- */
-class L16Sdp : public Sdp {
-public:
-    /**
-     * L16采样位数固定为16位
-     * @param payload_type rtp payload type
-     * @param channels 通道数
-     * @param sample_rate 音频采样率
-     * @param bitrate 比特率
-     * L16 sampling bit width is fixed to 16 bits
-     * @param payload_type rtp payload type
-     * @param channels number of channels
-     * @param sample_rate audio sampling rate
-     * @param bitrate bitrate
-     
-     
-     * [AUTO-TRANSLATED:7a08a400]
-     */
-    L16Sdp(int payload_type, int sample_rate, int channels, int bitrate) : Sdp(sample_rate, payload_type) {
-        _printer << "m=audio 0 RTP/AVP " << payload_type << "\r\n";
-        if (bitrate) {
-            _printer << "b=AS:" << bitrate << "\r\n";
-        }
-        _printer << "a=rtpmap:" << payload_type << " " << getCodecName(CodecL16) << "/" << sample_rate  << "/" << channels << "\r\n";
-    }
-
-    string getSdp() const override { return _printer; }
-
-private:
-    _StrPrinter _printer;
-};
-
 Sdp::Ptr L16Track::getSdp(uint8_t payload_type) const {
-    WarnL << "Enter  L16Track::getSdp function";
-    if (!ready()) {
-        WarnL << getCodecName() << " Track未准备好";
-        return nullptr;
-    }
-    return std::make_shared<L16Sdp>(payload_type, getAudioSampleRate(), getAudioChannel(), getBitRate() / 1024);
+    return std::make_shared<DefaultSdp>(payload_type, *this);
 }

 Track::Ptr L16Track::clone() const {
--- a/ext-codec/Opus.cpp
+++ b/ext-codec/Opus.cpp
@ -18,51 +18,9 @@ using namespace toolkit;

 namespace mediakit {

-/**
- * Opus类型SDP
- * Opus type SDP
- 
- * [AUTO-TRANSLATED:6c0a72ed]
- */
-class OpusSdp : public Sdp {
-public:
-    /**
-     * 构造opus sdp
-     * @param payload_type rtp payload type
-     * @param sample_rate 音频采样率
-     * @param channels 通道数
-     * @param bitrate 比特率
-     * Construct opus sdp
-     * @param payload_type rtp payload type
-     * @param sample_rate audio sample rate
-     * @param channels number of channels
-     * @param bitrate bitrate
-     
-     
-     * [AUTO-TRANSLATED:40713e9d]
-     */
-    OpusSdp(int payload_type, int sample_rate, int channels, int bitrate) : Sdp(sample_rate, payload_type) {
-        _printer << "m=audio 0 RTP/AVP " << payload_type << "\r\n";
-        if (bitrate) {
-            _printer << "b=AS:" << bitrate << "\r\n";
-        }
-        _printer << "a=rtpmap:" << payload_type << " " << getCodecName(CodecOpus) << "/" << sample_rate  << "/" << channels << "\r\n";
-    }
-
-    string getSdp() const override {
-        return _printer;
-    }
-
-private:
-    _StrPrinter _printer;
-};

 Sdp::Ptr OpusTrack::getSdp(uint8_t payload_type) const {
-    if (!ready()) {
-        WarnL << getCodecName() << " Track未准备好";
-        return nullptr;
-    }
-    return std::make_shared<OpusSdp>(payload_type, getAudioSampleRate(), getAudioChannel(), getBitRate() / 1024);
+    return std::make_shared<DefaultSdp>(payload_type, *this);
 }

 namespace {
--- a/server/WebApi.cpp
+++ b/server/WebApi.cpp
@ -570,7 +570,7 @@ void getStatisticJson(const function<void(Value &val)> &cb) {
 #ifdef ENABLE_MEM_DEBUG
    auto bytes = getTotalMemUsage();
    val["totalMemUsage"] = (Json::UInt64) bytes;
-    val["totalMemUsageMB"] = (int) (bytes / 1024 / 1024);
+    val["totalMemUsageMB"] = (int) (bytes >> 20);
    val["totalMemBlock"] = (Json::UInt64) getTotalMemBlock();
    static auto block_type_size = getBlockTypeSize();
    {
@ -604,7 +604,7 @@ void getStatisticJson(const function<void(Value &val)> &cb) {
            auto bytes = getThisThreadMemUsage();
            val["threadName"] = getThreadName();
            val["threadMemUsage"] = (Json::UInt64) bytes;
-            val["threadMemUsageMB"] = (Json::UInt64) (bytes / 1024 / 1024);
+            val["threadMemUsageMB"] = (Json::UInt64) (bytes >> 20);
            val["threadMemBlock"] = (Json::UInt64) getThisThreadMemBlock();
            {
                int i = 0;
--- a/src/Extension/Factory.cpp
+++ b/src/Extension/Factory.cpp
@ -10,6 +10,8 @@

 #include "Factory.h"
 #include "Rtmp/Rtmp.h"
+#include "CommonRtmp.h"
+#include "CommonRtp.h"
 #include "Common/config.h"

 using namespace std;
@ -19,15 +21,6 @@ namespace mediakit {

 static std::unordered_map<int, const CodecPlugin *> s_plugins;

-extern CodecPlugin h264_plugin;
-extern CodecPlugin h265_plugin;
-extern CodecPlugin jpeg_plugin;
-extern CodecPlugin aac_plugin;
-extern CodecPlugin opus_plugin;
-extern CodecPlugin g711a_plugin;
-extern CodecPlugin g711u_plugin;
-extern CodecPlugin l16_plugin;
-
 REGISTER_CODEC(h264_plugin);
 REGISTER_CODEC(h265_plugin);
 REGISTER_CODEC(jpeg_plugin);
@ -51,8 +44,7 @@ Track::Ptr Factory::getTrackBySdp(const SdpTrack::Ptr &track) {
    }
    auto it = s_plugins.find(codec);
    if (it == s_plugins.end()) {
-        WarnL << "Unsupported codec: " << track->getName();
-        return nullptr;
+        return getTrackByCodecId(codec, track->_samplerate, track->_channel);
    }
    return it->second->getTrackBySdp(track);
 }
@ -69,8 +61,8 @@ Track::Ptr Factory::getTrackByAbstractTrack(const Track::Ptr &track) {
 RtpCodec::Ptr Factory::getRtpEncoderByCodecId(CodecId codec, uint8_t pt) {
    auto it = s_plugins.find(codec);
    if (it == s_plugins.end()) {
-        WarnL << "Unsupported codec: " << getCodecName(codec);
-        return nullptr;
+        WarnL << "Unsupported codec: " << getCodecName(codec) << ", use CommonRtpEncoder";
+        return std::make_shared<CommonRtpEncoder>();
    }
    return it->second->getRtpEncoderByCodecId(pt);
 }
@ -78,8 +70,8 @@ RtpCodec::Ptr Factory::getRtpEncoderByCodecId(CodecId codec, uint8_t pt) {
 RtpCodec::Ptr Factory::getRtpDecoderByCodecId(CodecId codec) {
    auto it = s_plugins.find(codec);
    if (it == s_plugins.end()) {
-        WarnL << "Unsupported codec: " << getCodecName(codec);
-        return nullptr;
+        WarnL << "Unsupported codec: " << getCodecName(codec) << ", use CommonRtpDecoder";
+        return std::make_shared<CommonRtpDecoder>(codec, 10 * 1024);
    }
    return it->second->getRtpDecoderByCodecId();
 }
@ -87,7 +79,7 @@ RtpCodec::Ptr Factory::getRtpDecoderByCodecId(CodecId codec) {
 // ///////////////////////////rtmp相关///////////////////////////////////////////  [AUTO-TRANSLATED:da9645df]
 // ///////////////////////////rtmp related///////////////////////////////////////////

-static CodecId getVideoCodecIdByAmf(const AMFValue &val){
+static CodecId getVideoCodecIdByAmf(const AMFValue &val) {
    if (val.type() == AMF_STRING) {
        auto str = val.as_string();
        if (str == "avc1") {
@ -117,15 +109,25 @@ static CodecId getVideoCodecIdByAmf(const AMFValue &val){
 Track::Ptr Factory::getTrackByCodecId(CodecId codec, int sample_rate, int channels, int sample_bit) {
    auto it = s_plugins.find(codec);
    if (it == s_plugins.end()) {
-        WarnL << "Unsupported codec: " << getCodecName(codec);
-        return nullptr;
+        auto type = mediakit::getTrackType(codec);
+        switch (type) {
+            case TrackAudio: {
+                WarnL << "Unsupported codec: " << getCodecName(codec) << ", use default audio track";
+                return std::make_shared<AudioTrackImp>(codec, sample_rate, channels, sample_bit);
+            }
+            case TrackVideo: {
+                WarnL << "Unsupported codec: " << getCodecName(codec) << ", use default video track";
+                return std::make_shared<VideoTrackImp>(codec, 0, 0, 0);
+            }
+            default: WarnL << "Unsupported codec: " << getCodecName(codec); return nullptr;
+        }
    }
    return it->second->getTrackByCodecId(sample_rate, channels, sample_bit);
 }

 Track::Ptr Factory::getVideoTrackByAmf(const AMFValue &amf) {
    CodecId codecId = getVideoCodecIdByAmf(amf);
-    if(codecId == CodecInvalid){
+    if (codecId == CodecInvalid) {
        return nullptr;
    }
    return getTrackByCodecId(codecId);
@ -144,18 +146,19 @@ static CodecId getAudioCodecIdByAmf(const AMFValue &val) {
    if (val.type() != AMF_NULL) {
        auto type_id = (RtmpAudioCodec)val.as_integer();
        switch (type_id) {
-            case RtmpAudioCodec::aac : return CodecAAC;
-            case RtmpAudioCodec::g711a : return CodecG711A;
-            case RtmpAudioCodec::g711u : return CodecG711U;
-            case RtmpAudioCodec::opus : return CodecOpus;
-            default : WarnL << "Unsupported codec: " << (int)type_id; return CodecInvalid;
+            case RtmpAudioCodec::aac: return CodecAAC;
+            case RtmpAudioCodec::mp3: return CodecMP3;
+            case RtmpAudioCodec::adpcm: return CodecADPCM;
+            case RtmpAudioCodec::g711a: return CodecG711A;
+            case RtmpAudioCodec::g711u: return CodecG711U;
+            case RtmpAudioCodec::opus: return CodecOpus;
+            default: WarnL << "Unsupported codec: " << (int)type_id; return CodecInvalid;
        }
    }
-
    return CodecInvalid;
 }

-Track::Ptr Factory::getAudioTrackByAmf(const AMFValue& amf, int sample_rate, int channels, int sample_bit){
+Track::Ptr Factory::getAudioTrackByAmf(const AMFValue &amf, int sample_rate, int channels, int sample_bit) {
    CodecId codecId = getAudioCodecIdByAmf(amf);
    if (codecId == CodecInvalid) {
        return nullptr;
@ -166,8 +169,8 @@ Track::Ptr Factory::getAudioTrackByAmf(const AMFValue& amf, int sample_rate, int
 RtmpCodec::Ptr Factory::getRtmpDecoderByTrack(const Track::Ptr &track) {
    auto it = s_plugins.find(track->getCodecId());
    if (it == s_plugins.end()) {
-        WarnL << "Unsupported codec: " << track->getCodecName();
-        return nullptr;
+        WarnL << "Unsupported codec: " << track->getCodecName() << ", use CommonRtmpDecoder";
+        return std::make_shared<CommonRtmpDecoder>(track);
    }
    return it->second->getRtmpDecoderByTrack(track);
 }
@ -175,8 +178,8 @@ RtmpCodec::Ptr Factory::getRtmpDecoderByTrack(const Track::Ptr &track) {
 RtmpCodec::Ptr Factory::getRtmpEncoderByTrack(const Track::Ptr &track) {
    auto it = s_plugins.find(track->getCodecId());
    if (it == s_plugins.end()) {
-        WarnL << "Unsupported codec: " << track->getCodecName();
-        return nullptr;
+        WarnL << "Unsupported codec: " << track->getCodecName() << ", use CommonRtmpEncoder";
+        return std::make_shared<CommonRtmpEncoder>(track);
    }
    return it->second->getRtmpEncoderByTrack(track);
 }
@ -190,6 +193,8 @@ AMFValue Factory::getAmfByCodecId(CodecId codecId) {
        case CodecG711A: return AMFValue((int)RtmpAudioCodec::g711a);
        case CodecG711U: return AMFValue((int)RtmpAudioCodec::g711u);
        case CodecOpus: return AMFValue((int)RtmpAudioCodec::opus);
+        case CodecADPCM: return AMFValue((int)RtmpAudioCodec::adpcm);
+        case CodecMP3: return AMFValue((int)RtmpAudioCodec::mp3);
        case CodecAV1: return AMFValue((int)RtmpVideoCodec::fourcc_av1);
        case CodecVP9: return AMFValue((int)RtmpVideoCodec::fourcc_vp9);
        default: return AMFValue(AMF_NULL);
@ -208,11 +213,10 @@ Frame::Ptr Factory::getFrameFromPtr(CodecId codec, const char *data, size_t byte

 Frame::Ptr Factory::getFrameFromBuffer(CodecId codec, Buffer::Ptr data, uint64_t dts, uint64_t pts) {
    auto frame = Factory::getFrameFromPtr(codec, data->data(), data->size(), dts, pts);
-    if(!frame){
+    if (!frame) {
        return nullptr;
    }
    return std::make_shared<FrameCacheAble>(frame, false, std::move(data));
 }

-}//namespace mediakit
-
+} // namespace mediakit
--- a/src/Extension/Factory.h
+++ b/src/Extension/Factory.h
@ -23,6 +23,7 @@
 #define REGISTER_STATIC_VAR(var_name, line) REGISTER_STATIC_VAR_INNER(var_name, line)

 #define REGISTER_CODEC(plugin) \
+extern CodecPlugin plugin;     \
 static toolkit::onceToken REGISTER_STATIC_VAR(s_token, __LINE__) ([]() { \
    Factory::registerPlugin(plugin); \
 });
@ -64,7 +65,7 @@ public:
     
     * [AUTO-TRANSLATED:397b982e]
     */
-    static Track::Ptr getTrackByCodecId(CodecId codecId, int sample_rate = 0, int channels = 0, int sample_bit = 0);
+    static Track::Ptr getTrackByCodecId(CodecId codecId, int sample_rate = 0, int channels = 1, int sample_bit = 16);

    // //////////////////////////////rtsp相关//////////////////////////////////  [AUTO-TRANSLATED:884055ec]
    // //////////////////////////////rtsp相关//////////////////////////////////
--- a/src/Extension/Frame.cpp
+++ b/src/Extension/Frame.cpp
@ -261,7 +261,7 @@ static bool isNeedMerge(CodecId codec){

 bool FrameMerger::inputFrame(const Frame::Ptr &frame, onOutput cb, BufferLikeString *buffer) {
    if (frame && !isNeedMerge(frame->getCodecId())) {
-        cb(frame->dts(), frame->pts(), frame, true);
+        cb(frame->dts(), frame->pts(), Frame::getCacheAbleFrame(frame), true);
        return true;
    }
    if (willFlush(frame)) {
--- a/src/Extension/Frame.h
+++ b/src/Extension/Frame.h
@ -43,7 +43,18 @@ typedef enum {
    XX(CodecVP8,   TrackVideo, 7, "VP8", PSI_STREAM_VP8, MOV_OBJECT_VP8)             \
    XX(CodecVP9,   TrackVideo, 8, "VP9", PSI_STREAM_VP9, MOV_OBJECT_VP9)             \
    XX(CodecAV1,   TrackVideo, 9, "AV1", PSI_STREAM_AV1, MOV_OBJECT_AV1)             \
-    XX(CodecJPEG,  TrackVideo, 10, "JPEG", PSI_STREAM_JPEG_2000, MOV_OBJECT_JPEG)
+    XX(CodecJPEG,  TrackVideo, 10, "JPEG", PSI_STREAM_JPEG_2000, MOV_OBJECT_JPEG)    \
+    XX(CodecH266,  TrackVideo, 11, "H266", PSI_STREAM_H266, MOV_OBJECT_H266)         \
+    XX(CodecTS,    TrackVideo, 12, "MP2T", PSI_STREAM_RESERVED, MOV_OBJECT_NONE)     \
+    XX(CodecPS,    TrackVideo, 13, "MPEG", PSI_STREAM_RESERVED, MOV_OBJECT_NONE)     \
+    XX(CodecMP3,   TrackAudio, 14, "MP3",  PSI_STREAM_MP3, MOV_OBJECT_MP3)           \
+    XX(CodecADPCM, TrackAudio, 15, "ADPCM", PSI_STREAM_RESERVED, MOV_OBJECT_NONE)    \
+    XX(CodecSVACV, TrackVideo, 16, "SVACV", PSI_STREAM_VIDEO_SVAC, MOV_OBJECT_NONE)  \
+    XX(CodecSVACA, TrackAudio, 17, "SVACA", PSI_STREAM_AUDIO_SVAC, MOV_OBJECT_NONE)  \
+    XX(CodecG722,  TrackAudio, 18, "G722", PSI_STREAM_AUDIO_G722, MOV_OBJECT_NONE)   \
+    XX(CodecG723,  TrackAudio, 19, "G723", PSI_STREAM_AUDIO_G723, MOV_OBJECT_NONE)   \
+    XX(CodecG728,  TrackAudio, 20, "G728", PSI_STREAM_RESERVED, MOV_OBJECT_NONE)     \
+    XX(CodecG729,  TrackAudio, 21, "G729", PSI_STREAM_AUDIO_G729, MOV_OBJECT_NONE)

 typedef enum {
    CodecInvalid = -1,
--- a/src/Extension/Track.cpp
+++ b/src/Extension/Track.cpp
@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2016-present The ZLMediaKit project authors. All Rights Reserved.
+ *
+ * This file is part of ZLMediaKit(https://github.com/ZLMediaKit/ZLMediaKit).
+ *
+ * Use of this source code is governed by MIT-like license that can be found in the
+ * 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 "Track.h"
+#include "Util/util.h"
+
+using namespace std;
+using namespace toolkit;
+
+namespace mediakit {
+
+Sdp::Ptr AudioTrackImp::getSdp(uint8_t payload_type) const {
+    return std::make_shared<DefaultSdp>(payload_type, *this);
+}
+Sdp::Ptr VideoTrackImp::getSdp(uint8_t payload_type) const {
+    return std::make_shared<DefaultSdp>(payload_type, *this);
+}
+
+} // namespace mediakit
--- a/src/Extension/Track.h
+++ b/src/Extension/Track.h
@ -201,7 +201,7 @@ public:
    bool ready() const override { return true; }

    Track::Ptr clone() const override { return std::make_shared<VideoTrackImp>(*this); }
-    Sdp::Ptr getSdp(uint8_t payload_type) const override { return nullptr; }
+    Sdp::Ptr getSdp(uint8_t payload_type) const override;
    CodecId getCodecId() const override { return _codec_id; }

 private:
@ -298,7 +298,7 @@ public:
     * [AUTO-TRANSLATED:9af5a0a4]
     */
    int getAudioSampleRate() const override{
-        return _sample_rate;
+        return _sample_rate ? _sample_rate : RtpPayload::getClockRateByCodec(_codecid);
    }

    /**
@ -308,7 +308,7 @@ public:
     * [AUTO-TRANSLATED:5fedc65d]
     */
    int getAudioSampleBit() const override{
-        return _sample_bit;
+        return _sample_bit ? _sample_bit : 16;
    }

    /**
@ -318,11 +318,11 @@ public:
     * [AUTO-TRANSLATED:2613b317]
     */
    int getAudioChannel() const override{
-        return _channels;
+        return _channels ? _channels : 1;
    }

    Track::Ptr clone() const override { return std::make_shared<AudioTrackImp>(*this); }
-    Sdp::Ptr getSdp(uint8_t payload_type) const override { return nullptr; }
+    Sdp::Ptr getSdp(uint8_t payload_type) const override;

 private:
    CodecId _codecid;
--- a/src/Http/HttpFileManager.cpp
+++ b/src/Http/HttpFileManager.cpp
@ -284,9 +284,9 @@ static bool makeFolderMenu(const string &httpPath, const string &strFullPath, st
        } else if (fileSize < 1024 * 1024) {
            ss << fixed << setprecision(2) << " (" << fileSize / 1024.0 << "KB)";
        } else if (fileSize < 1024 * 1024 * 1024) {
-            ss << fixed << setprecision(2) << " (" << fileSize / 1024 / 1024.0 << "MB)";
+            ss << fixed << setprecision(2) << " (" << (fileSize >> 10) / 1024.0 << "MB)";
        } else {
-            ss << fixed << setprecision(2) << " (" << fileSize / 1024 / 1024 / 1024.0 << "GB)";
+            ss << fixed << setprecision(2) << " (" << (fileSize >> 20) / 1024.0 << "GB)";
        }
        ss << "</a></li>\r\n";
    }
--- a/src/Rtmp/Rtmp.cpp
+++ b/src/Rtmp/Rtmp.cpp
@ -34,14 +34,14 @@ VideoMeta::VideoMeta(const VideoTrack::Ptr &video) {
        _metadata.set("framerate", video->getVideoFps());
    }
    if (video->getBitRate()) {
-        _metadata.set("videodatarate", video->getBitRate() / 1024);
+        _metadata.set("videodatarate", video->getBitRate() >> 10);
    }
    _metadata.set("videocodecid", Factory::getAmfByCodecId(video->getCodecId()));
 }

 AudioMeta::AudioMeta(const AudioTrack::Ptr &audio) {
    if (audio->getBitRate()) {
-        _metadata.set("audiodatarate", audio->getBitRate() / 1024);
+        _metadata.set("audiodatarate", audio->getBitRate() >> 10);
    }
    if (audio->getAudioSampleRate() > 0) {
        _metadata.set("audiosamplerate", audio->getAudioSampleRate());
@ -68,29 +68,23 @@ uint8_t getAudioRtmpFlags(const Track::Ptr &track) {
            auto iChannel = audioTrack->getAudioChannel();
            auto iSampleBit = audioTrack->getAudioSampleBit();

-            uint8_t flvAudioType;
+            auto amf = Factory::getAmfByCodecId(track->getCodecId());
+            if (!amf) {
+                WarnL << "该编码格式不支持转换为RTMP: " << track->getCodecName();
+                return 0;
+            }
+            uint8_t flvAudioType = amf.as_integer();
            switch (track->getCodecId()) {
-                case CodecG711A: flvAudioType = (uint8_t)RtmpAudioCodec::g711a; break;
-                case CodecG711U: flvAudioType = (uint8_t)RtmpAudioCodec::g711u; break;
+                case CodecAAC:
                case CodecOpus: {
-                    flvAudioType = (uint8_t)RtmpAudioCodec::opus;
-                    // opus不通过flags获取音频相关信息  [AUTO-TRANSLATED:0ddf328b]
-                    // opus does not get audio information through flags
+                    // opus/aac不通过flags获取音频相关信息  [AUTO-TRANSLATED:0ddf328b]
+                    // opus/aac does not get audio information through flags
                    iSampleRate = 44100;
                    iSampleBit = 16;
                    iChannel = 2;
                    break;
                }
-                case CodecAAC: {
-                    flvAudioType = (uint8_t)RtmpAudioCodec::aac;
-                    // aac不通过flags获取音频相关信息  [AUTO-TRANSLATED:63ac5081]
-                    // aac does not get audio information through flags
-                    iSampleRate = 44100;
-                    iSampleBit = 16;
-                    iChannel = 2;
-                    break;
-                }
-                default: WarnL << "该编码格式不支持转换为RTMP: " << track->getCodecName(); return 0;
+                default: break;
            }

            uint8_t flvSampleRate;
--- a/src/Rtmp/Rtmp.h
+++ b/src/Rtmp/Rtmp.h
@ -371,6 +371,8 @@ enum class RtmpAudioCodec : uint8_t {
    14 = MP3 8 kHz
    15 = Device-specific sound
     */
+    adpcm = 1,
+    mp3 = 2,
    g711a = 7,
    g711u = 8,
    aac = 10,
--- a/src/Rtp/Decoder.cpp
+++ b/src/Rtp/Decoder.cpp
@ -90,7 +90,8 @@ void DecoderImp::onStream(int stream, int codecid, const void *extra, size_t byt
    }
    // G711传统只支持 8000/1/16的规格，FFmpeg貌似做了扩展，但是这里不管它了  [AUTO-TRANSLATED:851813f7]
    // G711 traditionally only supports the 8000/1/16 specification. FFmpeg seems to have extended it, but we'll ignore that here.
-    auto track = Factory::getTrackByCodecId(getCodecByMpegId(codecid), 8000, 1, 16);
+    auto codec = getCodecByMpegId(codecid);
+    auto track= Factory::getTrackByCodecId(codec);
    if (track) {
        onTrack(stream, std::move(track));
    }
@ -113,7 +114,7 @@ void DecoderImp::onDecode(int stream, int codecid, int flags, int64_t pts, int64
    }
    auto &ref = _tracks[stream];
    if (!ref.first) {
-        onTrack(stream, Factory::getTrackByCodecId(codec, 8000, 1, 16));
+        onTrack(stream, Factory::getTrackByCodecId(codec));
    }
    if (!ref.first) {
        WarnL << "Unsupported codec :" << getCodecName(codec);
--- a/src/Rtp/GB28181Process.cpp
+++ b/src/Rtp/GB28181Process.cpp
@ -83,79 +83,76 @@ bool GB28181Process::inputRtp(bool, const char *data, size_t data_len) {
            // Prevent too many pt types from causing memory overflow
            WarnL << "Rtp payload type more than 2 types: " << _rtp_receiver.size();
        }
-        switch (pt) {
-            case Rtsp::PT_PCMA:
-            case Rtsp::PT_PCMU: {
-                // CodecG711U or CodecG711A
-                ref = std::make_shared<RtpReceiverImp>(8000, [this](RtpPacket::Ptr rtp) { onRtpSorted(std::move(rtp)); });
-                auto track = Factory::getTrackByCodecId(pt == Rtsp::PT_PCMU ? CodecG711U : CodecG711A, 8000, 1, 16);
-                CHECK(track);
-                track->setIndex(pt);
-                _interface->addTrack(track);
-                _rtp_decoder[pt] = Factory::getRtpDecoderByCodecId(track->getCodecId());
-                break;
-            }
-            case Rtsp::PT_JPEG: {
-                // mjpeg
-                ref = std::make_shared<RtpReceiverImp>(90000, [this](RtpPacket::Ptr rtp) { onRtpSorted(std::move(rtp)); });
-                auto track = Factory::getTrackByCodecId(CodecJPEG);
-                CHECK(track);
-                track->setIndex(pt);
-                _interface->addTrack(track);
-                _rtp_decoder[pt] = Factory::getRtpDecoderByCodecId(track->getCodecId());
-                break;
-            }
-            default: {
-                if (pt == opus_pt) {
-                    // opus负载  [AUTO-TRANSLATED:defa6a8d]
-                    // opus payload
-                    ref = std::make_shared<RtpReceiverImp>(48000, [this](RtpPacket::Ptr rtp) { onRtpSorted(std::move(rtp)); });
-                    auto track = Factory::getTrackByCodecId(CodecOpus);
+
+        do {
+            if (pt < 96) {
+                auto codec = RtpPayload::getCodecId(pt);
+                if (codec != CodecInvalid && codec != CodecTS) {
+                    auto sample_rate = RtpPayload::getClockRate(pt);
+                    auto channels = RtpPayload::getAudioChannel(pt);
+                    ref = std::make_shared<RtpReceiverImp>(sample_rate, [this](RtpPacket::Ptr rtp) { onRtpSorted(std::move(rtp)); });
+                    auto track = Factory::getTrackByCodecId(codec, sample_rate, channels);
                    CHECK(track);
                    track->setIndex(pt);
                    _interface->addTrack(track);
                    _rtp_decoder[pt] = Factory::getRtpDecoderByCodecId(track->getCodecId());
-                } else if (pt == h265_pt) {
-                    // H265负载  [AUTO-TRANSLATED:61fbcf7f]
-                    // H265 payload
-                    ref = std::make_shared<RtpReceiverImp>(90000, [this](RtpPacket::Ptr rtp) { onRtpSorted(std::move(rtp)); });
-                    auto track = Factory::getTrackByCodecId(CodecH265);
-                    CHECK(track);
-                    track->setIndex(pt);
-                    _interface->addTrack(track);
-                    _rtp_decoder[pt] = Factory::getRtpDecoderByCodecId(track->getCodecId());
-                } else if (pt == h264_pt) {
-                    // H264负载  [AUTO-TRANSLATED:6f3fbb0d]
-                    // H264 payload
-                    ref = std::make_shared<RtpReceiverImp>(90000, [this](RtpPacket::Ptr rtp) { onRtpSorted(std::move(rtp)); });
-                    auto track = Factory::getTrackByCodecId(CodecH264);
-                    CHECK(track);
-                    track->setIndex(pt);
-                    _interface->addTrack(track);
-                    _rtp_decoder[pt] = Factory::getRtpDecoderByCodecId(track->getCodecId());
-                } else {
-                    if (pt != Rtsp::PT_MP2T && pt != ps_pt) {
-                        WarnL << "Unknown rtp payload type(" << (int)pt << "), decode it as mpeg-ps or mpeg-ts";
-                    }
-                    ref = std::make_shared<RtpReceiverImp>(90000, [this](RtpPacket::Ptr rtp) { onRtpSorted(std::move(rtp)); });
-                    // ts或ps负载  [AUTO-TRANSLATED:3ca31480]
-                    // ts or ps payload
-                    _rtp_decoder[pt] = std::make_shared<CommonRtpDecoder>(CodecInvalid, 32 * 1024);
-                    // 设置dump目录  [AUTO-TRANSLATED:23c88ace]
-                    // Set dump directory
-                    GET_CONFIG(string, dump_dir, RtpProxy::kDumpDir);
-                    if (!dump_dir.empty()) {
-                        auto save_path = File::absolutePath(_media_info.stream + ".mpeg", dump_dir);
-                        _save_file_ps.reset(File::create_file(save_path.data(), "wb"), [](FILE *fp) {
-                            if (fp) {
-                                fclose(fp);
-                            }
-                        });
-                    }
+                    break;
                }
+            }
+            if (pt == opus_pt) {
+                // opus负载  [AUTO-TRANSLATED:defa6a8d]
+                // opus payload
+                ref = std::make_shared<RtpReceiverImp>(48000, [this](RtpPacket::Ptr rtp) { onRtpSorted(std::move(rtp)); });
+                auto track = Factory::getTrackByCodecId(CodecOpus);
+                CHECK(track);
+                track->setIndex(pt);
+                _interface->addTrack(track);
+                _rtp_decoder[pt] = Factory::getRtpDecoderByCodecId(track->getCodecId());
                break;
            }
-        }
+            if (pt == h265_pt) {
+                // H265负载  [AUTO-TRANSLATED:61fbcf7f]
+                // H265 payload
+                ref = std::make_shared<RtpReceiverImp>(90000, [this](RtpPacket::Ptr rtp) { onRtpSorted(std::move(rtp)); });
+                auto track = Factory::getTrackByCodecId(CodecH265);
+                CHECK(track);
+                track->setIndex(pt);
+                _interface->addTrack(track);
+                _rtp_decoder[pt] = Factory::getRtpDecoderByCodecId(track->getCodecId());
+                break;
+            }
+            if (pt == h264_pt) {
+                // H264负载  [AUTO-TRANSLATED:6f3fbb0d]
+                // H264 payload
+                ref = std::make_shared<RtpReceiverImp>(90000, [this](RtpPacket::Ptr rtp) { onRtpSorted(std::move(rtp)); });
+                auto track = Factory::getTrackByCodecId(CodecH264);
+                CHECK(track);
+                track->setIndex(pt);
+                _interface->addTrack(track);
+                _rtp_decoder[pt] = Factory::getRtpDecoderByCodecId(track->getCodecId());
+                break;
+            }
+
+            if (pt != Rtsp::PT_MP2T && pt != ps_pt) {
+                WarnL << "Unknown rtp payload type(" << (int)pt << "), decode it as mpeg-ps or mpeg-ts";
+            }
+            ref = std::make_shared<RtpReceiverImp>(90000, [this](RtpPacket::Ptr rtp) { onRtpSorted(std::move(rtp)); });
+            // ts或ps负载  [AUTO-TRANSLATED:3ca31480]
+            // ts or ps payload
+            _rtp_decoder[pt] = std::make_shared<CommonRtpDecoder>(CodecInvalid, 32 * 1024);
+            // 设置dump目录  [AUTO-TRANSLATED:23c88ace]
+            // Set dump directory
+            GET_CONFIG(string, dump_dir, RtpProxy::kDumpDir);
+            if (!dump_dir.empty()) {
+                auto save_path = File::absolutePath(_media_info.stream + ".mpeg", dump_dir);
+                _save_file_ps.reset(File::create_file(save_path.data(), "wb"), [](FILE *fp) {
+                    if (fp) {
+                        fclose(fp);
+                    }
+                });
+            }
+        } while (false);
+
        // 设置frame回调  [AUTO-TRANSLATED:dec7590f]
        // Set frame callback
        _rtp_decoder[pt]->addDelegate([this, pt](const Frame::Ptr &frame) {
@ -169,11 +166,16 @@ bool GB28181Process::inputRtp(bool, const char *data, size_t data_len) {
 }

 void GB28181Process::onRtpDecode(const Frame::Ptr &frame) {
-    if (frame->getCodecId() != CodecInvalid) {
-        // 这里不是ps或ts  [AUTO-TRANSLATED:6f79ac69]
-        // This is not ps or ts
-        _interface->inputFrame(frame);
-        return;
+    switch (frame->getCodecId()) {
+        case CodecInvalid:
+        case CodecTS:
+        case CodecPS: break;
+
+        default:
+            // 这里不是ps或ts  [AUTO-TRANSLATED:6f79ac69]
+            // This is not ps or ts
+            _interface->inputFrame(frame);
+            return;
    }

    // 这是TS或PS  [AUTO-TRANSLATED:55782860]
--- a/src/Rtp/RtpSession.cpp
+++ b/src/Rtp/RtpSession.cpp
@ -127,8 +127,7 @@ void RtpSession::onRtpPacket(const char *data, size_t len) {
        weak_ptr<RtpSession>  weak_self = static_pointer_cast<RtpSession>(shared_from_this());
        _process->setOnDetach([weak_self](const SockException &ex) {
            if (auto strong_self = weak_self.lock()) {
-                strong_self->_process = nullptr;
-                strong_self->shutdown(ex);
+                strong_self->safeShutdown(ex);
            }
        });
    }
--- a/src/Rtsp/Rtsp.cpp
+++ b/src/Rtsp/Rtsp.cpp
@ -12,9 +12,10 @@
 #include <cinttypes>
 #include <random>
 #include "Rtsp.h"
+#include "Network/Socket.h"
 #include "Common/Parser.h"
 #include "Common/config.h"
-#include "Network/Socket.h"
+#include "Extension/Track.h"
 #include "Extension/Factory.h"

 using namespace std;
@ -24,50 +25,84 @@ namespace mediakit {

 int RtpPayload::getClockRate(int pt) {
    switch (pt) {
-#define SWITCH_CASE(name, type, value, clock_rate, channel, codec_id)                                                                                          \
+#define XX(name, type, value, clock_rate, channel, codec_id)                                                                                          \
    case value: return clock_rate;
-        RTP_PT_MAP(SWITCH_CASE)
-#undef SWITCH_CASE
+        RTP_PT_MAP(XX)
+#undef XX
        default: return 90000;
    }
 }

+int RtpPayload::getClockRateByCodec(CodecId codec) {
+#define XX(name, type, value, clock_rate, channel, codec_id) { codec_id, clock_rate },
+    static map<CodecId, int> s_map = { RTP_PT_MAP(XX) };
+#undef XX
+    auto it = s_map.find(codec);
+    if (it == s_map.end()) {
+        WarnL << "Unsupported codec: " << getCodecName(codec);
+        return 90000;
+    }
+    return it->second;
+}
+
+int RtpPayload::getPayloadType(const Track &track) {
+#define XX(name, type, value, clock_rate, channel, codec_id) { codec_id, info { clock_rate, channel, value } },
+    struct info {
+        int clock_rate;
+        int channels;
+        int pt;
+    };
+    static map<CodecId, info> s_map = { RTP_PT_MAP(XX) };
+#undef XX
+    auto it = s_map.find(track.getCodecId());
+    if (it == s_map.end()) {
+        return -1;
+    }
+    if (track.getTrackType() == TrackAudio) {
+        if (static_cast<const AudioTrack &>(track).getAudioSampleRate() != it->second.clock_rate
+            || static_cast<const AudioTrack &>(track).getAudioChannel() != it->second.channels) {
+            return -1;
+        }
+    }
+    return it->second.pt;
+}
+
 TrackType RtpPayload::getTrackType(int pt) {
    switch (pt) {
-#define SWITCH_CASE(name, type, value, clock_rate, channel, codec_id)                                                                                          \
+#define XX(name, type, value, clock_rate, channel, codec_id)                                                                                          \
    case value: return type;
-        RTP_PT_MAP(SWITCH_CASE)
-#undef SWITCH_CASE
+        RTP_PT_MAP(XX)
+#undef XX
        default: return TrackInvalid;
    }
 }

 int RtpPayload::getAudioChannel(int pt) {
    switch (pt) {
-#define SWITCH_CASE(name, type, value, clock_rate, channel, codec_id)                                                                                          \
+#define XX(name, type, value, clock_rate, channel, codec_id)                                                                                          \
    case value: return channel;
-        RTP_PT_MAP(SWITCH_CASE)
-#undef SWITCH_CASE
+        RTP_PT_MAP(XX)
+#undef XX
        default: return 1;
    }
 }

 const char *RtpPayload::getName(int pt) {
    switch (pt) {
-#define SWITCH_CASE(name, type, value, clock_rate, channel, codec_id)                                                                                          \
+#define XX(name, type, value, clock_rate, channel, codec_id)                                                                                          \
    case value: return #name;
-        RTP_PT_MAP(SWITCH_CASE)
-#undef SWITCH_CASE
+        RTP_PT_MAP(XX)
+#undef XX
        default: return "unknown payload type";
    }
 }

 CodecId RtpPayload::getCodecId(int pt) {
    switch (pt) {
-#define SWITCH_CASE(name, type, value, clock_rate, channel, codec_id)                                                                                          \
+#define XX(name, type, value, clock_rate, channel, codec_id)                                                                                          \
    case value: return codec_id;
-        RTP_PT_MAP(SWITCH_CASE)
-#undef SWITCH_CASE
+        RTP_PT_MAP(XX)
+#undef XX
        default: return CodecInvalid;
    }
 }
@ -91,13 +126,7 @@ static void getAttrSdp(const multimap<string, string> &attr, _StrPrinter &printe
 }

 string SdpTrack::getName() const {
-    switch (_pt) {
-#define SWITCH_CASE(name, type, value, clock_rate, channel, codec_id)                                                                                          \
-    case value: return #name;
-        RTP_PT_MAP(SWITCH_CASE)
-#undef SWITCH_CASE
-        default: return _codec;
-    }
+    return RtpPayload::getName(_pt);
 }

 string SdpTrack::getControlUrl(const string &base_url) const {
@ -715,6 +744,23 @@ TitleSdp::TitleSdp(float dur_sec, const std::map<std::string, std::string> &head
    _printer << "a=control:*\r\n";
 }

+DefaultSdp::DefaultSdp(int payload_type, const Track &track)
+    : Sdp(track.getTrackType() == TrackVideo ? 9000 : static_cast<const AudioTrack &>(track).getAudioSampleRate(), payload_type) {
+    _printer << "m=" << track.getTrackTypeStr() << " 0 RTP/AVP " << payload_type << "\r\n";
+    auto bitrate = track.getBitRate() >> 10;
+    if (bitrate) {
+        _printer << "b=AS:" << bitrate << "\r\n";
+    }
+    if (payload_type < 96) {
+        return;
+    }
+    _printer << "a=rtpmap:" << payload_type << " " << track.getCodecName() << "/" << getSampleRate();
+    if (track.getTrackType() == TrackAudio) {
+        _printer << "/" << static_cast<const AudioTrack &>(track).getAudioChannel();
+    }
+    _printer << "\r\n";
+}
+
 } // namespace mediakit

 namespace toolkit {
--- a/src/Rtsp/Rtsp.h
+++ b/src/Rtsp/Rtsp.h
@ -11,16 +11,18 @@
 #ifndef RTSP_RTSP_H_
 #define RTSP_RTSP_H_

-#include "Common/macros.h"
-#include "Extension/Frame.h"
-#include "Network/Socket.h"
-#include <memory>
 #include <string.h>
 #include <string>
+#include <memory>
 #include <unordered_map>
+#include "Network/Socket.h"
+#include "Common/macros.h"
+#include "Extension/Frame.h"

 namespace mediakit {

+class Track;
+
 namespace Rtsp {
 typedef enum {
    RTP_Invalid = -1,
@ -32,27 +34,27 @@ typedef enum {
 #define RTP_PT_MAP(XX)                                                                                                                                         \
    XX(PCMU, TrackAudio, 0, 8000, 1, CodecG711U)                                                                                                               \
    XX(GSM, TrackAudio, 3, 8000, 1, CodecInvalid)                                                                                                              \
-    XX(G723, TrackAudio, 4, 8000, 1, CodecInvalid)                                                                                                             \
+    XX(G723, TrackAudio, 4, 8000, 1, CodecG723)                                                                                                             \
    XX(DVI4_8000, TrackAudio, 5, 8000, 1, CodecInvalid)                                                                                                        \
    XX(DVI4_16000, TrackAudio, 6, 16000, 1, CodecInvalid)                                                                                                      \
    XX(LPC, TrackAudio, 7, 8000, 1, CodecInvalid)                                                                                                              \
    XX(PCMA, TrackAudio, 8, 8000, 1, CodecG711A)                                                                                                               \
-    XX(G722, TrackAudio, 9, 8000, 1, CodecInvalid)                                                                                                             \
+    XX(G722, TrackAudio, 9, 16000, 1, CodecG722)                                                                                                             \
    XX(L16_Stereo, TrackAudio, 10, 44100, 2, CodecInvalid)                                                                                                     \
    XX(L16_Mono, TrackAudio, 11, 44100, 1, CodecInvalid)                                                                                                       \
    XX(QCELP, TrackAudio, 12, 8000, 1, CodecInvalid)                                                                                                           \
    XX(CN, TrackAudio, 13, 8000, 1, CodecInvalid)                                                                                                              \
-    XX(MPA, TrackAudio, 14, 90000, 1, CodecInvalid)                                                                                                            \
-    XX(G728, TrackAudio, 15, 8000, 1, CodecInvalid)                                                                                                            \
+    XX(MP3, TrackAudio, 14, 44100, 2, CodecMP3)                                                                                                            \
+    XX(G728, TrackAudio, 15, 8000, 1, CodecG728)                                                                                                            \
    XX(DVI4_11025, TrackAudio, 16, 11025, 1, CodecInvalid)                                                                                                     \
    XX(DVI4_22050, TrackAudio, 17, 22050, 1, CodecInvalid)                                                                                                     \
-    XX(G729, TrackAudio, 18, 8000, 1, CodecInvalid)                                                                                                            \
+    XX(G729, TrackAudio, 18, 8000, 1, CodecG729)                                                                                                            \
    XX(CelB, TrackVideo, 25, 90000, 1, CodecInvalid)                                                                                                           \
    XX(JPEG, TrackVideo, 26, 90000, 1, CodecJPEG)                                                                                                              \
    XX(nv, TrackVideo, 28, 90000, 1, CodecInvalid)                                                                                                             \
    XX(H261, TrackVideo, 31, 90000, 1, CodecInvalid)                                                                                                           \
    XX(MPV, TrackVideo, 32, 90000, 1, CodecInvalid)                                                                                                            \
-    XX(MP2T, TrackVideo, 33, 90000, 1, CodecInvalid)                                                                                                           \
+    XX(MP2T, TrackVideo, 33, 90000, 1, CodecTS)                                                                                                           \
    XX(H263, TrackVideo, 34, 90000, 1, CodecInvalid)

 typedef enum {
@ -213,10 +215,12 @@ private:
 class RtpPayload {
 public:
    static int getClockRate(int pt);
+    static int getClockRateByCodec(CodecId codec);
    static TrackType getTrackType(int pt);
    static int getAudioChannel(int pt);
    static const char *getName(int pt);
    static CodecId getCodecId(int pt);
+    static int getPayloadType(const Track &track);

 private:
    RtpPayload() = delete;
@ -243,8 +247,8 @@ public:

 public:
    int _pt = 0xff;
-    int _channel;
-    int _samplerate;
+    int _channel = 0;
+    int _samplerate = 0;
    TrackType _type;
    std::string _codec;
    std::string _fmtp;
@ -340,6 +344,15 @@ private:
    uint32_t _sample_rate;
 };

+class DefaultSdp : public Sdp {
+public:
+    DefaultSdp(int payload_type, const Track &track);
+    std::string getSdp() const override { return _printer; }
+
+private:
+    toolkit::_StrPrinter _printer;
+};
+
 /**
 * sdp中除音视频外的其他描述部分
 * Other description part in sdp except audio and video
--- a/src/Rtsp/RtspMuxer.cpp
+++ b/src/Rtsp/RtspMuxer.cpp
@ -65,14 +65,19 @@ bool RtspMuxer::addTrack(const Track::Ptr &track) {
        WarnL << "Already add a track kind of: " << track->getTrackTypeStr() << ", ignore track: " << track->getCodecName();
        return false;
    }
+    if (!track->ready()) {
+        WarnL << track->getCodecName() << " unready!";
+        return false;
+    }

    auto &ref = _tracks[track->getIndex()];
    auto &encoder = ref.encoder;
    CHECK(!encoder);

+    auto pt = RtpPayload::getPayloadType(*track);
    // payload type 96以后则为动态pt  [AUTO-TRANSLATED:812ac0a2]
    // Payload type 96 and above is dynamic PT
-    Sdp::Ptr sdp = track->getSdp(96 + _index);
+    Sdp::Ptr sdp = track->getSdp(pt == -1 ? 96 + _index : pt);
    if (!sdp) {
        WarnL << "Unsupported codec: " << track->getCodecName();
        return false;
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@ -29,7 +29,7 @@ foreach(TEST_SRC ${TEST_SRC_LIST})
  get_filename_component(TEST_EXE_NAME ${TEST_SRC} NAME_WE)

  if(NOT PCAP_FOUND)
-    message(WARNING "PCAP 未找到")
+    # message(WARNING "PCAP 未找到")
    if("${TEST_EXE_NAME}" MATCHES "test_rtp_pcap")
      continue()
    endif()
--- a/tests/test_bench_push.cpp
+++ b/tests/test_bench_push.cpp
@ -7,7 +7,7 @@
 * 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.
 */
-
+#ifdef ENABLE_MP4
 #include <signal.h>
 #include <atomic>
 #include <iostream>
@ -261,3 +261,4 @@ int main(int argc, char *argv[]) {
    return 0;
 }

+#endif
--- a/tests/test_flv.cpp
+++ b/tests/test_flv.cpp
@ -84,7 +84,7 @@ static bool loadFile(const char *path){
        }
        timeStamp_last = timeStamp;
    }
-    WarnL << total_size / 1024 << "KB";
+    WarnL << (total_size >> 10) << "KB";
    fclose(fp);
    return true;
 }
--- a/tests/test_ps.cpp
+++ b/tests/test_ps.cpp
@ -85,7 +85,7 @@ static bool loadFile(const char *path, const EventPoller::Ptr &poller) {
    if (ps_decoder) {
        ps_decoder->input(text, lSize);
    }
-    WarnL << lSize / 1024 << "KB";
+    WarnL << (lSize >> 10) << "KB";
    fclose(fp);
    return true;
 }
--- a/tests/test_pusherMp4.cpp
+++ b/tests/test_pusherMp4.cpp
@ -7,7 +7,7 @@
 * 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.
 */
-
+#ifdef ENABLE_MP4
 #include <signal.h>
 #include <iostream>
 #include "Util/logger.h"
@ -141,3 +141,4 @@ int main(int argc, char *argv[]) {
    // return domain("/Users/xiongziliang/Downloads/mp4/Quantum.mp4", "rtsp://127.0.0.1/live/rtsp_push");
    return domain(argv[1], argv[2]);
 }
+#endif
--- a/tests/test_rtp.cpp
+++ b/tests/test_rtp.cpp
@ -89,7 +89,7 @@ static bool loadFile(const char *path, const EventPoller::Ptr &poller) {
    poller->doDelayTask(1, [do_read, total_size, process]() mutable {
        auto ret = do_read();
        if (!ret) {
-            WarnL << *total_size / 1024 << "KB";
+            WarnL << (*total_size >> 10) << "KB";
        }
        return ret;
    });
--- a/www/webassist
+++ b/www/webassist
@ -1 +1 @@
-Subproject commit 353af1f60115767e57662107e30935ac6ef178a2
+Subproject commit 6689195ac89462d40accd88f13dfde58902da57b
Author	SHA1	Message	Date
alex	c9da18e3e8	Merge `7141759d78` into `aa56576b0e`	2024-11-30 13:36:02 +00:00
xia-chu	aa56576b0e	修复默认音频参数相关bug Some checks are pending Android / build (push) Waiting to run Details CodeQL / Analyze (cpp) (push) Waiting to run Details CodeQL / Analyze (javascript) (push) Waiting to run Details Docker / build (push) Waiting to run Details Linux / build (push) Waiting to run Details macOS / build (push) Waiting to run Details Windows / build (push) Waiting to run Details	2024-11-30 10:54:45 +08:00
xia-chu	d1f3961326	完善rtp服务器对各编码类型es流的支持	2024-11-30 08:50:07 +08:00
xia-chu	892108d6ba	新增若干音视频编码类型的默认实现部分支持VP8/VP9/AV1/JPEG/MP3/H266/ADPCM/SVAC/G722/G723/G729	2024-11-30 08:23:10 +08:00
xia-chu	87b42ab492	优化代码除1024改成右移10位	2024-11-29 23:51:34 +08:00
xia-chu	67668c9f2c	更新第三方库	2024-11-29 23:38:10 +08:00
xia-chu	02a0b0402a	修复rtp单端口模式主动关闭时线程安全问题	2024-11-29 23:38:10 +08:00
xia-chu	64285b6b09	优化G711 rtp打包分片逻辑相关代码	2024-11-29 20:19:30 +08:00
xia-chu	f5d5b71731	修复FrameMerger输入不可缓存帧相关bug	2024-11-29 20:15:40 +08:00
xia-chu	4f8127f6f1	消除过多cmake警告	2024-11-29 20:14:32 +08:00
a839419160	78b00d9dc0	修复关闭mp4相关功能时test编译报错 (#4043 ) Some checks failed Android / build (push) Has been cancelled Details CodeQL / Analyze (cpp) (push) Has been cancelled Details CodeQL / Analyze (javascript) (push) Has been cancelled Details Docker / build (push) Has been cancelled Details Linux / build (push) Has been cancelled Details macOS / build (push) Has been cancelled Details Windows / build (push) Has been cancelled Details	2024-11-27 15:22:09 +08:00