amass/ZLMediaKit
1
0
Fork 0
mirror of https://github.com/ZLMediaKit/ZLMediaKit.git synced 2024-11-25 20:27:34 +08:00
Code Issues Actions 6 Packages Projects Releases Wiki Activity

大规模修改rtsp相关代码

Browse Source
This commit is contained in:
xiongziliang 2018-10-23 11:09:21 +08:00
parent 393f123e28
commit c1e91620d2
25 changed files with 468 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Device/Device.cpp
View File

@ -278,7 +278,7 @@ void DevChannel::initVideo(const VideoInfo& info) {
void DevChannel::initAudio(const AudioInfo& info) {
m_audio.reset(new AudioInfo(info));
m_pAdtsHeader = std::make_shared<AdtsFrame>();
m_pAdtsHeader = std::make_shared<AACFrame>();
m_pAdtsHeader->syncword = 0x0FFF;
m_pAdtsHeader->id = 0;

3
src/Device/Device.h
View File

@ -35,6 +35,7 @@
#include "RTP/RtpMakerAAC.h"
#include "RTP/RtpMakerH264.h"
#include "Rtsp/RtspToRtmpMediaSource.h"
#include "Rtsp/RtspEncoder.h"
#include "Util/TimeTicker.h"
using namespace std;
@ -119,7 +120,7 @@ private:
std::shared_ptr<VideoInfo> m_video;
std::shared_ptr<AudioInfo> m_audio;
SmoothTicker m_aTicker[2];
std::shared_ptr<AdtsFrame> m_pAdtsHeader;
std::shared_ptr<AACFrame> m_pAdtsHeader;
};

2
src/Device/PlayerProxy.cpp
View File

@ -97,7 +97,7 @@ void PlayerProxy::play(const char* strUrl) {
strongSelf->initMedia();
}
});
setOnAudioCB( [weakSelf](const AdtsFrame &data ) {
setOnAudioCB( [weakSelf](const AACFrame &data ) {
auto strongSelf = weakSelf.lock();
if(!strongSelf){
return;

2
src/MediaFile/MediaReader.h
View File

@ -74,7 +74,7 @@ private:
uint32_t m_audio_sample_rate = 0;
uint32_t m_audio_num_channels = 0;
string m_strAacCfg;
AdtsFrame m_adts;
AACFrame m_adts;
int m_iDuration = 0;
DevChannel::Ptr m_pChn;

130
src/Player/Frame.h
View File

@ -5,11 +5,43 @@
#ifndef ZLMEDIAKIT_FRAME_H
#define ZLMEDIAKIT_FRAME_H
#include "Util/RingBuffer.h"
#include "Network/Socket.h"
using namespace ZL::Util;
using namespace ZL::Network;
class Frame : public Buffer {
typedef enum {
CodecInvalid = -1,
CodecH264 = 0,
CodecAAC = 0x0100,
CodecMax
} CodecId;
typedef enum {
TrackInvalid = -1,
TrackVideo = 0,
TrackAudio,
TrackMax
} TrackType;
class CodecInfo {
public:
CodecInfo(){}
virtual ~CodecInfo(){}
/**
* 获取音视频类型
*/
virtual TrackType getTrackType() const = 0;
/**
* 获取编解码器类型
*/
virtual CodecId getCodecId() const = 0;
};
class Frame : public Buffer, public CodecInfo{
public:
typedef std::shared_ptr<Frame> Ptr;
virtual ~Frame(){}
@ -25,6 +57,78 @@ public:
virtual uint32_t prefixSize() = 0;
};
/**
* 帧环形缓存接口类
*/
class FrameRingInterface {
public:
typedef RingBuffer<Frame::Ptr> RingType;
FrameRingInterface(){}
virtual ~FrameRingInterface(){}
/**
* 获取帧环形缓存
* @return
*/
virtual RingType::Ptr getFrameRing() const = 0;
/**
* 设置帧环形缓存
* @param ring
*/
virtual void setFrameRing(const RingType::Ptr &ring) = 0;
/**
* 写入帧数据
* @param frame 帧
* @param key_pos 是否为关键帧
*/
virtual void inputFrame(const Frame::Ptr &frame,bool key_pos) = 0;
};
class FrameRing : public FrameRingInterface{
public:
typedef std::shared_ptr<FrameRing> Ptr;
FrameRing(){
//禁用缓存
_frameRing = std::make_shared<RingType>(1);
}
virtual ~FrameRing(){}
/**
* 获取帧环形缓存
* @return
*/
RingType::Ptr getFrameRing() const override {
return _frameRing;
}
/**
* 设置帧环形缓存
* @param ring
*/
void setFrameRing(const RingType::Ptr &ring) override {
_frameRing = ring;
}
/**
* 输入数据帧
* @param frame
* @param key_pos
*/
void inputFrame(const Frame::Ptr &frame,bool key_pos) override{
_frameRing->write(frame,key_pos);
}
protected:
RingType::Ptr _frameRing;
};
/**
* 264帧类
*/
class H264Frame : public Frame {
public:
typedef std::shared_ptr<H264Frame> Ptr;
@ -41,6 +145,14 @@ public:
uint32_t prefixSize() override{
return iPrefixSize;
}
TrackType getTrackType() const override{
return TrackVideo;
}
CodecId getCodecId() const override{
return CodecH264;
}
public:
uint16_t sequence;
uint32_t timeStamp;
@ -49,10 +161,12 @@ public:
uint32_t iPrefixSize = 4;
};
//ADTS 头中相对有用的信息 采样率、声道数、帧长度
class AdtsFrame : public Frame {
/**
* aac帧，包含adts头
*/
class AACFrame : public Frame {
public:
typedef std::shared_ptr<AdtsFrame> Ptr;
typedef std::shared_ptr<AACFrame> Ptr;
char *data() const override{
return (char *)buffer;
@ -66,6 +180,14 @@ public:
uint32_t prefixSize() override{
return iPrefixSize;
}
TrackType getTrackType() const override{
return TrackAudio;
}
CodecId getCodecId() const override{
return CodecAAC;
}
public:
unsigned int syncword; //12 bslbf 同步字The bit string ‘1111 1111 1111’，说明一个ADTS帧的开始
unsigned int id; //1 bslbf MPEG 标示符, 设置为1

6
src/Player/Player.cpp
View File

@ -32,7 +32,7 @@
using namespace ZL::Util;
void writeAdtsHeader(const AdtsFrame &hed, uint8_t *pcAdts) {
void writeAdtsHeader(const AACFrame &hed, uint8_t *pcAdts) {
pcAdts[0] = (hed.syncword >> 4 & 0xFF); //8bit
pcAdts[1] = (hed.syncword << 4 & 0xF0); //4 bit
pcAdts[1] |= (hed.id << 3 & 0x08); //1 bit
@ -85,7 +85,7 @@ string makeAdtsConfig(const uint8_t *pcAdts){
audioSpecificConfig[1] = (sampling_frequency_index << 7) | (channel_configuration << 3);
return string((char *)audioSpecificConfig,2);
}
void makeAdtsHeader(const string &strAudioCfg,AdtsFrame &adts) {
void makeAdtsHeader(const string &strAudioCfg,AACFrame &adts) {
uint8_t cfg1 = strAudioCfg[0];
uint8_t cfg2 = strAudioCfg[1];
@ -113,7 +113,7 @@ void makeAdtsHeader(const string &strAudioCfg,AdtsFrame &adts) {
adts.adts_buffer_fullness = 2047;
adts.no_raw_data_blocks_in_frame = 0;
}
void getAACInfo(const AdtsFrame &adts,int &iSampleRate,int &iChannel){
void getAACInfo(const AACFrame &adts,int &iSampleRate,int &iChannel){
iSampleRate = samplingFrequencyTable[adts.sf_index];
iChannel = adts.channel_configuration;
}

6
src/Player/Player.h
View File

@ -40,10 +40,10 @@ unsigned const samplingFrequencyTable[16] = { 96000, 88200,
11025, 8000,
7350, 0, 0, 0 };
void makeAdtsHeader(const string &strAudioCfg,AdtsFrame &adts);
void writeAdtsHeader(const AdtsFrame &adts, uint8_t *pcAdts) ;
void makeAdtsHeader(const string &strAudioCfg,AACFrame &adts);
void writeAdtsHeader(const AACFrame &adts, uint8_t *pcAdts) ;
string makeAdtsConfig(const uint8_t *pcAdts);
void getAACInfo(const AdtsFrame &adts,int &iSampleRate,int &iChannel);
void getAACInfo(const AACFrame &adts,int &iSampleRate,int &iChannel);
bool getAVCInfo(const string &strSps,int &iVideoWidth, int &iVideoHeight, float &iVideoFps);
#endif /* SRC_PLAYER_PLAYER_H_ */

6
src/Player/PlayerBase.h
View File

@ -94,7 +94,7 @@ public:
virtual void setOnShutdown( const function<void(const SockException &)> &cb) {};
virtual void setOnPlayResult( const function<void(const SockException &ex)> &cb) {};
virtual void setOnVideoCB( const function<void(const H264Frame &frame)> &cb) {};
virtual void setOnAudioCB( const function<void(const AdtsFrame &frame)> &cb) {};
virtual void setOnAudioCB( const function<void(const AACFrame &frame)> &cb) {};
virtual float getProgress() const { return 0;};
virtual void seekTo(float fProgress) {};
@ -140,7 +140,7 @@ public:
}
m_onGetVideoCB = cb;
}
void setOnAudioCB(const function<void(const AdtsFrame &frame)> &cb) override{
void setOnAudioCB(const function<void(const AACFrame &frame)> &cb) override{
if (m_parser) {
m_parser->setOnAudioCB(cb);
}
@ -269,7 +269,7 @@ protected:
function<void(const SockException &ex)> m_playResultCB;
std::shared_ptr<Parser> m_parser;
function<void(const H264Frame &frame)> m_onGetVideoCB;
function<void(const AdtsFrame &frame)> m_onGetAudioCB;
function<void(const AACFrame &frame)> m_onGetAudioCB;
MediaSource::Ptr m_pMediaSrc;
};

36
src/Player/Track.h
View File

@ -14,35 +14,11 @@
using namespace std;
using namespace ZL::Util;
class TrackFormat {
class TrackFormat : public FrameRingInterface , public CodecInfo{
public:
typedef std::shared_ptr<TrackFormat> Ptr;
typedef RingBuffer<Frame::Ptr> RingType;
typedef enum {
CodecInvalid = -1,
CodecH264 = 0,
CodecAAC = 0x0100,
CodecMax
} CodecID;
TrackFormat(){
_ring = std::make_shared<RingType>();
}
TrackFormat(){}
virtual ~TrackFormat(){}
virtual TrackType getTrackType() const = 0;
virtual int getCodecId() const = 0;
void writeFrame(const Frame::Ptr &frame,bool keypos = true){
_ring->write(frame, keypos);
}
RingType::Ptr& getRing() {
return _ring;
}
private:
RingType::Ptr _ring;
};
class VideoTrackFormat : public TrackFormat {
@ -73,8 +49,8 @@ public:
const string &getPps() const{
return _pps;
}
int getCodecId() const override{
return TrackFormat::CodecH264;
CodecId getCodecId() const override{
return CodecH264;
}
private:
string _sps;
@ -89,8 +65,8 @@ public:
const string &getAacCfg() const{
return _cfg;
}
int getCodecId() const override{
return TrackFormat::CodecAAC;
CodecId getCodecId() const override{
return CodecAAC;
}
private:
string _cfg;

22
src/RTP/AACRtpCodec.cpp
View File

@ -9,16 +9,16 @@ AACRtpEncoder::AACRtpEncoder(uint32_t ui32Ssrc,
uint32_t ui32SampleRate,
uint8_t ui8PlayloadType,
uint8_t ui8Interleaved) :
RtpInfo(ui32Ssrc,
ui32MtuSize,
ui32SampleRate,
ui8PlayloadType,
ui8Interleaved) {
RtpEncoder(ui32Ssrc,
ui32MtuSize,
ui32SampleRate,
ui8PlayloadType,
ui8Interleaved) {
}
void AACRtpEncoder::inputFame(const Frame::Ptr &frame, bool key_pos) {
RtpCodec::inputFame(frame, false);
void AACRtpEncoder::inputFrame(const Frame::Ptr &frame, bool key_pos) {
RtpCodec::inputFrame(frame, false);
GET_CONFIG_AND_REGISTER(uint32_t, cycleMS, Config::Rtp::kCycleMS);
auto uiStamp = frame->stamp();
@ -92,7 +92,7 @@ AACRtpDecoder::AACRtpDecoder(uint32_t ui32SampleRate) {
m_sampleRate = ui32SampleRate;
}
AdtsFrame::Ptr AACRtpDecoder::obtainFrame() {
AACFrame::Ptr AACRtpDecoder::obtainFrame() {
//从缓存池重新申请对象，防止覆盖已经写入环形缓存的对象
auto frame = m_framePool.obtain();
frame->aac_frame_length = 7;
@ -104,7 +104,7 @@ void AACRtpDecoder::inputRtp(const RtpPacket::Ptr &rtppack, bool key_pos) {
RtpCodec::inputRtp(rtppack, false);
int length = rtppack->length - rtppack->offset;
if (m_adts->aac_frame_length + length - 4 > sizeof(AdtsFrame::buffer)) {
if (m_adts->aac_frame_length + length - 4 > sizeof(AACFrame::buffer)) {
m_adts->aac_frame_length = 7;
WarnL << "aac负载数据太长";
return;
@ -120,9 +120,9 @@ void AACRtpDecoder::inputRtp(const RtpPacket::Ptr &rtppack, bool key_pos) {
}
}
void AACRtpDecoder::onGetAdts(const AdtsFrame::Ptr &frame) {
void AACRtpDecoder::onGetAdts(const AACFrame::Ptr &frame) {
//写入环形缓存
RtpCodec::inputFame(frame, false);
RtpCodec::inputFrame(frame, false);
m_adts = obtainFrame();
}

29
src/RTP/AACRtpCodec.h
View File

@ -24,12 +24,20 @@ public:
* @param key_pos 此参数内部强制转换为false,请忽略之
*/
void inputRtp(const RtpPacket::Ptr &rtp, bool key_pos = false) override;
TrackType getTrackType() const override{
return TrackAudio;
}
CodecId getCodecId() const override{
return CodecAAC;
}
private:
void onGetAdts(const AdtsFrame::Ptr &frame);
AdtsFrame::Ptr obtainFrame();
void onGetAdts(const AACFrame::Ptr &frame);
AACFrame::Ptr obtainFrame();
private:
AdtsFrame::Ptr m_adts;
ResourcePool<AdtsFrame> m_framePool;
AACFrame::Ptr m_adts;
ResourcePool<AACFrame> m_framePool;
uint32_t m_sampleRate;
};
@ -37,7 +45,7 @@ private:
/**
* aac adts转rtp类
*/
class AACRtpEncoder : public RtpInfo, public RtpCodec {
class AACRtpEncoder : public RtpEncoder {
public:
/**
* @param ui32Ssrc ssrc
@ -58,7 +66,16 @@ public:
* @param frame 带dats头的aac数据
* @param key_pos 此参数内部强制转换为false,请忽略之
*/
void inputFame(const Frame::Ptr &frame, bool key_pos = false) override;
void inputFrame(const Frame::Ptr &frame, bool key_pos = false) override;
TrackType getTrackType() const override{
return TrackAudio;
}
CodecId getCodecId() const override{
return CodecAAC;
}
private:
void makeAACRtp(const void *pData, unsigned int uiLen, bool bMark, uint32_t uiStamp);
private:

16
src/RTP/H264RtpCodec.cpp
View File

@ -97,7 +97,7 @@ bool H264RtpDecoder::decodeRtp(const RtpPacket::Ptr &rtppack) {
void H264RtpDecoder::onGetH264(const H264Frame::Ptr &frame) {
//写入环形缓存
RtpCodec::inputFame(frame,frame->type == 5);
RtpCodec::inputFrame(frame,frame->type == 5);
m_h264frame = obtainFrame();
}
@ -109,15 +109,15 @@ H264RtpEncoder::H264RtpEncoder(uint32_t ui32Ssrc,
uint32_t ui32SampleRate,
uint8_t ui8PlayloadType,
uint8_t ui8Interleaved) :
RtpInfo(ui32Ssrc,
ui32MtuSize,
ui32SampleRate,
ui8PlayloadType,
ui8Interleaved) {
RtpEncoder(ui32Ssrc,
ui32MtuSize,
ui32SampleRate,
ui8PlayloadType,
ui8Interleaved) {
}
void H264RtpEncoder::inputFame(const Frame::Ptr &frame, bool key_pos) {
RtpCodec::inputFame(frame, key_pos);
void H264RtpEncoder::inputFrame(const Frame::Ptr &frame, bool key_pos) {
RtpCodec::inputFrame(frame, key_pos);
GET_CONFIG_AND_REGISTER(uint32_t,cycleMS,Config::Rtp::kCycleMS);
auto uiStamp = frame->stamp();

20
src/RTP/H264RtpCodec.h
View File

@ -24,6 +24,14 @@ public:
* @param key_pos 此参数忽略之
*/
void inputRtp(const RtpPacket::Ptr &rtp, bool key_pos = true) override;
TrackType getTrackType() const override{
return TrackVideo;
}
CodecId getCodecId() const override{
return CodecH264;
}
private:
bool decodeRtp(const RtpPacket::Ptr &rtp);
void onGetH264(const H264Frame::Ptr &frame);
@ -36,7 +44,7 @@ private:
/**
* 264 rtp打包类
*/
class H264RtpEncoder : public RtpInfo, public RtpCodec {
class H264RtpEncoder : public RtpEncoder{
public:
/**
@ -58,7 +66,15 @@ public:
* @param frame 帧数据，必须
* @param key_pos
*/
void inputFame(const Frame::Ptr &frame, bool key_pos) override;
void inputFrame(const Frame::Ptr &frame, bool key_pos) override;
TrackType getTrackType() const override{
return TrackVideo;
}
CodecId getCodecId() const override{
return CodecH264;
}
private:
void makeH264Rtp(const void *pData, unsigned int uiLen, bool bMark, uint32_t uiStamp);
private:

13
src/RTP/RtpCodec.cpp
View File

@ -3,3 +3,16 @@
//
#include "RtpCodec.h"
RtpEncoder::RtpEncoder(uint32_t ui32Ssrc,
uint32_t ui32MtuSize,
uint32_t ui32SampleRate,
uint8_t ui8PlayloadType,
uint8_t ui8Interleaved) :
RtpInfo(ui32Ssrc,
ui32MtuSize,
ui32SampleRate,
ui8PlayloadType,
ui8Interleaved) {
}

81
src/RTP/RtpCodec.h
View File

@ -14,35 +14,55 @@ using namespace std;
using namespace ZL::Util;
using namespace ZL::Player;
class RtpCodec{
class RtpPacket {
public:
typedef std::shared_ptr<RtpCodec> Ptr;
typedef RingBuffer<Frame::Ptr> FrameRing;
typedef RingBuffer<RtpPacket::Ptr> RtpRing;
typedef std::shared_ptr<RtpPacket> Ptr;
uint8_t interleaved;
uint8_t PT;
bool mark;
uint32_t length;
uint32_t timeStamp;
uint16_t sequence;
uint32_t ssrc;
uint8_t payload[1560];
uint8_t offset;
TrackType type;
};
RtpCodec(){
class RtpRingInterface {
public:
typedef RingBuffer<RtpPacket::Ptr> RingType;
RtpRingInterface(){}
virtual ~RtpRingInterface(){}
virtual RingType::Ptr getRtpRing() const = 0;
virtual void setRtpRing(const RingType::Ptr &ring) = 0;
virtual void inputRtp(const RtpPacket::Ptr &rtp, bool key_pos) = 0;
};
class RtpRing : public RtpRingInterface {
public:
typedef std::shared_ptr<RtpRing> Ptr;
RtpRing(){
//禁用缓存
_frameRing = std::make_shared<FrameRing>(1);
_rtpRing = std::make_shared<RtpRing>(1);
_rtpRing = std::make_shared<RingType>(1);
}
virtual ~RtpCodec(){}
virtual ~RtpRing(){}
FrameRing::Ptr &getFrameRing() {
return _frameRing;
}
RtpRing::Ptr &getRtpRing() {
RingType::Ptr getRtpRing() const override {
return _rtpRing;
}
virtual void inputFame(const Frame::Ptr &frame,bool key_pos){
_frameRing->write(frame,key_pos);
void setRtpRing(const RingType::Ptr &ring) override {
_rtpRing = ring;
}
virtual void inputRtp(const RtpPacket::Ptr &rtp, bool key_pos){
void inputRtp(const RtpPacket::Ptr &rtp, bool key_pos) override{
_rtpRing->write(rtp,key_pos);
}
private:
FrameRing::Ptr _frameRing;
RtpRing::Ptr _rtpRing;
protected:
RingType::Ptr _rtpRing;
};
@ -105,6 +125,31 @@ protected:
ResourcePool<RtpPacket> m_rtpPool;
};
class RtpCodec : public RtpRing, public FrameRing , public CodecInfo{
public:
typedef std::shared_ptr<RtpCodec> Ptr;
RtpCodec(){}
virtual ~RtpCodec(){}
};
class RtpEncoder : public RtpInfo, public RtpCodec{
public:
typedef std::shared_ptr<RtpEncoder> Ptr;
/**
* @param ui32Ssrc ssrc
* @param ui32MtuSize mtu大小
* @param ui32SampleRate 采样率，强制为90000
* @param ui8PlayloadType pt类型
* @param ui8Interleaved rtsp interleaved
*/
RtpEncoder(uint32_t ui32Ssrc,
uint32_t ui32MtuSize = 1400,
uint32_t ui32SampleRate = 90000,
uint8_t ui8PlayloadType = 96,
uint8_t ui8Interleaved = TrackVideo * 2);
~RtpEncoder() {}
};

6
src/Rtmp/RtmpParser.h
View File

@ -57,7 +57,7 @@ public:
lock_guard<recursive_mutex> lck(m_mtxCB);
onVideo = cb;
}
void setOnAudioCB(const function<void(const AdtsFrame &frame)> &cb) override{
void setOnAudioCB(const function<void(const AACFrame &frame)> &cb) override{
lock_guard<recursive_mutex> lck(m_mtxCB);
onAudio = cb;
}
@ -140,7 +140,7 @@ private:
//video
H264Frame m_h264frame;
//aduio
AdtsFrame m_adts;
AACFrame m_adts;
int m_iSampleRate = 44100;
int m_iSampleBit = 16;
@ -158,7 +158,7 @@ private:
float m_fDuration = 0;
mutable Ticker m_ticker;
function<void(const H264Frame &frame)> onVideo;
function<void(const AdtsFrame &frame)> onAudio;
function<void(const AACFrame &frame)> onAudio;
recursive_mutex m_mtxCB;

2
src/Rtmp/RtmpToRtspMediaSource.cpp
View File

@ -55,7 +55,7 @@ void RtmpToRtspMediaSource::onGetH264(const H264Frame &frame) {
m_pRtpMaker_h264->makeRtp(frame.data() + 4, frame.size() - 4, frame.timeStamp);
}
}
inline void RtmpToRtspMediaSource::onGetAdts(const AdtsFrame &frame) {
inline void RtmpToRtspMediaSource::onGetAdts(const AACFrame &frame) {
if(m_pRecorder){
m_pRecorder->inputAAC((char *) frame.buffer, frame.aac_frame_length, frame.timeStamp);
}

2
src/Rtmp/RtmpToRtspMediaSource.h
View File

@ -94,7 +94,7 @@ private:
bool m_bEnableHls;
bool m_bEnableMp4;
void onGetH264(const H264Frame &frame);
void onGetAdts(const AdtsFrame &frame);
void onGetAdts(const AACFrame &frame);
void makeSDP();
};

4
src/Rtsp/RtpParser.cpp
View File

@ -242,7 +242,7 @@ inline bool RtpParser::inputAudio(const RtpPacket& rtppack,
char *frame = (char *) rtppack.payload + rtppack.offset;
int length = rtppack.length - rtppack.offset;
if (m_adts.aac_frame_length + length - 4 > sizeof(AdtsFrame::buffer)) {
if (m_adts.aac_frame_length + length - 4 > sizeof(AACFrame::buffer)) {
m_adts.aac_frame_length = 7;
return false;
}
@ -302,7 +302,7 @@ inline void RtpParser::onGetH264(H264Frame& frame) {
}
}
inline void RtpParser::onGetAdts(AdtsFrame& frame) {
inline void RtpParser::onGetAdts(AACFrame& frame) {
//frame.timeStamp=ticker1.elapsedTime();
lock_guard<recursive_mutex> lck(m_mtxCB);
if (onAudio) {

9
src/Rtsp/RtpParser.h
View File

@ -32,6 +32,7 @@
#include "Player/Player.h"
#include "Player/PlayerBase.h"
#include "Util/TimeTicker.h"
#include "RTP/RtpCodec.h"
using namespace std;
using namespace ZL::Util;
@ -51,7 +52,7 @@ public:
lock_guard<recursive_mutex> lck(m_mtxCB);
onVideo = cb;
}
void setOnAudioCB(const function<void(const AdtsFrame &frame)> &cb) override{
void setOnAudioCB(const function<void(const AACFrame &frame)> &cb) override{
lock_guard<recursive_mutex> lck(m_mtxCB);
onAudio = cb;
}
@ -120,11 +121,11 @@ private:
inline bool inputAudio(const RtpPacket &rtp, const RtspTrack &track);
inline void _onGetH264(H264Frame &frame);
inline void onGetH264(H264Frame &frame);
inline void onGetAdts(AdtsFrame &frame);
inline void onGetAdts(AACFrame &frame);
//video
H264Frame m_h264frame;
//aduio
AdtsFrame m_adts;
AACFrame m_adts;
int m_iSampleRate = 44100;
int m_iSampleBit = 16;
@ -142,7 +143,7 @@ private:
bool m_bParseSpsDelay = false;
function<void(const H264Frame &frame)> onVideo;
function<void(const AdtsFrame &frame)> onAudio;
function<void(const AACFrame &frame)> onAudio;
recursive_mutex m_mtxCB;
};

24
src/Rtsp/Rtsp.h
View File

@ -32,22 +32,17 @@
#include <unordered_map>
#include "Common/config.h"
#include "Util/util.h"
#include "Player/Frame.h"
using namespace std;
using namespace ZL::Util;
typedef enum {
TrackVideo = 0,
TrackAudio,
TrackInvalid,
TrackMax
} TrackType;
class RtspTrack{
public:
uint8_t PT;
uint8_t interleaved;
TrackType type = (TrackType) -1;
TrackType type = TrackInvalid;
string trackSdp;
string controlSuffix;
bool inited;
@ -56,21 +51,6 @@ public:
uint32_t timeStamp;
};
class RtpPacket {
public:
typedef std::shared_ptr<RtpPacket> Ptr;
uint8_t interleaved;
uint8_t PT;
bool mark;
uint32_t length;
uint32_t timeStamp;
uint16_t sequence;
uint32_t ssrc;
uint8_t payload[1560];
uint8_t offset;
TrackType type;
};
class RtcpCounter {
public:
uint32_t pktCnt = 0;

261
src/Rtsp/RtspMaker.h → src/Rtsp/RtspEncoder.h
View File

@ -5,51 +5,71 @@
#ifndef ZLMEDIAKIT_RTSPMAKER_H
#define ZLMEDIAKIT_RTSPMAKER_H
#include "Device/base64.h"
#include "Rtsp.h"
#include "RTP/RtpMaker.h"
#include "RTP/RtpMakerH264.h"
#include "RTP/RtpMakerAAC.h"
#include "Player/PlayerBase.h"
using namespace ZL::Player;
using namespace ZL::Rtsp;
#include "RTP/H264RtpCodec.h"
#include "RTP/AACRtpCodec.h"
#include "Util/base64.h"
namespace ZL{
namespace Rtsp{
/**
* sdp基类
*/
class Sdp {
* sdp基类
*/
class Sdp : public TrackFormat , public RtpRingInterface{
public:
typedef std::shared_ptr<Sdp> Ptr;
Sdp(){}
virtual ~Sdp(){}
/**
* 获取sdp字符串
* @return
*/
virtual string getSdp() const { return "";};
virtual string getSdp() const = 0;
/**
* 获取track类型
* @return
*/
virtual TrackType getTrackType() const { return TrackInvalid;};
TrackType getTrackType() const override {
return TrackInvalid;
}
/**
* 获取rtp生成器
* @param cb 回调lambad
* @param ui32Ssrc rtp ssrc
* @param iMtuSize rtp mtu
* @return
*/
virtual RtpMaker::Ptr createRtpMaker(const RtpMaker::onGetRTP &cb,uint32_t ui32Ssrc, int iMtuSize) const{ return nullptr;};
CodecId getCodecId() const override{
return CodecInvalid;
}
FrameRingInterface::RingType::Ptr getFrameRing() const override {
return _encoder->getFrameRing();
}
RtpRingInterface::RingType::Ptr getRtpRing() const override{
return _encoder->getRtpRing();
}
void inputFrame(const Frame::Ptr &frame,bool key_pos) override{
_encoder->inputFrame(frame,key_pos);
}
void inputRtp(const RtpPacket::Ptr &rtp, bool key_pos) override{
_encoder->inputRtp(rtp,key_pos);
}
virtual void createRtpEncoder(uint32_t ssrc, int mtu) = 0;
void setFrameRing(const FrameRingInterface::RingType::Ptr &ring) override{
if(_encoder){
_encoder->setFrameRing(ring);
}
}
void setRtpRing(const RtpRingInterface::RingType::Ptr &ring) override{
if(_encoder){
_encoder->setRtpRing(ring);
}
}
protected:
RtpEncoder::Ptr _encoder;
};
/**
* sdp中除音视频外的其他描述部分
*/
* sdp中除音视频外的其他描述部分
*/
class SdpTitle : public Sdp{
public:
@ -70,8 +90,8 @@ public:
}
} else {
_printer << "o=- 1383190487994921 1 IN IP4 0.0.0.0\r\n";
_printer << "s=RTSP Session, streamed by the ZL\r\n";
_printer << "i=ZL Live Stream\r\n";
_printer << "s=RTSP Session, streamed by the ZLMediaKit\r\n";
_printer << "i=ZLMediaKit Live Stream\r\n";
_printer << "c=IN IP4 0.0.0.0\r\n";
_printer << "t=0 0\r\n";
}
@ -86,14 +106,14 @@ public:
string getSdp() const override {
return _printer;
}
void createRtpEncoder(uint32_t ssrc, int mtu) override {}
private:
_StrPrinter _printer;
};
/**
* h264类型sdp
*/
* h264类型sdp
*/
class SdpH264 : public Sdp {
public:
@ -111,12 +131,12 @@ public:
int sample_rate = 90000,
int playload_type = 96,
int track_id = TrackVideo,
int bitrate = 4000){
int bitrate = 4000) {
_playload_type = playload_type;
_sample_rate = sample_rate;
_track_id = track_id;
//视频通道
_printer << "m=video 0 RTP/AVP " << playload_type << "\r\n";
_printer << "b=AS:" << bitrate << "\r\n";
@ -149,12 +169,19 @@ public:
TrackType getTrackType() const override {
return TrackVideo;
};
}
RtpMaker::Ptr createRtpMaker(const RtpMaker::onGetRTP &cb,uint32_t ui32Ssrc, int iMtuSize) const override{
return std::make_shared<RtpMaker_H264>(cb,ui32Ssrc,iMtuSize,_sample_rate,_playload_type,_track_id * 2);
};
CodecId getCodecId() const override {
return CodecH264;
}
void createRtpEncoder(uint32_t ssrc, int mtu) override{
_encoder = std::make_shared<H264RtpEncoder>(ssrc,
mtu,
_sample_rate,
_playload_type,
_track_id * 2);
}
private:
_StrPrinter _printer;
int _playload_type;
@ -165,8 +192,8 @@ private:
/**
* aac类型SDP
*/
* aac类型SDP
*/
class SdpAAC : public Sdp {
public:
@ -207,10 +234,29 @@ public:
TrackType getTrackType() const override {
return TrackAudio;
};
CodecId getCodecId() const override {
return CodecAAC;
}
RtpMaker::Ptr createRtpMaker(const RtpMaker::onGetRTP &cb,uint32_t ui32Ssrc, int iMtuSize) const override{
return std::make_shared<RtpMaker_AAC>(cb,ui32Ssrc,iMtuSize,_sample_rate,_playload_type,_track_id * 2);
};
void createRtpEncoder(uint32_t ssrc,
int mtu) override{
_encoder = std::make_shared<AACRtpEncoder>(ssrc,
mtu,
_sample_rate,
_playload_type,
_track_id * 2);
}
void setFrameRing(const FrameRingInterface::RingType::Ptr &ring) override{
if(_encoder){
_encoder->setFrameRing(ring);
}
}
void setRtpRing(const RtpRingInterface::RingType::Ptr &ring) override{
if(_encoder){
_encoder->setRtpRing(ring);
}
}
private:
_StrPrinter _printer;
int _playload_type;
@ -219,87 +265,118 @@ private:
};
/**
* rtsp生成器
*/
class RtspMaker{
* rtsp生成器
*/
class RtspEncoder : public FrameRingInterface , public RtpRingInterface{
public:
/**
* 构成函数
* @param callback rtp回调lambad
*/
RtspMaker(const RtpMaker::onGetRTP &callback) : _vec_rtp_maker(TrackMax){
_callback = callback;
RtspEncoder(){
//自适应缓存
_rtpRing = std::make_shared<RtpRingInterface::RingType>(0);
//禁用缓存
_frameRing = std::make_shared<FrameRingInterface::RingType>(1);
}
virtual ~RtspEncoder(){}
/**
* 添加音视频track
* @param sdp 媒体描述
* @param sdp 媒体描述对象
* @param ssrc 媒体rtp ssrc
* @param mtu 媒体rtp mtu
* @return 成功与否
*/
bool addTrack(const Sdp & sdp,uint32_t ssrc = 0,int mtu = 1400){
auto type = sdp.getTrackType();
if(type < 0 || type >= _vec_rtp_maker.size()){
return false;
}
if(_vec_rtp_maker[type]){
return false;
}
void addTrack(const Sdp::Ptr & sdp,uint32_t ssrc = 0,int mtu = 1400){
if(ssrc == 0){
ssrc = ((uint64_t) &sdp) & 0xFFFFFFFF;
ssrc = ((uint64_t) sdp.get()) & 0xFFFFFFFF;
}
auto rtpMaker = sdp.createRtpMaker(_callback, ssrc,mtu);
_vec_rtp_maker[sdp.getTrackType()] = rtpMaker;
_printer << sdp.getSdp();
return true;
sdp->createRtpEncoder(ssrc, mtu);
sdp->setFrameRing(_frameRing);
sdp->setRtpRing(_rtpRing);
_sdp_map[sdp->getTrackType()] = sdp;
}
virtual ~RtspMaker() {};
/**
* 获取完整的SDP字符串
* @return SDP字符串
*/
string getSdp() {
return _printer;
_StrPrinter printer;
for(auto &pr : _sdp_map){
printer << pr.second->getSdp() ;
}
return printer;
}
/**
* 打包RTP数据包
* @param type 媒体类型
* @param pcData 媒体数据
* @param iDataLen 媒体数据长度
* @param uiStamp 媒体时间戳，单位毫秒
* @return 是否成功
* 写入帧数据然后打包rtp
* @param frame 帧数据
* @param key_pos 是否为关键帧
*/
bool makeRtp(TrackType type,const char *pcData, int iDataLen, uint32_t uiStamp){
if(type < 0 || type >= _vec_rtp_maker.size()){
return false;
void inputFrame(const Frame::Ptr &frame,bool key_pos = true) override {
auto it = _sdp_map.find(frame->getTrackType());
if(it == _sdp_map.end()){
return ;
}
auto track = _vec_rtp_maker[type];
if(!track){
return false;
}
track->makeRtp(pcData,iDataLen,uiStamp);
return true;
it->second->inputFrame(frame,key_pos);
}
/**
* 也可以在外部打包好rtp然后再写入
* @param rtp rtp包
* @param key_pos 是否为关键帧的第一个rtp包
*/
void inputRtp(const RtpPacket::Ptr &rtp, bool key_pos = true) override {
_rtpRing->write(rtp,key_pos);
}
/**
* 获取rtp环形缓存
* @return
*/
RtpRingInterface::RingType::Ptr getRtpRing() const override{
return _rtpRing;
}
/**
* 获取帧环形缓存
* @return
*/
FrameRingInterface::RingType::Ptr getFrameRing() const override{
return _frameRing;
}
/**
* 设置帧环形缓存
* @param ring
*/
void setFrameRing(const FrameRingInterface::RingType::Ptr &ring) override{
_frameRing = ring;
for(auto &pr : _sdp_map){
pr.second->setFrameRing(ring);
}
}
/**
* 设置rtp环形缓存
* @param ring
*/
void setRtpRing(const RtpRingInterface::RingType::Ptr &ring) override{
_rtpRing = ring;
for(auto &pr : _sdp_map){
pr.second->setRtpRing(ring);
}
}
private:
vector<RtpMaker::Ptr> _vec_rtp_maker;
_StrPrinter _printer;
RtpMaker::onGetRTP _callback;
map<int,Sdp::Ptr> _sdp_map;
RtpRingInterface::RingType::Ptr _rtpRing;
FrameRingInterface::RingType::Ptr _frameRing;
};
}
}

1
src/Rtsp/RtspMediaSource.h
View File

@ -35,6 +35,7 @@
#include "Rtsp.h"
#include "Common/config.h"
#include "Common/MediaSource.h"
#include "RTP/RtpCodec.h"
#include "Util/logger.h"
#include "Util/RingBuffer.h"

2
src/Rtsp/RtspToRtmpMediaSource.cpp
View File

@ -124,7 +124,7 @@ void RtspToRtmpMediaSource::onGetH264(const H264Frame& frame) {
rtmpPkt->typeId = MSG_VIDEO;
m_pRtmpSrc->onGetMedia(rtmpPkt);
}
void RtspToRtmpMediaSource::onGetAdts(const AdtsFrame& frame) {
void RtspToRtmpMediaSource::onGetAdts(const AACFrame& frame) {
if(m_pRecorder){
m_pRecorder->inputAAC((char *) frame.buffer, frame.aac_frame_length, frame.timeStamp);
}

2
src/Rtsp/RtspToRtmpMediaSource.h
View File

@ -97,7 +97,7 @@ private:
bool m_bEnableHls;
bool m_bEnableMp4;
void onGetH264(const H264Frame &frame);
void onGetAdts(const AdtsFrame &frame);
void onGetAdts(const AACFrame &frame);
void makeVideoConfigPkt();
void makeAudioConfigPkt();
void makeMetaData();