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

[feat] clean rtp packet buffer queue when ice destroyed

Browse Source
This commit is contained in:
dijunkun
2025-03-05 17:48:33 +08:00
parent 0dbc0236bf
commit 02f00642e9
11 changed files with 82 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
src/channel/meida_channel/audio_channel_receive.cpp
View File

@@ -23,25 +23,23 @@ void AudioChannelReceive::Initialize(rtp::PAYLOAD_TYPE payload_type) {
} }
}); });
rtp_audio_receiver_->SetSendDataFunc( rtp_audio_receiver_->SetSendDataFunc([this](const char *data,
[this](const char *data, size_t size) -> int { size_t size) -> int {
if (!ice_agent_) { if (!ice_agent_) {
LOG_ERROR("ice_agent_ is nullptr"); LOG_ERROR("ice_agent_ is nullptr");
return -1; return -1;
} }
auto ice_state = ice_agent_->GetIceState(); auto ice_state = ice_agent_->GetIceState();
if (ice_state != NICE_COMPONENT_STATE_CONNECTED && if (ICE_STATE_NULLPTR == ice_state || ICE_STATE_DESTROYED == ice_state) {
ice_state != NICE_COMPONENT_STATE_READY) { LOG_ERROR("Ice is not connected, state = [{}]", (int)ice_state);
LOG_ERROR("Ice is not connected, state = [{}]", return -2;
nice_component_state_to_string(ice_state)); }
return -2;
}
ice_io_statistics_->UpdateAudioOutboundBytes((uint32_t)size); ice_io_statistics_->UpdateAudioOutboundBytes((uint32_t)size);
return ice_agent_->Send(data, size); return ice_agent_->Send(data, size);
}); });
} }
void AudioChannelReceive::Destroy() {} void AudioChannelReceive::Destroy() {}

5
src/channel/meida_channel/audio_channel_send.cpp
View File

@@ -25,10 +25,7 @@ void AudioChannelSend::Initialize(rtp::PAYLOAD_TYPE payload_type) {
auto ice_state = ice_agent_->GetIceState(); auto ice_state = ice_agent_->GetIceState();
if (ice_state != NICE_COMPONENT_STATE_CONNECTED && if (ICE_STATE_DESTROYED == ice_state) {
ice_state != NICE_COMPONENT_STATE_READY) {
LOG_ERROR("Ice is not connected, state = [{}]",
nice_component_state_to_string(ice_state));
return -2; return -2;
} }

30
src/channel/meida_channel/data_channel_receive.cpp
View File

@@ -23,25 +23,23 @@ void DataChannelReceive::Initialize(rtp::PAYLOAD_TYPE payload_type) {
} }
}); });
rtp_data_receiver_->SetSendDataFunc( rtp_data_receiver_->SetSendDataFunc([this](const char *data,
[this](const char *data, size_t size) -> int { size_t size) -> int {
if (!ice_agent_) { if (!ice_agent_) {
LOG_ERROR("ice_agent_ is nullptr"); LOG_ERROR("ice_agent_ is nullptr");
return -1; return -1;
} }
auto ice_state = ice_agent_->GetIceState(); auto ice_state = ice_agent_->GetIceState();
if (ice_state != NICE_COMPONENT_STATE_CONNECTED && if (ICE_STATE_NULLPTR == ice_state || ICE_STATE_DESTROYED == ice_state) {
ice_state != NICE_COMPONENT_STATE_READY) { LOG_ERROR("Ice is not connected, state = [{}]", (int)ice_state);
LOG_ERROR("Ice is not connected, state = [{}]", return -2;
nice_component_state_to_string(ice_state)); }
return -2;
}
ice_io_statistics_->UpdateDataOutboundBytes((uint32_t)size); ice_io_statistics_->UpdateDataOutboundBytes((uint32_t)size);
return ice_agent_->Send(data, size); return ice_agent_->Send(data, size);
}); });
} }
void DataChannelReceive::Destroy() {} void DataChannelReceive::Destroy() {}

5
src/channel/meida_channel/data_channel_send.cpp
View File

@@ -25,10 +25,7 @@ void DataChannelSend::Initialize(rtp::PAYLOAD_TYPE payload_type) {
auto ice_state = ice_agent_->GetIceState(); auto ice_state = ice_agent_->GetIceState();
if (ice_state != NICE_COMPONENT_STATE_CONNECTED && if (ICE_STATE_DESTROYED == ice_state) {
ice_state != NICE_COMPONENT_STATE_READY) {
LOG_ERROR("Ice is not connected, state = [{}]",
nice_component_state_to_string(ice_state));
return -2; return -2;
} }

30
src/channel/meida_channel/video_channel_receive.cpp
View File

@@ -23,25 +23,23 @@ void VideoChannelReceive::Initialize(rtp::PAYLOAD_TYPE payload_type) {
on_receive_complete_frame_(video_frame); on_receive_complete_frame_(video_frame);
}); });
rtp_video_receiver_->SetSendDataFunc( rtp_video_receiver_->SetSendDataFunc([this](const char *data,
[this](const char *data, size_t size) -> int { size_t size) -> int {
if (!ice_agent_) { if (!ice_agent_) {
LOG_ERROR("ice_agent_ is nullptr"); LOG_ERROR("ice_agent_ is nullptr");
return -1; return -1;
} }
auto ice_state = ice_agent_->GetIceState(); auto ice_state = ice_agent_->GetIceState();
if (ice_state != NICE_COMPONENT_STATE_CONNECTED && if (ICE_STATE_NULLPTR == ice_state || ICE_STATE_DESTROYED == ice_state) {
ice_state != NICE_COMPONENT_STATE_READY) { LOG_ERROR("Ice is not connected, state = [{}]", (int)ice_state);
LOG_ERROR("Ice is not connected, state = [{}]", return -2;
nice_component_state_to_string(ice_state)); }
return -2;
}
ice_io_statistics_->UpdateVideoOutboundBytes((uint32_t)size); ice_io_statistics_->UpdateVideoOutboundBytes((uint32_t)size);
return ice_agent_->Send(data, size); return ice_agent_->Send(data, size);
}); });
rtp_video_receiver_->Start(); rtp_video_receiver_->Start();
} }

5
src/channel/meida_channel/video_channel_send.cpp
View File

@@ -31,10 +31,7 @@ void VideoChannelSend::Initialize(rtp::PAYLOAD_TYPE payload_type) {
auto ice_state = ice_agent_->GetIceState(); auto ice_state = ice_agent_->GetIceState();
if (ice_state != NICE_COMPONENT_STATE_CONNECTED && if (ICE_STATE_DESTROYED == ice_state) {
ice_state != NICE_COMPONENT_STATE_READY) {
// LOG_ERROR("Ice is not connected, state = [{}]",
// nice_component_state_to_string(ice_state));
return -2; return -2;
} }

7
src/channel/rtp_channel/rtp_audio_sender.cpp
View File

@@ -45,9 +45,10 @@ int RtpAudioSender::SendRtpPacket(std::shared_ptr<RtpPacket> rtp_packet) {
return -1; return -1;
} }
if (0 != data_send_func_((const char*)rtp_packet->Buffer().data(), int ret = data_send_func_((const char*)rtp_packet->Buffer().data(),
rtp_packet->Size())) { rtp_packet->Size());
LOG_ERROR("Send rtp packet failed"); if (-2 == ret) {
rtp_packet_queue_.clear();
return -1; return -1;
} }

7
src/channel/rtp_channel/rtp_data_sender.cpp
View File

@@ -45,9 +45,10 @@ int RtpDataSender::SendRtpPacket(std::shared_ptr<RtpPacket> rtp_packet) {
return -1; return -1;
} }
if (0 != data_send_func_((const char*)rtp_packet->Buffer().data(), int ret = data_send_func_((const char*)rtp_packet->Buffer().data(),
rtp_packet->Size())) { rtp_packet->Size());
LOG_ERROR("Send rtp packet failed"); if (-2 == ret) {
rtp_packet_queue_.clear();
return -1; return -1;
} }

13
src/channel/rtp_channel/rtp_video_sender.cpp
View File

@@ -85,9 +85,11 @@ int RtpVideoSender::SendRtpPacket(
} }
last_rtp_timestamp_ = rtp_packet_to_send->capture_time().ms(); last_rtp_timestamp_ = rtp_packet_to_send->capture_time().ms();
if (0 != data_send_func_((const char*)rtp_packet_to_send->Buffer().data(),
rtp_packet_to_send->Size())) { int ret = data_send_func_((const char*)rtp_packet_to_send->Buffer().data(),
// LOG_ERROR("Send rtp packet failed"); rtp_packet_to_send->Size());
if (-2 == ret) {
rtp_packet_queue_.clear();
return -1; return -1;
} }
@@ -131,8 +133,9 @@ int RtpVideoSender::SendRtcpSR(SenderReport& rtcp_sr) {
return -1; return -1;
} }
if (data_send_func_((const char*)rtcp_sr.Buffer(), rtcp_sr.Size())) { int ret = data_send_func_((const char*)rtcp_sr.Buffer(), rtcp_sr.Size());
LOG_ERROR("Send SR failed"); if (ret != 0) {
LOG_ERROR("Send rtcp sr failed");
return -1; return -1;
} }

15
src/ice/ice_agent.cpp
View File

@@ -335,23 +335,20 @@ int IceAgent::GatherCandidates() {
return 0; return 0;
} }
NiceComponentState IceAgent::GetIceState() { ICE_STATE IceAgent::GetIceState() {
if (!nice_inited_) { if (!nice_inited_) {
LOG_ERROR("Nice agent has not been initialized"); return ICE_STATE_NOT_INITIALIZED;
return NiceComponentState::NICE_COMPONENT_STATE_LAST;
} }
if (nullptr == agent_) { if (nullptr == agent_) {
LOG_ERROR("Nice agent is nullptr"); return ICE_STATE_NULLPTR;
return NiceComponentState::NICE_COMPONENT_STATE_LAST;
} }
if (destroyed_) { if (destroyed_) {
LOG_ERROR("Nice agent is destroyed"); return ICE_STATE_DESTROYED;
return NiceComponentState::NICE_COMPONENT_STATE_LAST;
} }
state_ = nice_agent_get_component_state(agent_, stream_id_, 1); state_ = (ICE_STATE)nice_agent_get_component_state(agent_, stream_id_, 1);
return state_; return state_;
} }
@@ -377,7 +374,7 @@ int IceAgent::Send(const char *data, size_t size) {
return -1; return -1;
} }
// if (NiceComponentState::NICE_COMPONENT_STATE_READY != // if (ICE_STATE_READY !=
// nice_agent_get_component_state(agent_, stream_id_, 1)) { // nice_agent_get_component_state(agent_, stream_id_, 1)) {
// LOG_ERROR("Nice agent not ready"); // LOG_ERROR("Nice agent not ready");
// return -1; // return -1;

17
src/ice/ice_agent.h
View File

@@ -9,6 +9,19 @@
#include "glib.h" #include "glib.h"
#include "nice/agent.h" #include "nice/agent.h"
typedef enum {
ICE_STATE_DISCONNECTED,
ICE_STATE_GATHERING,
ICE_STATE_CONNECTING,
ICE_STATE_CONNECTED,
ICE_STATE_READY,
ICE_STATE_FAILED,
ICE_STATE_NOT_INITIALIZED,
ICE_STATE_DESTROYED,
ICE_STATE_NULLPTR,
ICE_STATE_LAST
} ICE_STATE;
typedef void (*nice_cb_state_changed_t)(NiceAgent* agent, guint stream_id, typedef void (*nice_cb_state_changed_t)(NiceAgent* agent, guint stream_id,
guint component_id, guint component_id,
NiceComponentState state, NiceComponentState state,
@@ -56,7 +69,7 @@ class IceAgent {
int GatherCandidates(); int GatherCandidates();
NiceComponentState GetIceState(); ICE_STATE GetIceState();
int SetRemoteGatheringDone(); int SetRemoteGatheringDone();
@@ -99,7 +112,7 @@ class IceAgent {
uint32_t n_components_ = 1; uint32_t n_components_ = 1;
// char* local_sdp_ = nullptr; // char* local_sdp_ = nullptr;
std::string local_sdp_ = ""; std::string local_sdp_ = "";
NiceComponentState state_ = NiceComponentState::NICE_COMPONENT_STATE_LAST; ICE_STATE state_ = ICE_STATE_LAST;
bool destroyed_ = false; bool destroyed_ = false;
gboolean agent_closed_ = false; gboolean agent_closed_ = false;