amass/ZLMediaKit
1
0
Fork 0
mirror of https://github.com/ZLMediaKit/ZLMediaKit.git synced 2024-11-26 04:31:37 +08:00
Code Issues Actions 6 Packages Projects Releases Wiki Activity

时间戳改为64位

Browse Source
This commit is contained in:
ziyue 2022-08-08 17:13:39 +08:00
parent 143580d780
commit 9c3b8a6a95
44 changed files with 143 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
api/include/mk_frame.h
View File

@ -55,7 +55,7 @@ typedef void(API_CALL *on_mk_frame_data_release)(void *user_data, char *ptr);
* @param user_data data指针free释放回调用户指针 * @param user_data data指针free释放回调用户指针
* @return frame对象引用 * @return frame对象引用
*/ */
API_EXPORT mk_frame API_CALL mk_frame_create(int codec_id, uint32_t dts, uint32_t pts, const char *data, size_t size, API_EXPORT mk_frame API_CALL mk_frame_create(int codec_id, uint64_t dts, uint64_t pts, const char *data, size_t size,
on_mk_frame_data_release cb, void *user_data); on_mk_frame_data_release cb, void *user_data);
/** /**
@ -104,12 +104,12 @@ API_EXPORT size_t API_CALL mk_frame_get_data_prefix_size(mk_frame frame);
/** /**
* 获取解码时间戳，单位毫秒 * 获取解码时间戳，单位毫秒
*/ */
API_EXPORT uint32_t API_CALL mk_frame_get_dts(mk_frame frame); API_EXPORT uint64_t API_CALL mk_frame_get_dts(mk_frame frame);
/** /**
* 获取显示时间戳，单位毫秒 * 获取显示时间戳，单位毫秒
*/ */
API_EXPORT uint32_t API_CALL mk_frame_get_pts(mk_frame frame); API_EXPORT uint64_t API_CALL mk_frame_get_pts(mk_frame frame);
/** /**
* 获取帧flag，请参考 MK_FRAME_FLAG * 获取帧flag，请参考 MK_FRAME_FLAG

12
api/include/mk_media.h
View File

@ -99,7 +99,7 @@ API_EXPORT int API_CALL mk_media_input_frame(mk_media ctx, mk_frame frame);
* @param pts 播放时间戳，单位毫秒 * @param pts 播放时间戳，单位毫秒
* @return 1代表成功，0失败 * @return 1代表成功，0失败
*/ */
API_EXPORT int API_CALL mk_media_input_h264(mk_media ctx, const void *data, int len, uint32_t dts, uint32_t pts); API_EXPORT int API_CALL mk_media_input_h264(mk_media ctx, const void *data, int len, uint64_t dts, uint64_t pts);
/** /**
* 输入单帧H265视频，帧起始字节00 00 01,00 00 00 01均可，请改用mk_media_input_frame方法 * 输入单帧H265视频，帧起始字节00 00 01,00 00 00 01均可，请改用mk_media_input_frame方法
@ -110,7 +110,7 @@ API_EXPORT int API_CALL mk_media_input_h264(mk_media ctx, const void *data, int
* @param pts 播放时间戳，单位毫秒 * @param pts 播放时间戳，单位毫秒
* @return 1代表成功，0失败 * @return 1代表成功，0失败
*/ */
API_EXPORT int API_CALL mk_media_input_h265(mk_media ctx, const void *data, int len, uint32_t dts, uint32_t pts); API_EXPORT int API_CALL mk_media_input_h265(mk_media ctx, const void *data, int len, uint64_t dts, uint64_t pts);
/** /**
* 输入YUV视频数据 * 输入YUV视频数据
@ -119,7 +119,7 @@ API_EXPORT int API_CALL mk_media_input_h265(mk_media ctx, const void *data, int
* @param linesize yuv420p linesize * @param linesize yuv420p linesize
* @param cts 视频采集时间戳，单位毫秒 * @param cts 视频采集时间戳，单位毫秒
*/ */
API_EXPORT void API_CALL mk_media_input_yuv(mk_media ctx, const char *yuv[3], int linesize[3], uint32_t cts); API_EXPORT void API_CALL mk_media_input_yuv(mk_media ctx, const char *yuv[3], int linesize[3], uint64_t cts);
/** /**
* 输入单帧AAC音频(单独指定adts头)，请改用mk_media_input_frame方法 * 输入单帧AAC音频(单独指定adts头)，请改用mk_media_input_frame方法
@ -130,7 +130,7 @@ API_EXPORT void API_CALL mk_media_input_yuv(mk_media ctx, const char *yuv[3], in
* @param adts adts头，可以为null * @param adts adts头，可以为null
* @return 1代表成功，0失败 * @return 1代表成功，0失败
*/ */
API_EXPORT int API_CALL mk_media_input_aac(mk_media ctx, const void *data, int len, uint32_t dts, void *adts); API_EXPORT int API_CALL mk_media_input_aac(mk_media ctx, const void *data, int len, uint64_t dts, void *adts);
/** /**
* 输入单帧PCM音频,启用ENABLE_FAAC编译时，该函数才有效 * 输入单帧PCM音频,启用ENABLE_FAAC编译时，该函数才有效
@ -140,7 +140,7 @@ API_EXPORT int API_CALL mk_media_input_aac(mk_media ctx, const void *data, int l
* @param dts 时间戳，毫秒 * @param dts 时间戳，毫秒
* @return 1代表成功，0失败 * @return 1代表成功，0失败
*/ */
API_EXPORT int API_CALL mk_media_input_pcm(mk_media ctx, void *data, int len, uint32_t pts); API_EXPORT int API_CALL mk_media_input_pcm(mk_media ctx, void *data, int len, uint64_t pts);
/** /**
* 输入单帧OPUS/G711音频帧，请改用mk_media_input_frame方法 * 输入单帧OPUS/G711音频帧，请改用mk_media_input_frame方法
@ -150,7 +150,7 @@ API_EXPORT int API_CALL mk_media_input_pcm(mk_media ctx, void *data, int len, ui
* @param dts 时间戳，毫秒 * @param dts 时间戳，毫秒
* @return 1代表成功，0失败 * @return 1代表成功，0失败
*/ */
API_EXPORT int API_CALL mk_media_input_audio(mk_media ctx, const void* data, int len, uint32_t dts); API_EXPORT int API_CALL mk_media_input_audio(mk_media ctx, const void* data, int len, uint64_t dts);
/** /**
* MediaSource.close()回调事件 * MediaSource.close()回调事件

8
api/source/mk_frame.cpp
View File

@ -70,7 +70,7 @@ private:
bool _cache_able; bool _cache_able;
}; };
static mk_frame mk_frame_create_complex(int codec_id, uint32_t dts, uint32_t pts, uint32_t frame_flags, size_t prefix_size, static mk_frame mk_frame_create_complex(int codec_id, uint64_t dts, uint64_t pts, uint32_t frame_flags, size_t prefix_size,
char *data, size_t size, on_mk_frame_data_release cb, void *user_data) { char *data, size_t size, on_mk_frame_data_release cb, void *user_data) {
switch (codec_id) { switch (codec_id) {
case CodecH264: case CodecH264:
@ -85,7 +85,7 @@ static mk_frame mk_frame_create_complex(int codec_id, uint32_t dts, uint32_t pts
} }
} }
API_EXPORT mk_frame API_CALL mk_frame_create(int codec_id, uint32_t dts, uint32_t pts, const char *data, size_t size, API_EXPORT mk_frame API_CALL mk_frame_create(int codec_id, uint64_t dts, uint64_t pts, const char *data, size_t size,
on_mk_frame_data_release cb, void *user_data) { on_mk_frame_data_release cb, void *user_data) {
switch (codec_id) { switch (codec_id) {
@ -146,12 +146,12 @@ API_EXPORT size_t API_CALL mk_frame_get_data_prefix_size(mk_frame frame) {
return (*((Frame::Ptr *) frame))->prefixSize(); return (*((Frame::Ptr *) frame))->prefixSize();
} }
API_EXPORT uint32_t API_CALL mk_frame_get_dts(mk_frame frame) { API_EXPORT uint64_t API_CALL mk_frame_get_dts(mk_frame frame) {
assert(frame); assert(frame);
return (*((Frame::Ptr *) frame))->dts(); return (*((Frame::Ptr *) frame))->dts();
} }
API_EXPORT uint32_t API_CALL mk_frame_get_pts(mk_frame frame) { API_EXPORT uint64_t API_CALL mk_frame_get_pts(mk_frame frame) {
assert(frame); assert(frame);
return (*((Frame::Ptr *) frame))->pts(); return (*((Frame::Ptr *) frame))->pts();
} }

12
api/source/mk_media.cpp
View File

@ -219,37 +219,37 @@ API_EXPORT int API_CALL mk_media_input_frame(mk_media ctx, mk_frame frame){
return (*obj)->getChannel()->inputFrame(*((Frame::Ptr *) frame)); return (*obj)->getChannel()->inputFrame(*((Frame::Ptr *) frame));
} }
API_EXPORT int API_CALL mk_media_input_h264(mk_media ctx, const void *data, int len, uint32_t dts, uint32_t pts) { API_EXPORT int API_CALL mk_media_input_h264(mk_media ctx, const void *data, int len, uint64_t dts, uint64_t pts) {
assert(ctx && data && len > 0); assert(ctx && data && len > 0);
MediaHelper::Ptr *obj = (MediaHelper::Ptr *) ctx; MediaHelper::Ptr *obj = (MediaHelper::Ptr *) ctx;
return (*obj)->getChannel()->inputH264((const char *) data, len, dts, pts); return (*obj)->getChannel()->inputH264((const char *) data, len, dts, pts);
} }
API_EXPORT int API_CALL mk_media_input_h265(mk_media ctx, const void *data, int len, uint32_t dts, uint32_t pts) { API_EXPORT int API_CALL mk_media_input_h265(mk_media ctx, const void *data, int len, uint64_t dts, uint64_t pts) {
assert(ctx && data && len > 0); assert(ctx && data && len > 0);
MediaHelper::Ptr *obj = (MediaHelper::Ptr *) ctx; MediaHelper::Ptr *obj = (MediaHelper::Ptr *) ctx;
return (*obj)->getChannel()->inputH265((const char *) data, len, dts, pts); return (*obj)->getChannel()->inputH265((const char *) data, len, dts, pts);
} }
API_EXPORT void API_CALL mk_media_input_yuv(mk_media ctx, const char *yuv[3], int linesize[3], uint32_t cts) { API_EXPORT void API_CALL mk_media_input_yuv(mk_media ctx, const char *yuv[3], int linesize[3], uint64_t cts) {
assert(ctx && yuv && linesize); assert(ctx && yuv && linesize);
MediaHelper::Ptr *obj = (MediaHelper::Ptr *) ctx; MediaHelper::Ptr *obj = (MediaHelper::Ptr *) ctx;
(*obj)->getChannel()->inputYUV((char **) yuv, linesize, cts); (*obj)->getChannel()->inputYUV((char **) yuv, linesize, cts);
} }
API_EXPORT int API_CALL mk_media_input_aac(mk_media ctx, const void *data, int len, uint32_t dts, void *adts) { API_EXPORT int API_CALL mk_media_input_aac(mk_media ctx, const void *data, int len, uint64_t dts, void *adts) {
assert(ctx && data && len > 0 && adts); assert(ctx && data && len > 0 && adts);
MediaHelper::Ptr *obj = (MediaHelper::Ptr *) ctx; MediaHelper::Ptr *obj = (MediaHelper::Ptr *) ctx;
return (*obj)->getChannel()->inputAAC((const char *) data, len, dts, (char *) adts); return (*obj)->getChannel()->inputAAC((const char *) data, len, dts, (char *) adts);
} }
API_EXPORT int API_CALL mk_media_input_pcm(mk_media ctx, void *data , int len, uint32_t pts){ API_EXPORT int API_CALL mk_media_input_pcm(mk_media ctx, void *data , int len, uint64_t pts){
assert(ctx && data && len > 0); assert(ctx && data && len > 0);
MediaHelper::Ptr* obj = (MediaHelper::Ptr*) ctx; MediaHelper::Ptr* obj = (MediaHelper::Ptr*) ctx;
return (*obj)->getChannel()->inputPCM((char*)data, len, pts); return (*obj)->getChannel()->inputPCM((char*)data, len, pts);
} }
API_EXPORT int API_CALL mk_media_input_audio(mk_media ctx, const void* data, int len, uint32_t dts){ API_EXPORT int API_CALL mk_media_input_audio(mk_media ctx, const void* data, int len, uint64_t dts){
assert(ctx && data && len > 0); assert(ctx && data && len > 0);
MediaHelper::Ptr* obj = (MediaHelper::Ptr*) ctx; MediaHelper::Ptr* obj = (MediaHelper::Ptr*) ctx;
return (*obj)->getChannel()->inputAudio((const char*)data, len, dts); return (*obj)->getChannel()->inputAudio((const char*)data, len, dts);

6
src/Codec/Transcode.cpp
View File

@ -420,7 +420,7 @@ FFmpegDecoder::FFmpegDecoder(const Track::Ptr &track, int thread_num) {
FFmpegDecoder::~FFmpegDecoder() { FFmpegDecoder::~FFmpegDecoder() {
stopThread(true); stopThread(true);
if (_do_merger) { if (_do_merger) {
_merger.inputFrame(nullptr, [&](uint32_t dts, uint32_t pts, const Buffer::Ptr &buffer, bool have_idr) { _merger.inputFrame(nullptr, [&](uint64_t dts, uint64_t pts, const Buffer::Ptr &buffer, bool have_idr) {
decodeFrame(buffer->data(), buffer->size(), dts, pts, false); decodeFrame(buffer->data(), buffer->size(), dts, pts, false);
}); });
} }
@ -452,7 +452,7 @@ const AVCodecContext *FFmpegDecoder::getContext() const {
bool FFmpegDecoder::inputFrame_l(const Frame::Ptr &frame, bool live, bool enable_merge) { bool FFmpegDecoder::inputFrame_l(const Frame::Ptr &frame, bool live, bool enable_merge) {
if (_do_merger && enable_merge) { if (_do_merger && enable_merge) {
return _merger.inputFrame(frame, [&](uint32_t dts, uint32_t pts, const Buffer::Ptr &buffer, bool have_idr) { return _merger.inputFrame(frame, [&](uint64_t dts, uint64_t pts, const Buffer::Ptr &buffer, bool have_idr) {
decodeFrame(buffer->data(), buffer->size(), dts, pts, live); decodeFrame(buffer->data(), buffer->size(), dts, pts, live);
}); });
} }
@ -478,7 +478,7 @@ bool FFmpegDecoder::inputFrame(const Frame::Ptr &frame, bool live, bool async, b
}); });
} }
bool FFmpegDecoder::decodeFrame(const char *data, size_t size, uint32_t dts, uint32_t pts, bool live) { bool FFmpegDecoder::decodeFrame(const char *data, size_t size, uint64_t dts, uint64_t pts, bool live) {
TimeTicker2(30, TraceL); TimeTicker2(30, TraceL);
auto pkt = alloc_av_packet(); auto pkt = alloc_av_packet();

2
src/Codec/Transcode.h
View File

@ -113,7 +113,7 @@ public:
private: private:
void onDecode(const FFmpegFrame::Ptr &frame); void onDecode(const FFmpegFrame::Ptr &frame);
bool inputFrame_l(const Frame::Ptr &frame, bool live, bool enable_merge); bool inputFrame_l(const Frame::Ptr &frame, bool live, bool enable_merge);
bool decodeFrame(const char *data, size_t size, uint32_t dts, uint32_t pts, bool live); bool decodeFrame(const char *data, size_t size, uint64_t dts, uint64_t pts, bool live);
private: private:
bool _do_merger = false; bool _do_merger = false;

20
src/Common/Device.cpp
View File

@ -28,7 +28,7 @@ using namespace std;
namespace mediakit { namespace mediakit {
bool DevChannel::inputYUV(char *yuv[3], int linesize[3], uint32_t cts) { bool DevChannel::inputYUV(char *yuv[3], int linesize[3], uint64_t cts) {
#ifdef ENABLE_X264 #ifdef ENABLE_X264
//TimeTicker1(50); //TimeTicker1(50);
if (!_pH264Enc) { if (!_pH264Enc) {
@ -54,7 +54,7 @@ bool DevChannel::inputYUV(char *yuv[3], int linesize[3], uint32_t cts) {
#endif //ENABLE_X264 #endif //ENABLE_X264
} }
bool DevChannel::inputPCM(char* pcData, int iDataLen, uint32_t uiStamp) { bool DevChannel::inputPCM(char* pcData, int iDataLen, uint64_t uiStamp) {
#ifdef ENABLE_FAAC #ifdef ENABLE_FAAC
if (!_pAacEnc) { if (!_pAacEnc) {
_pAacEnc.reset(new AACEncoder()); _pAacEnc.reset(new AACEncoder());
@ -77,9 +77,9 @@ bool DevChannel::inputPCM(char* pcData, int iDataLen, uint32_t uiStamp) {
#endif //ENABLE_FAAC #endif //ENABLE_FAAC
} }
bool DevChannel::inputH264(const char *data, int len, uint32_t dts, uint32_t pts) { bool DevChannel::inputH264(const char *data, int len, uint64_t dts, uint64_t pts) {
if (dts == 0) { if (dts == 0) {
dts = (uint32_t)_aTicker[0].elapsedTime(); dts = _aTicker[0].elapsedTime();
} }
if (pts == 0) { if (pts == 0) {
pts = dts; pts = dts;
@ -96,9 +96,9 @@ bool DevChannel::inputH264(const char *data, int len, uint32_t dts, uint32_t pts
return inputFrame(frame); return inputFrame(frame);
} }
bool DevChannel::inputH265(const char *data, int len, uint32_t dts, uint32_t pts) { bool DevChannel::inputH265(const char *data, int len, uint64_t dts, uint64_t pts) {
if (dts == 0) { if (dts == 0) {
dts = (uint32_t)_aTicker[0].elapsedTime(); dts = _aTicker[0].elapsedTime();
} }
if (pts == 0) { if (pts == 0) {
pts = dts; pts = dts;
@ -129,9 +129,9 @@ public:
} }
}; };
bool DevChannel::inputAAC(const char *data_without_adts, int len, uint32_t dts, const char *adts_header){ bool DevChannel::inputAAC(const char *data_without_adts, int len, uint64_t dts, const char *adts_header){
if (dts == 0) { if (dts == 0) {
dts = (uint32_t) _aTicker[1].elapsedTime(); dts = _aTicker[1].elapsedTime();
} }
if (!adts_header) { if (!adts_header) {
@ -152,9 +152,9 @@ bool DevChannel::inputAAC(const char *data_without_adts, int len, uint32_t dts,
} }
bool DevChannel::inputAudio(const char *data, int len, uint32_t dts){ bool DevChannel::inputAudio(const char *data, int len, uint64_t dts){
if (dts == 0) { if (dts == 0) {
dts = (uint32_t) _aTicker[1].elapsedTime(); dts = _aTicker[1].elapsedTime();
} }
return inputFrame(std::make_shared<FrameFromPtr>(_audio->codecId, (char *) data, len, dts, 0)); return inputFrame(std::make_shared<FrameFromPtr>(_audio->codecId, (char *) data, len, dts, 0));
} }

12
src/Common/Device.h
View File

@ -75,7 +75,7 @@ public:
* @param dts 解码时间戳，单位毫秒；等于0时内部会自动生成时间戳 * @param dts 解码时间戳，单位毫秒；等于0时内部会自动生成时间戳
* @param pts 播放时间戳，单位毫秒；等于0时内部会赋值为dts * @param pts 播放时间戳，单位毫秒；等于0时内部会赋值为dts
*/ */
bool inputH264(const char *data, int len, uint32_t dts, uint32_t pts = 0); bool inputH264(const char *data, int len, uint64_t dts, uint64_t pts = 0);
/** /**
* 输入265帧 * 输入265帧
@ -84,7 +84,7 @@ public:
* @param dts 解码时间戳，单位毫秒；等于0时内部会自动生成时间戳 * @param dts 解码时间戳，单位毫秒；等于0时内部会自动生成时间戳
* @param pts 播放时间戳，单位毫秒；等于0时内部会赋值为dts * @param pts 播放时间戳，单位毫秒；等于0时内部会赋值为dts
*/ */
bool inputH265(const char *data, int len, uint32_t dts, uint32_t pts = 0); bool inputH265(const char *data, int len, uint64_t dts, uint64_t pts = 0);
/** /**
* 输入aac帧 * 输入aac帧
@ -93,7 +93,7 @@ public:
* @param dts 时间戳，单位毫秒 * @param dts 时间戳，单位毫秒
* @param adts_header adts头 * @param adts_header adts头
*/ */
bool inputAAC(const char *data_without_adts, int len, uint32_t dts, const char *adts_header); bool inputAAC(const char *data_without_adts, int len, uint64_t dts, const char *adts_header);
/** /**
* 输入OPUS/G711音频帧 * 输入OPUS/G711音频帧
@ -101,7 +101,7 @@ public:
* @param len 帧数据长度 * @param len 帧数据长度
* @param dts 时间戳，单位毫秒 * @param dts 时间戳，单位毫秒
*/ */
bool inputAudio(const char *data, int len, uint32_t dts); bool inputAudio(const char *data, int len, uint64_t dts);
/** /**
* 输入yuv420p视频帧，内部会完成编码并调用inputH264方法 * 输入yuv420p视频帧，内部会完成编码并调用inputH264方法
@ -109,7 +109,7 @@ public:
* @param linesize yuv420p数据linesize * @param linesize yuv420p数据linesize
* @param cts 采集时间戳，单位毫秒 * @param cts 采集时间戳，单位毫秒
*/ */
bool inputYUV(char *yuv[3], int linesize[3], uint32_t cts); bool inputYUV(char *yuv[3], int linesize[3], uint64_t cts);
/** /**
* 输入pcm数据，内部会完成编码并调用inputAAC方法 * 输入pcm数据，内部会完成编码并调用inputAAC方法
@ -117,7 +117,7 @@ public:
* @param len pcm数据长度 * @param len pcm数据长度
* @param cts 采集时间戳，单位毫秒 * @param cts 采集时间戳，单位毫秒
*/ */
bool inputPCM(char *data, int len, uint32_t cts); bool inputPCM(char *data, int len, uint64_t cts);
private: private:
MediaOriginType getOriginType(MediaSource &sender) const override; MediaOriginType getOriginType(MediaSource &sender) const override;

4
src/Common/Stamp.cpp
View File

@ -137,7 +137,7 @@ int64_t Stamp::getRelativeStamp() const {
return _relative_stamp; return _relative_stamp;
} }
bool DtsGenerator::getDts(uint32_t pts, uint32_t &dts){ bool DtsGenerator::getDts(uint64_t pts, uint64_t &dts){
bool ret = false; bool ret = false;
if (pts == _last_pts) { if (pts == _last_pts) {
//pts未变，说明dts也不会变，返回上次dts //pts未变，说明dts也不会变，返回上次dts
@ -167,7 +167,7 @@ bool DtsGenerator::getDts(uint32_t pts, uint32_t &dts){
//该算法核心思想是对pts进行排序，排序好的pts就是dts。 //该算法核心思想是对pts进行排序，排序好的pts就是dts。
//排序有一定的滞后性，那么需要加上排序导致的时间戳偏移量 //排序有一定的滞后性，那么需要加上排序导致的时间戳偏移量
bool DtsGenerator::getDts_l(uint32_t pts, uint32_t &dts){ bool DtsGenerator::getDts_l(uint64_t pts, uint64_t &dts){
if(_sorter_max_size == 1){ if(_sorter_max_size == 1){
//没有B帧，dts就等于pts //没有B帧，dts就等于pts
dts = pts; dts = pts;

14
src/Common/Stamp.h
View File

@ -97,20 +97,20 @@ class DtsGenerator{
public: public:
DtsGenerator() = default; DtsGenerator() = default;
~DtsGenerator() = default; ~DtsGenerator() = default;
bool getDts(uint32_t pts, uint32_t &dts); bool getDts(uint64_t pts, uint64_t &dts);
private: private:
bool getDts_l(uint32_t pts, uint32_t &dts); bool getDts_l(uint64_t pts, uint64_t &dts);
private: private:
uint32_t _dts_pts_offset = 0; uint64_t _dts_pts_offset = 0;
uint32_t _last_dts = 0; uint64_t _last_dts = 0;
uint32_t _last_pts = 0; uint64_t _last_pts = 0;
uint32_t _last_max_pts = 0; uint64_t _last_max_pts = 0;
size_t _frames_since_last_max_pts = 0; size_t _frames_since_last_max_pts = 0;
size_t _sorter_max_size = 0; size_t _sorter_max_size = 0;
size_t _count_sorter_max_size = 0; size_t _count_sorter_max_size = 0;
std::set<uint32_t> _pts_sorter; std::set<uint64_t> _pts_sorter;
}; };
class NtpStamp { class NtpStamp {

4
src/Extension/AACRtp.cpp
View File

@ -53,8 +53,8 @@ bool AACRtpEncoder::inputFrame(const Frame::Ptr &frame) {
return len > 0; return len > 0;
} }
void AACRtpEncoder::makeAACRtp(const void *data, size_t len, bool mark, uint32_t uiStamp) { void AACRtpEncoder::makeAACRtp(const void *data, size_t len, bool mark, uint64_t stamp) {
RtpCodec::inputRtp(makeRtp(getTrackType(), data, len, mark, uiStamp), false); RtpCodec::inputRtp(makeRtp(getTrackType(), data, len, mark, stamp), false);
} }
///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////

4
src/Extension/AACRtp.h
View File

@ -43,7 +43,7 @@ private:
void flushData(); void flushData();
private: private:
uint32_t _last_dts = 0; uint64_t _last_dts = 0;
std::string _aac_cfg; std::string _aac_cfg;
FrameImp::Ptr _frame; FrameImp::Ptr _frame;
}; };
@ -77,7 +77,7 @@ public:
bool inputFrame(const Frame::Ptr &frame) override; bool inputFrame(const Frame::Ptr &frame) override;
private: private:
void makeAACRtp(const void *pData, size_t uiLen, bool bMark, uint32_t uiStamp); void makeAACRtp(const void *data, size_t len, bool mark, uint64_t stamp);
private: private:
unsigned char _section_buf[1600]; unsigned char _section_buf[1600];

36
src/Extension/Frame.h
View File

@ -112,12 +112,12 @@ public:
/** /**
* 返回解码时间戳，单位毫秒 * 返回解码时间戳，单位毫秒
*/ */
virtual uint32_t dts() const = 0; virtual uint64_t dts() const = 0;
/** /**
* 返回显示时间戳，单位毫秒 * 返回显示时间戳，单位毫秒
*/ */
virtual uint32_t pts() const { return dts(); } virtual uint64_t pts() const { return dts(); }
/** /**
* 前缀长度，譬如264前缀为0x00 00 00 01,那么前缀长度就是4 * 前缀长度，譬如264前缀为0x00 00 00 01,那么前缀长度就是4
@ -194,8 +194,8 @@ public:
char *data() const override { return (char *)_buffer.data(); } char *data() const override { return (char *)_buffer.data(); }
size_t size() const override { return _buffer.size(); } size_t size() const override { return _buffer.size(); }
uint32_t dts() const override { return _dts; } uint64_t dts() const override { return _dts; }
uint32_t pts() const override { return _pts ? _pts : _dts; } uint64_t pts() const override { return _pts ? _pts : _dts; }
size_t prefixSize() const override { return _prefix_size; } size_t prefixSize() const override { return _prefix_size; }
CodecId getCodecId() const override { return _codec_id; } CodecId getCodecId() const override { return _codec_id; }
bool keyFrame() const override { return false; } bool keyFrame() const override { return false; }
@ -203,8 +203,8 @@ public:
public: public:
CodecId _codec_id = CodecInvalid; CodecId _codec_id = CodecInvalid;
uint32_t _dts = 0; uint64_t _dts = 0;
uint32_t _pts = 0; uint64_t _pts = 0;
size_t _prefix_size = 0; size_t _prefix_size = 0;
toolkit::BufferLikeString _buffer; toolkit::BufferLikeString _buffer;
@ -248,7 +248,7 @@ class FrameTSInternal : public Parent {
public: public:
typedef std::shared_ptr<FrameTSInternal> Ptr; typedef std::shared_ptr<FrameTSInternal> Ptr;
FrameTSInternal( FrameTSInternal(
const Frame::Ptr &parent_frame, char *ptr, size_t size, size_t prefix_size, uint32_t dts, uint32_t pts) const Frame::Ptr &parent_frame, char *ptr, size_t size, size_t prefix_size, uint64_t dts, uint64_t pts)
: Parent(ptr, size, dts, pts, prefix_size) { : Parent(ptr, size, dts, pts, prefix_size) {
_parent_frame = parent_frame; _parent_frame = parent_frame;
} }
@ -361,13 +361,13 @@ public:
typedef std::shared_ptr<FrameFromPtr> Ptr; typedef std::shared_ptr<FrameFromPtr> Ptr;
FrameFromPtr( FrameFromPtr(
CodecId codec_id, char *ptr, size_t size, uint32_t dts, uint32_t pts = 0, size_t prefix_size = 0, CodecId codec_id, char *ptr, size_t size, uint64_t dts, uint64_t pts = 0, size_t prefix_size = 0,
bool is_key = false) bool is_key = false)
: FrameFromPtr(ptr, size, dts, pts, prefix_size, is_key) { : FrameFromPtr(ptr, size, dts, pts, prefix_size, is_key) {
_codec_id = codec_id; _codec_id = codec_id;
} }
FrameFromPtr(char *ptr, size_t size, uint32_t dts, uint32_t pts = 0, size_t prefix_size = 0, bool is_key = false) { FrameFromPtr(char *ptr, size_t size, uint64_t dts, uint64_t pts = 0, size_t prefix_size = 0, bool is_key = false) {
_ptr = ptr; _ptr = ptr;
_size = size; _size = size;
_dts = dts; _dts = dts;
@ -378,8 +378,8 @@ public:
char *data() const override { return _ptr; } char *data() const override { return _ptr; }
size_t size() const override { return _size; } size_t size() const override { return _size; }
uint32_t dts() const override { return _dts; } uint64_t dts() const override { return _dts; }
uint32_t pts() const override { return _pts ? _pts : dts(); } uint64_t pts() const override { return _pts ? _pts : dts(); }
size_t prefixSize() const override { return _prefix_size; } size_t prefixSize() const override { return _prefix_size; }
bool cacheAble() const override { return false; } bool cacheAble() const override { return false; }
bool keyFrame() const override { return _is_key; } bool keyFrame() const override { return _is_key; }
@ -399,8 +399,8 @@ protected:
protected: protected:
bool _is_key; bool _is_key;
char *_ptr; char *_ptr;
uint32_t _dts; uint64_t _dts;
uint32_t _pts = 0; uint64_t _pts = 0;
size_t _size; size_t _size;
size_t _prefix_size; size_t _prefix_size;
CodecId _codec_id = CodecInvalid; CodecId _codec_id = CodecInvalid;
@ -464,8 +464,8 @@ public:
} }
~FrameStamp() override {} ~FrameStamp() override {}
uint32_t dts() const override { return (uint32_t)_dts; } uint64_t dts() const override { return (uint64_t)_dts; }
uint32_t pts() const override { return (uint32_t)_pts; } uint64_t pts() const override { return (uint64_t)_pts; }
size_t prefixSize() const override { return _frame->prefixSize(); } size_t prefixSize() const override { return _frame->prefixSize(); }
bool keyFrame() const override { return _frame->keyFrame(); } bool keyFrame() const override { return _frame->keyFrame(); }
bool configFrame() const override { return _frame->configFrame(); } bool configFrame() const override { return _frame->configFrame(); }
@ -498,7 +498,7 @@ public:
* @param prefix 帧前缀长度 * @param prefix 帧前缀长度
* @param offset buffer有效数据偏移量 * @param offset buffer有效数据偏移量
*/ */
FrameWrapper(toolkit::Buffer::Ptr buf, uint32_t dts, uint32_t pts, size_t prefix, size_t offset) FrameWrapper(toolkit::Buffer::Ptr buf, uint64_t dts, uint64_t pts, size_t prefix, size_t offset)
: Parent(buf->data() + offset, buf->size() - offset, dts, pts, prefix) { : Parent(buf->data() + offset, buf->size() - offset, dts, pts, prefix) {
_buf = std::move(buf); _buf = std::move(buf);
} }
@ -512,7 +512,7 @@ public:
* @param offset buffer有效数据偏移量 * @param offset buffer有效数据偏移量
* @param codec 帧类型 * @param codec 帧类型
*/ */
FrameWrapper(toolkit::Buffer::Ptr buf, uint32_t dts, uint32_t pts, size_t prefix, size_t offset, CodecId codec) FrameWrapper(toolkit::Buffer::Ptr buf, uint64_t dts, uint64_t pts, size_t prefix, size_t offset, CodecId codec)
: Parent(codec, buf->data() + offset, buf->size() - offset, dts, pts, prefix) { : Parent(codec, buf->data() + offset, buf->size() - offset, dts, pts, prefix) {
_buf = std::move(buf); _buf = std::move(buf);
} }
@ -531,7 +531,7 @@ private:
*/ */
class FrameMerger { class FrameMerger {
public: public:
using onOutput = std::function<void(uint32_t dts, uint32_t pts, const toolkit::Buffer::Ptr &buffer, bool have_key_frame)>; using onOutput = std::function<void(uint64_t dts, uint64_t pts, const toolkit::Buffer::Ptr &buffer, bool have_key_frame)>;
using Ptr = std::shared_ptr<FrameMerger>; using Ptr = std::shared_ptr<FrameMerger>;
enum { enum {
none = 0, none = 0,

2
src/Extension/H264Rtmp.cpp
View File

@ -152,7 +152,7 @@ bool H264RtmpEncoder::inputFrame(const Frame::Ptr &frame) {
_rtmp_packet->buffer.resize(5); _rtmp_packet->buffer.resize(5);
} }
return _merger.inputFrame(frame, [this](uint32_t dts, uint32_t pts, const Buffer::Ptr &, bool have_key_frame) { return _merger.inputFrame(frame, [this](uint64_t dts, uint64_t pts, const Buffer::Ptr &, bool have_key_frame) {
//flags //flags
_rtmp_packet->buffer[0] = FLV_CODEC_H264 | ((have_key_frame ? FLV_KEY_FRAME : FLV_INTER_FRAME) << 4); _rtmp_packet->buffer[0] = FLV_CODEC_H264 | ((have_key_frame ? FLV_KEY_FRAME : FLV_INTER_FRAME) << 4);
//not config //not config

14
src/Extension/H264Rtp.cpp
View File

@ -73,7 +73,7 @@ Table 1. Summary of NAL unit types and their payload structures
30-31 undefined - 30-31 undefined -
*/ */
bool H264RtpDecoder::singleFrame(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint32_t stamp){ bool H264RtpDecoder::singleFrame(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint64_t stamp){
_frame->_buffer.assign("\x00\x00\x00\x01", 4); _frame->_buffer.assign("\x00\x00\x00\x01", 4);
_frame->_buffer.append((char *) ptr, size); _frame->_buffer.append((char *) ptr, size);
_frame->_pts = stamp; _frame->_pts = stamp;
@ -82,7 +82,7 @@ bool H264RtpDecoder::singleFrame(const RtpPacket::Ptr &rtp, const uint8_t *ptr,
return key; return key;
} }
bool H264RtpDecoder::unpackStapA(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint32_t stamp) { bool H264RtpDecoder::unpackStapA(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint64_t stamp) {
//STAP-A 单一时间的组合包 //STAP-A 单一时间的组合包
auto have_key_frame = false; auto have_key_frame = false;
auto end = ptr + size; auto end = ptr + size;
@ -102,7 +102,7 @@ bool H264RtpDecoder::unpackStapA(const RtpPacket::Ptr &rtp, const uint8_t *ptr,
return have_key_frame; return have_key_frame;
} }
bool H264RtpDecoder::mergeFu(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint32_t stamp, uint16_t seq){ bool H264RtpDecoder::mergeFu(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint64_t stamp, uint16_t seq){
auto nal_suffix = *ptr & (~0x1F); auto nal_suffix = *ptr & (~0x1F);
FuFlags *fu = (FuFlags *) (ptr + 1); FuFlags *fu = (FuFlags *) (ptr + 1);
if (fu->start_bit) { if (fu->start_bit) {
@ -197,7 +197,7 @@ H264RtpEncoder::H264RtpEncoder(uint32_t ssrc, uint32_t mtu, uint32_t sample_rate
: RtpInfo(ssrc, mtu, sample_rate, pt, interleaved) { : RtpInfo(ssrc, mtu, sample_rate, pt, interleaved) {
} }
void H264RtpEncoder::insertConfigFrame(uint32_t pts){ void H264RtpEncoder::insertConfigFrame(uint64_t pts){
if (!_sps || !_pps) { if (!_sps || !_pps) {
return; return;
} }
@ -206,7 +206,7 @@ void H264RtpEncoder::insertConfigFrame(uint32_t pts){
packRtp(_pps->data() + _pps->prefixSize(), _pps->size() - _pps->prefixSize(), pts, false, false); packRtp(_pps->data() + _pps->prefixSize(), _pps->size() - _pps->prefixSize(), pts, false, false);
} }
void H264RtpEncoder::packRtp(const char *ptr, size_t len, uint32_t pts, bool is_mark, bool gop_pos){ void H264RtpEncoder::packRtp(const char *ptr, size_t len, uint64_t pts, bool is_mark, bool gop_pos){
if (len + 3 <= getMaxSize()) { if (len + 3 <= getMaxSize()) {
//STAP-A模式打包小于MTU //STAP-A模式打包小于MTU
packRtpStapA(ptr, len, pts, is_mark, gop_pos); packRtpStapA(ptr, len, pts, is_mark, gop_pos);
@ -216,7 +216,7 @@ void H264RtpEncoder::packRtp(const char *ptr, size_t len, uint32_t pts, bool is_
} }
} }
void H264RtpEncoder::packRtpFu(const char *ptr, size_t len, uint32_t pts, bool is_mark, bool gop_pos){ void H264RtpEncoder::packRtpFu(const char *ptr, size_t len, uint64_t pts, bool is_mark, bool gop_pos){
auto packet_size = getMaxSize() - 2; auto packet_size = getMaxSize() - 2;
if (len <= packet_size + 1) { if (len <= packet_size + 1) {
//小于FU-A打包最小字节长度要求，采用STAP-A模式 //小于FU-A打包最小字节长度要求，采用STAP-A模式
@ -256,7 +256,7 @@ void H264RtpEncoder::packRtpFu(const char *ptr, size_t len, uint32_t pts, bool i
} }
} }
void H264RtpEncoder::packRtpStapA(const char *ptr, size_t len, uint32_t pts, bool is_mark, bool gop_pos){ void H264RtpEncoder::packRtpStapA(const char *ptr, size_t len, uint64_t pts, bool is_mark, bool gop_pos){
//如果帧长度不超过mtu,为了兼容性 webrtc，采用STAP-A模式打包 //如果帧长度不超过mtu,为了兼容性 webrtc，采用STAP-A模式打包
auto rtp = makeRtp(getTrackType(), nullptr, len + 3, is_mark, pts); auto rtp = makeRtp(getTrackType(), nullptr, len + 3, is_mark, pts);
uint8_t *payload = rtp->getPayload(); uint8_t *payload = rtp->getPayload();

14
src/Extension/H264Rtp.h
View File

@ -42,9 +42,9 @@ public:
} }
private: private:
bool singleFrame(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint32_t stamp); bool singleFrame(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint64_t stamp);
bool unpackStapA(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint32_t stamp); bool unpackStapA(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint64_t stamp);
bool mergeFu(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint32_t stamp, uint16_t seq); bool mergeFu(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint64_t stamp, uint16_t seq);
bool decodeRtp(const RtpPacket::Ptr &rtp); bool decodeRtp(const RtpPacket::Ptr &rtp);
H264Frame::Ptr obtainFrame(); H264Frame::Ptr obtainFrame();
@ -86,11 +86,11 @@ public:
bool inputFrame(const Frame::Ptr &frame) override; bool inputFrame(const Frame::Ptr &frame) override;
private: private:
void insertConfigFrame(uint32_t pts); void insertConfigFrame(uint64_t pts);
bool inputFrame_l(const Frame::Ptr &frame, bool is_mark); bool inputFrame_l(const Frame::Ptr &frame, bool is_mark);
void packRtp(const char *data, size_t len, uint32_t pts, bool is_mark, bool gop_pos); void packRtp(const char *data, size_t len, uint64_t pts, bool is_mark, bool gop_pos);
void packRtpFu(const char *data, size_t len, uint32_t pts, bool is_mark, bool gop_pos); void packRtpFu(const char *data, size_t len, uint64_t pts, bool is_mark, bool gop_pos);
void packRtpStapA(const char *data, size_t len, uint32_t pts, bool is_mark, bool gop_pos); void packRtpStapA(const char *data, size_t len, uint64_t pts, bool is_mark, bool gop_pos);
private: private:
Frame::Ptr _sps; Frame::Ptr _sps;

2
src/Extension/H265Rtmp.cpp
View File

@ -172,7 +172,7 @@ bool H265RtmpEncoder::inputFrame(const Frame::Ptr &frame) {
_rtmp_packet->buffer.resize(5); _rtmp_packet->buffer.resize(5);
} }
return _merger.inputFrame(frame, [this](uint32_t dts, uint32_t pts, const Buffer::Ptr &, bool have_key_frame) { return _merger.inputFrame(frame, [this](uint64_t dts, uint64_t pts, const Buffer::Ptr &, bool have_key_frame) {
//flags //flags
_rtmp_packet->buffer[0] = FLV_CODEC_H265 | ((have_key_frame ? FLV_KEY_FRAME : FLV_INTER_FRAME) << 4); _rtmp_packet->buffer[0] = FLV_CODEC_H265 | ((have_key_frame ? FLV_KEY_FRAME : FLV_INTER_FRAME) << 4);
//not config //not config

6
src/Extension/H265Rtp.cpp
View File

@ -69,7 +69,7 @@ H265Frame::Ptr H265RtpDecoder::obtainFrame() {
| : ...OPTIONAL RTP padding | | : ...OPTIONAL RTP padding |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/ */
bool H265RtpDecoder::unpackAp(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint32_t stamp){ bool H265RtpDecoder::unpackAp(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint64_t stamp){
bool have_key_frame = false; bool have_key_frame = false;
//忽略PayloadHdr //忽略PayloadHdr
CHECK_SIZE(size, 2, have_key_frame); CHECK_SIZE(size, 2, have_key_frame);
@ -119,7 +119,7 @@ bool H265RtpDecoder::unpackAp(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssi
+---------------+ +---------------+
*/ */
bool H265RtpDecoder::mergeFu(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint32_t stamp, uint16_t seq){ bool H265RtpDecoder::mergeFu(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint64_t stamp, uint16_t seq){
CHECK_SIZE(size, 4, false); CHECK_SIZE(size, 4, false);
auto s_bit = ptr[2] >> 7; auto s_bit = ptr[2] >> 7;
auto e_bit = (ptr[2] >> 6) & 0x01; auto e_bit = (ptr[2] >> 6) & 0x01;
@ -216,7 +216,7 @@ bool H265RtpDecoder::decodeRtp(const RtpPacket::Ptr &rtp) {
} }
} }
bool H265RtpDecoder::singleFrame(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint32_t stamp){ bool H265RtpDecoder::singleFrame(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint64_t stamp){
_frame->_buffer.assign("\x00\x00\x00\x01", 4); _frame->_buffer.assign("\x00\x00\x00\x01", 4);
_frame->_buffer.append((char *) ptr, size); _frame->_buffer.append((char *) ptr, size);
_frame->_pts = stamp; _frame->_pts = stamp;

6
src/Extension/H265Rtp.h
View File

@ -42,9 +42,9 @@ public:
} }
private: private:
bool unpackAp(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint32_t stamp); bool unpackAp(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint64_t stamp);
bool mergeFu(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint32_t stamp, uint16_t seq); bool mergeFu(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint64_t stamp, uint16_t seq);
bool singleFrame(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint32_t stamp); bool singleFrame(const RtpPacket::Ptr &rtp, const uint8_t *ptr, ssize_t size, uint64_t stamp);
bool decodeRtp(const RtpPacket::Ptr &rtp); bool decodeRtp(const RtpPacket::Ptr &rtp);
H265Frame::Ptr obtainFrame(); H265Frame::Ptr obtainFrame();

2
src/FMP4/FMP4MediaSourceMuxer.h
View File

@ -72,7 +72,7 @@ public:
} }
protected: protected:
void onSegmentData(std::string string, uint32_t stamp, bool key_frame) override { void onSegmentData(std::string string, uint64_t stamp, bool key_frame) override {
if (string.empty()) { if (string.empty()) {
return; return;
} }

4
src/Record/HlsMaker.cpp
View File

@ -75,7 +75,7 @@ void HlsMaker::makeIndexFile(bool eof) {
} }
void HlsMaker::inputData(void *data, size_t len, uint32_t timestamp, bool is_idr_fast_packet) { void HlsMaker::inputData(void *data, size_t len, uint64_t timestamp, bool is_idr_fast_packet) {
if (data && len) { if (data && len) {
if (timestamp < _last_timestamp) { if (timestamp < _last_timestamp) {
//时间戳回退了，切片时长重新计时 //时间戳回退了，切片时长重新计时
@ -117,7 +117,7 @@ void HlsMaker::delOldSegment() {
} }
} }
void HlsMaker::addNewSegment(uint32_t stamp) { void HlsMaker::addNewSegment(uint64_t stamp) {
if (!_last_file_name.empty() && stamp - _last_seg_timestamp < _seg_duration * 1000) { if (!_last_file_name.empty() && stamp - _last_seg_timestamp < _seg_duration * 1000) {
//存在上个切片，并且未到分片时间 //存在上个切片，并且未到分片时间
return; return;

10
src/Record/HlsMaker.h
View File

@ -38,7 +38,7 @@ public:
* @param timestamp 毫秒时间戳 * @param timestamp 毫秒时间戳
* @param is_idr_fast_packet 是否为关键帧第一个包 * @param is_idr_fast_packet 是否为关键帧第一个包
*/ */
void inputData(void *data, size_t len, uint32_t timestamp, bool is_idr_fast_packet); void inputData(void *data, size_t len, uint64_t timestamp, bool is_idr_fast_packet);
/** /**
* 是否为直播 * 是否为直播
@ -85,7 +85,7 @@ protected:
* 上一个 ts 切片写入完成, 可在这里进行通知处理 * 上一个 ts 切片写入完成, 可在这里进行通知处理
* @param duration_ms 上一个 ts 切片的时长, 单位为毫秒 * @param duration_ms 上一个 ts 切片的时长, 单位为毫秒
*/ */
virtual void onFlushLastSegment(uint32_t duration_ms) {}; virtual void onFlushLastSegment(uint64_t duration_ms) {};
/** /**
* 关闭上个ts切片并且写入m3u8索引 * 关闭上个ts切片并且写入m3u8索引
@ -109,14 +109,14 @@ private:
* 添加新的ts切片 * 添加新的ts切片
* @param timestamp * @param timestamp
*/ */
void addNewSegment(uint32_t timestamp); void addNewSegment(uint64_t timestamp);
private: private:
float _seg_duration = 0; float _seg_duration = 0;
uint32_t _seg_number = 0; uint32_t _seg_number = 0;
bool _seg_keep = false; bool _seg_keep = false;
uint32_t _last_timestamp = 0; uint64_t _last_timestamp = 0;
uint32_t _last_seg_timestamp = 0; uint64_t _last_seg_timestamp = 0;
uint64_t _file_index = 0; uint64_t _file_index = 0;
std::string _last_file_name; std::string _last_file_name;
std::deque<std::tuple<int,std::string> > _seg_dur_list; std::deque<std::tuple<int,std::string> > _seg_dur_list;

2
src/Record/HlsMakerImp.cpp
View File

@ -130,7 +130,7 @@ void HlsMakerImp::onWriteHls(const std::string &data) {
//DebugL << "\r\n" << string(data,len); //DebugL << "\r\n" << string(data,len);
} }
void HlsMakerImp::onFlushLastSegment(uint32_t duration_ms) { void HlsMakerImp::onFlushLastSegment(uint64_t duration_ms) {
//关闭并flush文件到磁盘 //关闭并flush文件到磁盘
_file = nullptr; _file = nullptr;

2
src/Record/HlsMakerImp.h
View File

@ -54,7 +54,7 @@ protected:
void onDelSegment(uint64_t index) override; void onDelSegment(uint64_t index) override;
void onWriteSegment(const char *data, size_t len) override; void onWriteSegment(const char *data, size_t len) override;
void onWriteHls(const std::string &data) override; void onWriteHls(const std::string &data) override;
void onFlushLastSegment(uint32_t duration_ms) override; void onFlushLastSegment(uint64_t duration_ms) override;
private: private:
std::shared_ptr<FILE> makeFile(const std::string &file,bool setbuf = false); std::shared_ptr<FILE> makeFile(const std::string &file,bool setbuf = false);

2
src/Record/HlsRecorder.h
View File

@ -75,7 +75,7 @@ public:
} }
private: private:
void onWrite(std::shared_ptr<toolkit::Buffer> buffer, uint32_t timestamp, bool key_pos) override { void onWrite(std::shared_ptr<toolkit::Buffer> buffer, uint64_t timestamp, bool key_pos) override {
if (!buffer) { if (!buffer) {
_hls->inputData(nullptr, 0, timestamp, key_pos); _hls->inputData(nullptr, 0, timestamp, key_pos);
} else { } else {

8
src/Record/MP4Demuxer.cpp
View File

@ -233,10 +233,10 @@ Frame::Ptr MP4Demuxer::makeFrame(uint32_t track_id, const Buffer::Ptr &buf, int6
offset += (frame_len + 4); offset += (frame_len + 4);
} }
if (codec == CodecH264) { if (codec == CodecH264) {
ret = std::make_shared<FrameWrapper<H264FrameNoCacheAble> >(buf, (uint32_t)dts, (uint32_t)pts, 4, DATA_OFFSET); ret = std::make_shared<FrameWrapper<H264FrameNoCacheAble> >(buf, (uint64_t)dts, (uint64_t)pts, 4, DATA_OFFSET);
break; break;
} }
ret = std::make_shared<FrameWrapper<H265FrameNoCacheAble> >(buf, (uint32_t)dts, (uint32_t)pts, 4, DATA_OFFSET); ret = std::make_shared<FrameWrapper<H265FrameNoCacheAble> >(buf, (uint64_t)dts, (uint64_t)pts, 4, DATA_OFFSET);
break; break;
} }
@ -245,14 +245,14 @@ Frame::Ptr MP4Demuxer::makeFrame(uint32_t track_id, const Buffer::Ptr &buf, int6
assert(track); assert(track);
//加上adts头 //加上adts头
dumpAacConfig(track->getAacCfg(), buf->size() - DATA_OFFSET, (uint8_t *) buf->data() + (DATA_OFFSET - ADTS_HEADER_LEN), ADTS_HEADER_LEN); dumpAacConfig(track->getAacCfg(), buf->size() - DATA_OFFSET, (uint8_t *) buf->data() + (DATA_OFFSET - ADTS_HEADER_LEN), ADTS_HEADER_LEN);
ret = std::make_shared<FrameWrapper<FrameFromPtr> >(buf, (uint32_t)dts, (uint32_t)pts, ADTS_HEADER_LEN, DATA_OFFSET - ADTS_HEADER_LEN, codec); ret = std::make_shared<FrameWrapper<FrameFromPtr> >(buf, (uint64_t)dts, (uint64_t)pts, ADTS_HEADER_LEN, DATA_OFFSET - ADTS_HEADER_LEN, codec);
break; break;
} }
case CodecOpus: case CodecOpus:
case CodecG711A: case CodecG711A:
case CodecG711U: { case CodecG711U: {
ret = std::make_shared<FrameWrapper<FrameFromPtr> >(buf, (uint32_t)dts, (uint32_t)pts, 0, DATA_OFFSET, codec); ret = std::make_shared<FrameWrapper<FrameFromPtr> >(buf, (uint64_t)dts, (uint64_t)pts, 0, DATA_OFFSET, codec);
break; break;
} }

2
src/Record/MP4Muxer.cpp
View File

@ -93,7 +93,7 @@ bool MP4MuxerInterface::inputFrame(const Frame::Ptr &frame) {
case CodecH264: case CodecH264:
case CodecH265: { case CodecH265: {
//这里的代码逻辑是让SPS、PPS、IDR这些时间戳相同的帧打包到一起当做一个帧处理， //这里的代码逻辑是让SPS、PPS、IDR这些时间戳相同的帧打包到一起当做一个帧处理，
_frame_merger.inputFrame(frame, [&](uint32_t dts, uint32_t pts, const Buffer::Ptr &buffer, bool have_idr) { _frame_merger.inputFrame(frame, [&](uint64_t dts, uint64_t pts, const Buffer::Ptr &buffer, bool have_idr) {
track_info.stamp.revise(dts, pts, dts_out, pts_out); track_info.stamp.revise(dts, pts, dts_out, pts_out);
mp4_writer_write(_mov_writter.get(), mp4_writer_write(_mov_writter.get(),
track_info.track_id, track_info.track_id,

2
src/Record/MP4Muxer.h
View File

@ -134,7 +134,7 @@ protected:
* @param stamp 切片末尾时间戳 * @param stamp 切片末尾时间戳
* @param key_frame 是否有关键帧 * @param key_frame 是否有关键帧
*/ */
virtual void onSegmentData(std::string string, uint32_t stamp, bool key_frame) = 0; virtual void onSegmentData(std::string string, uint64_t stamp, bool key_frame) = 0;
protected: protected:
MP4FileIO::Writer createWriter() override; MP4FileIO::Writer createWriter() override;

6
src/Record/MPEG.cpp
View File

@ -63,10 +63,10 @@ bool MpegMuxer::inputFrame(const Frame::Ptr &frame) {
case CodecH264: case CodecH264:
case CodecH265: { case CodecH265: {
//这里的代码逻辑是让SPS、PPS、IDR这些时间戳相同的帧打包到一起当做一个帧处理， //这里的代码逻辑是让SPS、PPS、IDR这些时间戳相同的帧打包到一起当做一个帧处理，
return _frame_merger.inputFrame(frame,[&](uint32_t dts, uint32_t pts, const Buffer::Ptr &buffer, bool have_idr) { return _frame_merger.inputFrame(frame,[&](uint64_t dts, uint64_t pts, const Buffer::Ptr &buffer, bool have_idr) {
_key_pos = have_idr; _key_pos = have_idr;
//取视频时间戳为TS的时间戳 //取视频时间戳为TS的时间戳
_timestamp = (uint32_t) dts; _timestamp = dts;
_max_cache_size = 512 + 1.2 * buffer->size(); _max_cache_size = 512 + 1.2 * buffer->size();
mpeg_muxer_input((::mpeg_muxer_t *)_context, track_id, have_idr ? 0x0001 : 0, pts * 90LL,dts * 90LL, buffer->data(), buffer->size()); mpeg_muxer_input((::mpeg_muxer_t *)_context, track_id, have_idr ? 0x0001 : 0, pts * 90LL,dts * 90LL, buffer->data(), buffer->size());
flushCache(); flushCache();
@ -83,7 +83,7 @@ bool MpegMuxer::inputFrame(const Frame::Ptr &frame) {
default: { default: {
if (!_have_video) { if (!_have_video) {
//没有视频时，才以音频时间戳为TS的时间戳 //没有视频时，才以音频时间戳为TS的时间戳
_timestamp = (uint32_t) frame->dts(); _timestamp = frame->dts();
} }
_max_cache_size = 512 + 1.2 * frame->size(); _max_cache_size = 512 + 1.2 * frame->size();
mpeg_muxer_input((::mpeg_muxer_t *)_context, track_id, frame->keyFrame() ? 0x0001 : 0, frame->pts() * 90LL, frame->dts() * 90LL, frame->data(), frame->size()); mpeg_muxer_input((::mpeg_muxer_t *)_context, track_id, frame->keyFrame() ? 0x0001 : 0, frame->pts() * 90LL, frame->dts() * 90LL, frame->data(), frame->size());

6
src/Record/MPEG.h
View File

@ -52,7 +52,7 @@ protected:
* @param timestamp 时间戳，单位毫秒 * @param timestamp 时间戳，单位毫秒
* @param key_pos 是否为关键帧的第一个ts/ps包，用于确保ts切片第一帧为关键帧 * @param key_pos 是否为关键帧的第一个ts/ps包，用于确保ts切片第一帧为关键帧
*/ */
virtual void onWrite(std::shared_ptr<toolkit::Buffer> buffer, uint32_t timestamp, bool key_pos) = 0; virtual void onWrite(std::shared_ptr<toolkit::Buffer> buffer, uint64_t timestamp, bool key_pos) = 0;
private: private:
void createContext(); void createContext();
@ -65,7 +65,7 @@ private:
bool _have_video = false; bool _have_video = false;
bool _key_pos = false; bool _key_pos = false;
uint32_t _max_cache_size = 0; uint32_t _max_cache_size = 0;
uint32_t _timestamp = 0; uint64_t _timestamp = 0;
struct mpeg_muxer_t *_context = nullptr; struct mpeg_muxer_t *_context = nullptr;
std::unordered_map<int, int/*track_id*/> _codec_to_trackid; std::unordered_map<int, int/*track_id*/> _codec_to_trackid;
FrameMerger _frame_merger{FrameMerger::h264_prefix}; FrameMerger _frame_merger{FrameMerger::h264_prefix};
@ -90,7 +90,7 @@ public:
bool inputFrame(const Frame::Ptr &frame) override { return false; } bool inputFrame(const Frame::Ptr &frame) override { return false; }
protected: protected:
virtual void onWrite(std::shared_ptr<toolkit::Buffer> buffer, uint32_t timestamp, bool key_pos) = 0; virtual void onWrite(std::shared_ptr<toolkit::Buffer> buffer, uint64_t timestamp, bool key_pos) = 0;
}; };
}//namespace mediakit }//namespace mediakit

14
src/Rtp/Decoder.cpp
View File

@ -165,8 +165,8 @@ void DecoderImp::onDecode(int stream,int codecid,int flags,int64_t pts,int64_t d
if (!_tracks[TrackVideo]) { if (!_tracks[TrackVideo]) {
onTrack(std::make_shared<H264Track>()); onTrack(std::make_shared<H264Track>());
} }
auto frame = std::make_shared<H264FrameNoCacheAble>((char *) data, bytes, (uint32_t)dts, (uint32_t)pts, prefixSize((char *) data, bytes)); auto frame = std::make_shared<H264FrameNoCacheAble>((char *) data, bytes, (uint64_t)dts, (uint64_t)pts, prefixSize((char *) data, bytes));
_merger.inputFrame(frame,[this](uint32_t dts, uint32_t pts, const Buffer::Ptr &buffer, bool) { _merger.inputFrame(frame,[this](uint64_t dts, uint64_t pts, const Buffer::Ptr &buffer, bool) {
onFrame(std::make_shared<FrameWrapper<H264FrameNoCacheAble> >(buffer, dts, pts, prefixSize(buffer->data(), buffer->size()), 0)); onFrame(std::make_shared<FrameWrapper<H264FrameNoCacheAble> >(buffer, dts, pts, prefixSize(buffer->data(), buffer->size()), 0));
}); });
break; break;
@ -176,8 +176,8 @@ void DecoderImp::onDecode(int stream,int codecid,int flags,int64_t pts,int64_t d
if (!_tracks[TrackVideo]) { if (!_tracks[TrackVideo]) {
onTrack(std::make_shared<H265Track>()); onTrack(std::make_shared<H265Track>());
} }
auto frame = std::make_shared<H265FrameNoCacheAble>((char *) data, bytes, (uint32_t)dts, (uint32_t)pts, prefixSize((char *) data, bytes)); auto frame = std::make_shared<H265FrameNoCacheAble>((char *) data, bytes, (uint64_t)dts, (uint64_t)pts, prefixSize((char *) data, bytes));
_merger.inputFrame(frame,[this](uint32_t dts, uint32_t pts, const Buffer::Ptr &buffer, bool) { _merger.inputFrame(frame,[this](uint64_t dts, uint64_t pts, const Buffer::Ptr &buffer, bool) {
onFrame(std::make_shared<FrameWrapper<H265FrameNoCacheAble> >(buffer, dts, pts, prefixSize(buffer->data(), buffer->size()), 0)); onFrame(std::make_shared<FrameWrapper<H265FrameNoCacheAble> >(buffer, dts, pts, prefixSize(buffer->data(), buffer->size()), 0));
}); });
break; break;
@ -193,7 +193,7 @@ void DecoderImp::onDecode(int stream,int codecid,int flags,int64_t pts,int64_t d
if (!_tracks[TrackAudio]) { if (!_tracks[TrackAudio]) {
onTrack(std::make_shared<AACTrack>()); onTrack(std::make_shared<AACTrack>());
} }
onFrame(std::make_shared<FrameFromPtr>(CodecAAC, (char *) data, bytes, (uint32_t)dts, 0, ADTS_HEADER_LEN)); onFrame(std::make_shared<FrameFromPtr>(CodecAAC, (char *) data, bytes, (uint64_t)dts, 0, ADTS_HEADER_LEN));
break; break;
} }
@ -204,7 +204,7 @@ void DecoderImp::onDecode(int stream,int codecid,int flags,int64_t pts,int64_t d
//G711传统只支持 8000/1/16的规格，FFmpeg貌似做了扩展，但是这里不管它了 //G711传统只支持 8000/1/16的规格，FFmpeg貌似做了扩展，但是这里不管它了
onTrack(std::make_shared<G711Track>(codec, 8000, 1, 16)); onTrack(std::make_shared<G711Track>(codec, 8000, 1, 16));
} }
onFrame(std::make_shared<FrameFromPtr>(codec, (char *) data, bytes, (uint32_t)dts)); onFrame(std::make_shared<FrameFromPtr>(codec, (char *) data, bytes, (uint64_t)dts));
break; break;
} }
@ -212,7 +212,7 @@ void DecoderImp::onDecode(int stream,int codecid,int flags,int64_t pts,int64_t d
if (!_tracks[TrackAudio]) { if (!_tracks[TrackAudio]) {
onTrack(std::make_shared<OpusTrack>()); onTrack(std::make_shared<OpusTrack>());
} }
onFrame(std::make_shared<FrameFromPtr>(CodecOpus, (char *) data, bytes, (uint32_t)dts)); onFrame(std::make_shared<FrameFromPtr>(CodecOpus, (char *) data, bytes, (uint64_t)dts));
break; break;
} }

2
src/Rtp/PSEncoder.cpp
View File

@ -32,7 +32,7 @@ PSEncoderImp::~PSEncoderImp() {
InfoL << this << " " << printSSRC(_rtp_encoder->getSsrc()); InfoL << this << " " << printSSRC(_rtp_encoder->getSsrc());
} }
void PSEncoderImp::onWrite(std::shared_ptr<Buffer> buffer, uint32_t stamp, bool key_pos) { void PSEncoderImp::onWrite(std::shared_ptr<Buffer> buffer, uint64_t stamp, bool key_pos) {
if (!buffer) { if (!buffer) {
return; return;
} }

2
src/Rtp/PSEncoder.h
View File

@ -30,7 +30,7 @@ protected:
virtual void onRTP(toolkit::Buffer::Ptr rtp,bool is_key = false) = 0; virtual void onRTP(toolkit::Buffer::Ptr rtp,bool is_key = false) = 0;
protected: protected:
void onWrite(std::shared_ptr<toolkit::Buffer> buffer, uint32_t stamp, bool key_pos) override; void onWrite(std::shared_ptr<toolkit::Buffer> buffer, uint64_t stamp, bool key_pos) override;
private: private:
std::shared_ptr<CommonRtpEncoder> _rtp_encoder; std::shared_ptr<CommonRtpEncoder> _rtp_encoder;

2
src/Rtp/RtpProcess.cpp
View File

@ -64,7 +64,7 @@ RtpProcess::~RtpProcess() {
} }
} }
bool RtpProcess::inputRtp(bool is_udp, const Socket::Ptr &sock, const char *data, size_t len, const struct sockaddr *addr, uint32_t *dts_out) { bool RtpProcess::inputRtp(bool is_udp, const Socket::Ptr &sock, const char *data, size_t len, const struct sockaddr *addr, uint64_t *dts_out) {
auto is_busy = _busy_flag.test_and_set(); auto is_busy = _busy_flag.test_and_set();
if (is_busy) { if (is_busy) {
//其他线程正在执行本函数 //其他线程正在执行本函数

4
src/Rtp/RtpProcess.h
View File

@ -35,7 +35,7 @@ public:
* @param dts_out 解析出最新的dts * @param dts_out 解析出最新的dts
* @return 是否解析成功 * @return 是否解析成功
*/ */
bool inputRtp(bool is_udp, const toolkit::Socket::Ptr &sock, const char *data, size_t len, const struct sockaddr *addr , uint32_t *dts_out = nullptr); bool inputRtp(bool is_udp, const toolkit::Socket::Ptr &sock, const char *data, size_t len, const struct sockaddr *addr , uint64_t *dts_out = nullptr);
/** /**
* 是否超时，用于超时移除对象 * 是否超时，用于超时移除对象
@ -86,7 +86,7 @@ private:
void doCachedFunc(); void doCachedFunc();
private: private:
uint32_t _dts = 0; uint64_t _dts = 0;
uint64_t _total_bytes = 0; uint64_t _total_bytes = 0;
std::unique_ptr<sockaddr_storage> _addr; std::unique_ptr<sockaddr_storage> _addr;
toolkit::Socket::Ptr _sock; toolkit::Socket::Ptr _sock;

4
src/Rtp/RtpSelector.cpp
View File

@ -25,8 +25,8 @@ void RtpSelector::clear(){
_map_rtp_process.clear(); _map_rtp_process.clear();
} }
bool RtpSelector::inputRtp(const Socket::Ptr &sock, const char *data, size_t data_len, bool RtpSelector::inputRtp(const Socket::Ptr &sock, const char *data, size_t data_len, const struct sockaddr *addr,
const struct sockaddr *addr,uint32_t *dts_out) { uint64_t *dts_out) {
uint32_t ssrc = 0; uint32_t ssrc = 0;
if (!getSSRC(data, data_len, ssrc)) { if (!getSSRC(data, data_len, ssrc)) {
WarnL << "get ssrc from rtp failed:" << data_len; WarnL << "get ssrc from rtp failed:" << data_len;

2
src/Rtp/RtpSelector.h
View File

@ -64,7 +64,7 @@ public:
* @return 是否成功 * @return 是否成功
*/ */
bool inputRtp(const toolkit::Socket::Ptr &sock, const char *data, size_t data_len, bool inputRtp(const toolkit::Socket::Ptr &sock, const char *data, size_t data_len,
const struct sockaddr *addr, uint32_t *dts_out = nullptr); const struct sockaddr *addr, uint64_t *dts_out = nullptr);
/** /**
* 获取一个rtp处理器 * 获取一个rtp处理器

2
src/Rtsp/RtpCodec.cpp
View File

@ -12,7 +12,7 @@
namespace mediakit{ namespace mediakit{
RtpPacket::Ptr RtpInfo::makeRtp(TrackType type, const void* data, size_t len, bool mark, uint32_t stamp) { RtpPacket::Ptr RtpInfo::makeRtp(TrackType type, const void* data, size_t len, bool mark, uint64_t stamp) {
uint16_t payload_len = (uint16_t) (len + RtpPacket::kRtpHeaderSize); uint16_t payload_len = (uint16_t) (len + RtpPacket::kRtpHeaderSize);
auto rtp = RtpPacket::create(); auto rtp = RtpPacket::create();
rtp->setCapacity(payload_len + RtpPacket::kRtpTcpHeaderSize); rtp->setCapacity(payload_len + RtpPacket::kRtpTcpHeaderSize);

2
src/Rtsp/RtpCodec.h
View File

@ -84,7 +84,7 @@ public:
return _ssrc; return _ssrc;
} }
RtpPacket::Ptr makeRtp(TrackType type,const void *data, size_t len, bool mark, uint32_t stamp); RtpPacket::Ptr makeRtp(TrackType type,const void *data, size_t len, bool mark, uint64_t stamp);
private: private:
uint8_t _pt; uint8_t _pt;

4
src/Rtsp/Rtsp.cpp
View File

@ -558,8 +558,8 @@ uint32_t RtpPacket::getStamp() const {
return ntohl(getHeader()->stamp); return ntohl(getHeader()->stamp);
} }
uint32_t RtpPacket::getStampMS(bool ntp) const { uint64_t RtpPacket::getStampMS(bool ntp) const {
return ntp ? ntp_stamp & 0xFFFFFFFF : getStamp() * uint64_t(1000) / sample_rate; return ntp ? ntp_stamp : getStamp() * uint64_t(1000) / sample_rate;
} }
uint32_t RtpPacket::getSSRC() const { uint32_t RtpPacket::getSSRC() const {

2
src/Rtsp/Rtsp.h
View File

@ -159,7 +159,7 @@ public:
uint16_t getSeq() const; uint16_t getSeq() const;
uint32_t getStamp() const; uint32_t getStamp() const;
//主机字节序的时间戳，已经转换为毫秒 //主机字节序的时间戳，已经转换为毫秒
uint32_t getStampMS(bool ntp = true) const; uint64_t getStampMS(bool ntp = true) const;
//主机字节序的ssrc //主机字节序的ssrc
uint32_t getSSRC() const; uint32_t getSSRC() const;
//有效负载，跳过csrc、ext //有效负载，跳过csrc、ext

2
src/TS/TSMediaSource.h
View File

@ -27,7 +27,7 @@ public:
~TSPacket() override = default; ~TSPacket() override = default;
public: public:
uint32_t time_stamp = 0; uint64_t time_stamp = 0;
}; };
//TS直播源 //TS直播源

2
src/TS/TSMediaSourceMuxer.h
View File

@ -66,7 +66,7 @@ public:
} }
protected: protected:
void onWrite(std::shared_ptr<toolkit::Buffer> buffer, uint32_t timestamp, bool key_pos) override { void onWrite(std::shared_ptr<toolkit::Buffer> buffer, uint64_t timestamp, bool key_pos) override {
if (!buffer) { if (!buffer) {
return; return;
} }

4
tests/test_rtp.cpp
View File

@ -34,7 +34,7 @@ static bool loadFile(const char *path){
return false; return false;
} }
uint32_t timeStamp_last = 0; uint64_t timeStamp_last = 0;
uint16_t len; uint16_t len;
char rtp[0xFFFF]; char rtp[0xFFFF];
struct sockaddr_storage addr = {0}; struct sockaddr_storage addr = {0};
@ -57,7 +57,7 @@ static bool loadFile(const char *path){
break; break;
} }
total_size += len; total_size += len;
uint32_t timeStamp; uint64_t timeStamp;
RtpSelector::Instance().inputRtp(sock, rtp, len, (struct sockaddr *)&addr, &timeStamp); RtpSelector::Instance().inputRtp(sock, rtp, len, (struct sockaddr *)&addr, &timeStamp);
auto diff = timeStamp - timeStamp_last; auto diff = timeStamp - timeStamp_last;