THENG
/
ZLMediaKit
mirror of https://gitcode.com/gh_mirrors/zlme/ZLMediaKit.git
6
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

整理代码

This commit is contained in:
xiongziliang 2020-08-30 10:48:34 +08:00
parent 4255914613
commit fbd711a6bb
28 changed files with 1052 additions and 1011 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Common/MediaSource.h
View File

@ -174,7 +174,7 @@ public:
} }
uint32_t getStamp(const RtmpPacket::Ptr &packet) { uint32_t getStamp(const RtmpPacket::Ptr &packet) {
return packet->timeStamp; return packet->time_stamp;
} }
bool isFlushAble(bool is_video, bool is_key, uint32_t new_stamp, int cache_size); bool isFlushAble(bool is_video, bool is_key, uint32_t new_stamp, int cache_size);

2
src/Extension/AAC.cpp
View File

@ -144,7 +144,7 @@ int dumpAacConfig(const string &config, int length, uint8_t *out, int out_size)
#ifndef ENABLE_MP4 #ifndef ENABLE_MP4
AdtsHeader header; AdtsHeader header;
parseAacConfig(config, header); parseAacConfig(config, header);
header.aac_frame_length = length; header.aac_frame_length = ADTS_HEADER_LEN + length;
dumpAdtsHeader(header, out); dumpAdtsHeader(header, out);
return ADTS_HEADER_LEN; return ADTS_HEADER_LEN;
#else #else

42
src/Extension/AACRtmp.cpp
View File

@ -21,11 +21,11 @@ static string getAacCfg(const RtmpPacket &thiz) {
if (!thiz.isCfgFrame()) { if (!thiz.isCfgFrame()) {
return ret; return ret;
} }
if (thiz.strBuf.size() < 4) { if (thiz.buffer.size() < 4) {
WarnL << "bad aac cfg!"; WarnL << "bad aac cfg!";
return ret; return ret;
} }
ret = thiz.strBuf.substr(2); ret = thiz.buffer.substr(2);
return ret; return ret;
} }
@ -37,7 +37,7 @@ bool AACRtmpDecoder::inputRtmp(const RtmpPacket::Ptr &pkt, bool) {
} }
if (!_aac_cfg.empty()) { if (!_aac_cfg.empty()) {
onGetAAC(pkt->strBuf.data() + 2, pkt->strBuf.size() - 2, pkt->timeStamp); onGetAAC(pkt->buffer.data() + 2, pkt->buffer.size() - 2, pkt->time_stamp);
} }
return false; return false;
} }
@ -97,21 +97,21 @@ void AACRtmpEncoder::inputFrame(const Frame::Ptr &frame) {
if(!_aac_cfg.empty()){ if(!_aac_cfg.empty()){
RtmpPacket::Ptr rtmpPkt = ResourcePoolHelper<RtmpPacket>::obtainObj(); RtmpPacket::Ptr rtmpPkt = ResourcePoolHelper<RtmpPacket>::obtainObj();
rtmpPkt->strBuf.clear(); rtmpPkt->buffer.clear();
//header //header
uint8_t is_config = false; uint8_t is_config = false;
rtmpPkt->strBuf.push_back(_audio_flv_flags); rtmpPkt->buffer.push_back(_audio_flv_flags);
rtmpPkt->strBuf.push_back(!is_config); rtmpPkt->buffer.push_back(!is_config);
//aac data //aac data
rtmpPkt->strBuf.append(frame->data() + frame->prefixSize(), frame->size() - frame->prefixSize()); rtmpPkt->buffer.append(frame->data() + frame->prefixSize(), frame->size() - frame->prefixSize());
rtmpPkt->bodySize = rtmpPkt->strBuf.size(); rtmpPkt->body_size = rtmpPkt->buffer.size();
rtmpPkt->chunkId = CHUNK_AUDIO; rtmpPkt->chunk_id = CHUNK_AUDIO;
rtmpPkt->streamId = STREAM_MEDIA; rtmpPkt->stream_index = STREAM_MEDIA;
rtmpPkt->timeStamp = frame->dts(); rtmpPkt->time_stamp = frame->dts();
rtmpPkt->typeId = MSG_AUDIO; rtmpPkt->type_id = MSG_AUDIO;
RtmpCodec::inputRtmp(rtmpPkt, false); RtmpCodec::inputRtmp(rtmpPkt, false);
} }
} }
@ -119,20 +119,20 @@ void AACRtmpEncoder::inputFrame(const Frame::Ptr &frame) {
void AACRtmpEncoder::makeAudioConfigPkt() { void AACRtmpEncoder::makeAudioConfigPkt() {
_audio_flv_flags = getAudioRtmpFlags(std::make_shared<AACTrack>(_aac_cfg)); _audio_flv_flags = getAudioRtmpFlags(std::make_shared<AACTrack>(_aac_cfg));
RtmpPacket::Ptr rtmpPkt = ResourcePoolHelper<RtmpPacket>::obtainObj(); RtmpPacket::Ptr rtmpPkt = ResourcePoolHelper<RtmpPacket>::obtainObj();
rtmpPkt->strBuf.clear(); rtmpPkt->buffer.clear();
//header //header
uint8_t is_config = true; uint8_t is_config = true;
rtmpPkt->strBuf.push_back(_audio_flv_flags); rtmpPkt->buffer.push_back(_audio_flv_flags);
rtmpPkt->strBuf.push_back(!is_config); rtmpPkt->buffer.push_back(!is_config);
//aac config //aac config
rtmpPkt->strBuf.append(_aac_cfg); rtmpPkt->buffer.append(_aac_cfg);
rtmpPkt->bodySize = rtmpPkt->strBuf.size(); rtmpPkt->body_size = rtmpPkt->buffer.size();
rtmpPkt->chunkId = CHUNK_AUDIO; rtmpPkt->chunk_id = CHUNK_AUDIO;
rtmpPkt->streamId = STREAM_MEDIA; rtmpPkt->stream_index = STREAM_MEDIA;
rtmpPkt->timeStamp = 0; rtmpPkt->time_stamp = 0;
rtmpPkt->typeId = MSG_AUDIO; rtmpPkt->type_id = MSG_AUDIO;
RtmpCodec::inputRtmp(rtmpPkt, false); RtmpCodec::inputRtmp(rtmpPkt, false);
} }

20
src/Extension/CommonRtmp.cpp
View File

@ -31,8 +31,8 @@ void CommonRtmpDecoder::obtainFrame() {
bool CommonRtmpDecoder::inputRtmp(const RtmpPacket::Ptr &rtmp, bool) { bool CommonRtmpDecoder::inputRtmp(const RtmpPacket::Ptr &rtmp, bool) {
//拷贝负载 //拷贝负载
_frame->_buffer.assign(rtmp->strBuf.data() + 1, rtmp->strBuf.size() - 1); _frame->_buffer.assign(rtmp->buffer.data() + 1, rtmp->buffer.size() - 1);
_frame->_dts = rtmp->timeStamp; _frame->_dts = rtmp->time_stamp;
//写入环形缓存 //写入环形缓存
RtmpCodec::inputFrame(_frame); RtmpCodec::inputFrame(_frame);
//创建下一帧 //创建下一帧
@ -51,16 +51,16 @@ void CommonRtmpEncoder::inputFrame(const Frame::Ptr &frame) {
return; return;
} }
RtmpPacket::Ptr rtmp = ResourcePoolHelper<RtmpPacket>::obtainObj(); RtmpPacket::Ptr rtmp = ResourcePoolHelper<RtmpPacket>::obtainObj();
rtmp->strBuf.clear(); rtmp->buffer.clear();
//header //header
rtmp->strBuf.push_back(_audio_flv_flags); rtmp->buffer.push_back(_audio_flv_flags);
//data //data
rtmp->strBuf.append(frame->data() + frame->prefixSize(), frame->size() - frame->prefixSize()); rtmp->buffer.append(frame->data() + frame->prefixSize(), frame->size() - frame->prefixSize());
rtmp->bodySize = rtmp->strBuf.size(); rtmp->body_size = rtmp->buffer.size();
rtmp->chunkId = CHUNK_AUDIO; rtmp->chunk_id = CHUNK_AUDIO;
rtmp->streamId = STREAM_MEDIA; rtmp->stream_index = STREAM_MEDIA;
rtmp->timeStamp = frame->dts(); rtmp->time_stamp = frame->dts();
rtmp->typeId = MSG_AUDIO; rtmp->type_id = MSG_AUDIO;
RtmpCodec::inputRtmp(rtmp, false); RtmpCodec::inputRtmp(rtmp, false);
} }

100
src/Extension/H264Rtmp.cpp
View File

@ -39,18 +39,18 @@ static string getH264SPS(const RtmpPacket &thiz) {
if (!thiz.isCfgFrame()) { if (!thiz.isCfgFrame()) {
return ret; return ret;
} }
if (thiz.strBuf.size() < 13) { if (thiz.buffer.size() < 13) {
WarnL << "bad H264 cfg!"; WarnL << "bad H264 cfg!";
return ret; return ret;
} }
uint16_t sps_size ; uint16_t sps_size ;
memcpy(&sps_size, thiz.strBuf.data() + 11,2); memcpy(&sps_size, thiz.buffer.data() + 11, 2);
sps_size = ntohs(sps_size); sps_size = ntohs(sps_size);
if ((int) thiz.strBuf.size() < 13 + sps_size) { if ((int) thiz.buffer.size() < 13 + sps_size) {
WarnL << "bad H264 cfg!"; WarnL << "bad H264 cfg!";
return ret; return ret;
} }
ret.assign(thiz.strBuf.data() + 13, sps_size); ret.assign(thiz.buffer.data() + 13, sps_size);
return ret; return ret;
} }
@ -66,27 +66,27 @@ static string getH264PPS(const RtmpPacket &thiz) {
if (!thiz.isCfgFrame()) { if (!thiz.isCfgFrame()) {
return ret; return ret;
} }
if (thiz.strBuf.size() < 13) { if (thiz.buffer.size() < 13) {
WarnL << "bad H264 cfg!"; WarnL << "bad H264 cfg!";
return ret; return ret;
} }
uint16_t sps_size ; uint16_t sps_size ;
memcpy(&sps_size,thiz.strBuf.data() + 11,2); memcpy(&sps_size, thiz.buffer.data() + 11, 2);
sps_size = ntohs(sps_size); sps_size = ntohs(sps_size);
if ((int) thiz.strBuf.size() < 13 + sps_size + 1 + 2) { if ((int) thiz.buffer.size() < 13 + sps_size + 1 + 2) {
WarnL << "bad H264 cfg!"; WarnL << "bad H264 cfg!";
return ret; return ret;
} }
uint16_t pps_size ; uint16_t pps_size ;
memcpy(&pps_size, thiz.strBuf.data() + 13 + sps_size + 1,2); memcpy(&pps_size, thiz.buffer.data() + 13 + sps_size + 1, 2);
pps_size = ntohs(pps_size); pps_size = ntohs(pps_size);
if ((int) thiz.strBuf.size() < 13 + sps_size + 1 + 2 + pps_size) { if ((int) thiz.buffer.size() < 13 + sps_size + 1 + 2 + pps_size) {
WarnL << "bad H264 cfg!"; WarnL << "bad H264 cfg!";
return ret; return ret;
} }
ret.assign(thiz.strBuf.data() + 13 + sps_size + 1 + 2, pps_size); ret.assign(thiz.buffer.data() + 13 + sps_size + 1 + 2, pps_size);
return ret; return ret;
} }
@ -95,27 +95,27 @@ bool H264RtmpDecoder::decodeRtmp(const RtmpPacket::Ptr &pkt) {
//缓存sps pps，后续插入到I帧之前 //缓存sps pps，后续插入到I帧之前
_sps = getH264SPS(*pkt); _sps = getH264SPS(*pkt);
_pps = getH264PPS(*pkt); _pps = getH264PPS(*pkt);
onGetH264(_sps.data(), _sps.size(), pkt->timeStamp , pkt->timeStamp); onGetH264(_sps.data(), _sps.size(), pkt->time_stamp , pkt->time_stamp);
onGetH264(_pps.data(), _pps.size(), pkt->timeStamp , pkt->timeStamp); onGetH264(_pps.data(), _pps.size(), pkt->time_stamp , pkt->time_stamp);
return false; return false;
} }
if (pkt->strBuf.size() > 9) { if (pkt->buffer.size() > 9) {
uint32_t iTotalLen = pkt->strBuf.size(); uint32_t iTotalLen = pkt->buffer.size();
uint32_t iOffset = 5; uint32_t iOffset = 5;
uint8_t *cts_ptr = (uint8_t *) (pkt->strBuf.data() + 2); uint8_t *cts_ptr = (uint8_t *) (pkt->buffer.data() + 2);
int32_t cts = (((cts_ptr[0] << 16) | (cts_ptr[1] << 8) | (cts_ptr[2])) + 0xff800000) ^ 0xff800000; int32_t cts = (((cts_ptr[0] << 16) | (cts_ptr[1] << 8) | (cts_ptr[2])) + 0xff800000) ^ 0xff800000;
auto pts = pkt->timeStamp + cts; auto pts = pkt->time_stamp + cts;
while(iOffset + 4 < iTotalLen){ while(iOffset + 4 < iTotalLen){
uint32_t iFrameLen; uint32_t iFrameLen;
memcpy(&iFrameLen, pkt->strBuf.data() + iOffset, 4); memcpy(&iFrameLen, pkt->buffer.data() + iOffset, 4);
iFrameLen = ntohl(iFrameLen); iFrameLen = ntohl(iFrameLen);
iOffset += 4; iOffset += 4;
if(iFrameLen + iOffset > iTotalLen){ if(iFrameLen + iOffset > iTotalLen){
break; break;
} }
onGetH264(pkt->strBuf.data() + iOffset, iFrameLen, pkt->timeStamp , pts); onGetH264(pkt->buffer.data() + iOffset, iFrameLen, pkt->time_stamp , pts);
iOffset += iFrameLen; iOffset += iFrameLen;
} }
} }
@ -190,7 +190,7 @@ void H264RtmpEncoder::inputFrame(const Frame::Ptr &frame) {
} }
} }
if(_lastPacket && _lastPacket->timeStamp != frame->dts()) { if(_lastPacket && _lastPacket->time_stamp != frame->dts()) {
RtmpCodec::inputRtmp(_lastPacket, _lastPacket->isVideoKeyFrame()); RtmpCodec::inputRtmp(_lastPacket, _lastPacket->isVideoKeyFrame());
_lastPacket = nullptr; _lastPacket = nullptr;
} }
@ -202,23 +202,23 @@ void H264RtmpEncoder::inputFrame(const Frame::Ptr &frame) {
flags |= (((frame->configFrame() || frame->keyFrame()) ? FLV_KEY_FRAME : FLV_INTER_FRAME) << 4); flags |= (((frame->configFrame() || frame->keyFrame()) ? FLV_KEY_FRAME : FLV_INTER_FRAME) << 4);
_lastPacket = ResourcePoolHelper<RtmpPacket>::obtainObj(); _lastPacket = ResourcePoolHelper<RtmpPacket>::obtainObj();
_lastPacket->strBuf.clear(); _lastPacket->buffer.clear();
_lastPacket->strBuf.push_back(flags); _lastPacket->buffer.push_back(flags);
_lastPacket->strBuf.push_back(!is_config); _lastPacket->buffer.push_back(!is_config);
auto cts = frame->pts() - frame->dts(); auto cts = frame->pts() - frame->dts();
cts = htonl(cts); cts = htonl(cts);
_lastPacket->strBuf.append((char *)&cts + 1, 3); _lastPacket->buffer.append((char *)&cts + 1, 3);
_lastPacket->chunkId = CHUNK_VIDEO; _lastPacket->chunk_id = CHUNK_VIDEO;
_lastPacket->streamId = STREAM_MEDIA; _lastPacket->stream_index = STREAM_MEDIA;
_lastPacket->timeStamp = frame->dts(); _lastPacket->time_stamp = frame->dts();
_lastPacket->typeId = MSG_VIDEO; _lastPacket->type_id = MSG_VIDEO;
} }
auto size = htonl(iLen); auto size = htonl(iLen);
_lastPacket->strBuf.append((char *) &size, 4); _lastPacket->buffer.append((char *) &size, 4);
_lastPacket->strBuf.append(pcData, iLen); _lastPacket->buffer.append(pcData, iLen);
_lastPacket->bodySize = _lastPacket->strBuf.size(); _lastPacket->body_size = _lastPacket->buffer.size();
} }
void H264RtmpEncoder::makeVideoConfigPkt() { void H264RtmpEncoder::makeVideoConfigPkt() {
@ -227,38 +227,38 @@ void H264RtmpEncoder::makeVideoConfigPkt() {
bool is_config = true; bool is_config = true;
RtmpPacket::Ptr rtmpPkt = ResourcePoolHelper<RtmpPacket>::obtainObj(); RtmpPacket::Ptr rtmpPkt = ResourcePoolHelper<RtmpPacket>::obtainObj();
rtmpPkt->strBuf.clear(); rtmpPkt->buffer.clear();
//header //header
rtmpPkt->strBuf.push_back(flags); rtmpPkt->buffer.push_back(flags);
rtmpPkt->strBuf.push_back(!is_config); rtmpPkt->buffer.push_back(!is_config);
//cts //cts
rtmpPkt->strBuf.append("\x0\x0\x0", 3); rtmpPkt->buffer.append("\x0\x0\x0", 3);
//AVCDecoderConfigurationRecord start //AVCDecoderConfigurationRecord start
rtmpPkt->strBuf.push_back(1); // version rtmpPkt->buffer.push_back(1); // version
rtmpPkt->strBuf.push_back(_sps[1]); // profile rtmpPkt->buffer.push_back(_sps[1]); // profile
rtmpPkt->strBuf.push_back(_sps[2]); // compat rtmpPkt->buffer.push_back(_sps[2]); // compat
rtmpPkt->strBuf.push_back(_sps[3]); // level rtmpPkt->buffer.push_back(_sps[3]); // level
rtmpPkt->strBuf.push_back(0xff); // 6 bits reserved + 2 bits nal size length - 1 (11) rtmpPkt->buffer.push_back(0xff); // 6 bits reserved + 2 bits nal size length - 1 (11)
rtmpPkt->strBuf.push_back(0xe1); // 3 bits reserved + 5 bits number of sps (00001) rtmpPkt->buffer.push_back(0xe1); // 3 bits reserved + 5 bits number of sps (00001)
//sps //sps
uint16_t size = _sps.size(); uint16_t size = _sps.size();
size = htons(size); size = htons(size);
rtmpPkt->strBuf.append((char *) &size, 2); rtmpPkt->buffer.append((char *) &size, 2);
rtmpPkt->strBuf.append(_sps); rtmpPkt->buffer.append(_sps);
//pps //pps
rtmpPkt->strBuf.push_back(1); // version rtmpPkt->buffer.push_back(1); // version
size = _pps.size(); size = _pps.size();
size = htons(size); size = htons(size);
rtmpPkt->strBuf.append((char *) &size, 2); rtmpPkt->buffer.append((char *) &size, 2);
rtmpPkt->strBuf.append(_pps); rtmpPkt->buffer.append(_pps);
rtmpPkt->bodySize = rtmpPkt->strBuf.size(); rtmpPkt->body_size = rtmpPkt->buffer.size();
rtmpPkt->chunkId = CHUNK_VIDEO; rtmpPkt->chunk_id = CHUNK_VIDEO;
rtmpPkt->streamId = STREAM_MEDIA; rtmpPkt->stream_index = STREAM_MEDIA;
rtmpPkt->timeStamp = 0; rtmpPkt->time_stamp = 0;
rtmpPkt->typeId = MSG_VIDEO; rtmpPkt->type_id = MSG_VIDEO;
RtmpCodec::inputRtmp(rtmpPkt, false); RtmpCodec::inputRtmp(rtmpPkt, false);
} }

64
src/Extension/H265Rtmp.cpp
View File

@ -43,13 +43,13 @@ static bool getH265ConfigFrame(const RtmpPacket &thiz,string &frame) {
if (!thiz.isCfgFrame()) { if (!thiz.isCfgFrame()) {
return false; return false;
} }
if (thiz.strBuf.size() < 6) { if (thiz.buffer.size() < 6) {
WarnL << "bad H265 cfg!"; WarnL << "bad H265 cfg!";
return false; return false;
} }
auto extra = thiz.strBuf.data() + 5; auto extra = thiz.buffer.data() + 5;
auto bytes = thiz.strBuf.size() - 5; auto bytes = thiz.buffer.size() - 5;
struct mpeg4_hevc_t hevc = {0}; struct mpeg4_hevc_t hevc = {0};
if (mpeg4_hevc_decoder_configuration_record_load((uint8_t *) extra, bytes, &hevc) > 0) { if (mpeg4_hevc_decoder_configuration_record_load((uint8_t *) extra, bytes, &hevc) > 0) {
@ -70,7 +70,7 @@ bool H265RtmpDecoder::decodeRtmp(const RtmpPacket::Ptr &pkt) {
#ifdef ENABLE_MP4 #ifdef ENABLE_MP4
string config; string config;
if(getH265ConfigFrame(*pkt,config)){ if(getH265ConfigFrame(*pkt,config)){
onGetH265(config.data(), config.size(), pkt->timeStamp , pkt->timeStamp); onGetH265(config.data(), config.size(), pkt->time_stamp , pkt->time_stamp);
} }
#else #else
WarnL << "请开启MP4相关功能并使能\"ENABLE_MP4\",否则对H265-RTMP支持不完善"; WarnL << "请开启MP4相关功能并使能\"ENABLE_MP4\",否则对H265-RTMP支持不完善";
@ -78,22 +78,22 @@ bool H265RtmpDecoder::decodeRtmp(const RtmpPacket::Ptr &pkt) {
return false; return false;
} }
if (pkt->strBuf.size() > 9) { if (pkt->buffer.size() > 9) {
uint32_t iTotalLen = pkt->strBuf.size(); uint32_t iTotalLen = pkt->buffer.size();
uint32_t iOffset = 5; uint32_t iOffset = 5;
uint8_t *cts_ptr = (uint8_t *) (pkt->strBuf.data() + 2); uint8_t *cts_ptr = (uint8_t *) (pkt->buffer.data() + 2);
int32_t cts = (((cts_ptr[0] << 16) | (cts_ptr[1] << 8) | (cts_ptr[2])) + 0xff800000) ^ 0xff800000; int32_t cts = (((cts_ptr[0] << 16) | (cts_ptr[1] << 8) | (cts_ptr[2])) + 0xff800000) ^ 0xff800000;
auto pts = pkt->timeStamp + cts; auto pts = pkt->time_stamp + cts;
while(iOffset + 4 < iTotalLen){ while(iOffset + 4 < iTotalLen){
uint32_t iFrameLen; uint32_t iFrameLen;
memcpy(&iFrameLen, pkt->strBuf.data() + iOffset, 4); memcpy(&iFrameLen, pkt->buffer.data() + iOffset, 4);
iFrameLen = ntohl(iFrameLen); iFrameLen = ntohl(iFrameLen);
iOffset += 4; iOffset += 4;
if(iFrameLen + iOffset > iTotalLen){ if(iFrameLen + iOffset > iTotalLen){
break; break;
} }
onGetH265(pkt->strBuf.data() + iOffset, iFrameLen, pkt->timeStamp , pts); onGetH265(pkt->buffer.data() + iOffset, iFrameLen, pkt->time_stamp , pts);
iOffset += iFrameLen; iOffset += iFrameLen;
} }
} }
@ -176,7 +176,7 @@ void H265RtmpEncoder::inputFrame(const Frame::Ptr &frame) {
return; return;
} }
if(_lastPacket && _lastPacket->timeStamp != frame->dts()) { if(_lastPacket && _lastPacket->time_stamp != frame->dts()) {
RtmpCodec::inputRtmp(_lastPacket, _lastPacket->isVideoKeyFrame()); RtmpCodec::inputRtmp(_lastPacket, _lastPacket->isVideoKeyFrame());
_lastPacket = nullptr; _lastPacket = nullptr;
} }
@ -188,23 +188,23 @@ void H265RtmpEncoder::inputFrame(const Frame::Ptr &frame) {
flags |= (((frame->configFrame() || frame->keyFrame()) ? FLV_KEY_FRAME : FLV_INTER_FRAME) << 4); flags |= (((frame->configFrame() || frame->keyFrame()) ? FLV_KEY_FRAME : FLV_INTER_FRAME) << 4);
_lastPacket = ResourcePoolHelper<RtmpPacket>::obtainObj(); _lastPacket = ResourcePoolHelper<RtmpPacket>::obtainObj();
_lastPacket->strBuf.clear(); _lastPacket->buffer.clear();
_lastPacket->strBuf.push_back(flags); _lastPacket->buffer.push_back(flags);
_lastPacket->strBuf.push_back(!is_config); _lastPacket->buffer.push_back(!is_config);
auto cts = frame->pts() - frame->dts(); auto cts = frame->pts() - frame->dts();
cts = htonl(cts); cts = htonl(cts);
_lastPacket->strBuf.append((char *)&cts + 1, 3); _lastPacket->buffer.append((char *)&cts + 1, 3);
_lastPacket->chunkId = CHUNK_VIDEO; _lastPacket->chunk_id = CHUNK_VIDEO;
_lastPacket->streamId = STREAM_MEDIA; _lastPacket->stream_index = STREAM_MEDIA;
_lastPacket->timeStamp = frame->dts(); _lastPacket->time_stamp = frame->dts();
_lastPacket->typeId = MSG_VIDEO; _lastPacket->type_id = MSG_VIDEO;
} }
auto size = htonl(iLen); auto size = htonl(iLen);
_lastPacket->strBuf.append((char *) &size, 4); _lastPacket->buffer.append((char *) &size, 4);
_lastPacket->strBuf.append(pcData, iLen); _lastPacket->buffer.append(pcData, iLen);
_lastPacket->bodySize = _lastPacket->strBuf.size(); _lastPacket->body_size = _lastPacket->buffer.size();
} }
void H265RtmpEncoder::makeVideoConfigPkt() { void H265RtmpEncoder::makeVideoConfigPkt() {
@ -214,13 +214,13 @@ void H265RtmpEncoder::makeVideoConfigPkt() {
bool is_config = true; bool is_config = true;
RtmpPacket::Ptr rtmpPkt = ResourcePoolHelper<RtmpPacket>::obtainObj(); RtmpPacket::Ptr rtmpPkt = ResourcePoolHelper<RtmpPacket>::obtainObj();
rtmpPkt->strBuf.clear(); rtmpPkt->buffer.clear();
//header //header
rtmpPkt->strBuf.push_back(flags); rtmpPkt->buffer.push_back(flags);
rtmpPkt->strBuf.push_back(!is_config); rtmpPkt->buffer.push_back(!is_config);
//cts //cts
rtmpPkt->strBuf.append("\x0\x0\x0", 3); rtmpPkt->buffer.append("\x0\x0\x0", 3);
struct mpeg4_hevc_t hevc = {0}; struct mpeg4_hevc_t hevc = {0};
string vps_sps_pps = string("\x00\x00\x00\x01", 4) + _vps + string vps_sps_pps = string("\x00\x00\x00\x01", 4) + _vps +
@ -235,13 +235,13 @@ void H265RtmpEncoder::makeVideoConfigPkt() {
} }
//HEVCDecoderConfigurationRecord //HEVCDecoderConfigurationRecord
rtmpPkt->strBuf.append((char *)extra_data, extra_data_size); rtmpPkt->buffer.append((char *)extra_data, extra_data_size);
rtmpPkt->bodySize = rtmpPkt->strBuf.size(); rtmpPkt->body_size = rtmpPkt->buffer.size();
rtmpPkt->chunkId = CHUNK_VIDEO; rtmpPkt->chunk_id = CHUNK_VIDEO;
rtmpPkt->streamId = STREAM_MEDIA; rtmpPkt->stream_index = STREAM_MEDIA;
rtmpPkt->timeStamp = 0; rtmpPkt->time_stamp = 0;
rtmpPkt->typeId = MSG_VIDEO; rtmpPkt->type_id = MSG_VIDEO;
RtmpCodec::inputRtmp(rtmpPkt, false); RtmpCodec::inputRtmp(rtmpPkt, false);
#else #else
WarnL << "请开启MP4相关功能并使能\"ENABLE_MP4\",否则对H265-RTMP支持不完善"; WarnL << "请开启MP4相关功能并使能\"ENABLE_MP4\",否则对H265-RTMP支持不完善";

18
src/Rtmp/FlvMuxer.cpp
View File

@ -73,10 +73,10 @@ void FlvMuxer::onWriteFlvHeader(const RtmpMediaSource::Ptr &mediaSrc) {
bool is_have_audio = false,is_have_video = false; bool is_have_audio = false,is_have_video = false;
mediaSrc->getConfigFrame([&](const RtmpPacket::Ptr &pkt){ mediaSrc->getConfigFrame([&](const RtmpPacket::Ptr &pkt){
if(pkt->typeId == MSG_VIDEO){ if(pkt->type_id == MSG_VIDEO){
is_have_video = true; is_have_video = true;
} }
if(pkt->typeId == MSG_AUDIO){ if(pkt->type_id == MSG_AUDIO){
is_have_audio = true; is_have_audio = true;
} }
}); });
@ -133,16 +133,16 @@ public:
#pragma pack(pop) #pragma pack(pop)
#endif // defined(_WIN32) #endif // defined(_WIN32)
void FlvMuxer::onWriteFlvTag(const RtmpPacket::Ptr &pkt, uint32_t ui32TimeStamp , bool flush) { void FlvMuxer::onWriteFlvTag(const RtmpPacket::Ptr &pkt, uint32_t time_stamp , bool flush) {
onWriteFlvTag(pkt->typeId,pkt,ui32TimeStamp, flush); onWriteFlvTag(pkt->type_id, pkt, time_stamp, flush);
} }
void FlvMuxer::onWriteFlvTag(uint8_t ui8Type, const Buffer::Ptr &buffer, uint32_t ui32TimeStamp, bool flush) { void FlvMuxer::onWriteFlvTag(uint8_t type, const Buffer::Ptr &buffer, uint32_t time_stamp, bool flush) {
RtmpTagHeader header; RtmpTagHeader header;
header.type = ui8Type; header.type = type;
set_be24(header.data_size, buffer->size()); set_be24(header.data_size, buffer->size());
header.timestamp_ex = (uint8_t) ((ui32TimeStamp >> 24) & 0xff); header.timestamp_ex = (uint8_t) ((time_stamp >> 24) & 0xff);
set_be24(header.timestamp,ui32TimeStamp & 0xFFFFFF); set_be24(header.timestamp, time_stamp & 0xFFFFFF);
//tag header //tag header
onWrite(std::make_shared<BufferRaw>((char *)&header, sizeof(header)), false); onWrite(std::make_shared<BufferRaw>((char *)&header, sizeof(header)), false);
//tag data //tag data
@ -154,7 +154,7 @@ void FlvMuxer::onWriteFlvTag(uint8_t ui8Type, const Buffer::Ptr &buffer, uint32_
void FlvMuxer::onWriteRtmp(const RtmpPacket::Ptr &pkt,bool flush) { void FlvMuxer::onWriteRtmp(const RtmpPacket::Ptr &pkt,bool flush) {
int64_t dts_out; int64_t dts_out;
_stamp[pkt->typeId % 2].revise(pkt->timeStamp, 0, dts_out, dts_out); _stamp[pkt->type_id % 2].revise(pkt->time_stamp, 0, dts_out, dts_out);
onWriteFlvTag(pkt, dts_out,flush); onWriteFlvTag(pkt, dts_out,flush);
} }

15
src/Rtmp/FlvMuxer.h
View File

@ -25,21 +25,23 @@ public:
FlvMuxer(); FlvMuxer();
virtual ~FlvMuxer(); virtual ~FlvMuxer();
void stop(); void stop();
protected: protected:
void start(const EventPoller::Ptr &poller, const RtmpMediaSource::Ptr &media); void start(const EventPoller::Ptr &poller, const RtmpMediaSource::Ptr &media);
virtual void onWrite(const Buffer::Ptr &data, bool flush) = 0; virtual void onWrite(const Buffer::Ptr &data, bool flush) = 0;
virtual void onDetach() = 0; virtual void onDetach() = 0;
virtual std::shared_ptr<FlvMuxer> getSharedPtr() = 0; virtual std::shared_ptr<FlvMuxer> getSharedPtr() = 0;
private: private:
void onWriteFlvHeader(const RtmpMediaSource::Ptr &media); void onWriteFlvHeader(const RtmpMediaSource::Ptr &media);
void onWriteRtmp(const RtmpPacket::Ptr &pkt, bool flush); void onWriteRtmp(const RtmpPacket::Ptr &pkt, bool flush);
void onWriteFlvTag(const RtmpPacket::Ptr &pkt, uint32_t ui32TimeStamp, bool flush); void onWriteFlvTag(const RtmpPacket::Ptr &pkt, uint32_t time_stamp, bool flush);
void onWriteFlvTag(uint8_t ui8Type, const Buffer::Ptr &buffer, uint32_t ui32TimeStamp, bool flush); void onWriteFlvTag(uint8_t type, const Buffer::Ptr &buffer, uint32_t time_stamp, bool flush);
private: private:
RtmpMediaSource::RingType::RingReader::Ptr _ring_reader;
//时间戳修整器 //时间戳修整器
Stamp _stamp[2]; Stamp _stamp[2];
RtmpMediaSource::RingType::RingReader::Ptr _ring_reader;
}; };
class FlvRecorder : public FlvMuxer , public std::enable_shared_from_this<FlvRecorder>{ class FlvRecorder : public FlvMuxer , public std::enable_shared_from_this<FlvRecorder>{
@ -47,12 +49,14 @@ public:
typedef std::shared_ptr<FlvRecorder> Ptr; typedef std::shared_ptr<FlvRecorder> Ptr;
FlvRecorder(); FlvRecorder();
virtual ~FlvRecorder(); virtual ~FlvRecorder();
void startRecord(const EventPoller::Ptr &poller,const string &vhost,const string &app,const string &stream,const string &file_path);
void startRecord(const EventPoller::Ptr &poller, const RtmpMediaSource::Ptr &media, const string &file_path); void startRecord(const EventPoller::Ptr &poller, const RtmpMediaSource::Ptr &media, const string &file_path);
void startRecord(const EventPoller::Ptr &poller, const string &vhost, const string &app, const string &stream, const string &file_path);
private: private:
virtual void onWrite(const Buffer::Ptr &data, bool flush) override ; virtual void onWrite(const Buffer::Ptr &data, bool flush) override ;
virtual void onDetach() override; virtual void onDetach() override;
virtual std::shared_ptr<FlvMuxer> getSharedPtr() override; virtual std::shared_ptr<FlvMuxer> getSharedPtr() override;
private: private:
std::shared_ptr<FILE> _file; std::shared_ptr<FILE> _file;
recursive_mutex _file_mtx; recursive_mutex _file_mtx;
@ -60,5 +64,4 @@ private:
}//namespace mediakit }//namespace mediakit
#endif //ZLMEDIAKIT_FLVMUXER_H #endif //ZLMEDIAKIT_FLVMUXER_H

90
src/Rtmp/Rtmp.h
View File

@ -23,9 +23,6 @@
using namespace toolkit; using namespace toolkit;
#define PORT 1935
#define DEFAULT_CHUNK_LEN 128
#if !defined(_WIN32) #if !defined(_WIN32)
#define PACKED __attribute__((packed)) #define PACKED __attribute__((packed))
#else #else
@ -33,6 +30,7 @@ using namespace toolkit;
#endif //!defined(_WIN32) #endif //!defined(_WIN32)
#define DEFAULT_CHUNK_LEN 128
#define HANDSHAKE_PLAINTEXT 0x03 #define HANDSHAKE_PLAINTEXT 0x03
#define RANDOM_LEN (1536 - 8) #define RANDOM_LEN (1536 - 8)
@ -91,16 +89,18 @@ class RtmpHandshake {
public: public:
RtmpHandshake(uint32_t _time, uint8_t *_random = nullptr) { RtmpHandshake(uint32_t _time, uint8_t *_random = nullptr) {
_time = htonl(_time); _time = htonl(_time);
memcpy(timeStamp, &_time, 4); memcpy(time_stamp, &_time, 4);
if (!_random) { if (!_random) {
random_generate((char *) random, sizeof(random)); random_generate((char *) random, sizeof(random));
} else { } else {
memcpy(random, _random, sizeof(random)); memcpy(random, _random, sizeof(random));
} }
} }
uint8_t timeStamp[4];
uint8_t time_stamp[4];
uint8_t zero[4] = {0}; uint8_t zero[4] = {0};
uint8_t random[RANDOM_LEN]; uint8_t random[RANDOM_LEN];
void random_generate(char *bytes, int size) { void random_generate(char *bytes, int size) {
static char cdata[] = {0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x2d, 0x72, static char cdata[] = {0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x2d, 0x72,
0x74, 0x6d, 0x70, 0x2d, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x74, 0x6d, 0x70, 0x2d, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72,
@ -116,10 +116,10 @@ public:
class RtmpHeader { class RtmpHeader {
public: public:
uint8_t flags; uint8_t flags;
uint8_t timeStamp[3]; uint8_t time_stamp[3];
uint8_t bodySize[3]; uint8_t body_size[3];
uint8_t typeId; uint8_t type_id;
uint8_t streamId[4]; /* Note, this is little-endian while others are BE */ uint8_t stream_index[4]; /* Note, this is little-endian while others are BE */
}PACKED; }PACKED;
#if defined(_WIN32) #if defined(_WIN32)
@ -129,21 +129,23 @@ public:
class RtmpPacket : public Buffer{ class RtmpPacket : public Buffer{
public: public:
typedef std::shared_ptr<RtmpPacket> Ptr; typedef std::shared_ptr<RtmpPacket> Ptr;
uint8_t typeId; uint8_t type_id;
uint32_t bodySize = 0; uint32_t body_size = 0;
uint32_t timeStamp = 0; uint32_t time_stamp = 0;
bool hasAbsStamp = false; bool is_abs_stamp = false;
uint32_t tsField = 0; uint32_t ts_field = 0;
uint32_t streamId; uint32_t stream_index;
uint32_t chunkId; uint32_t chunk_id;
std::string strBuf; std::string buffer;
public: public:
char *data() const override{ char *data() const override{
return (char*)strBuf.data(); return (char*)buffer.data();
} }
uint32_t size() const override { uint32_t size() const override {
return strBuf.size(); return buffer.size();
}; }
public: public:
RtmpPacket() = default; RtmpPacket() = default;
RtmpPacket(const RtmpPacket &that) = delete; RtmpPacket(const RtmpPacket &that) = delete;
@ -151,58 +153,64 @@ public:
RtmpPacket &operator=(RtmpPacket &&that) = delete; RtmpPacket &operator=(RtmpPacket &&that) = delete;
RtmpPacket(RtmpPacket &&that){ RtmpPacket(RtmpPacket &&that){
typeId = that.typeId; type_id = that.type_id;
bodySize = that.bodySize; body_size = that.body_size;
timeStamp = that.timeStamp; time_stamp = that.time_stamp;
hasAbsStamp = that.hasAbsStamp; is_abs_stamp = that.is_abs_stamp;
tsField = that.tsField; ts_field = that.ts_field;
streamId = that.streamId; stream_index = that.stream_index;
chunkId = that.chunkId; chunk_id = that.chunk_id;
strBuf = std::move(that.strBuf); buffer = std::move(that.buffer);
} }
bool isVideoKeyFrame() const { bool isVideoKeyFrame() const {
return typeId == MSG_VIDEO && (uint8_t) strBuf[0] >> 4 == FLV_KEY_FRAME && (uint8_t) strBuf[1] == 1; return type_id == MSG_VIDEO && (uint8_t) buffer[0] >> 4 == FLV_KEY_FRAME && (uint8_t) buffer[1] == 1;
} }
bool isCfgFrame() const { bool isCfgFrame() const {
switch (typeId){ switch (type_id){
case MSG_VIDEO : return strBuf[1] == 0; case MSG_VIDEO : return buffer[1] == 0;
case MSG_AUDIO : { case MSG_AUDIO : {
switch (getMediaType()){ switch (getMediaType()){
case FLV_CODEC_AAC : return strBuf[1] == 0; case FLV_CODEC_AAC : return buffer[1] == 0;
default : return false; default : return false;
} }
} }
default : return false; default : return false;
} }
} }
int getMediaType() const { int getMediaType() const {
switch (typeId) { switch (type_id) {
case MSG_VIDEO : return (uint8_t) strBuf[0] & 0x0F; case MSG_VIDEO : return (uint8_t) buffer[0] & 0x0F;
case MSG_AUDIO : return (uint8_t) strBuf[0] >> 4; case MSG_AUDIO : return (uint8_t) buffer[0] >> 4;
default : return 0; default : return 0;
} }
} }
int getAudioSampleRate() const { int getAudioSampleRate() const {
if (typeId != MSG_AUDIO) { if (type_id != MSG_AUDIO) {
return 0; return 0;
} }
int flvSampleRate = ((uint8_t) strBuf[0] & 0x0C) >> 2; int flvSampleRate = ((uint8_t) buffer[0] & 0x0C) >> 2;
const static int sampleRate[] = { 5512, 11025, 22050, 44100 }; const static int sampleRate[] = { 5512, 11025, 22050, 44100 };
return sampleRate[flvSampleRate]; return sampleRate[flvSampleRate];
} }
int getAudioSampleBit() const { int getAudioSampleBit() const {
if (typeId != MSG_AUDIO) { if (type_id != MSG_AUDIO) {
return 0; return 0;
} }
int flvSampleBit = ((uint8_t) strBuf[0] & 0x02) >> 1; int flvSampleBit = ((uint8_t) buffer[0] & 0x02) >> 1;
const static int sampleBit[] = { 8, 16 }; const static int sampleBit[] = { 8, 16 };
return sampleBit[flvSampleBit]; return sampleBit[flvSampleBit];
} }
int getAudioChannel() const { int getAudioChannel() const {
if (typeId != MSG_AUDIO) { if (type_id != MSG_AUDIO) {
return 0; return 0;
} }
int flvStereoOrMono = (uint8_t) strBuf[0] & 0x01; int flvStereoOrMono = (uint8_t) buffer[0] & 0x01;
const static int channel[] = { 1, 2 }; const static int channel[] = { 1, 2 };
return channel[flvStereoOrMono]; return channel[flvStereoOrMono];
} }

3
src/Rtmp/RtmpCodec.h
View File

@ -54,11 +54,11 @@ public:
} }
return key_pos; return key_pos;
} }
protected: protected:
RingType::Ptr _rtmpRing; RingType::Ptr _rtmpRing;
}; };
class RtmpCodec : public RtmpRing, public FrameDispatcher , public CodecInfo{ class RtmpCodec : public RtmpRing, public FrameDispatcher , public CodecInfo{
public: public:
typedef std::shared_ptr<RtmpCodec> Ptr; typedef std::shared_ptr<RtmpCodec> Ptr;
@ -69,5 +69,4 @@ public:
}//namespace mediakit }//namespace mediakit
#endif //ZLMEDIAKIT_RTMPCODEC_H #endif //ZLMEDIAKIT_RTMPCODEC_H

34
src/Rtmp/RtmpDemuxer.cpp
View File

@ -66,27 +66,27 @@ bool RtmpDemuxer::loadMetaData(const AMFValue &val){
} }
bool RtmpDemuxer::inputRtmp(const RtmpPacket::Ptr &pkt) { bool RtmpDemuxer::inputRtmp(const RtmpPacket::Ptr &pkt) {
switch (pkt->typeId) { switch (pkt->type_id) {
case MSG_VIDEO: { case MSG_VIDEO: {
if(!_tryedGetVideoTrack){ if(!_try_get_video_track){
_tryedGetVideoTrack = true; _try_get_video_track = true;
auto codec = AMFValue(pkt->getMediaType()); auto codec = AMFValue(pkt->getMediaType());
makeVideoTrack(codec); makeVideoTrack(codec);
} }
if(_videoRtmpDecoder){ if(_video_rtmp_decoder){
return _videoRtmpDecoder->inputRtmp(pkt, true); return _video_rtmp_decoder->inputRtmp(pkt, true);
} }
return false; return false;
} }
case MSG_AUDIO: { case MSG_AUDIO: {
if(!_tryedGetAudioTrack) { if(!_try_get_audio_track) {
_tryedGetAudioTrack = true; _try_get_audio_track = true;
auto codec = AMFValue(pkt->getMediaType()); auto codec = AMFValue(pkt->getMediaType());
makeAudioTrack(codec, pkt->getAudioSampleRate(), pkt->getAudioChannel(), pkt->getAudioSampleBit()); makeAudioTrack(codec, pkt->getAudioSampleRate(), pkt->getAudioChannel(), pkt->getAudioSampleBit());
} }
if(_audioRtmpDecoder){ if(_audio_rtmp_decoder){
_audioRtmpDecoder->inputRtmp(pkt, false); _audio_rtmp_decoder->inputRtmp(pkt, false);
return false; return false;
} }
return false; return false;
@ -101,12 +101,12 @@ void RtmpDemuxer::makeVideoTrack(const AMFValue &videoCodec) {
_videoTrack = dynamic_pointer_cast<VideoTrack>(Factory::getVideoTrackByAmf(videoCodec)); _videoTrack = dynamic_pointer_cast<VideoTrack>(Factory::getVideoTrackByAmf(videoCodec));
if (_videoTrack) { if (_videoTrack) {
//生成rtmpCodec对象以便解码rtmp //生成rtmpCodec对象以便解码rtmp
_videoRtmpDecoder = Factory::getRtmpCodecByTrack(_videoTrack, false); _video_rtmp_decoder = Factory::getRtmpCodecByTrack(_videoTrack, false);
if (_videoRtmpDecoder) { if (_video_rtmp_decoder) {
//设置rtmp解码器代理，生成的frame写入该Track //设置rtmp解码器代理，生成的frame写入该Track
_videoRtmpDecoder->addDelegate(_videoTrack); _video_rtmp_decoder->addDelegate(_videoTrack);
onAddTrack(_videoTrack); onAddTrack(_videoTrack);
_tryedGetVideoTrack = true; _try_get_video_track = true;
} else { } else {
//找不到相应的rtmp解码器，该track无效 //找不到相应的rtmp解码器，该track无效
_videoTrack.reset(); _videoTrack.reset();
@ -119,12 +119,12 @@ void RtmpDemuxer::makeAudioTrack(const AMFValue &audioCodec,int sample_rate, int
_audioTrack = dynamic_pointer_cast<AudioTrack>(Factory::getAudioTrackByAmf(audioCodec, sample_rate, channels, sample_bit)); _audioTrack = dynamic_pointer_cast<AudioTrack>(Factory::getAudioTrackByAmf(audioCodec, sample_rate, channels, sample_bit));
if (_audioTrack) { if (_audioTrack) {
//生成rtmpCodec对象以便解码rtmp //生成rtmpCodec对象以便解码rtmp
_audioRtmpDecoder = Factory::getRtmpCodecByTrack(_audioTrack, false); _audio_rtmp_decoder = Factory::getRtmpCodecByTrack(_audioTrack, false);
if (_audioRtmpDecoder) { if (_audio_rtmp_decoder) {
//设置rtmp解码器代理，生成的frame写入该Track //设置rtmp解码器代理，生成的frame写入该Track
_audioRtmpDecoder->addDelegate(_audioTrack); _audio_rtmp_decoder->addDelegate(_audioTrack);
onAddTrack(_audioTrack); onAddTrack(_audioTrack);
_tryedGetAudioTrack = true; _try_get_audio_track = true;
} else { } else {
//找不到相应的rtmp解码器，该track无效 //找不到相应的rtmp解码器，该track无效
_audioTrack.reset(); _audioTrack.reset();

12
src/Rtmp/RtmpDemuxer.h
View File

@ -28,7 +28,7 @@ public:
typedef std::shared_ptr<RtmpDemuxer> Ptr; typedef std::shared_ptr<RtmpDemuxer> Ptr;
RtmpDemuxer() = default; RtmpDemuxer() = default;
virtual ~RtmpDemuxer() = default; ~RtmpDemuxer() override = default;
bool loadMetaData(const AMFValue &metadata); bool loadMetaData(const AMFValue &metadata);
@ -38,14 +38,16 @@ public:
* @return true 代表是i帧 * @return true 代表是i帧
*/ */
bool inputRtmp(const RtmpPacket::Ptr &pkt); bool inputRtmp(const RtmpPacket::Ptr &pkt);
private: private:
void makeVideoTrack(const AMFValue &val); void makeVideoTrack(const AMFValue &val);
void makeAudioTrack(const AMFValue &val, int sample_rate, int channels, int sample_bit); void makeAudioTrack(const AMFValue &val, int sample_rate, int channels, int sample_bit);
private: private:
bool _tryedGetVideoTrack = false; bool _try_get_video_track = false;
bool _tryedGetAudioTrack = false; bool _try_get_audio_track = false;
RtmpCodec::Ptr _audioRtmpDecoder; RtmpCodec::Ptr _audio_rtmp_decoder;
RtmpCodec::Ptr _videoRtmpDecoder; RtmpCodec::Ptr _video_rtmp_decoder;
}; };
} /* namespace mediakit */ } /* namespace mediakit */

8
src/Rtmp/RtmpMediaSource.h
View File

@ -122,17 +122,17 @@ public:
*/ */
void onWrite(const RtmpPacket::Ptr &pkt, bool key = true) override { void onWrite(const RtmpPacket::Ptr &pkt, bool key = true) override {
lock_guard<recursive_mutex> lock(_mtx); lock_guard<recursive_mutex> lock(_mtx);
if(pkt->typeId == MSG_VIDEO){ if(pkt->type_id == MSG_VIDEO){
//有视频，那么启用GOP缓存 //有视频，那么启用GOP缓存
_have_video = true; _have_video = true;
} }
if (pkt->isCfgFrame()) { if (pkt->isCfgFrame()) {
_config_frame_map[pkt->typeId] = pkt; _config_frame_map[pkt->type_id] = pkt;
return; return;
} }
//保存当前时间戳 //保存当前时间戳
_track_stamps_map[pkt->typeId] = pkt->timeStamp; _track_stamps_map[pkt->type_id] = pkt->time_stamp;
if (!_ring) { if (!_ring) {
weak_ptr<RtmpMediaSource> weakSelf = dynamic_pointer_cast<RtmpMediaSource>(shared_from_this()); weak_ptr<RtmpMediaSource> weakSelf = dynamic_pointer_cast<RtmpMediaSource>(shared_from_this());
@ -154,7 +154,7 @@ public:
regist(); regist();
} }
} }
PacketCache<RtmpPacket>::inputPacket(pkt->typeId == MSG_VIDEO, pkt, key); PacketCache<RtmpPacket>::inputPacket(pkt->type_id == MSG_VIDEO, pkt, key);
} }
/** /**

7
src/Rtmp/RtmpMediaSourceImp.h
View File

@ -161,11 +161,12 @@ public:
} }
private: private:
RtmpDemuxer::Ptr _demuxer;
MultiMediaSourceMuxer::Ptr _muxer;
AMFValue _metadata;
bool _all_track_ready = false; bool _all_track_ready = false;
bool _recreate_metadata = false; bool _recreate_metadata = false;
AMFValue _metadata;
RtmpDemuxer::Ptr _demuxer;
MultiMediaSourceMuxer::Ptr _muxer;
}; };
} /* namespace mediakit */ } /* namespace mediakit */

17
src/Rtmp/RtmpMediaSourceMuxer.h
View File

@ -24,34 +24,35 @@ public:
const string &strApp, const string &strApp,
const string &strId, const string &strId,
const TitleMeta::Ptr &title = nullptr) : RtmpMuxer(title){ const TitleMeta::Ptr &title = nullptr) : RtmpMuxer(title){
_mediaSouce = std::make_shared<RtmpMediaSource>(vhost,strApp,strId); _media_src = std::make_shared<RtmpMediaSource>(vhost, strApp, strId);
getRtmpRing()->setDelegate(_mediaSouce); getRtmpRing()->setDelegate(_media_src);
} }
virtual ~RtmpMediaSourceMuxer(){} virtual ~RtmpMediaSourceMuxer(){}
void setListener(const std::weak_ptr<MediaSourceEvent> &listener){ void setListener(const std::weak_ptr<MediaSourceEvent> &listener){
_mediaSouce->setListener(listener); _media_src->setListener(listener);
} }
void setTimeStamp(uint32_t stamp){ void setTimeStamp(uint32_t stamp){
_mediaSouce->setTimeStamp(stamp); _media_src->setTimeStamp(stamp);
} }
int readerCount() const{ int readerCount() const{
return _mediaSouce->readerCount(); return _media_src->readerCount();
} }
void onAllTrackReady(){ void onAllTrackReady(){
makeConfigPacket(); makeConfigPacket();
_mediaSouce->setMetaData(getMetadata()); _media_src->setMetaData(getMetadata());
} }
// 设置TrackSource // 设置TrackSource
void setTrackSource(const std::weak_ptr<TrackSource> &track_src){ void setTrackSource(const std::weak_ptr<TrackSource> &track_src){
_mediaSouce->setTrackSource(track_src); _media_src->setTrackSource(track_src);
} }
private: private:
RtmpMediaSource::Ptr _mediaSouce; RtmpMediaSource::Ptr _media_src;
}; };

6
src/Rtmp/RtmpMuxer.cpp
View File

@ -19,7 +19,7 @@ RtmpMuxer::RtmpMuxer(const TitleMeta::Ptr &title) {
}else{ }else{
_metadata = title->getMetadata(); _metadata = title->getMetadata();
} }
_rtmpRing = std::make_shared<RtmpRing::RingType>(); _rtmp_ring = std::make_shared<RtmpRing::RingType>();
} }
void RtmpMuxer::addTrack(const Track::Ptr &track) { void RtmpMuxer::addTrack(const Track::Ptr &track) {
@ -31,7 +31,7 @@ void RtmpMuxer::addTrack(const Track::Ptr &track) {
} }
//设置rtmp输出环形缓存 //设置rtmp输出环形缓存
encoder->setRtmpRing(_rtmpRing); encoder->setRtmpRing(_rtmp_ring);
//添加metadata //添加metadata
Metadata::addTrack(_metadata,track); Metadata::addTrack(_metadata,track);
@ -57,7 +57,7 @@ const AMFValue &RtmpMuxer::getMetadata() const {
} }
RtmpRing::RingType::Ptr RtmpMuxer::getRtmpRing() const { RtmpRing::RingType::Ptr RtmpMuxer::getRtmpRing() const {
return _rtmpRing; return _rtmp_ring;
} }
void RtmpMuxer::resetTracks() { void RtmpMuxer::resetTracks() {

2
src/Rtmp/RtmpMuxer.h
View File

@ -61,7 +61,7 @@ public:
*/ */
void makeConfigPacket(); void makeConfigPacket();
private: private:
RtmpRing::RingType::Ptr _rtmpRing; RtmpRing::RingType::Ptr _rtmp_ring;
AMFValue _metadata; AMFValue _metadata;
RtmpCodec::Ptr _encoder[TrackMax]; RtmpCodec::Ptr _encoder[TrackMax];
}; };

212
src/Rtmp/RtmpPlayer.cpp
View File

@ -18,8 +18,7 @@ using namespace mediakit::Client;
namespace mediakit { namespace mediakit {
RtmpPlayer::RtmpPlayer(const EventPoller::Ptr &poller) : TcpClient(poller) { RtmpPlayer::RtmpPlayer(const EventPoller::Ptr &poller) : TcpClient(poller) {}
}
RtmpPlayer::~RtmpPlayer() { RtmpPlayer::~RtmpPlayer() {
DebugL << endl; DebugL << endl;
@ -29,97 +28,82 @@ void RtmpPlayer::teardown() {
if (alive()) { if (alive()) {
shutdown(SockException(Err_shutdown,"teardown")); shutdown(SockException(Err_shutdown,"teardown"));
} }
_strApp.clear(); _app.clear();
_strStream.clear(); _stream_id.clear();
_strTcUrl.clear(); _tc_url.clear();
_pBeatTimer.reset(); _beat_timer.reset();
_pPlayTimer.reset(); _play_timer.reset();
_pMediaTimer.reset(); _rtmp_recv_timer.reset();
_iSeekTo = 0; _seek_ms = 0;
RtmpProtocol::reset(); RtmpProtocol::reset();
CLEAR_ARR(_aiFistStamp); CLEAR_ARR(_fist_stamp);
CLEAR_ARR(_aiNowStamp); CLEAR_ARR(_now_stamp);
lock_guard<recursive_mutex> lck(_mtxOnResultCB); lock_guard<recursive_mutex> lck(_mtx_on_result);
_mapOnResultCB.clear(); _map_on_result.clear();
lock_guard<recursive_mutex> lck2(_mtxOnStatusCB); lock_guard<recursive_mutex> lck2(_mtx_on_status);
_dqOnStatusCB.clear(); _deque_on_status.clear();
} }
void RtmpPlayer::play(const string &strUrl) { void RtmpPlayer::play(const string &strUrl) {
teardown(); teardown();
string strHost = FindField(strUrl.data(), "://", "/"); string host_url = FindField(strUrl.data(), "://", "/");
_strApp = FindField(strUrl.data(), (strHost + "/").data(), "/"); _app = FindField(strUrl.data(), (host_url + "/").data(), "/");
_strStream = FindField(strUrl.data(), (strHost + "/" + _strApp + "/").data(), NULL); _stream_id = FindField(strUrl.data(), (host_url + "/" + _app + "/").data(), NULL);
_strTcUrl = string("rtmp://") + strHost + "/" + _strApp; _tc_url = string("rtmp://") + host_url + "/" + _app;
if (!_strApp.size() || !_strStream.size()) { if (!_app.size() || !_stream_id.size()) {
onPlayResult_l(SockException(Err_other, "rtmp url非法"), false); onPlayResult_l(SockException(Err_other, "rtmp url非法"), false);
return; return;
} }
DebugL << strHost << " " << _strApp << " " << _strStream; DebugL << host_url << " " << _app << " " << _stream_id;
auto iPort = atoi(FindField(strHost.data(), ":", NULL).data()); auto iPort = atoi(FindField(host_url.data(), ":", NULL).data());
if (iPort <= 0) { if (iPort <= 0) {
//rtmp 默认端口1935 //rtmp 默认端口1935
iPort = 1935; iPort = 1935;
} else { } else {
//服务器域名 //服务器域名
strHost = FindField(strHost.data(), NULL, ":"); host_url = FindField(host_url.data(), NULL, ":");
} }
if (!(*this)[kNetAdapter].empty()) { if (!(*this)[kNetAdapter].empty()) {
setNetAdapter((*this)[kNetAdapter]); setNetAdapter((*this)[kNetAdapter]);
} }
weak_ptr<RtmpPlayer> weakSelf= dynamic_pointer_cast<RtmpPlayer>(shared_from_this()); weak_ptr<RtmpPlayer> weak_self = dynamic_pointer_cast<RtmpPlayer>(shared_from_this());
float playTimeOutSec = (*this)[kTimeoutMS].as<int>() / 1000.0; float play_timeout_sec = (*this)[kTimeoutMS].as<int>() / 1000.0;
_pPlayTimer.reset( new Timer(playTimeOutSec, [weakSelf]() { _play_timer.reset(new Timer(play_timeout_sec, [weak_self]() {
auto strongSelf=weakSelf.lock(); auto strong_self = weak_self.lock();
if(!strongSelf) { if (!strong_self) {
return false; return false;
} }
strongSelf->onPlayResult_l(SockException(Err_timeout,"play rtmp timeout"),false); strong_self->onPlayResult_l(SockException(Err_timeout, "play rtmp timeout"), false);
return false; return false;
}, getPoller())); }, getPoller()));
_metadata_got = false; _metadata_got = false;
startConnect(strHost, iPort , playTimeOutSec); startConnect(host_url, iPort, play_timeout_sec);
} }
void RtmpPlayer::onErr(const SockException &ex){ void RtmpPlayer::onErr(const SockException &ex){
//定时器_pPlayTimer为空后表明握手结束了 //定时器_pPlayTimer为空后表明握手结束了
onPlayResult_l(ex, !_pPlayTimer); onPlayResult_l(ex, !_play_timer);
} }
void RtmpPlayer::onPlayResult_l(const SockException &ex, bool handshakeCompleted) { void RtmpPlayer::onPlayResult_l(const SockException &ex, bool handshakeCompleted) {
if (ex.getErrCode() == Err_shutdown) {
//主动shutdown的，不触发回调
return;
}
WarnL << ex.getErrCode() << " " << ex.what(); WarnL << ex.getErrCode() << " " << ex.what();
if(!ex){
//播放成功，恢复rtmp接收超时定时器
_mediaTicker.resetTime();
weak_ptr<RtmpPlayer> weakSelf = dynamic_pointer_cast<RtmpPlayer>(shared_from_this());
int timeoutMS = (*this)[kMediaTimeoutMS].as<int>();
//创建rtmp数据接收超时检测定时器
_pMediaTimer.reset( new Timer(timeoutMS / 2000.0, [weakSelf,timeoutMS]() {
auto strongSelf=weakSelf.lock();
if(!strongSelf) {
return false;
}
if(strongSelf->_mediaTicker.elapsedTime()> timeoutMS) {
//接收rtmp媒体数据超时
strongSelf->onPlayResult_l(SockException(Err_timeout,"receive rtmp timeout"),true);
return false;
}
return true;
},getPoller()));
}
if (!handshakeCompleted) { if (!handshakeCompleted) {
//开始播放阶段 //开始播放阶段
_pPlayTimer.reset(); _play_timer.reset();
onPlayResult(ex);
//是否为性能测试模式 //是否为性能测试模式
_benchmark_mode = (*this)[Client::kBenchmarkMode].as<int>(); _benchmark_mode = (*this)[Client::kBenchmarkMode].as<int>();
onPlayResult(ex);
} else if (ex) { } else if (ex) {
//播放成功后异常断开回调 //播放成功后异常断开回调
onShutdown(ex); onShutdown(ex);
@ -128,10 +112,31 @@ void RtmpPlayer::onPlayResult_l(const SockException &ex , bool handshakeComplete
onResume(); onResume();
} }
if(ex){ if (!ex) {
//播放成功，恢复rtmp接收超时定时器
_rtmp_recv_ticker.resetTime();
int timeout_ms = (*this)[kMediaTimeoutMS].as<int>();
weak_ptr<RtmpPlayer> weakSelf = dynamic_pointer_cast<RtmpPlayer>(shared_from_this());
auto lam = [weakSelf, timeout_ms]() {
auto strongSelf = weakSelf.lock();
if (!strongSelf) {
return false;
}
if (strongSelf->_rtmp_recv_ticker.elapsedTime() > timeout_ms) {
//接收rtmp媒体数据超时
SockException ex(Err_timeout, "receive rtmp timeout");
strongSelf->onPlayResult_l(ex, true);
return false;
}
return true;
};
//创建rtmp数据接收超时检测定时器
_rtmp_recv_timer = std::make_shared<Timer>(timeout_ms / 2000.0, lam, getPoller());
} else {
teardown(); teardown();
} }
} }
void RtmpPlayer::onConnect(const SockException &err){ void RtmpPlayer::onConnect(const SockException &err){
if (err.getErrCode() != Err_success) { if (err.getErrCode() != Err_success) {
onPlayResult_l(err, false); onPlayResult_l(err, false);
@ -146,18 +151,19 @@ void RtmpPlayer::onConnect(const SockException &err){
strongSelf->send_connect(); strongSelf->send_connect();
}); });
} }
void RtmpPlayer::onRecv(const Buffer::Ptr &pBuf){ void RtmpPlayer::onRecv(const Buffer::Ptr &pBuf){
try { try {
if(_benchmark_mode && !_pPlayTimer){ if (_benchmark_mode && !_play_timer) {
//在性能测试模式下，如果rtmp握手完毕后，不再解析rtmp包 //在性能测试模式下，如果rtmp握手完毕后，不再解析rtmp包
_mediaTicker.resetTime(); _rtmp_recv_ticker.resetTime();
return; return;
} }
onParseRtmp(pBuf->data(), pBuf->size()); onParseRtmp(pBuf->data(), pBuf->size());
} catch (exception &e) { } catch (exception &e) {
SockException ex(Err_other, e.what()); SockException ex(Err_other, e.what());
//定时器_pPlayTimer为空后表明握手结束了 //定时器_pPlayTimer为空后表明握手结束了
onPlayResult_l(ex, !_pPlayTimer); onPlayResult_l(ex, !_play_timer);
} }
} }
@ -167,8 +173,8 @@ void RtmpPlayer::pause(bool bPause) {
inline void RtmpPlayer::send_connect() { inline void RtmpPlayer::send_connect() {
AMFValue obj(AMF_OBJECT); AMFValue obj(AMF_OBJECT);
obj.set("app", _strApp); obj.set("app", _app);
obj.set("tcUrl", _strTcUrl); obj.set("tcUrl", _tc_url);
//未使用代理 //未使用代理
obj.set("fpad", false); obj.set("fpad", false);
//参考librtmp,什么作用? //参考librtmp,什么作用?
@ -199,14 +205,14 @@ inline void RtmpPlayer::send_createStream() {
addOnResultCB([this](AMFDecoder &dec) { addOnResultCB([this](AMFDecoder &dec) {
//TraceL << "createStream result"; //TraceL << "createStream result";
dec.load<AMFValue>(); dec.load<AMFValue>();
_ui32StreamId = dec.load<int>(); _stream_index = dec.load<int>();
send_play(); send_play();
}); });
} }
inline void RtmpPlayer::send_play() { inline void RtmpPlayer::send_play() {
AMFEncoder enc; AMFEncoder enc;
enc << "play" << ++_iReqID << nullptr << _strStream << (double)_ui32StreamId; enc << "play" << ++_send_req_id << nullptr << _stream_id << (double) _stream_index;
sendRequest(MSG_CMD, enc.data()); sendRequest(MSG_CMD, enc.data());
auto fun = [this](AMFValue &val) { auto fun = [this](AMFValue &val) {
//TraceL << "play onStatus"; //TraceL << "play onStatus";
@ -222,7 +228,7 @@ inline void RtmpPlayer::send_play() {
inline void RtmpPlayer::send_pause(bool bPause) { inline void RtmpPlayer::send_pause(bool bPause) {
AMFEncoder enc; AMFEncoder enc;
enc << "pause" << ++_iReqID << nullptr << bPause; enc << "pause" << ++_send_req_id << nullptr << bPause;
sendRequest(MSG_CMD, enc.data()); sendRequest(MSG_CMD, enc.data());
auto fun = [this, bPause](AMFValue &val) { auto fun = [this, bPause](AMFValue &val) {
//TraceL << "pause onStatus"; //TraceL << "pause onStatus";
@ -233,21 +239,21 @@ inline void RtmpPlayer::send_pause(bool bPause) {
throw std::runtime_error(StrPrinter << "pause 恢复播放失败:" << level << " " << code << endl); throw std::runtime_error(StrPrinter << "pause 恢复播放失败:" << level << " " << code << endl);
} }
} else { } else {
_bPaused = bPause; _paused = bPause;
if (!bPause) { if (!bPause) {
onPlayResult_l(SockException(Err_success, "resum rtmp success"), true); onPlayResult_l(SockException(Err_success, "resum rtmp success"), true);
} else { } else {
//暂停播放 //暂停播放
_pMediaTimer.reset(); _rtmp_recv_timer.reset();
} }
} }
}; };
addOnStatusCB(fun); addOnStatusCB(fun);
_pBeatTimer.reset(); _beat_timer.reset();
if (bPause) { if (bPause) {
weak_ptr<RtmpPlayer> weakSelf = dynamic_pointer_cast<RtmpPlayer>(shared_from_this()); weak_ptr<RtmpPlayer> weakSelf = dynamic_pointer_cast<RtmpPlayer>(shared_from_this());
_pBeatTimer.reset(new Timer((*this)[kBeatIntervalMS].as<int>() / 1000.0,[weakSelf](){ _beat_timer.reset(new Timer((*this)[kBeatIntervalMS].as<int>() / 1000.0, [weakSelf]() {
auto strongSelf = weakSelf.lock(); auto strongSelf = weakSelf.lock();
if (!strongSelf) { if (!strongSelf) {
return false; return false;
@ -260,16 +266,17 @@ inline void RtmpPlayer::send_pause(bool bPause) {
} }
void RtmpPlayer::onCmd_result(AMFDecoder &dec){ void RtmpPlayer::onCmd_result(AMFDecoder &dec){
auto iReqId = dec.load<int>(); auto req_id = dec.load<int>();
lock_guard<recursive_mutex> lck(_mtxOnResultCB); lock_guard<recursive_mutex> lck(_mtx_on_result);
auto it = _mapOnResultCB.find(iReqId); auto it = _map_on_result.find(req_id);
if(it != _mapOnResultCB.end()){ if (it != _map_on_result.end()) {
it->second(dec); it->second(dec);
_mapOnResultCB.erase(it); _map_on_result.erase(it);
} else { } else {
WarnL << "unhandled _result"; WarnL << "unhandled _result";
} }
} }
void RtmpPlayer::onCmd_onStatus(AMFDecoder &dec) { void RtmpPlayer::onCmd_onStatus(AMFDecoder &dec) {
AMFValue val; AMFValue val;
while (true) { while (true) {
@ -282,10 +289,10 @@ void RtmpPlayer::onCmd_onStatus(AMFDecoder &dec) {
throw std::runtime_error("onStatus:the result object was not found"); throw std::runtime_error("onStatus:the result object was not found");
} }
lock_guard<recursive_mutex> lck(_mtxOnStatusCB); lock_guard<recursive_mutex> lck(_mtx_on_status);
if(_dqOnStatusCB.size()){ if (_deque_on_status.size()) {
_dqOnStatusCB.front()(val); _deque_on_status.front()(val);
_dqOnStatusCB.pop_front(); _deque_on_status.pop_front();
} else { } else {
auto level = val["level"]; auto level = val["level"];
auto code = val["code"].as_string(); auto code = val["code"].as_string();
@ -307,14 +314,14 @@ void RtmpPlayer::onCmd_onMetaData(AMFDecoder &dec) {
_metadata_got = true; _metadata_got = true;
} }
void RtmpPlayer::onStreamDry(uint32_t ui32StreamId) { void RtmpPlayer::onStreamDry(uint32_t stream_id) {
//TraceL << ui32StreamId; //TraceL << stream_id;
onPlayResult_l(SockException(Err_other, "rtmp stream dry"), true); onPlayResult_l(SockException(Err_other, "rtmp stream dry"), true);
} }
void RtmpPlayer::onMediaData_l(const RtmpPacket::Ptr &packet) { void RtmpPlayer::onMediaData_l(const RtmpPacket::Ptr &packet) {
_mediaTicker.resetTime(); _rtmp_recv_ticker.resetTime();
if(!_pPlayTimer){ if (!_play_timer) {
//已经触发了onPlayResult事件，直接触发onMediaData事件 //已经触发了onPlayResult事件，直接触发onMediaData事件
onMediaData(packet); onMediaData(packet);
return; return;
@ -340,14 +347,14 @@ void RtmpPlayer::onRtmpChunk(RtmpPacket &chunkData) {
s_func_map.emplace("_result", &RtmpPlayer::onCmd_result); s_func_map.emplace("_result", &RtmpPlayer::onCmd_result);
s_func_map.emplace("onStatus", &RtmpPlayer::onCmd_onStatus); s_func_map.emplace("onStatus", &RtmpPlayer::onCmd_onStatus);
s_func_map.emplace("onMetaData", &RtmpPlayer::onCmd_onMetaData); s_func_map.emplace("onMetaData", &RtmpPlayer::onCmd_onMetaData);
}, []() {}); });
switch (chunkData.typeId) { switch (chunkData.type_id) {
case MSG_CMD: case MSG_CMD:
case MSG_CMD3: case MSG_CMD3:
case MSG_DATA: case MSG_DATA:
case MSG_DATA3: { case MSG_DATA3: {
AMFDecoder dec(chunkData.strBuf, 0); AMFDecoder dec(chunkData.buffer, 0);
std::string type = dec.load<std::string>(); std::string type = dec.load<std::string>();
auto it = s_func_map.find(type); auto it = s_func_map.find(type);
if (it != s_func_map.end()) { if (it != s_func_map.end()) {
@ -356,14 +363,15 @@ void RtmpPlayer::onRtmpChunk(RtmpPacket &chunkData) {
} else { } else {
WarnL << "can not support cmd:" << type; WarnL << "can not support cmd:" << type;
} }
}
break; break;
}
case MSG_AUDIO: case MSG_AUDIO:
case MSG_VIDEO: { case MSG_VIDEO: {
auto idx = chunkData.typeId%2; auto idx = chunkData.type_id % 2;
if (_aNowStampTicker[idx].elapsedTime() > 500) { if (_now_stamp_ticker[idx].elapsedTime() > 500) {
//计算播放进度时间轴用 //计算播放进度时间轴用
_aiNowStamp[idx] = chunkData.timeStamp; _now_stamp[idx] = chunkData.time_stamp;
} }
if (!_metadata_got) { if (!_metadata_got) {
if (!onCheckMeta(TitleMeta().getMetadata())) { if (!onCheckMeta(TitleMeta().getMetadata())) {
@ -372,41 +380,39 @@ void RtmpPlayer::onRtmpChunk(RtmpPacket &chunkData) {
_metadata_got = true; _metadata_got = true;
} }
onMediaData_l(std::make_shared<RtmpPacket>(std::move(chunkData))); onMediaData_l(std::make_shared<RtmpPacket>(std::move(chunkData)));
break;
} }
break;
default: default: break;
//WarnL << "unhandled message:" << (int) chunkData.typeId << hexdump(chunkData.strBuf.data(), chunkData.strBuf.size());
break;
} }
} }
uint32_t RtmpPlayer::getProgressMilliSecond() const{ uint32_t RtmpPlayer::getProgressMilliSecond() const{
uint32_t iTime[2] = {0,0}; uint32_t stamp[2] = {0, 0};
for (auto i = 0; i < 2; i++) { for (auto i = 0; i < 2; i++) {
iTime[i] = _aiNowStamp[i] - _aiFistStamp[i]; stamp[i] = _now_stamp[i] - _fist_stamp[i];
} }
return _iSeekTo + MAX(iTime[0],iTime[1]); return _seek_ms + MAX(stamp[0], stamp[1]);
} }
void RtmpPlayer::seekToMilliSecond(uint32_t seekMS){ void RtmpPlayer::seekToMilliSecond(uint32_t seekMS){
if (_bPaused) { if (_paused) {
pause(false); pause(false);
} }
AMFEncoder enc; AMFEncoder enc;
enc << "seek" << ++_iReqID << nullptr << seekMS * 1.0; enc << "seek" << ++_send_req_id << nullptr << seekMS * 1.0;
sendRequest(MSG_CMD, enc.data()); sendRequest(MSG_CMD, enc.data());
addOnStatusCB([this, seekMS](AMFValue &val) { addOnStatusCB([this, seekMS](AMFValue &val) {
//TraceL << "seek result"; //TraceL << "seek result";
_aNowStampTicker[0].resetTime(); _now_stamp_ticker[0].resetTime();
_aNowStampTicker[1].resetTime(); _now_stamp_ticker[1].resetTime();
int iTimeInc = seekMS - getProgressMilliSecond(); int iTimeInc = seekMS - getProgressMilliSecond();
for (auto i = 0; i < 2; i++) { for (auto i = 0; i < 2; i++) {
_aiFistStamp[i] = _aiNowStamp[i] + iTimeInc; _fist_stamp[i] = _now_stamp[i] + iTimeInc;
_aiNowStamp[i] = _aiFistStamp[i]; _now_stamp[i] = _fist_stamp[i];
} }
_iSeekTo = seekMS; _seek_ms = seekMS;
}); });
} }
} /* namespace mediakit */ } /* namespace mediakit */

74
src/Rtmp/RtmpPlayer.h
View File

@ -8,8 +8,8 @@
* may be found in the AUTHORS file in the root of the source tree. * may be found in the AUTHORS file in the root of the source tree.
*/ */
#ifndef SRC_RTMP_RtmpPlayer2_H_ #ifndef SRC_RTMP_RtmpPlayer_H_
#define SRC_RTMP_RtmpPlayer2_H_ #define SRC_RTMP_RtmpPlayer_H_
#include <memory> #include <memory>
#include <string> #include <string>
@ -28,21 +28,24 @@ using namespace toolkit;
using namespace mediakit::Client; using namespace mediakit::Client;
namespace mediakit { namespace mediakit {
//实现了rtmp播放器协议部分的功能，及数据接收功能 //实现了rtmp播放器协议部分的功能，及数据接收功能
class RtmpPlayer : public PlayerBase, public TcpClient, public RtmpProtocol { class RtmpPlayer : public PlayerBase, public TcpClient, public RtmpProtocol {
public: public:
typedef std::shared_ptr<RtmpPlayer> Ptr; typedef std::shared_ptr<RtmpPlayer> Ptr;
RtmpPlayer(const EventPoller::Ptr &poller); RtmpPlayer(const EventPoller::Ptr &poller);
virtual ~RtmpPlayer(); ~RtmpPlayer() override;
void play(const string &strUrl) override; void play(const string &strUrl) override;
void pause(bool bPause) override; void pause(bool bPause) override;
void teardown() override; void teardown() override;
protected: protected:
virtual bool onCheckMeta(const AMFValue &val) =0; virtual bool onCheckMeta(const AMFValue &val) =0;
virtual void onMediaData(const RtmpPacket::Ptr &chunkData) =0; virtual void onMediaData(const RtmpPacket::Ptr &chunkData) =0;
uint32_t getProgressMilliSecond() const; uint32_t getProgressMilliSecond() const;
void seekToMilliSecond(uint32_t ms); void seekToMilliSecond(uint32_t ms);
protected: protected:
void onMediaData_l(const RtmpPacket::Ptr &chunkData); void onMediaData_l(const RtmpPacket::Ptr &chunkData);
//在获取config帧后才触发onPlayResult_l(而不是收到play命令回复)，所以此时所有track都初始化完毕了 //在获取config帧后才触发onPlayResult_l(而不是收到play命令回复)，所以此时所有track都初始化完毕了
@ -59,15 +62,15 @@ protected:
send(buffer); send(buffer);
} }
template<typename FUN> template<typename FUNC>
inline void addOnResultCB(const FUN &fun) { inline void addOnResultCB(const FUNC &func) {
lock_guard<recursive_mutex> lck(_mtxOnResultCB); lock_guard<recursive_mutex> lck(_mtx_on_result);
_mapOnResultCB.emplace(_iReqID, fun); _map_on_result.emplace(_send_req_id, func);
} }
template<typename FUN> template<typename FUNC>
inline void addOnStatusCB(const FUN &fun) { inline void addOnStatusCB(const FUNC &func) {
lock_guard<recursive_mutex> lck(_mtxOnStatusCB); lock_guard<recursive_mutex> lck(_mtx_on_status);
_dqOnStatusCB.emplace_back(fun); _deque_on_status.emplace_back(func);
} }
void onCmd_result(AMFDecoder &dec); void onCmd_result(AMFDecoder &dec);
@ -78,34 +81,37 @@ protected:
inline void send_createStream(); inline void send_createStream();
inline void send_play(); inline void send_play();
inline void send_pause(bool bPause); inline void send_pause(bool bPause);
private: private:
string _strApp; string _app;
string _strStream; string _stream_id;
string _strTcUrl; string _tc_url;
bool _bPaused = false;
unordered_map<int, function<void(AMFDecoder &dec)> > _mapOnResultCB; bool _paused = false;
recursive_mutex _mtxOnResultCB;
deque<function<void(AMFValue &dec)> > _dqOnStatusCB;
recursive_mutex _mtxOnStatusCB;
//超时功能实现
Ticker _mediaTicker;
std::shared_ptr<Timer> _pMediaTimer;
std::shared_ptr<Timer> _pPlayTimer;
//心跳定时器
std::shared_ptr<Timer> _pBeatTimer;
//播放进度控制
uint32_t _iSeekTo = 0;
uint32_t _aiFistStamp[2] = { 0, 0 };
uint32_t _aiNowStamp[2] = { 0, 0 };
Ticker _aNowStampTicker[2];
bool _metadata_got = false; bool _metadata_got = false;
//是否为性能测试模式 //是否为性能测试模式
bool _benchmark_mode = false; bool _benchmark_mode = false;
//播放进度控制
uint32_t _seek_ms = 0;
uint32_t _fist_stamp[2] = {0, 0};
uint32_t _now_stamp[2] = {0, 0};
Ticker _now_stamp_ticker[2];
recursive_mutex _mtx_on_result;
recursive_mutex _mtx_on_status;
deque<function<void(AMFValue &dec)> > _deque_on_status;
unordered_map<int, function<void(AMFDecoder &dec)> > _map_on_result;
//rtmp接收超时计时器
Ticker _rtmp_recv_ticker;
//心跳发送定时器
std::shared_ptr<Timer> _beat_timer;
//播放超时定时器
std::shared_ptr<Timer> _play_timer;
//rtmp接收超时定时器
std::shared_ptr<Timer> _rtmp_recv_timer;
}; };
} /* namespace mediakit */ } /* namespace mediakit */
#endif /* SRC_RTMP_RtmpPlayer_H_ */
#endif /* SRC_RTMP_RtmpPlayer2_H_ */

30
src/Rtmp/RtmpPlayerImp.h
View File

@ -27,42 +27,49 @@ namespace mediakit {
class RtmpPlayerImp: public PlayerImp<RtmpPlayer,RtmpDemuxer> { class RtmpPlayerImp: public PlayerImp<RtmpPlayer,RtmpDemuxer> {
public: public:
typedef std::shared_ptr<RtmpPlayerImp> Ptr; typedef std::shared_ptr<RtmpPlayerImp> Ptr;
RtmpPlayerImp(const EventPoller::Ptr &poller) : PlayerImp<RtmpPlayer, RtmpDemuxer>(poller) {}; RtmpPlayerImp(const EventPoller::Ptr &poller) : PlayerImp<RtmpPlayer, RtmpDemuxer>(poller) {};
virtual ~RtmpPlayerImp(){
~RtmpPlayerImp() override {
DebugL << endl; DebugL << endl;
}; }
float getProgress() const override { float getProgress() const override {
if (getDuration() > 0) { if (getDuration() > 0) {
return getProgressMilliSecond() / (getDuration() * 1000); return getProgressMilliSecond() / (getDuration() * 1000);
} }
return PlayerBase::getProgress(); return PlayerBase::getProgress();
}; }
void seekTo(float fProgress) override { void seekTo(float fProgress) override {
fProgress = MAX(float(0), MIN(fProgress, float(1.0))); fProgress = MAX(float(0), MIN(fProgress, float(1.0)));
seekToMilliSecond(fProgress * getDuration() * 1000); seekToMilliSecond(fProgress * getDuration() * 1000);
}; }
void play(const string &strUrl) override { void play(const string &strUrl) override {
PlayerImp<RtmpPlayer, RtmpDemuxer>::play(strUrl); PlayerImp<RtmpPlayer, RtmpDemuxer>::play(strUrl);
} }
private: private:
//派生类回调函数 //派生类回调函数
bool onCheckMeta(const AMFValue &val) override { bool onCheckMeta(const AMFValue &val) override {
_pRtmpMediaSrc = dynamic_pointer_cast<RtmpMediaSource>(_pMediaSrc); _rtmp_src = dynamic_pointer_cast<RtmpMediaSource>(_pMediaSrc);
if(_pRtmpMediaSrc){ if (_rtmp_src) {
_pRtmpMediaSrc->setMetaData(val); _rtmp_src->setMetaData(val);
_set_meta_data = true; _set_meta_data = true;
} }
_delegate.reset(new RtmpDemuxer); _delegate.reset(new RtmpDemuxer);
_delegate->loadMetaData(val); _delegate->loadMetaData(val);
return true; return true;
} }
void onMediaData(const RtmpPacket::Ptr &chunkData) override { void onMediaData(const RtmpPacket::Ptr &chunkData) override {
if(_pRtmpMediaSrc){ if (_rtmp_src) {
if (!_set_meta_data && !chunkData->isCfgFrame()) { if (!_set_meta_data && !chunkData->isCfgFrame()) {
_set_meta_data = true; _set_meta_data = true;
_pRtmpMediaSrc->setMetaData(TitleMeta().getMetadata()); _rtmp_src->setMetaData(TitleMeta().getMetadata());
} }
_pRtmpMediaSrc->onWrite(chunkData); _rtmp_src->onWrite(chunkData);
} }
if (!_delegate) { if (!_delegate) {
//这个流没有metadata //这个流没有metadata
@ -70,8 +77,9 @@ private:
} }
_delegate->inputRtmp(chunkData); _delegate->inputRtmp(chunkData);
} }
private: private:
RtmpMediaSource::Ptr _pRtmpMediaSrc; RtmpMediaSource::Ptr _rtmp_src;
bool _set_meta_data = false; bool _set_meta_data = false;
}; };

520
src/Rtmp/RtmpProtocol.cpp
View File

@ -20,8 +20,16 @@ using namespace toolkit;
#include <openssl/hmac.h> #include <openssl/hmac.h>
#include <openssl/opensslv.h> #include <openssl/opensslv.h>
static string openssl_HMACsha256(const void *key,unsigned int key_len, #define C1_DIGEST_SIZE 32
const void *data,unsigned int data_len){ #define C1_KEY_SIZE 128
#define C1_SCHEMA_SIZE 764
#define C1_HANDSHARK_SIZE (RANDOM_LEN + 8)
#define C1_FPKEY_SIZE 30
#define S1_FMS_KEY_SIZE 36
#define S2_FMS_KEY_SIZE 68
#define C1_OFFSET_SIZE 4
static string openssl_HMACsha256(const void *key, unsigned int key_len, const void *data,unsigned int data_len){
std::shared_ptr<char> out(new char[32], [](char *ptr) { delete[] ptr; }); std::shared_ptr<char> out(new char[32], [](char *ptr) { delete[] ptr; });
unsigned int out_len; unsigned int out_len;
@ -46,130 +54,120 @@ static string openssl_HMACsha256(const void *key,unsigned int key_len,
} }
#endif //ENABLE_OPENSSL #endif //ENABLE_OPENSSL
#define C1_DIGEST_SIZE 32
#define C1_KEY_SIZE 128
#define C1_SCHEMA_SIZE 764
#define C1_HANDSHARK_SIZE (RANDOM_LEN + 8)
#define C1_FPKEY_SIZE 30
#define S1_FMS_KEY_SIZE 36
#define S2_FMS_KEY_SIZE 68
#define C1_OFFSET_SIZE 4
namespace mediakit { namespace mediakit {
RtmpProtocol::RtmpProtocol() { RtmpProtocol::RtmpProtocol() {
_nextHandle = [this](){ _next_step_func = [this]() {
handle_C0C1(); handle_C0C1();
}; };
} }
RtmpProtocol::~RtmpProtocol() { RtmpProtocol::~RtmpProtocol() {
reset(); reset();
} }
void RtmpProtocol::reset() { void RtmpProtocol::reset() {
////////////ChunkSize//////////// ////////////ChunkSize////////////
_iChunkLenIn = DEFAULT_CHUNK_LEN; _chunk_size_in = DEFAULT_CHUNK_LEN;
_iChunkLenOut = DEFAULT_CHUNK_LEN; _chunk_size_out = DEFAULT_CHUNK_LEN;
////////////Acknowledgement//////////// ////////////Acknowledgement////////////
_ui32ByteSent = 0; _bytes_sent = 0;
_ui32LastSent = 0; _bytes_sent_last = 0;
_ui32WinSize = 0; _windows_size = 0;
///////////PeerBandwidth/////////// ///////////PeerBandwidth///////////
_ui32Bandwidth = 2500000; _bandwidth = 2500000;
_ui8LimitType = 2; _band_limit_type = 2;
////////////Chunk//////////// ////////////Chunk////////////
_mapChunkData.clear(); _map_chunk_data.clear();
_iNowStreamID = 0; _now_stream_index = 0;
_iNowChunkID = 0; _now_chunk_id = 0;
//////////Invoke Request////////// //////////Invoke Request//////////
_iReqID = 0; _send_req_id = 0;
//////////Rtmp parser////////// //////////Rtmp parser//////////
_strRcvBuf.clear(); _recv_data_buf.clear();
_ui32StreamId = STREAM_CONTROL; _stream_index = STREAM_CONTROL;
_nextHandle = [this]() { _next_step_func = [this]() {
handle_C0C1(); handle_C0C1();
}; };
} }
void RtmpProtocol::sendAcknowledgement(uint32_t ui32Size) { void RtmpProtocol::sendAcknowledgement(uint32_t size) {
std::string control; size = htonl(size);
uint32_t stream = htonl(ui32Size); std::string acknowledgement((char *) &size, 4);
control.append((char *) &stream, 4); sendRequest(MSG_ACK, acknowledgement);
sendRequest(MSG_ACK, control);
} }
void RtmpProtocol::sendAcknowledgementSize(uint32_t ui32Size) { void RtmpProtocol::sendAcknowledgementSize(uint32_t size) {
uint32_t windowSize = htonl(ui32Size); size = htonl(size);
std::string set_windowSize((char *) &windowSize, 4); std::string set_windowSize((char *) &size, 4);
sendRequest(MSG_WIN_SIZE, set_windowSize); sendRequest(MSG_WIN_SIZE, set_windowSize);
} }
void RtmpProtocol::sendPeerBandwidth(uint32_t ui32Size) { void RtmpProtocol::sendPeerBandwidth(uint32_t size) {
uint32_t peerBandwidth = htonl(ui32Size); size = htonl(size);
std::string set_peerBandwidth((char *) &peerBandwidth, 4); std::string set_peerBandwidth((char *) &size, 4);
set_peerBandwidth.push_back((char) 0x02); set_peerBandwidth.push_back((char) 0x02);
sendRequest(MSG_SET_PEER_BW, set_peerBandwidth); sendRequest(MSG_SET_PEER_BW, set_peerBandwidth);
} }
void RtmpProtocol::sendChunkSize(uint32_t ui32Size) { void RtmpProtocol::sendChunkSize(uint32_t size) {
uint32_t len = htonl(ui32Size); uint32_t len = htonl(size);
std::string set_chunk((char *) &len, 4); std::string set_chunk((char *) &len, 4);
sendRequest(MSG_SET_CHUNK, set_chunk); sendRequest(MSG_SET_CHUNK, set_chunk);
_iChunkLenOut = ui32Size; _chunk_size_out = size;
} }
void RtmpProtocol::sendPingRequest(uint32_t ui32TimeStamp) { void RtmpProtocol::sendPingRequest(uint32_t stamp) {
sendUserControl(CONTROL_PING_REQUEST, ui32TimeStamp); sendUserControl(CONTROL_PING_REQUEST, stamp);
} }
void RtmpProtocol::sendPingResponse(uint32_t ui32TimeStamp) { void RtmpProtocol::sendPingResponse(uint32_t time_stamp) {
sendUserControl(CONTROL_PING_RESPONSE, ui32TimeStamp); sendUserControl(CONTROL_PING_RESPONSE, time_stamp);
} }
void RtmpProtocol::sendSetBufferLength(uint32_t ui32StreamId, void RtmpProtocol::sendSetBufferLength(uint32_t stream_index, uint32_t len) {
uint32_t ui32Length) {
std::string control; std::string control;
ui32StreamId = htonl(ui32StreamId); stream_index = htonl(stream_index);
control.append((char *) &ui32StreamId, 4); control.append((char *) &stream_index, 4);
ui32Length = htonl(ui32Length);
control.append((char *) &ui32Length, 4); len = htonl(len);
control.append((char *) &len, 4);
sendUserControl(CONTROL_SETBUFFER, control); sendUserControl(CONTROL_SETBUFFER, control);
} }
void RtmpProtocol::sendUserControl(uint16_t ui16EventType, void RtmpProtocol::sendUserControl(uint16_t event_type, uint32_t event_data) {
uint32_t ui32EventData) {
std::string control; std::string control;
uint16_t type = htons(ui16EventType); event_type = htons(event_type);
control.append((char *) &type, 2); control.append((char *) &event_type, 2);
uint32_t stream = htonl(ui32EventData);
control.append((char *) &stream, 4); event_data = htonl(event_data);
control.append((char *) &event_data, 4);
sendRequest(MSG_USER_CONTROL, control); sendRequest(MSG_USER_CONTROL, control);
} }
void RtmpProtocol::sendUserControl(uint16_t ui16EventType, void RtmpProtocol::sendUserControl(uint16_t event_type, const string &event_data) {
const string& strEventData) {
std::string control; std::string control;
uint16_t type = htons(ui16EventType); event_type = htons(event_type);
control.append((char *) &type, 2); control.append((char *) &event_type, 2);
control.append(strEventData); control.append(event_data);
sendRequest(MSG_USER_CONTROL, control); sendRequest(MSG_USER_CONTROL, control);
} }
void RtmpProtocol::sendResponse(int iType, const string& str) { void RtmpProtocol::sendResponse(int type, const string &str) {
if(!_bDataStarted && (iType == MSG_DATA)){ if(!_data_started && (type == MSG_DATA)){
_bDataStarted = true; _data_started = true;
} }
sendRtmp(iType, _iNowStreamID, str, 0, _bDataStarted ? CHUNK_CLIENT_REQUEST_AFTER : CHUNK_CLIENT_REQUEST_BEFORE); sendRtmp(type, _now_stream_index, str, 0, _data_started ? CHUNK_CLIENT_REQUEST_AFTER : CHUNK_CLIENT_REQUEST_BEFORE);
} }
void RtmpProtocol::sendInvoke(const string& strCmd, const AMFValue& val) { void RtmpProtocol::sendInvoke(const string &cmd, const AMFValue &val) {
AMFEncoder enc; AMFEncoder enc;
enc << strCmd << ++_iReqID << val; enc << cmd << ++_send_req_id << val;
sendRequest(MSG_CMD, enc.data()); sendRequest(MSG_CMD, enc.data());
} }
void RtmpProtocol::sendRequest(int iCmd, const string& str) { void RtmpProtocol::sendRequest(int cmd, const string& str) {
sendRtmp(iCmd, _ui32StreamId, str, 0, CHUNK_SERVER_REQUEST); sendRtmp(cmd, _stream_index, str, 0, CHUNK_SERVER_REQUEST);
} }
class BufferPartial : public Buffer { class BufferPartial : public Buffer {
@ -180,136 +178,144 @@ public:
_size = size; _size = size;
} }
~BufferPartial(){} ~BufferPartial() override{}
char *data() const override { char *data() const override {
return _data; return _data;
} }
uint32_t size() const override{ uint32_t size() const override{
return _size; return _size;
} }
private: private:
Buffer::Ptr _buffer;
char *_data; char *_data;
uint32_t _size; uint32_t _size;
Buffer::Ptr _buffer;
}; };
void RtmpProtocol::sendRtmp(uint8_t ui8Type, uint32_t ui32StreamId, void RtmpProtocol::sendRtmp(uint8_t type, uint32_t stream_index, const std::string &buffer, uint32_t stamp, int chunk_id) {
const std::string& strBuf, uint32_t ui32TimeStamp, int iChunkId) { sendRtmp(type, stream_index, std::make_shared<BufferString>(buffer), stamp, chunk_id);
sendRtmp(ui8Type,ui32StreamId,std::make_shared<BufferString>(strBuf),ui32TimeStamp,iChunkId);
} }
void RtmpProtocol::sendRtmp(uint8_t ui8Type, uint32_t ui32StreamId, void RtmpProtocol::sendRtmp(uint8_t type, uint32_t stream_index, const Buffer::Ptr &buf, uint32_t stamp, int chunk_id){
const Buffer::Ptr &buf, uint32_t ui32TimeStamp, int iChunkId){ if (chunk_id < 2 || chunk_id > 63) {
if (iChunkId < 2 || iChunkId > 63) { auto strErr = StrPrinter << "不支持发送该类型的块流 ID:" << chunk_id << endl;
auto strErr = StrPrinter << "不支持发送该类型的块流 ID:" << iChunkId << endl;
throw std::runtime_error(strErr); throw std::runtime_error(strErr);
} }
//是否有扩展时间戳 //是否有扩展时间戳
bool bExtStamp = ui32TimeStamp >= 0xFFFFFF; bool ext_stamp = stamp >= 0xFFFFFF;
//rtmp头 //rtmp头
BufferRaw::Ptr bufferHeader = obtainBuffer(); BufferRaw::Ptr buffer_header = obtainBuffer();
bufferHeader->setCapacity(sizeof(RtmpHeader)); buffer_header->setCapacity(sizeof(RtmpHeader));
bufferHeader->setSize(sizeof(RtmpHeader)); buffer_header->setSize(sizeof(RtmpHeader));
//对rtmp头赋值，如果使用整形赋值，在arm android上可能由于数据对齐导致总线错误的问题 //对rtmp头赋值，如果使用整形赋值，在arm android上可能由于数据对齐导致总线错误的问题
RtmpHeader *header = (RtmpHeader*) bufferHeader->data(); RtmpHeader *header = (RtmpHeader *) buffer_header->data();
header->flags = (iChunkId & 0x3f) | (0 << 6); header->flags = (chunk_id & 0x3f) | (0 << 6);
header->typeId = ui8Type; header->type_id = type;
set_be24(header->timeStamp, bExtStamp ? 0xFFFFFF : ui32TimeStamp); set_be24(header->time_stamp, ext_stamp ? 0xFFFFFF : stamp);
set_be24(header->bodySize, buf->size()); set_be24(header->body_size, buf->size());
set_le32(header->streamId, ui32StreamId); set_le32(header->stream_index, stream_index);
//发送rtmp头 //发送rtmp头
onSendRawData(bufferHeader); onSendRawData(buffer_header);
//扩展时间戳字段 //扩展时间戳字段
BufferRaw::Ptr bufferExtStamp; BufferRaw::Ptr buffer_ext_stamp;
if (bExtStamp) { if (ext_stamp) {
//生成扩展时间戳 //生成扩展时间戳
bufferExtStamp = obtainBuffer(); buffer_ext_stamp = obtainBuffer();
bufferExtStamp->setCapacity(4); buffer_ext_stamp->setCapacity(4);
bufferExtStamp->setSize(4); buffer_ext_stamp->setSize(4);
set_be32(bufferExtStamp->data(), ui32TimeStamp); set_be32(buffer_ext_stamp->data(), stamp);
} }
//生成一个字节的flag，标明是什么chunkId //生成一个字节的flag，标明是什么chunkId
BufferRaw::Ptr bufferFlags = obtainBuffer(); BufferRaw::Ptr buffer_flags = obtainBuffer();
bufferFlags->setCapacity(1); buffer_flags->setCapacity(1);
bufferFlags->setSize(1); buffer_flags->setSize(1);
bufferFlags->data()[0] = (iChunkId & 0x3f) | (3 << 6); buffer_flags->data()[0] = (chunk_id & 0x3f) | (3 << 6);
size_t offset = 0; size_t offset = 0;
uint32_t totalSize = sizeof(RtmpHeader); uint32_t totalSize = sizeof(RtmpHeader);
while (offset < buf->size()) { while (offset < buf->size()) {
if (offset) { if (offset) {
onSendRawData(bufferFlags); onSendRawData(buffer_flags);
totalSize += 1; totalSize += 1;
} }
if (bExtStamp) { if (ext_stamp) {
//扩展时间戳 //扩展时间戳
onSendRawData(bufferExtStamp); onSendRawData(buffer_ext_stamp);
totalSize += 4; totalSize += 4;
} }
size_t chunk = min(_iChunkLenOut, buf->size() - offset); size_t chunk = min(_chunk_size_out, buf->size() - offset);
onSendRawData(std::make_shared<BufferPartial>(buf, offset, chunk)); onSendRawData(std::make_shared<BufferPartial>(buf, offset, chunk));
totalSize += chunk; totalSize += chunk;
offset += chunk; offset += chunk;
} }
_ui32ByteSent += totalSize; _bytes_sent += totalSize;
if (_ui32WinSize > 0 && _ui32ByteSent - _ui32LastSent >= _ui32WinSize) { if (_windows_size > 0 && _bytes_sent - _bytes_sent_last >= _windows_size) {
_ui32LastSent = _ui32ByteSent; _bytes_sent_last = _bytes_sent;
sendAcknowledgement(_ui32ByteSent); sendAcknowledgement(_bytes_sent);
} }
} }
void RtmpProtocol::onParseRtmp(const char *data, int size) {
_recv_data_buf.append(data, size);
//移动拷贝提高性能
function<void()> next_step_func(std::move(_next_step_func));
//执行下一步
next_step_func();
void RtmpProtocol::onParseRtmp(const char *pcRawData, int iSize) { if (!_next_step_func) {
_strRcvBuf.append(pcRawData, iSize); //为设置下一步，恢复之
auto cb = _nextHandle; next_step_func.swap(_next_step_func);
cb(); }
} }
////for client//// ////for client////
void RtmpProtocol::startClientSession(const function<void()> &callBack) { void RtmpProtocol::startClientSession(const function<void()> &func) {
//发送 C0C1 //发送 C0C1
char handshake_head = HANDSHAKE_PLAINTEXT; char handshake_head = HANDSHAKE_PLAINTEXT;
onSendRawData(obtainBuffer(&handshake_head, 1)); onSendRawData(obtainBuffer(&handshake_head, 1));
RtmpHandshake c1(0); RtmpHandshake c1(0);
onSendRawData(obtainBuffer((char *) (&c1), sizeof(c1))); onSendRawData(obtainBuffer((char *) (&c1), sizeof(c1)));
_nextHandle = [this,callBack]() { _next_step_func = [this, func]() {
//等待 S0+S1+S2 //等待 S0+S1+S2
handle_S0S1S2(callBack); handle_S0S1S2(func);
}; };
} }
void RtmpProtocol::handle_S0S1S2(const function<void()> &callBack) {
if (_strRcvBuf.size() < 1 + 2 * C1_HANDSHARK_SIZE) { void RtmpProtocol::handle_S0S1S2(const function<void()> &func) {
if (_recv_data_buf.size() < 1 + 2 * C1_HANDSHARK_SIZE) {
//数据不够 //数据不够
return; return;
} }
if (_strRcvBuf[0] != HANDSHAKE_PLAINTEXT) { if (_recv_data_buf[0] != HANDSHAKE_PLAINTEXT) {
throw std::runtime_error("only plaintext[0x03] handshake supported"); throw std::runtime_error("only plaintext[0x03] handshake supported");
} }
//发送 C2 //发送 C2
const char *pcC2 = _strRcvBuf.data() + 1; const char *pcC2 = _recv_data_buf.data() + 1;
onSendRawData(obtainBuffer(pcC2, C1_HANDSHARK_SIZE)); onSendRawData(obtainBuffer(pcC2, C1_HANDSHARK_SIZE));
_strRcvBuf.erase(0, 1 + 2 * C1_HANDSHARK_SIZE); _recv_data_buf.erase(0, 1 + 2 * C1_HANDSHARK_SIZE);
//握手结束 //握手结束
_nextHandle = [this]() { _next_step_func = [this]() {
//握手结束并且开始进入解析命令模式 //握手结束并且开始进入解析命令模式
handle_rtmp(); handle_rtmp();
}; };
callBack(); func();
} }
////for server //// ////for server ////
void RtmpProtocol::handle_C0C1() { void RtmpProtocol::handle_C0C1() {
if (_strRcvBuf.size() < 1 + C1_HANDSHARK_SIZE) { if (_recv_data_buf.size() < 1 + C1_HANDSHARK_SIZE) {
//need more data! //need more data!
return; return;
} }
if (_strRcvBuf[0] != HANDSHAKE_PLAINTEXT) { if (_recv_data_buf[0] != HANDSHAKE_PLAINTEXT) {
throw std::runtime_error("only plaintext[0x03] handshake supported"); throw std::runtime_error("only plaintext[0x03] handshake supported");
} }
if(memcmp(_strRcvBuf.data() + 5,"\x00\x00\x00\x00",4) ==0 ){ if (memcmp(_recv_data_buf.data() + 5, "\x00\x00\x00\x00", 4) == 0) {
//simple handsharke //simple handsharke
handle_C1_simple(); handle_C1_simple();
} else { } else {
@ -321,8 +327,9 @@ void RtmpProtocol::handle_C0C1() {
handle_C1_simple(); handle_C1_simple();
#endif//ENABLE_OPENSSL #endif//ENABLE_OPENSSL
} }
_strRcvBuf.erase(0, 1 + C1_HANDSHARK_SIZE); _recv_data_buf.erase(0, 1 + C1_HANDSHARK_SIZE);
} }
void RtmpProtocol::handle_C1_simple(){ void RtmpProtocol::handle_C1_simple(){
//发送S0 //发送S0
char handshake_head = HANDSHAKE_PLAINTEXT; char handshake_head = HANDSHAKE_PLAINTEXT;
@ -331,17 +338,18 @@ void RtmpProtocol::handle_C1_simple(){
RtmpHandshake s1(0); RtmpHandshake s1(0);
onSendRawData(obtainBuffer((char *) &s1, C1_HANDSHARK_SIZE)); onSendRawData(obtainBuffer((char *) &s1, C1_HANDSHARK_SIZE));
//发送S2 //发送S2
onSendRawData(obtainBuffer(_strRcvBuf.data() + 1, C1_HANDSHARK_SIZE)); onSendRawData(obtainBuffer(_recv_data_buf.data() + 1, C1_HANDSHARK_SIZE));
//等待C2 //等待C2
_nextHandle = [this]() { _next_step_func = [this]() {
handle_C2(); handle_C2();
}; };
} }
#ifdef ENABLE_OPENSSL #ifdef ENABLE_OPENSSL
void RtmpProtocol::handle_C1_complex(){ void RtmpProtocol::handle_C1_complex(){
//参考自:http://blog.csdn.net/win_lin/article/details/13006803 //参考自:http://blog.csdn.net/win_lin/article/details/13006803
//skip c0,time,version //skip c0,time,version
const char *c1_start = _strRcvBuf.data() + 1; const char *c1_start = _recv_data_buf.data() + 1;
const char *schema_start = c1_start + 8; const char *schema_start = c1_start + 8;
char *digest_start; char *digest_start;
try { try {
@ -408,6 +416,7 @@ static u_int8_t FPKey[] = {
0x6E, 0xEC, 0x5D, 0x2D, 0x29, 0x80, 0x6F, 0xAB, 0x6E, 0xEC, 0x5D, 0x2D, 0x29, 0x80, 0x6F, 0xAB,
0x93, 0xB8, 0xE6, 0x36, 0xCF, 0xEB, 0x31, 0xAE 0x93, 0xB8, 0xE6, 0x36, 0xCF, 0xEB, 0x31, 0xAE
}; // 62 }; // 62
void RtmpProtocol::check_C1_Digest(const string &digest,const string &data){ void RtmpProtocol::check_C1_Digest(const string &digest,const string &data){
auto sha256 = openssl_HMACsha256(FPKey, C1_FPKEY_SIZE, data.data(), data.size()); auto sha256 = openssl_HMACsha256(FPKey, C1_FPKEY_SIZE, data.data(), data.size());
if (sha256 != digest) { if (sha256 != digest) {
@ -416,6 +425,7 @@ void RtmpProtocol::check_C1_Digest(const string &digest,const string &data){
InfoL << "check rtmp complex handshark success!"; InfoL << "check rtmp complex handshark success!";
} }
} }
string RtmpProtocol::get_C1_digest(const uint8_t *ptr,char **digestPos){ string RtmpProtocol::get_C1_digest(const uint8_t *ptr,char **digestPos){
/* 764bytes digest结构 /* 764bytes digest结构
offset: 4bytes offset: 4bytes
@ -433,6 +443,7 @@ string RtmpProtocol::get_C1_digest(const uint8_t *ptr,char **digestPos){
//DebugL << "digest offset:" << offset << ",digest:" << hexdump(digest.data(),digest.size()); //DebugL << "digest offset:" << offset << ",digest:" << hexdump(digest.data(),digest.size());
return digest; return digest;
} }
string RtmpProtocol::get_C1_key(const uint8_t *ptr){ string RtmpProtocol::get_C1_key(const uint8_t *ptr){
/* 764bytes key结构 /* 764bytes key结构
random-data: (offset)bytes random-data: (offset)bytes
@ -449,6 +460,7 @@ string RtmpProtocol::get_C1_key(const uint8_t *ptr){
//DebugL << "key offset:" << offset << ",key:" << hexdump(key.data(),key.size()); //DebugL << "key offset:" << offset << ",key:" << hexdump(key.data(),key.size());
return key; return key;
} }
void RtmpProtocol::send_complex_S0S1S2(int schemeType,const string &digest){ void RtmpProtocol::send_complex_S0S1S2(int schemeType,const string &digest){
//S1S2计算参考自:https://github.com/hitYangfei/golang/blob/master/rtmpserver.go //S1S2计算参考自:https://github.com/hitYangfei/golang/blob/master/rtmpserver.go
//发送S0 //发送S0
@ -490,208 +502,218 @@ void RtmpProtocol::send_complex_S0S1S2(int schemeType,const string &digest){
memcpy((char *) &s2 + C1_HANDSHARK_SIZE - C1_DIGEST_SIZE, s2_digest.data(), C1_DIGEST_SIZE); memcpy((char *) &s2 + C1_HANDSHARK_SIZE - C1_DIGEST_SIZE, s2_digest.data(), C1_DIGEST_SIZE);
onSendRawData(obtainBuffer((char *) &s2, sizeof(s2))); onSendRawData(obtainBuffer((char *) &s2, sizeof(s2)));
//等待C2 //等待C2
_nextHandle = [this]() { _next_step_func = [this]() {
handle_C2(); handle_C2();
}; };
} }
#endif //ENABLE_OPENSSL #endif //ENABLE_OPENSSL
void RtmpProtocol::handle_C2() { void RtmpProtocol::handle_C2() {
if (_strRcvBuf.size() < C1_HANDSHARK_SIZE) { if (_recv_data_buf.size() < C1_HANDSHARK_SIZE) {
//need more data! //need more data!
return; return;
} }
_strRcvBuf.erase(0, C1_HANDSHARK_SIZE); _recv_data_buf.erase(0, C1_HANDSHARK_SIZE);
//握手结束，进入命令模式 //握手结束，进入命令模式
if (!_strRcvBuf.empty()) { if (!_recv_data_buf.empty()) {
handle_rtmp(); handle_rtmp();
} }
_nextHandle = [this]() { _next_step_func = [this]() {
handle_rtmp(); handle_rtmp();
}; };
} }
void RtmpProtocol::handle_rtmp() {
while (!_strRcvBuf.empty()) {
uint8_t flags = _strRcvBuf[0];
int iOffset = 0;
static const size_t HEADER_LENGTH[] = {12, 8, 4, 1}; static const size_t HEADER_LENGTH[] = {12, 8, 4, 1};
size_t iHeaderLen = HEADER_LENGTH[flags >> 6];
_iNowChunkID = flags & 0x3f; void RtmpProtocol::handle_rtmp() {
switch (_iNowChunkID) { while (!_recv_data_buf.empty()) {
int offset = 0;
uint8_t flags = _recv_data_buf[0];
size_t header_len = HEADER_LENGTH[flags >> 6];
_now_chunk_id = flags & 0x3f;
switch (_now_chunk_id) {
case 0: { case 0: {
//0 值表示二字节形式，并且 ID 范围 64 - 319 //0 值表示二字节形式，并且 ID 范围 64 - 319
//(第二个字节 + 64)。 //(第二个字节 + 64)。
if (_strRcvBuf.size() < 2) { if (_recv_data_buf.size() < 2) {
//need more data //need more data
return; return;
} }
_iNowChunkID = 64 + (uint8_t) (_strRcvBuf[1]); _now_chunk_id = 64 + (uint8_t) (_recv_data_buf[1]);
iOffset = 1; offset = 1;
}
break; break;
}
case 1: { case 1: {
//1 值表示三字节形式，并且 ID 范围为 64 - 65599 //1 值表示三字节形式，并且 ID 范围为 64 - 65599
//((第三个字节) * 256 + 第二个字节 + 64)。 //((第三个字节) * 256 + 第二个字节 + 64)。
if (_strRcvBuf.size() < 3) { if (_recv_data_buf.size() < 3) {
//need more data //need more data
return; return;
} }
_iNowChunkID = 64 + ((uint8_t) (_strRcvBuf[2]) << 8) + (uint8_t) (_strRcvBuf[1]); _now_chunk_id = 64 + ((uint8_t) (_recv_data_buf[2]) << 8) + (uint8_t) (_recv_data_buf[1]);
iOffset = 2; offset = 2;
}
break; break;
default: }
//带有 2 值的块流 ID 被保留，用于下层协议控制消息和命令。 //带有 2 值的块流 ID 被保留，用于下层协议控制消息和命令。
break; default : break;
} }
if (_strRcvBuf.size() < iHeaderLen + iOffset) { if (_recv_data_buf.size() < header_len + offset) {
//need more data //need more data
return; return;
} }
RtmpHeader &header = *((RtmpHeader *) (_strRcvBuf.data() + iOffset));
auto &chunkData = _mapChunkData[_iNowChunkID]; RtmpHeader &header = *((RtmpHeader *) (_recv_data_buf.data() + offset));
chunkData.chunkId = _iNowChunkID; auto &chunk_data = _map_chunk_data[_now_chunk_id];
switch (iHeaderLen) { chunk_data.chunk_id = _now_chunk_id;
switch (header_len) {
case 12: case 12:
chunkData.hasAbsStamp = true; chunk_data.is_abs_stamp = true;
chunkData.streamId = load_le32(header.streamId); chunk_data.stream_index = load_le32(header.stream_index);
case 8: case 8:
chunkData.bodySize = load_be24(header.bodySize); chunk_data.body_size = load_be24(header.body_size);
chunkData.typeId = header.typeId; chunk_data.type_id = header.type_id;
case 4: case 4:
chunkData.tsField = load_be24(header.timeStamp); chunk_data.ts_field = load_be24(header.time_stamp);
} }
auto timeStamp = chunkData.tsField; auto time_stamp = chunk_data.ts_field;
if (chunkData.tsField == 0xFFFFFF) { if (chunk_data.ts_field == 0xFFFFFF) {
if (_strRcvBuf.size() < iHeaderLen + iOffset + 4) { if (_recv_data_buf.size() < header_len + offset + 4) {
//need more data //need more data
return; return;
} }
timeStamp = load_be32(_strRcvBuf.data() + iOffset + iHeaderLen); time_stamp = load_be32(_recv_data_buf.data() + offset + header_len);
iOffset += 4; offset += 4;
} }
if (chunkData.bodySize < chunkData.strBuf.size()) { if (chunk_data.body_size < chunk_data.buffer.size()) {
throw std::runtime_error("非法的bodySize"); throw std::runtime_error("非法的bodySize");
} }
auto iMore = min(_iChunkLenIn, chunkData.bodySize - chunkData.strBuf.size()); auto iMore = min(_chunk_size_in, chunk_data.body_size - chunk_data.buffer.size());
if (_strRcvBuf.size() < iHeaderLen + iOffset + iMore) { if (_recv_data_buf.size() < header_len + offset + iMore) {
//need more data //need more data
return; return;
} }
chunkData.strBuf.append(_strRcvBuf, iHeaderLen + iOffset, iMore); chunk_data.buffer.append(_recv_data_buf, header_len + offset, iMore);
_strRcvBuf.erase(0, iHeaderLen + iOffset + iMore); _recv_data_buf.erase(0, header_len + offset + iMore);
if (chunkData.strBuf.size() == chunkData.bodySize) { if (chunk_data.buffer.size() == chunk_data.body_size) {
//frame is ready //frame is ready
_iNowStreamID = chunkData.streamId; _now_stream_index = chunk_data.stream_index;
chunkData.timeStamp = timeStamp + (chunkData.hasAbsStamp ? 0 : chunkData.timeStamp); chunk_data.time_stamp = time_stamp + (chunk_data.is_abs_stamp ? 0 : chunk_data.time_stamp);
if(chunkData.bodySize){ if (chunk_data.body_size) {
handle_rtmpChunk(chunkData); handle_rtmpChunk(chunk_data);
} }
chunkData.strBuf.clear(); chunk_data.buffer.clear();
chunkData.hasAbsStamp = false; chunk_data.is_abs_stamp = false;
} }
} }
} }
void RtmpProtocol::handle_rtmpChunk(RtmpPacket& chunkData) { void RtmpProtocol::handle_rtmpChunk(RtmpPacket& chunk_data) {
switch (chunkData.typeId) { switch (chunk_data.type_id) {
case MSG_ACK: { case MSG_ACK: {
if (chunkData.strBuf.size() < 4) { if (chunk_data.buffer.size() < 4) {
throw std::runtime_error("MSG_ACK: Not enough data"); throw std::runtime_error("MSG_ACK: Not enough data");
} }
//auto bytePeerRecv = load_be32(&chunkData.strBuf[0]); //auto bytePeerRecv = load_be32(&chunk_data.buffer[0]);
//TraceL << "MSG_ACK:" << bytePeerRecv; //TraceL << "MSG_ACK:" << bytePeerRecv;
}
break; break;
}
case MSG_SET_CHUNK: { case MSG_SET_CHUNK: {
if (chunkData.strBuf.size() < 4) { if (chunk_data.buffer.size() < 4) {
throw std::runtime_error("MSG_SET_CHUNK :Not enough data"); throw std::runtime_error("MSG_SET_CHUNK :Not enough data");
} }
_iChunkLenIn = load_be32(&chunkData.strBuf[0]); _chunk_size_in = load_be32(&chunk_data.buffer[0]);
TraceL << "MSG_SET_CHUNK:" << _iChunkLenIn; TraceL << "MSG_SET_CHUNK:" << _chunk_size_in;
}
break; break;
}
case MSG_USER_CONTROL: { case MSG_USER_CONTROL: {
//user control message //user control message
if (chunkData.strBuf.size() < 2) { if (chunk_data.buffer.size() < 2) {
throw std::runtime_error("MSG_USER_CONTROL: Not enough data."); throw std::runtime_error("MSG_USER_CONTROL: Not enough data.");
} }
uint16_t event_type = load_be16(&chunkData.strBuf[0]); uint16_t event_type = load_be16(&chunk_data.buffer[0]);
chunkData.strBuf.erase(0, 2); chunk_data.buffer.erase(0, 2);
switch (event_type) { switch (event_type) {
case CONTROL_PING_REQUEST: { case CONTROL_PING_REQUEST: {
if (chunkData.strBuf.size() < 4) { if (chunk_data.buffer.size() < 4) {
throw std::runtime_error("CONTROL_PING_REQUEST: Not enough data."); throw std::runtime_error("CONTROL_PING_REQUEST: Not enough data.");
} }
uint32_t timeStamp = load_be32(&chunkData.strBuf[0]); uint32_t timeStamp = load_be32(&chunk_data.buffer[0]);
//TraceL << "CONTROL_PING_REQUEST:" << timeStamp; //TraceL << "CONTROL_PING_REQUEST:" << time_stamp;
sendUserControl(CONTROL_PING_RESPONSE, timeStamp); sendUserControl(CONTROL_PING_RESPONSE, timeStamp);
}
break; break;
}
case CONTROL_PING_RESPONSE: { case CONTROL_PING_RESPONSE: {
if (chunkData.strBuf.size() < 4) { if (chunk_data.buffer.size() < 4) {
throw std::runtime_error("CONTROL_PING_RESPONSE: Not enough data."); throw std::runtime_error("CONTROL_PING_RESPONSE: Not enough data.");
} }
//uint32_t timeStamp = load_be32(&chunkData.strBuf[0]); //uint32_t time_stamp = load_be32(&chunk_data.buffer[0]);
//TraceL << "CONTROL_PING_RESPONSE:" << timeStamp; //TraceL << "CONTROL_PING_RESPONSE:" << time_stamp;
}
break; break;
}
case CONTROL_STREAM_BEGIN: { case CONTROL_STREAM_BEGIN: {
//开始播放 //开始播放
if (chunkData.strBuf.size() < 4) { if (chunk_data.buffer.size() < 4) {
throw std::runtime_error("CONTROL_STREAM_BEGIN: Not enough data."); throw std::runtime_error("CONTROL_STREAM_BEGIN: Not enough data.");
} }
uint32_t stramId = load_be32(&chunkData.strBuf[0]); uint32_t stream_index = load_be32(&chunk_data.buffer[0]);
onStreamBegin(stramId); onStreamBegin(stream_index);
TraceL << "CONTROL_STREAM_BEGIN:" << stramId; TraceL << "CONTROL_STREAM_BEGIN:" << stream_index;
}
break; break;
}
case CONTROL_STREAM_EOF: { case CONTROL_STREAM_EOF: {
//暂停 //暂停
if (chunkData.strBuf.size() < 4) { if (chunk_data.buffer.size() < 4) {
throw std::runtime_error("CONTROL_STREAM_EOF: Not enough data."); throw std::runtime_error("CONTROL_STREAM_EOF: Not enough data.");
} }
uint32_t stramId = load_be32(&chunkData.strBuf[0]); uint32_t stream_index = load_be32(&chunk_data.buffer[0]);
onStreamEof(stramId); onStreamEof(stream_index);
TraceL << "CONTROL_STREAM_EOF:" << stramId; TraceL << "CONTROL_STREAM_EOF:" << stream_index;
}
break; break;
}
case CONTROL_STREAM_DRY: { case CONTROL_STREAM_DRY: {
//停止播放 //停止播放
if (chunkData.strBuf.size() < 4) { if (chunk_data.buffer.size() < 4) {
throw std::runtime_error("CONTROL_STREAM_DRY: Not enough data."); throw std::runtime_error("CONTROL_STREAM_DRY: Not enough data.");
} }
uint32_t stramId = load_be32(&chunkData.strBuf[0]); uint32_t stream_index = load_be32(&chunk_data.buffer[0]);
onStreamDry(stramId); onStreamDry(stream_index);
TraceL << "CONTROL_STREAM_DRY:" << stramId; TraceL << "CONTROL_STREAM_DRY:" << stream_index;
}
break;
default:
//WarnL << "unhandled user control:" << event_type;
break; break;
} }
default: /*WarnL << "unhandled user control:" << event_type; */ break;
} }
break; break;
}
case MSG_WIN_SIZE: { case MSG_WIN_SIZE: {
_ui32WinSize = load_be32(&chunkData.strBuf[0]); _windows_size = load_be32(&chunk_data.buffer[0]);
TraceL << "MSG_WIN_SIZE:" << _ui32WinSize; TraceL << "MSG_WIN_SIZE:" << _windows_size;
}
break; break;
}
case MSG_SET_PEER_BW: { case MSG_SET_PEER_BW: {
_ui32Bandwidth = load_be32(&chunkData.strBuf[0]); _bandwidth = load_be32(&chunk_data.buffer[0]);
_ui8LimitType = chunkData.strBuf[4]; _band_limit_type = chunk_data.buffer[4];
TraceL << "MSG_SET_PEER_BW:" << _ui32WinSize; TraceL << "MSG_SET_PEER_BW:" << _windows_size;
}
break; break;
}
case MSG_AGGREGATE: { case MSG_AGGREGATE: {
auto ptr = (uint8_t*)chunkData.strBuf.data(); auto ptr = (uint8_t *) chunk_data.buffer.data();
auto ptr_tail = ptr + chunkData.strBuf.length() ; auto ptr_tail = ptr + chunk_data.buffer.length();
while (ptr + 8 + 3 < ptr_tail) { while (ptr + 8 + 3 < ptr_tail) {
auto type = *ptr; auto type = *ptr;
ptr += 1; ptr += 1;
@ -701,55 +723,27 @@ void RtmpProtocol::handle_rtmpChunk(RtmpPacket& chunkData) {
ptr += 3; ptr += 3;
ts |= (*ptr << 24); ts |= (*ptr << 24);
ptr += 1; ptr += 1;
//参考ffmpeg忽略了3个字节
/**
* while (next - pkt->data < pkt->size - RTMP_HEADER) {
type = bytestream_get_byte(&next);
size = bytestream_get_be24(&next);
cts = bytestream_get_be24(&next);
cts |= bytestream_get_byte(&next) << 24;
if (!pts)
pts = cts;
ts += cts - pts;
pts = cts;
if (size + 3 + 4 > pkt->data + pkt->size - next)
break;
bytestream_put_byte(&p, type);
bytestream_put_be24(&p, size);
bytestream_put_be24(&p, ts);
bytestream_put_byte(&p, ts >> 24);
memcpy(p, next, size + 3 + 4);
p += size + 3;
bytestream_put_be32(&p, size + RTMP_HEADER);
next += size + 3 + 4;
}
*/
ptr += 3; ptr += 3;
//参考FFmpeg多拷贝了4个字节 //参考FFmpeg多拷贝了4个字节
size += 4; size += 4;
if (ptr + size > ptr_tail) { if (ptr + size > ptr_tail) {
// ErrorL << ptr + size << " " << ptr_tail << " " << ptr_tail - ptr - size;
break; break;
} }
// DebugL << (int)type << " " << size << " " << ts << " " << chunkData.timeStamp << " " << ptr_tail - ptr;
RtmpPacket sub_packet; RtmpPacket sub_packet;
sub_packet.strBuf.resize(size); sub_packet.buffer.resize(size);
memcpy((char *)sub_packet.strBuf.data(),ptr,size); memcpy((char *) sub_packet.buffer.data(), ptr, size);
sub_packet.typeId = type; sub_packet.type_id = type;
sub_packet.bodySize = size; sub_packet.body_size = size;
sub_packet.timeStamp = ts; sub_packet.time_stamp = ts;
sub_packet.streamId = chunkData.streamId; sub_packet.stream_index = chunk_data.stream_index;
sub_packet.chunkId = chunkData.chunkId; sub_packet.chunk_id = chunk_data.chunk_id;
handle_rtmpChunk(sub_packet); handle_rtmpChunk(sub_packet);
ptr += size; ptr += size;
} }
// InfoL << ptr_tail - ptr; break;
} }
break;
default: default: onRtmpChunk(chunk_data); break;
onRtmpChunk(chunkData);
break;
} }
} }

91
src/Rtmp/RtmpProtocol.h
View File

@ -31,45 +31,42 @@ class RtmpProtocol {
public: public:
RtmpProtocol(); RtmpProtocol();
virtual ~RtmpProtocol(); virtual ~RtmpProtocol();
void onParseRtmp(const char *data, int size);
//作为客户端发送c0c1，等待s0s1s2并且回调 //作为客户端发送c0c1，等待s0s1s2并且回调
void startClientSession(const function<void()> &cb); void startClientSession(const function<void()> &cb);
void onParseRtmp(const char *pcRawData,int iSize);
void reset();
protected: protected:
virtual void onSendRawData(const Buffer::Ptr &buffer) = 0; virtual void onSendRawData(const Buffer::Ptr &buffer) = 0;
virtual void onRtmpChunk(RtmpPacket &chunkData) = 0; virtual void onRtmpChunk(RtmpPacket &chunk_data) = 0;
virtual void onStreamBegin(uint32_t ui32StreamId){ virtual void onStreamBegin(uint32_t stream_index){
_ui32StreamId = ui32StreamId; _stream_index = stream_index;
} }
virtual void onStreamEof(uint32_t ui32StreamId){}; virtual void onStreamEof(uint32_t stream_index){};
virtual void onStreamDry(uint32_t ui32StreamId){}; virtual void onStreamDry(uint32_t stream_index){};
protected:
void sendAcknowledgement(uint32_t ui32Size);
void sendAcknowledgementSize(uint32_t ui32Size);
void sendPeerBandwidth(uint32_t ui32Size);
void sendChunkSize(uint32_t ui32Size);
void sendPingRequest(uint32_t ui32TimeStamp = ::time(NULL));
void sendPingResponse(uint32_t ui32TimeStamp = ::time(NULL));
void sendSetBufferLength(uint32_t ui32StreamId, uint32_t ui32Length);
void sendUserControl(uint16_t ui16EventType, uint32_t ui32EventData);
void sendUserControl(uint16_t ui16EventType, const string &strEventData);
void sendInvoke(const string &strCmd, const AMFValue &val);
void sendRequest(int iCmd, const string &str);
void sendResponse(int iType, const string &str);
void sendRtmp(uint8_t ui8Type, uint32_t ui32StreamId, const std::string &strBuf, uint32_t ui32TimeStamp, int iChunkID);
void sendRtmp(uint8_t ui8Type, uint32_t ui32StreamId, const Buffer::Ptr &buffer, uint32_t ui32TimeStamp, int iChunkID);
protected: protected:
int _iReqID = 0; void reset();
uint32_t _ui32StreamId = STREAM_CONTROL; BufferRaw::Ptr obtainBuffer();
int _iNowStreamID = 0; BufferRaw::Ptr obtainBuffer(const void *data, int len);
int _iNowChunkID = 0;
bool _bDataStarted = false; void sendAcknowledgement(uint32_t size);
inline BufferRaw::Ptr obtainBuffer(); void sendAcknowledgementSize(uint32_t size);
inline BufferRaw::Ptr obtainBuffer(const void *data, int len); void sendPeerBandwidth(uint32_t size);
//ResourcePool<BufferRaw,MAX_SEND_PKT> _bufferPool; void sendChunkSize(uint32_t size);
void sendPingRequest(uint32_t ti = ::time(NULL));
void sendPingResponse(uint32_t time_stamp = ::time(NULL));
void sendSetBufferLength(uint32_t stream_index, uint32_t len);
void sendUserControl(uint16_t event_type, uint32_t event_data);
void sendUserControl(uint16_t event_type, const string &event_data);
void sendInvoke(const string &cmd, const AMFValue &val);
void sendRequest(int cmd, const string &str);
void sendResponse(int type, const string &str);
void sendRtmp(uint8_t type, uint32_t stream_index, const std::string &buffer, uint32_t stamp, int chunk_id);
void sendRtmp(uint8_t type, uint32_t stream_index, const Buffer::Ptr &buffer, uint32_t stamp, int chunk_id);
private: private:
void handle_S0S1S2(const function<void()> &cb); void handle_S0S1S2(const function<void()> &func);
void handle_C0C1(); void handle_C0C1();
void handle_C1_simple(); void handle_C1_simple();
#ifdef ENABLE_OPENSSL #ifdef ENABLE_OPENSSL
@ -82,26 +79,32 @@ private:
void handle_C2(); void handle_C2();
void handle_rtmp(); void handle_rtmp();
void handle_rtmpChunk(RtmpPacket &chunkData); void handle_rtmpChunk(RtmpPacket &chunk_data);
protected:
int _send_req_id = 0;
uint32_t _stream_index = STREAM_CONTROL;
private: private:
int _now_stream_index = 0;
int _now_chunk_id = 0;
bool _data_started = false;
////////////ChunkSize//////////// ////////////ChunkSize////////////
size_t _iChunkLenIn = DEFAULT_CHUNK_LEN; size_t _chunk_size_in = DEFAULT_CHUNK_LEN;
size_t _iChunkLenOut = DEFAULT_CHUNK_LEN; size_t _chunk_size_out = DEFAULT_CHUNK_LEN;
////////////Acknowledgement//////////// ////////////Acknowledgement////////////
uint32_t _ui32ByteSent = 0; uint32_t _bytes_sent = 0;
uint32_t _ui32LastSent = 0; uint32_t _bytes_sent_last = 0;
uint32_t _ui32WinSize = 0; uint32_t _windows_size = 0;
///////////PeerBandwidth/////////// ///////////PeerBandwidth///////////
uint32_t _ui32Bandwidth = 2500000; uint32_t _bandwidth = 2500000;
uint8_t _ui8LimitType = 2; uint8_t _band_limit_type = 2;
////////////Chunk////////////
unordered_map<int, RtmpPacket> _mapChunkData;
//////////Rtmp parser////////// //////////Rtmp parser//////////
string _strRcvBuf; string _recv_data_buf;
function<void()> _nextHandle; function<void()> _next_step_func;
////////////Chunk////////////
unordered_map<int, RtmpPacket> _map_chunk_data;
}; };
} /* namespace mediakit */ } /* namespace mediakit */
#endif /* SRC_RTMP_RTMPPROTOCOL_H_ */ #endif /* SRC_RTMP_RTMPPROTOCOL_H_ */

16
src/Rtmp/RtmpPusher.cpp
View File

@ -164,13 +164,13 @@ inline void RtmpPusher::send_createStream() {
addOnResultCB([this](AMFDecoder &dec){ addOnResultCB([this](AMFDecoder &dec){
//TraceL << "createStream result"; //TraceL << "createStream result";
dec.load<AMFValue>(); dec.load<AMFValue>();
_ui32StreamId = dec.load<int>(); _stream_index = dec.load<int>();
send_publish(); send_publish();
}); });
} }
inline void RtmpPusher::send_publish() { inline void RtmpPusher::send_publish() {
AMFEncoder enc; AMFEncoder enc;
enc << "publish" << ++_iReqID << nullptr << _strStream << _strApp ; enc << "publish" << ++_send_req_id << nullptr << _strStream << _strApp ;
sendRequest(MSG_CMD, enc.data()); sendRequest(MSG_CMD, enc.data());
addOnStatusCB([this](AMFValue &val) { addOnStatusCB([this](AMFValue &val) {
@ -195,7 +195,7 @@ inline void RtmpPusher::send_metaData(){
sendRequest(MSG_DATA, enc.data()); sendRequest(MSG_DATA, enc.data());
src->getConfigFrame([&](const RtmpPacket::Ptr &pkt){ src->getConfigFrame([&](const RtmpPacket::Ptr &pkt){
sendRtmp(pkt->typeId, _ui32StreamId, pkt, pkt->timeStamp, pkt->chunkId ); sendRtmp(pkt->type_id, _stream_index, pkt, pkt->time_stamp, pkt->chunk_id );
}); });
_pRtmpReader = src->getRing()->attach(getPoller()); _pRtmpReader = src->getRing()->attach(getPoller());
@ -213,7 +213,7 @@ inline void RtmpPusher::send_metaData(){
if(++i == size){ if(++i == size){
strongSelf->setSendFlushFlag(true); strongSelf->setSendFlushFlag(true);
} }
strongSelf->sendRtmp(rtmp->typeId, strongSelf->_ui32StreamId, rtmp, rtmp->timeStamp, rtmp->chunkId); strongSelf->sendRtmp(rtmp->type_id, strongSelf->_stream_index, rtmp, rtmp->time_stamp, rtmp->chunk_id);
}); });
}); });
_pRtmpReader->setDetachCB([weakSelf](){ _pRtmpReader->setDetachCB([weakSelf](){
@ -275,7 +275,7 @@ void RtmpPusher::onCmd_onStatus(AMFDecoder &dec) {
} }
void RtmpPusher::onRtmpChunk(RtmpPacket &chunkData) { void RtmpPusher::onRtmpChunk(RtmpPacket &chunkData) {
switch (chunkData.typeId) { switch (chunkData.type_id) {
case MSG_CMD: case MSG_CMD:
case MSG_CMD3: { case MSG_CMD3: {
typedef void (RtmpPusher::*rtmpCMDHandle)(AMFDecoder &dec); typedef void (RtmpPusher::*rtmpCMDHandle)(AMFDecoder &dec);
@ -284,9 +284,9 @@ void RtmpPusher::onRtmpChunk(RtmpPacket &chunkData) {
g_mapCmd.emplace("_error",&RtmpPusher::onCmd_result); g_mapCmd.emplace("_error",&RtmpPusher::onCmd_result);
g_mapCmd.emplace("_result",&RtmpPusher::onCmd_result); g_mapCmd.emplace("_result",&RtmpPusher::onCmd_result);
g_mapCmd.emplace("onStatus",&RtmpPusher::onCmd_onStatus); g_mapCmd.emplace("onStatus",&RtmpPusher::onCmd_onStatus);
}, []() {}); });
AMFDecoder dec(chunkData.strBuf, 0); AMFDecoder dec(chunkData.buffer, 0);
std::string type = dec.load<std::string>(); std::string type = dec.load<std::string>();
auto it = g_mapCmd.find(type); auto it = g_mapCmd.find(type);
if(it != g_mapCmd.end()){ if(it != g_mapCmd.end()){
@ -298,7 +298,7 @@ void RtmpPusher::onRtmpChunk(RtmpPacket &chunkData) {
} }
break; break;
default: default:
//WarnL << "unhandled message:" << (int) chunkData.typeId << hexdump(chunkData.strBuf.data(), chunkData.strBuf.size()); //WarnL << "unhandled message:" << (int) chunkData.type_id << hexdump(chunkData.buffer.data(), chunkData.buffer.size());
break; break;
} }
} }

2
src/Rtmp/RtmpPusher.h
View File

@ -52,7 +52,7 @@ private:
template<typename FUN> template<typename FUN>
inline void addOnResultCB(const FUN &fun) { inline void addOnResultCB(const FUN &fun) {
lock_guard<recursive_mutex> lck(_mtxOnResultCB); lock_guard<recursive_mutex> lck(_mtxOnResultCB);
_mapOnResultCB.emplace(_iReqID, fun); _mapOnResultCB.emplace(_send_req_id, fun);
} }
template<typename FUN> template<typename FUN>
inline void addOnStatusCB(const FUN &fun) { inline void addOnStatusCB(const FUN &fun) {

256
src/Rtmp/RtmpSession.cpp
View File

@ -13,12 +13,12 @@
#include "Util/onceToken.h" #include "Util/onceToken.h"
namespace mediakit { namespace mediakit {
RtmpSession::RtmpSession(const Socket::Ptr &pSock) : TcpSession(pSock) { RtmpSession::RtmpSession(const Socket::Ptr &sock) : TcpSession(sock) {
DebugP(this); DebugP(this);
GET_CONFIG(uint32_t,keep_alive_sec,Rtmp::kKeepAliveSecond); GET_CONFIG(uint32_t,keep_alive_sec,Rtmp::kKeepAliveSecond);
pSock->setSendTimeOutSecond(keep_alive_sec); sock->setSendTimeOutSecond(keep_alive_sec);
//起始接收buffer缓存设置为4K，节省内存 //起始接收buffer缓存设置为4K，节省内存
pSock->setReadBuffer(std::make_shared<BufferRaw>(4 * 1024)); sock->setReadBuffer(std::make_shared<BufferRaw>(4 * 1024));
} }
RtmpSession::~RtmpSession() { RtmpSession::~RtmpSession() {
@ -26,20 +26,20 @@ RtmpSession::~RtmpSession() {
} }
void RtmpSession::onError(const SockException& err) { void RtmpSession::onError(const SockException& err) {
bool isPlayer = !_pPublisherSrc; bool isPlayer = !_publisher_src;
uint64_t duration = _ticker.createdTime()/1000; uint64_t duration = _ticker.createdTime()/1000;
WarnP(this) << (isPlayer ? "RTMP播放器(" : "RTMP推流器(") WarnP(this) << (isPlayer ? "RTMP播放器(" : "RTMP推流器(")
<< _mediaInfo._vhost << "/" << _media_info._vhost << "/"
<< _mediaInfo._app << "/" << _media_info._app << "/"
<< _mediaInfo._streamid << _media_info._streamid
<< ")断开:" << err.what() << ")断开:" << err.what()
<< ",耗时(s):" << duration; << ",耗时(s):" << duration;
//流量统计事件广播 //流量统计事件广播
GET_CONFIG(uint32_t,iFlowThreshold,General::kFlowThreshold); GET_CONFIG(uint32_t,iFlowThreshold,General::kFlowThreshold);
if(_ui64TotalBytes > iFlowThreshold * 1024){ if(_total_bytes > iFlowThreshold * 1024){
NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastFlowReport, _mediaInfo, _ui64TotalBytes, duration, isPlayer, static_cast<SockInfo &>(*this)); NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastFlowReport, _media_info, _total_bytes, duration, isPlayer, static_cast<SockInfo &>(*this));
} }
} }
@ -48,11 +48,11 @@ void RtmpSession::onManager() {
GET_CONFIG(uint32_t,keep_alive_sec,Rtmp::kKeepAliveSecond); GET_CONFIG(uint32_t,keep_alive_sec,Rtmp::kKeepAliveSecond);
if (_ticker.createdTime() > handshake_sec * 1000) { if (_ticker.createdTime() > handshake_sec * 1000) {
if (!_pRingReader && !_pPublisherSrc) { if (!_ring_reader && !_publisher_src) {
shutdown(SockException(Err_timeout,"illegal connection")); shutdown(SockException(Err_timeout,"illegal connection"));
} }
} }
if (_pPublisherSrc) { if (_publisher_src) {
//publisher //publisher
if (_ticker.elapsedTime() > keep_alive_sec * 1000) { if (_ticker.elapsedTime() > keep_alive_sec * 1000) {
shutdown(SockException(Err_timeout,"recv data from rtmp pusher timeout")); shutdown(SockException(Err_timeout,"recv data from rtmp pusher timeout"));
@ -60,22 +60,22 @@ void RtmpSession::onManager() {
} }
} }
void RtmpSession::onRecv(const Buffer::Ptr &pBuf) { void RtmpSession::onRecv(const Buffer::Ptr &buf) {
_ticker.resetTime(); _ticker.resetTime();
try { try {
_ui64TotalBytes += pBuf->size(); _total_bytes += buf->size();
onParseRtmp(pBuf->data(), pBuf->size()); onParseRtmp(buf->data(), buf->size());
} catch (exception &e) { } catch (exception &ex) {
shutdown(SockException(Err_shutdown, e.what())); shutdown(SockException(Err_shutdown, ex.what()));
} }
} }
void RtmpSession::onCmd_connect(AMFDecoder &dec) { void RtmpSession::onCmd_connect(AMFDecoder &dec) {
auto params = dec.load<AMFValue>(); auto params = dec.load<AMFValue>();
double amfVer = 0; double amf_ver = 0;
AMFValue objectEncoding = params["objectEncoding"]; AMFValue objectEncoding = params["objectEncoding"];
if(objectEncoding){ if(objectEncoding){
amfVer = objectEncoding.as_number(); amf_ver = objectEncoding.as_number();
} }
///////////set chunk size//////////////// ///////////set chunk size////////////////
sendChunkSize(60000); sendChunkSize(60000);
@ -84,11 +84,11 @@ void RtmpSession::onCmd_connect(AMFDecoder &dec) {
///////////set peerBandwidth//////////////// ///////////set peerBandwidth////////////////
sendPeerBandwidth(5000000); sendPeerBandwidth(5000000);
_mediaInfo._app = params["app"].as_string(); _media_info._app = params["app"].as_string();
_strTcUrl = params["tcUrl"].as_string(); _tc_url = params["tcUrl"].as_string();
if(_strTcUrl.empty()){ if(_tc_url.empty()){
//defaultVhost:默认vhost //defaultVhost:默认vhost
_strTcUrl = string(RTMP_SCHEMA) + "://" + DEFAULT_VHOST + "/" + _mediaInfo._app; _tc_url = string(RTMP_SCHEMA) + "://" + DEFAULT_VHOST + "/" + _media_info._app;
} }
bool ok = true; //(app == APP_NAME); bool ok = true; //(app == APP_NAME);
AMFValue version(AMF_OBJECT); AMFValue version(AMF_OBJECT);
@ -98,10 +98,10 @@ void RtmpSession::onCmd_connect(AMFDecoder &dec) {
status.set("level", ok ? "status" : "error"); status.set("level", ok ? "status" : "error");
status.set("code", ok ? "NetConnection.Connect.Success" : "NetConnection.Connect.InvalidApp"); status.set("code", ok ? "NetConnection.Connect.Success" : "NetConnection.Connect.InvalidApp");
status.set("description", ok ? "Connection succeeded." : "InvalidApp."); status.set("description", ok ? "Connection succeeded." : "InvalidApp.");
status.set("objectEncoding", amfVer); status.set("objectEncoding", amf_ver);
sendReply(ok ? "_result" : "_error", version, status); sendReply(ok ? "_result" : "_error", version, status);
if (!ok) { if (!ok) {
throw std::runtime_error("Unsupported application: " + _mediaInfo._app); throw std::runtime_error("Unsupported application: " + _media_info._app);
} }
AMFEncoder invoke; AMFEncoder invoke;
@ -114,75 +114,75 @@ void RtmpSession::onCmd_createStream(AMFDecoder &dec) {
} }
void RtmpSession::onCmd_publish(AMFDecoder &dec) { void RtmpSession::onCmd_publish(AMFDecoder &dec) {
std::shared_ptr<Ticker> pTicker(new Ticker); std::shared_ptr<Ticker> ticker(new Ticker);
weak_ptr<RtmpSession> weakSelf = dynamic_pointer_cast<RtmpSession>(shared_from_this()); weak_ptr<RtmpSession> weak_self = dynamic_pointer_cast<RtmpSession>(shared_from_this());
std::shared_ptr<onceToken> pToken(new onceToken(nullptr,[pTicker,weakSelf](){ std::shared_ptr<onceToken> pToken(new onceToken(nullptr,[ticker,weak_self](){
auto strongSelf = weakSelf.lock(); auto strong_self = weak_self.lock();
if(strongSelf){ if(strong_self){
DebugP(strongSelf.get()) << "publish 回复时间:" << pTicker->elapsedTime() << "ms"; DebugP(strong_self.get()) << "publish 回复时间:" << ticker->elapsedTime() << "ms";
} }
})); }));
dec.load<AMFValue>();/* NULL */ dec.load<AMFValue>();/* NULL */
_mediaInfo.parse(_strTcUrl + "/" + getStreamId(dec.load<std::string>())); _media_info.parse(_tc_url + "/" + getStreamId(dec.load<std::string>()));
_mediaInfo._schema = RTMP_SCHEMA; _media_info._schema = RTMP_SCHEMA;
auto onRes = [this,pToken](const string &err,bool enableRtxp,bool enableHls,bool enableMP4){ auto on_res = [this,pToken](const string &err, bool enableRtxp, bool enableHls, bool enableMP4){
auto src = dynamic_pointer_cast<RtmpMediaSource>(MediaSource::find(RTMP_SCHEMA, auto src = dynamic_pointer_cast<RtmpMediaSource>(MediaSource::find(RTMP_SCHEMA,
_mediaInfo._vhost, _media_info._vhost,
_mediaInfo._app, _media_info._app,
_mediaInfo._streamid)); _media_info._streamid));
bool authSuccess = err.empty(); bool auth_success = err.empty();
bool ok = (!src && !_pPublisherSrc && authSuccess); bool ok = (!src && !_publisher_src && auth_success);
AMFValue status(AMF_OBJECT); AMFValue status(AMF_OBJECT);
status.set("level", ok ? "status" : "error"); status.set("level", ok ? "status" : "error");
status.set("code", ok ? "NetStream.Publish.Start" : (authSuccess ? "NetStream.Publish.BadName" : "NetStream.Publish.BadAuth")); status.set("code", ok ? "NetStream.Publish.Start" : (auth_success ? "NetStream.Publish.BadName" : "NetStream.Publish.BadAuth"));
status.set("description", ok ? "Started publishing stream." : (authSuccess ? "Already publishing." : err.data())); status.set("description", ok ? "Started publishing stream." : (auth_success ? "Already publishing." : err.data()));
status.set("clientid", "0"); status.set("clientid", "0");
sendReply("onStatus", nullptr, status); sendReply("onStatus", nullptr, status);
if (!ok) { if (!ok) {
string errMsg = StrPrinter << (authSuccess ? "already publishing:" : err.data()) << " " string errMsg = StrPrinter << (auth_success ? "already publishing:" : err.data()) << " "
<< _mediaInfo._vhost << " " << _media_info._vhost << " "
<< _mediaInfo._app << " " << _media_info._app << " "
<< _mediaInfo._streamid; << _media_info._streamid;
shutdown(SockException(Err_shutdown,errMsg)); shutdown(SockException(Err_shutdown,errMsg));
return; return;
} }
_pPublisherSrc.reset(new RtmpMediaSourceImp(_mediaInfo._vhost,_mediaInfo._app,_mediaInfo._streamid)); _publisher_src.reset(new RtmpMediaSourceImp(_media_info._vhost, _media_info._app, _media_info._streamid));
_pPublisherSrc->setListener(dynamic_pointer_cast<MediaSourceEvent>(shared_from_this())); _publisher_src->setListener(dynamic_pointer_cast<MediaSourceEvent>(shared_from_this()));
//设置转协议 //设置转协议
_pPublisherSrc->setProtocolTranslation(enableRtxp,enableHls,enableMP4); _publisher_src->setProtocolTranslation(enableRtxp, enableHls, enableMP4);
//如果是rtmp推流客户端，那么加大TCP接收缓存，这样能提升接收性能 //如果是rtmp推流客户端，那么加大TCP接收缓存，这样能提升接收性能
_sock->setReadBuffer(std::make_shared<BufferRaw>(256 * 1024)); _sock->setReadBuffer(std::make_shared<BufferRaw>(256 * 1024));
setSocketFlags(); setSocketFlags();
}; };
if(_mediaInfo._app.empty() || _mediaInfo._streamid.empty()){ if(_media_info._app.empty() || _media_info._streamid.empty()){
//不允许莫名其妙的推流url //不允许莫名其妙的推流url
onRes("rtmp推流url非法", false, false, false); on_res("rtmp推流url非法", false, false, false);
return; return;
} }
Broadcast::PublishAuthInvoker invoker = [weakSelf,onRes,pToken](const string &err,bool enableRtxp,bool enableHls,bool enableMP4){ Broadcast::PublishAuthInvoker invoker = [weak_self,on_res,pToken](const string &err, bool enableRtxp, bool enableHls, bool enableMP4){
auto strongSelf = weakSelf.lock(); auto strongSelf = weak_self.lock();
if(!strongSelf){ if(!strongSelf){
return; return;
} }
strongSelf->async([weakSelf,onRes,err,pToken,enableRtxp,enableHls,enableMP4](){ strongSelf->async([weak_self,on_res,err,pToken,enableRtxp,enableHls,enableMP4](){
auto strongSelf = weakSelf.lock(); auto strongSelf = weak_self.lock();
if(!strongSelf){ if(!strongSelf){
return; return;
} }
onRes(err,enableRtxp,enableHls,enableMP4); on_res(err, enableRtxp, enableHls, enableMP4);
}); });
}; };
auto flag = NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastMediaPublish,_mediaInfo,invoker,static_cast<SockInfo &>(*this)); auto flag = NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastMediaPublish, _media_info, invoker, static_cast<SockInfo &>(*this));
if(!flag){ if(!flag){
//该事件无人监听，默认鉴权成功 //该事件无人监听，默认鉴权成功
GET_CONFIG(bool,toRtxp,General::kPublishToRtxp); GET_CONFIG(bool,to_rtxp,General::kPublishToRtxp);
GET_CONFIG(bool,toHls,General::kPublishToHls); GET_CONFIG(bool,to_hls,General::kPublishToHls);
GET_CONFIG(bool,toMP4,General::kPublishToMP4); GET_CONFIG(bool,to_mp4,General::kPublishToMP4);
onRes("",toRtxp,toHls,toMP4); on_res("", to_rtxp, to_hls, to_mp4);
} }
} }
@ -196,8 +196,8 @@ void RtmpSession::onCmd_deleteStream(AMFDecoder &dec) {
} }
void RtmpSession::sendPlayResponse(const string &err,const RtmpMediaSource::Ptr &src){ void RtmpSession::sendPlayResponse(const string &err,const RtmpMediaSource::Ptr &src){
bool authSuccess = err.empty(); bool auth_success = err.empty();
bool ok = (src.operator bool() && authSuccess); bool ok = (src.operator bool() && auth_success);
if (ok) { if (ok) {
//stream begin //stream begin
sendUserControl(CONTROL_STREAM_BEGIN, STREAM_MEDIA); sendUserControl(CONTROL_STREAM_BEGIN, STREAM_MEDIA);
@ -205,17 +205,17 @@ void RtmpSession::sendPlayResponse(const string &err,const RtmpMediaSource::Ptr
// onStatus(NetStream.Play.Reset) // onStatus(NetStream.Play.Reset)
AMFValue status(AMF_OBJECT); AMFValue status(AMF_OBJECT);
status.set("level", ok ? "status" : "error"); status.set("level", ok ? "status" : "error");
status.set("code", ok ? "NetStream.Play.Reset" : (authSuccess ? "NetStream.Play.StreamNotFound" : "NetStream.Play.BadAuth")); status.set("code", ok ? "NetStream.Play.Reset" : (auth_success ? "NetStream.Play.StreamNotFound" : "NetStream.Play.BadAuth"));
status.set("description", ok ? "Resetting and playing." : (authSuccess ? "No such stream." : err.data())); status.set("description", ok ? "Resetting and playing." : (auth_success ? "No such stream." : err.data()));
status.set("details", _mediaInfo._streamid); status.set("details", _media_info._streamid);
status.set("clientid", "0"); status.set("clientid", "0");
sendReply("onStatus", nullptr, status); sendReply("onStatus", nullptr, status);
if (!ok) { if (!ok) {
string errMsg = StrPrinter << (authSuccess ? "no such stream:" : err.data()) << " " string err_msg = StrPrinter << (auth_success ? "no such stream:" : err.data()) << " "
<< _mediaInfo._vhost << " " << _media_info._vhost << " "
<< _mediaInfo._app << " " << _media_info._app << " "
<< _mediaInfo._streamid; << _media_info._streamid;
shutdown(SockException(Err_shutdown,errMsg)); shutdown(SockException(Err_shutdown, err_msg));
return; return;
} }
@ -224,7 +224,7 @@ void RtmpSession::sendPlayResponse(const string &err,const RtmpMediaSource::Ptr
status.set("level", "status"); status.set("level", "status");
status.set("code", "NetStream.Play.Start"); status.set("code", "NetStream.Play.Start");
status.set("description", "Started playing."); status.set("description", "Started playing.");
status.set("details", _mediaInfo._streamid); status.set("details", _media_info._streamid);
status.set("clientid", "0"); status.set("clientid", "0");
sendReply("onStatus", nullptr, status); sendReply("onStatus", nullptr, status);
@ -245,7 +245,7 @@ void RtmpSession::sendPlayResponse(const string &err,const RtmpMediaSource::Ptr
status.set("level", "status"); status.set("level", "status");
status.set("code", "NetStream.Play.PublishNotify"); status.set("code", "NetStream.Play.PublishNotify");
status.set("description", "Now published."); status.set("description", "Now published.");
status.set("details", _mediaInfo._streamid); status.set("details", _media_info._streamid);
status.set("clientid", "0"); status.set("clientid", "0");
sendReply("onStatus", nullptr, status); sendReply("onStatus", nullptr, status);
@ -273,9 +273,9 @@ void RtmpSession::sendPlayResponse(const string &err,const RtmpMediaSource::Ptr
//音频同步于视频 //音频同步于视频
_stamp[0].syncTo(_stamp[1]); _stamp[0].syncTo(_stamp[1]);
_pRingReader = src->getRing()->attach(getPoller()); _ring_reader = src->getRing()->attach(getPoller());
weak_ptr<RtmpSession> weakSelf = dynamic_pointer_cast<RtmpSession>(shared_from_this()); weak_ptr<RtmpSession> weakSelf = dynamic_pointer_cast<RtmpSession>(shared_from_this());
_pRingReader->setReadCB([weakSelf](const RtmpMediaSource::RingDataType &pkt) { _ring_reader->setReadCB([weakSelf](const RtmpMediaSource::RingDataType &pkt) {
auto strongSelf = weakSelf.lock(); auto strongSelf = weakSelf.lock();
if (!strongSelf) { if (!strongSelf) {
return; return;
@ -293,14 +293,14 @@ void RtmpSession::sendPlayResponse(const string &err,const RtmpMediaSource::Ptr
strongSelf->onSendMedia(rtmp); strongSelf->onSendMedia(rtmp);
}); });
}); });
_pRingReader->setDetachCB([weakSelf]() { _ring_reader->setDetachCB([weakSelf]() {
auto strongSelf = weakSelf.lock(); auto strongSelf = weakSelf.lock();
if (!strongSelf) { if (!strongSelf) {
return; return;
} }
strongSelf->shutdown(SockException(Err_shutdown,"rtmp ring buffer detached")); strongSelf->shutdown(SockException(Err_shutdown,"rtmp ring buffer detached"));
}); });
_pPlayerSrc = src; _player_src = src;
if (src->totalReaderCount() == 1) { if (src->totalReaderCount() == 1) {
src->seekTo(0); src->seekTo(0);
} }
@ -317,46 +317,47 @@ void RtmpSession::doPlayResponse(const string &err,const std::function<void(bool
} }
//鉴权成功，查找媒体源并回复 //鉴权成功，查找媒体源并回复
weak_ptr<RtmpSession> weakSelf = dynamic_pointer_cast<RtmpSession>(shared_from_this()); weak_ptr<RtmpSession> weak_self = dynamic_pointer_cast<RtmpSession>(shared_from_this());
MediaSource::findAsync(_mediaInfo,weakSelf.lock(),[weakSelf,cb](const MediaSource::Ptr &src){ MediaSource::findAsync(_media_info, weak_self.lock(), [weak_self,cb](const MediaSource::Ptr &src){
auto rtmp_src = dynamic_pointer_cast<RtmpMediaSource>(src); auto rtmp_src = dynamic_pointer_cast<RtmpMediaSource>(src);
auto strongSelf = weakSelf.lock(); auto strong_self = weak_self.lock();
if(strongSelf){ if(strong_self){
strongSelf->sendPlayResponse("", rtmp_src); strong_self->sendPlayResponse("", rtmp_src);
} }
cb(rtmp_src.operator bool()); cb(rtmp_src.operator bool());
}); });
} }
void RtmpSession::doPlay(AMFDecoder &dec){ void RtmpSession::doPlay(AMFDecoder &dec){
std::shared_ptr<Ticker> pTicker(new Ticker); std::shared_ptr<Ticker> ticker(new Ticker);
weak_ptr<RtmpSession> weakSelf = dynamic_pointer_cast<RtmpSession>(shared_from_this()); weak_ptr<RtmpSession> weak_self = dynamic_pointer_cast<RtmpSession>(shared_from_this());
std::shared_ptr<onceToken> pToken(new onceToken(nullptr,[pTicker,weakSelf](){ std::shared_ptr<onceToken> token(new onceToken(nullptr, [ticker,weak_self](){
auto strongSelf = weakSelf.lock(); auto strongSelf = weak_self.lock();
if (strongSelf) { if (strongSelf) {
DebugP(strongSelf.get()) << "play 回复时间:" << pTicker->elapsedTime() << "ms"; DebugP(strongSelf.get()) << "play 回复时间:" << ticker->elapsedTime() << "ms";
} }
})); }));
Broadcast::AuthInvoker invoker = [weakSelf,pToken](const string &err){ Broadcast::AuthInvoker invoker = [weak_self,token](const string &err){
auto strongSelf = weakSelf.lock(); auto strong_self = weak_self.lock();
if(!strongSelf){ if (!strong_self) {
return; return;
} }
strongSelf->async([weakSelf,err,pToken](){ strong_self->async([weak_self, err, token]() {
auto strongSelf = weakSelf.lock(); auto strong_self = weak_self.lock();
if(!strongSelf){ if (!strong_self) {
return; return;
} }
strongSelf->doPlayResponse(err,[pToken](bool){}); strong_self->doPlayResponse(err, [token](bool) {});
}); });
}; };
auto flag = NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastMediaPlayed,_mediaInfo,invoker,static_cast<SockInfo &>(*this)); auto flag = NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastMediaPlayed, _media_info, invoker, static_cast<SockInfo &>(*this));
if(!flag){ if(!flag){
//该事件无人监听,默认不鉴权 //该事件无人监听,默认不鉴权
doPlayResponse("",[pToken](bool){}); doPlayResponse("",[token](bool){});
} }
} }
void RtmpSession::onCmd_play2(AMFDecoder &dec) { void RtmpSession::onCmd_play2(AMFDecoder &dec) {
doPlay(dec); doPlay(dec);
} }
@ -399,8 +400,8 @@ string RtmpSession::getStreamId(const string &str){
void RtmpSession::onCmd_play(AMFDecoder &dec) { void RtmpSession::onCmd_play(AMFDecoder &dec) {
dec.load<AMFValue>();/* NULL */ dec.load<AMFValue>();/* NULL */
_mediaInfo.parse(_strTcUrl + "/" + getStreamId(dec.load<std::string>())); _media_info.parse(_tc_url + "/" + getStreamId(dec.load<std::string>()));
_mediaInfo._schema = RTMP_SCHEMA; _media_info._schema = RTMP_SCHEMA;
doPlay(dec); doPlay(dec);
} }
@ -419,7 +420,7 @@ void RtmpSession::onCmd_pause(AMFDecoder &dec) {
} }
void RtmpSession::setMetaData(AMFDecoder &dec) { void RtmpSession::setMetaData(AMFDecoder &dec) {
if (!_pPublisherSrc) { if (!_publisher_src) {
throw std::runtime_error("not a publisher"); throw std::runtime_error("not a publisher");
} }
std::string type = dec.load<std::string>(); std::string type = dec.load<std::string>();
@ -428,13 +429,13 @@ void RtmpSession::setMetaData(AMFDecoder &dec) {
} }
auto metadata = dec.load<AMFValue>(); auto metadata = dec.load<AMFValue>();
// dumpMetadata(metadata); // dumpMetadata(metadata);
_pPublisherSrc->setMetaData(metadata); _publisher_src->setMetaData(metadata);
_set_meta_data = true; _set_meta_data = true;
} }
void RtmpSession::onProcessCmd(AMFDecoder &dec) { void RtmpSession::onProcessCmd(AMFDecoder &dec) {
typedef void (RtmpSession::*rtmpCMDHandle)(AMFDecoder &dec); typedef void (RtmpSession::*cmd_function)(AMFDecoder &dec);
static unordered_map<string, rtmpCMDHandle> s_cmd_functions; static unordered_map<string, cmd_function> s_cmd_functions;
static onceToken token([]() { static onceToken token([]() {
s_cmd_functions.emplace("connect", &RtmpSession::onCmd_connect); s_cmd_functions.emplace("connect", &RtmpSession::onCmd_connect);
s_cmd_functions.emplace("createStream", &RtmpSession::onCmd_createStream); s_cmd_functions.emplace("createStream", &RtmpSession::onCmd_createStream);
@ -443,7 +444,8 @@ void RtmpSession::onProcessCmd(AMFDecoder &dec) {
s_cmd_functions.emplace("play", &RtmpSession::onCmd_play); s_cmd_functions.emplace("play", &RtmpSession::onCmd_play);
s_cmd_functions.emplace("play2", &RtmpSession::onCmd_play2); s_cmd_functions.emplace("play2", &RtmpSession::onCmd_play2);
s_cmd_functions.emplace("seek", &RtmpSession::onCmd_seek); s_cmd_functions.emplace("seek", &RtmpSession::onCmd_seek);
s_cmd_functions.emplace("pause",&RtmpSession::onCmd_pause);}, []() {}); s_cmd_functions.emplace("pause", &RtmpSession::onCmd_pause);
});
std::string method = dec.load<std::string>(); std::string method = dec.load<std::string>();
auto it = s_cmd_functions.find(method); auto it = s_cmd_functions.find(method);
@ -451,52 +453,54 @@ void RtmpSession::onProcessCmd(AMFDecoder &dec) {
// TraceP(this) << "can not support cmd:" << method; // TraceP(this) << "can not support cmd:" << method;
return; return;
} }
_dNowReqID = dec.load<double>(); _recv_req_id = dec.load<double>();
auto fun = it->second; auto fun = it->second;
(this->*fun)(dec); (this->*fun)(dec);
} }
void RtmpSession::onRtmpChunk(RtmpPacket &chunkData) { void RtmpSession::onRtmpChunk(RtmpPacket &chunk_data) {
switch (chunkData.typeId) { switch (chunk_data.type_id) {
case MSG_CMD: case MSG_CMD:
case MSG_CMD3: { case MSG_CMD3: {
AMFDecoder dec(chunkData.strBuf, chunkData.typeId == MSG_CMD3 ? 1 : 0); AMFDecoder dec(chunk_data.buffer, chunk_data.type_id == MSG_CMD3 ? 1 : 0);
onProcessCmd(dec); onProcessCmd(dec);
}
break; break;
}
case MSG_DATA: case MSG_DATA:
case MSG_DATA3: { case MSG_DATA3: {
AMFDecoder dec(chunkData.strBuf, chunkData.typeId == MSG_CMD3 ? 1 : 0); AMFDecoder dec(chunk_data.buffer, chunk_data.type_id == MSG_CMD3 ? 1 : 0);
std::string type = dec.load<std::string>(); std::string type = dec.load<std::string>();
if (type == "@setDataFrame") { if (type == "@setDataFrame") {
setMetaData(dec); setMetaData(dec);
} else { } else {
TraceP(this) << "unknown notify:" << type; TraceP(this) << "unknown notify:" << type;
} }
}
break; break;
}
case MSG_AUDIO: case MSG_AUDIO:
case MSG_VIDEO: { case MSG_VIDEO: {
if (!_pPublisherSrc) { if (!_publisher_src) {
throw std::runtime_error("Not a rtmp publisher!"); throw std::runtime_error("Not a rtmp publisher!");
} }
GET_CONFIG(bool, rtmp_modify_stamp, Rtmp::kModifyStamp); GET_CONFIG(bool, rtmp_modify_stamp, Rtmp::kModifyStamp);
if (rtmp_modify_stamp) { if (rtmp_modify_stamp) {
int64_t dts_out; int64_t dts_out;
_stamp[chunkData.typeId % 2].revise(chunkData.timeStamp, chunkData.timeStamp, dts_out, dts_out, true); _stamp[chunk_data.type_id % 2].revise(chunk_data.time_stamp, chunk_data.time_stamp, dts_out, dts_out, true);
chunkData.timeStamp = dts_out; chunk_data.time_stamp = dts_out;
} }
if(!_set_meta_data && !chunkData.isCfgFrame()){ if (!_set_meta_data && !chunk_data.isCfgFrame()) {
_set_meta_data = true; _set_meta_data = true;
_pPublisherSrc->setMetaData(TitleMeta().getMetadata()); _publisher_src->setMetaData(TitleMeta().getMetadata());
}
_pPublisherSrc->onWrite(std::make_shared<RtmpPacket>(std::move(chunkData)));
} }
_publisher_src->onWrite(std::make_shared<RtmpPacket>(std::move(chunk_data)));
break; break;
}
default: default:
WarnP(this) << "unhandled message:" << (int) chunkData.typeId << hexdump(chunkData.strBuf.data(), chunkData.strBuf.size()); WarnP(this) << "unhandled message:" << (int) chunk_data.type_id << hexdump(chunk_data.buffer.data(), chunk_data.buffer.size());
break; break;
} }
} }
@ -512,23 +516,23 @@ void RtmpSession::onCmd_seek(AMFDecoder &dec) {
auto milliSeconds = dec.load<AMFValue>().as_number(); auto milliSeconds = dec.load<AMFValue>().as_number();
InfoP(this) << "rtmp seekTo(ms):" << milliSeconds; InfoP(this) << "rtmp seekTo(ms):" << milliSeconds;
auto stongSrc = _pPlayerSrc.lock(); auto strong_src = _player_src.lock();
if (stongSrc) { if (strong_src) {
stongSrc->seekTo(milliSeconds); strong_src->seekTo(milliSeconds);
} }
} }
void RtmpSession::onSendMedia(const RtmpPacket::Ptr &pkt) { void RtmpSession::onSendMedia(const RtmpPacket::Ptr &pkt) {
//rtmp播放器时间戳从零开始 //rtmp播放器时间戳从零开始
int64_t dts_out; int64_t dts_out;
_stamp[pkt->typeId % 2].revise(pkt->timeStamp, 0, dts_out, dts_out); _stamp[pkt->type_id % 2].revise(pkt->time_stamp, 0, dts_out, dts_out);
sendRtmp(pkt->typeId, pkt->streamId, pkt, dts_out, pkt->chunkId); sendRtmp(pkt->type_id, pkt->stream_index, pkt, dts_out, pkt->chunk_id);
} }
bool RtmpSession::close(MediaSource &sender,bool force) { bool RtmpSession::close(MediaSource &sender,bool force) {
//此回调在其他线程触发 //此回调在其他线程触发
if(!_pPublisherSrc || (!force && _pPublisherSrc->totalReaderCount())){ if(!_publisher_src || (!force && _publisher_src->totalReaderCount())){
return false; return false;
} }
string err = StrPrinter << "close media:" << sender.getSchema() << "/" << sender.getVhost() << "/" << sender.getApp() << "/" << sender.getId() << " " << force; string err = StrPrinter << "close media:" << sender.getSchema() << "/" << sender.getVhost() << "/" << sender.getApp() << "/" << sender.getId() << " " << force;
@ -537,12 +541,12 @@ bool RtmpSession::close(MediaSource &sender,bool force) {
} }
int RtmpSession::totalReaderCount(MediaSource &sender) { int RtmpSession::totalReaderCount(MediaSource &sender) {
return _pPublisherSrc ? _pPublisherSrc->totalReaderCount() : sender.readerCount(); return _publisher_src ? _publisher_src->totalReaderCount() : sender.readerCount();
} }
void RtmpSession::setSocketFlags(){ void RtmpSession::setSocketFlags(){
GET_CONFIG(int, mergeWriteMS, General::kMergeWriteMS); GET_CONFIG(int, merge_write_ms, General::kMergeWriteMS);
if(mergeWriteMS > 0) { if (merge_write_ms > 0) {
//推流模式下，关闭TCP_NODELAY会增加推流端的延时，但是服务器性能将提高 //推流模式下，关闭TCP_NODELAY会增加推流端的延时，但是服务器性能将提高
SockUtil::setNoDelay(_sock->rawFD(), false); SockUtil::setNoDelay(_sock->rawFD(), false);
//播放模式下，开启MSG_MORE会增加延时，但是能提高发送性能 //播放模式下，开启MSG_MORE会增加延时，但是能提高发送性能
@ -559,6 +563,6 @@ void RtmpSession::dumpMetadata(const AMFValue &metadata) {
metadata.object_for_each([&](const string &key, const AMFValue &val) { metadata.object_for_each([&](const string &key, const AMFValue &val) {
printer << "\r\n" << key << "\t:" << val.to_string(); printer << "\r\n" << key << "\t:" << val.to_string();
}); });
InfoL << _mediaInfo._vhost << " " << _mediaInfo._app << " " << _mediaInfo._streamid << (string)printer; InfoL << _media_info._vhost << " " << _media_info._app << " " << _media_info._streamid << (string) printer;
} }
} /* namespace mediakit */ } /* namespace mediakit */

39
src/Rtmp/RtmpSession.h
View File

@ -30,11 +30,13 @@ namespace mediakit {
class RtmpSession: public TcpSession ,public RtmpProtocol , public MediaSourceEvent{ class RtmpSession: public TcpSession ,public RtmpProtocol , public MediaSourceEvent{
public: public:
typedef std::shared_ptr<RtmpSession> Ptr; typedef std::shared_ptr<RtmpSession> Ptr;
RtmpSession(const Socket::Ptr &_sock); RtmpSession(const Socket::Ptr &sock);
virtual ~RtmpSession(); ~RtmpSession() override;
void onRecv(const Buffer::Ptr &pBuf) override;
void onRecv(const Buffer::Ptr &buf) override;
void onError(const SockException &err) override; void onError(const SockException &err) override;
void onManager() override; void onManager() override;
private: private:
void onProcessCmd(AMFDecoder &dec); void onProcessCmd(AMFDecoder &dec);
void onCmd_connect(AMFDecoder &dec); void onCmd_connect(AMFDecoder &dec);
@ -55,15 +57,15 @@ private:
void onSendMedia(const RtmpPacket::Ptr &pkt); void onSendMedia(const RtmpPacket::Ptr &pkt);
void onSendRawData(const Buffer::Ptr &buffer) override{ void onSendRawData(const Buffer::Ptr &buffer) override{
_ui64TotalBytes += buffer->size(); _total_bytes += buffer->size();
send(buffer); send(buffer);
} }
void onRtmpChunk(RtmpPacket &chunkData) override; void onRtmpChunk(RtmpPacket &chunk_data) override;
template<typename first, typename second> template<typename first, typename second>
inline void sendReply(const char *str, const first &reply, const second &status) { inline void sendReply(const char *str, const first &reply, const second &status) {
AMFEncoder invoke; AMFEncoder invoke;
invoke << str << _dNowReqID << reply << status; invoke << str << _recv_req_id << reply << status;
sendResponse(MSG_CMD, invoke.data()); sendResponse(MSG_CMD, invoke.data());
} }
@ -74,29 +76,30 @@ private:
void setSocketFlags(); void setSocketFlags();
string getStreamId(const string &str); string getStreamId(const string &str);
void dumpMetadata(const AMFValue &metadata); void dumpMetadata(const AMFValue &metadata);
private: private:
std::string _strTcUrl; bool _paused = false;
MediaInfo _mediaInfo;
double _dNowReqID = 0;
bool _set_meta_data = false; bool _set_meta_data = false;
Ticker _ticker;//数据接收时间 double _recv_req_id = 0;
RtmpMediaSource::RingType::RingReader::Ptr _pRingReader; //消耗的总流量
std::shared_ptr<RtmpMediaSourceImp> _pPublisherSrc; uint64_t _total_bytes = 0;
std::weak_ptr<RtmpMediaSource> _pPlayerSrc;
std::string _tc_url;
//时间戳修整器 //时间戳修整器
Stamp _stamp[2]; Stamp _stamp[2];
//消耗的总流量 //数据接收超时计时器
uint64_t _ui64TotalBytes = 0; Ticker _ticker;
bool _paused = false; MediaInfo _media_info;
std::weak_ptr<RtmpMediaSource> _player_src;
std::shared_ptr<RtmpMediaSourceImp> _publisher_src;
RtmpMediaSource::RingType::RingReader::Ptr _ring_reader;
}; };
/** /**
* 支持ssl加密的rtmp服务器 * 支持ssl加密的rtmp服务器
*/ */
typedef TcpSessionWithSSL<RtmpSession> RtmpSessionWithSSL; typedef TcpSessionWithSSL<RtmpSession> RtmpSessionWithSSL;
} /* namespace mediakit */ } /* namespace mediakit */
#endif /* SRC_RTMP_RTMPSESSION_H_ */ #endif /* SRC_RTMP_RTMPSESSION_H_ */

47
src/Rtsp/RtspPlayer.cpp
View File

@ -733,28 +733,12 @@ void RtspPlayer::onRecvRTP_l(const RtpPacket::Ptr &rtp, const SdpTrack::Ptr &tra
} }
void RtspPlayer::onPlayResult_l(const SockException &ex , bool handshakeCompleted) { void RtspPlayer::onPlayResult_l(const SockException &ex , bool handshakeCompleted) {
if (ex.getErrCode() == Err_shutdown) {
//主动shutdown的，不触发回调
return;
}
WarnL << ex.getErrCode() << " " << ex.what(); WarnL << ex.getErrCode() << " " << ex.what();
if(!ex){
//播放成功，恢复rtp接收超时定时器
_rtp_recv_ticker.resetTime();
weak_ptr<RtspPlayer> weakSelf = dynamic_pointer_cast<RtspPlayer>(shared_from_this());
int timeoutMS = (*this)[kMediaTimeoutMS].as<int>();
//创建rtp数据接收超时检测定时器
_rtp_check_timer.reset(new Timer(timeoutMS / 2000.0, [weakSelf,timeoutMS]() {
auto strongSelf=weakSelf.lock();
if(!strongSelf) {
return false;
}
if(strongSelf->_rtp_recv_ticker.elapsedTime() > timeoutMS) {
//接收rtp媒体数据包超时
strongSelf->onPlayResult_l(SockException(Err_timeout,"receive rtp timeout"), true);
return false;
}
return true;
}, getPoller()));
}
if (!handshakeCompleted) { if (!handshakeCompleted) {
//开始播放阶段 //开始播放阶段
_play_check_timer.reset(); _play_check_timer.reset();
@ -769,7 +753,26 @@ void RtspPlayer::onPlayResult_l(const SockException &ex , bool handshakeComplete
onResume(); onResume();
} }
if(ex){ if (!ex) {
//播放成功，恢复rtp接收超时定时器
_rtp_recv_ticker.resetTime();
int timeoutMS = (*this)[kMediaTimeoutMS].as<int>();
weak_ptr<RtspPlayer> weakSelf = dynamic_pointer_cast<RtspPlayer>(shared_from_this());
auto lam = [weakSelf, timeoutMS]() {
auto strongSelf = weakSelf.lock();
if (!strongSelf) {
return false;
}
if (strongSelf->_rtp_recv_ticker.elapsedTime() > timeoutMS) {
//接收rtp媒体数据包超时
strongSelf->onPlayResult_l(SockException(Err_timeout, "receive rtp timeout"), true);
return false;
}
return true;
};
//创建rtp数据接收超时检测定时器
_rtp_check_timer = std::make_shared<Timer>(timeoutMS / 2000.0, lam, getPoller());
} else {
teardown(); teardown();
} }
} }

2
src/Rtsp/RtspSession.cpp
View File

@ -1123,7 +1123,7 @@ inline void RtspSession::onSendRtpPacket(const RtpPacket::Ptr &pkt){
//send rtcp every 5 second //send rtcp every 5 second
ticker.resetTime(); ticker.resetTime();
//直接保存网络字节序 //直接保存网络字节序
memcpy(&counter.timeStamp, pkt->data() + 8, 4); memcpy(&counter.time_stamp, pkt->data() + 8, 4);
sendSenderReport(_rtp_type == Rtsp::RTP_TCP, track_index); sendSenderReport(_rtp_type == Rtsp::RTP_TCP, track_index);
} }
#endif #endif