YangWX/crossdesk
1
0
Fork 0
mirror of https://github.com/kunkundi/crossdesk.git synced 2025-10-27 04:35:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

Implementation for jitter

Browse Source
This commit is contained in:
dijunkun
2023-09-08 17:45:01 +08:00
parent dc11f50d82
commit 79c838629a
9 changed files with 177 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
src/rtp/rtp_video_receiver.cpp
View File

@@ -6,16 +6,33 @@
RtpVideoReceiver::RtpVideoReceiver() {}
RtpVideoReceiver::~RtpVideoReceiver() {}
RtpVideoReceiver::~RtpVideoReceiver() {
if (jitter_thread_ && jitter_thread_->joinable()) {
jitter_thread_->join();
delete jitter_thread_;
jitter_thread_ = nullptr;
}
}
void RtpVideoReceiver::InsertRtpPacket(RtpPacket& rtp_packet) {
if (!jitter_thread_) {
jitter_thread_ = new std::thread(&RtpVideoReceiver::Process, this);
}
if (NAL_UNIT_TYPE::NALU == rtp_packet.NalUnitType()) {
// compelete_video_frame_queue_.push(
// VideoFrame(rtp_packet.Payload(), rtp_packet.Size()));
if (on_receive_complete_frame_) {
on_receive_complete_frame_(
VideoFrame(rtp_packet.Payload(), rtp_packet.Size()));
}
compelete_video_frame_queue_.push(
VideoFrame(rtp_packet.Payload(), rtp_packet.Size()));
// if (on_receive_complete_frame_) {
// auto now_complete_frame_ts =
// std::chrono::high_resolution_clock::now().time_since_epoch().count()
// / 1000000;
// uint32_t duration = now_complete_frame_ts - last_complete_frame_ts_;
// LOG_ERROR("Duration {}", 1000 / duration);
// last_complete_frame_ts_ = now_complete_frame_ts;
// on_receive_complete_frame_(
// VideoFrame(rtp_packet.Payload(), rtp_packet.Size()));
// }
} else if (NAL_UNIT_TYPE::FU_A == rtp_packet.NalUnitType()) {
incomplete_frame_list_[rtp_packet.SequenceNumber()] = rtp_packet;
bool complete = CheckIsFrameCompleted(rtp_packet);
@@ -53,16 +70,22 @@ bool RtpVideoReceiver::CheckIsFrameCompleted(RtpPacket& rtp_packet) {
incomplete_frame_list_.erase(start);
}
// compelete_video_frame_queue_.push(
// VideoFrame(nv12_data_, complete_frame_size));
compelete_video_frame_queue_.push(
VideoFrame(nv12_data_, complete_frame_size));
// LOG_ERROR("Size of compelete_video_frame_queue_ [{}]",
// compelete_video_frame_queue_.size());
// if (on_receive_complete_frame_) {
// auto now_complete_frame_ts =
// std::chrono::high_resolution_clock::now()
// .time_since_epoch()
// .count() /
// 1000000;
// uint32_t duration = now_complete_frame_ts -
// last_complete_frame_ts_; LOG_ERROR("Duration {}", 1000 / duration);
// last_complete_frame_ts_ = now_complete_frame_ts;
if (on_receive_complete_frame_) {
on_receive_complete_frame_(
VideoFrame(nv12_data_, complete_frame_size));
}
// on_receive_complete_frame_(
// VideoFrame(nv12_data_, complete_frame_size));
// }
return true;
} else {
LOG_WARN("What happened?")
@@ -73,4 +96,25 @@ bool RtpVideoReceiver::CheckIsFrameCompleted(RtpPacket& rtp_packet) {
return true;
}
return false;
}
void RtpVideoReceiver::Process() {
while (1) {
if (!compelete_video_frame_queue_.isEmpty()) {
VideoFrame video_frame;
compelete_video_frame_queue_.pop(video_frame);
if (on_receive_complete_frame_) {
auto now_complete_frame_ts = std::chrono::high_resolution_clock::now()
.time_since_epoch()
.count() /
1000000;
uint32_t duration = now_complete_frame_ts - last_complete_frame_ts_;
LOG_ERROR("Duration {}", 1000 / duration);
last_complete_frame_ts_ = now_complete_frame_ts;
on_receive_complete_frame_(video_frame);
}
}
std::this_thread::sleep_for(std::chrono::milliseconds(13));
}
}

9
src/rtp/rtp_video_receiver.h
View File

@@ -4,8 +4,10 @@
#include <functional>
#include <map>
#include <queue>
#include <thread>
#include "frame.h"
#include "ringbuffer.h"
#include "rtp_video_session.h"
class RtpVideoReceiver {
@@ -23,15 +25,20 @@ class RtpVideoReceiver {
private:
bool CheckIsFrameCompleted(RtpPacket& rtp_packet);
void Process();
// private:
// void OnReceiveFrame(uint8_t* payload) {}
private:
std::map<uint16_t, RtpPacket> incomplete_frame_list_;
std::queue<VideoFrame> compelete_video_frame_queue_;
uint8_t* nv12_data_ = nullptr;
std::function<void(VideoFrame&)> on_receive_complete_frame_ = nullptr;
uint32_t last_complete_frame_ts_ = 0;
RingBuffer<VideoFrame> compelete_video_frame_queue_;
std::thread* jitter_thread_ = nullptr;
bool start_ = false;
};
#endif

38
src/rtp/rtp_video_sender.cpp Normal file
View File

@@ -0,0 +1,38 @@
#include "rtp_video_sender.h"
#include <chrono>
RtpVideoSender::RtpVideoSender() {}
RtpVideoSender::~RtpVideoSender() {
if (send_thread_ && send_thread_->joinable()) {
send_thread_->join();
delete send_thread_;
send_thread_ = nullptr;
}
}
void RtpVideoSender::Enqueue(std::vector<RtpPacket>& rtp_packets) {
if (!send_thread_) {
send_thread_ = new std::thread(&RtpVideoSender::Process, this);
}
for (auto& rtp_packet : rtp_packets) {
start_ = true;
rtp_packe_queue_.push(rtp_packet);
}
}
void RtpVideoSender::Process() {
while (1) {
if (!rtp_packe_queue_.isEmpty()) {
RtpPacket rtp_packet;
rtp_packe_queue_.pop(rtp_packet);
if (rtp_packet_send_func_) {
rtp_packet_send_func_(rtp_packet);
}
}
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
}

34
src/rtp/rtp_video_sender.h Normal file
View File

@@ -0,0 +1,34 @@
#ifndef _RTP_VIDEO_SENDER_H_
#define _RTP_VIDEO_SENDER_H_
#include <functional>
#include <thread>
#include "ringbuffer.h"
#include "rtp_packet.h"
class RtpVideoSender {
public:
RtpVideoSender();
~RtpVideoSender();
public:
void Enqueue(std::vector<RtpPacket> &rtp_packets);
public:
void SetRtpPacketSendFunc(
std::function<void(RtpPacket &)> rtp_packet_send_func) {
rtp_packet_send_func_ = rtp_packet_send_func;
}
private:
void Process();
private:
std::function<void(RtpPacket &)> rtp_packet_send_func_ = nullptr;
RingBuffer<RtpPacket> rtp_packe_queue_;
std::thread *send_thread_ = nullptr;
bool start_ = false;
};
#endif