zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move PostTask for DeliverRtcp from PeerConnection to Call.

Browse Source 
This is part of moving the thread hops from the network thread to
worker (required by Call) into Call itself so that we can eventually
remove them.

Bug: webrtc:11993
Change-Id: Ib3ccdd6c75a3848daae2e3ce6c9a55d9617c2f50
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/220604
Commit-Queue: Tommi <tommi@webrtc.org>
Reviewed-by: Markus Handell <handellm@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#34160}
This commit is contained in:
Tommi
2021-05-31 10:51:09 +02:00
committed by WebRTC LUCI CQ
parent acd16af8c6
commit cae1f1d47b
2 changed files with 47 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
call/call.cc
View File

@ -352,16 +352,12 @@ class Call final : public webrtc::Call,
RTC_GUARDED_BY(sequence_checker_);
};
DeliveryStatus DeliverRtcp(MediaType media_type,
const uint8_t* packet,
size_t length)
RTC_EXCLUSIVE_LOCKS_REQUIRED(worker_thread_);
void DeliverRtcp(MediaType media_type, rtc::CopyOnWriteBuffer packet)
RTC_RUN_ON(network_thread_);
DeliveryStatus DeliverRtp(MediaType media_type,
rtc::CopyOnWriteBuffer packet,
int64_t packet_time_us)
RTC_EXCLUSIVE_LOCKS_REQUIRED(worker_thread_);
void ConfigureSync(const std::string& sync_group)
RTC_EXCLUSIVE_LOCKS_REQUIRED(worker_thread_);
int64_t packet_time_us) RTC_RUN_ON(worker_thread_);
void ConfigureSync(const std::string& sync_group) RTC_RUN_ON(worker_thread_);
void NotifyBweOfReceivedPacket(const RtpPacketReceived& packet,
MediaType media_type)
@ -371,7 +367,7 @@ class Call final : public webrtc::Call,
// Ensure that necessary process threads are started, and any required
// callbacks have been registered.
void EnsureStarted() RTC_EXCLUSIVE_LOCKS_REQUIRED(worker_thread_);
void EnsureStarted() RTC_RUN_ON(worker_thread_);
rtc::TaskQueue* send_transport_queue() const {
return transport_send_ptr_->GetWorkerQueue();
@ -1420,9 +1416,8 @@ void Call::ConfigureSync(const std::string& sync_group) {
}
}
PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type,
const uint8_t* packet,
size_t length) {
// RTC_RUN_ON(network_thread_)
void Call::DeliverRtcp(MediaType media_type, rtc::CopyOnWriteBuffer packet) {
TRACE_EVENT0("webrtc", "Call::DeliverRtcp");
// TODO(bugs.webrtc.org/11993): This DCHECK is here just to maintain the
@ -1437,42 +1432,39 @@ PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type,
// This way we'll also know more about the context of the packet.
RTC_DCHECK_EQ(media_type, MediaType::ANY);
// TODO(pbos): Make sure it's a valid packet.
// Return DELIVERY_UNKNOWN_SSRC if it can be determined that
// there's no receiver of the packet.
receive_stats_.AddReceivedRtcpBytes(static_cast<int>(length));
bool rtcp_delivered = false;
if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
for (VideoReceiveStream2* stream : video_receive_streams_) {
if (stream->DeliverRtcp(packet, length))
rtcp_delivered = true;
}
}
if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
for (AudioReceiveStream* stream : audio_receive_streams_) {
stream->DeliverRtcp(packet, length);
rtcp_delivered = true;
}
}
if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
for (VideoSendStream* stream : video_send_streams_) {
stream->DeliverRtcp(packet, length);
rtcp_delivered = true;
}
}
if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
for (auto& kv : audio_send_ssrcs_) {
kv.second->DeliverRtcp(packet, length);
rtcp_delivered = true;
}
}
// TODO(bugs.webrtc.org/11993): This should execute directly on the network
// thread.
worker_thread_->PostTask(
ToQueuedTask(task_safety_, [this, packet = std::move(packet)]() {
RTC_DCHECK_RUN_ON(worker_thread_);
if (rtcp_delivered) {
event_log_->Log(std::make_unique<RtcEventRtcpPacketIncoming>(
rtc::MakeArrayView(packet, length)));
}
receive_stats_.AddReceivedRtcpBytes(static_cast<int>(packet.size()));
bool rtcp_delivered = false;
for (VideoReceiveStream2* stream : video_receive_streams_) {
if (stream->DeliverRtcp(packet.cdata(), packet.size()))
rtcp_delivered = true;
}
return rtcp_delivered ? DELIVERY_OK : DELIVERY_PACKET_ERROR;
for (AudioReceiveStream* stream : audio_receive_streams_) {
stream->DeliverRtcp(packet.cdata(), packet.size());
rtcp_delivered = true;
}
for (VideoSendStream* stream : video_send_streams_) {
stream->DeliverRtcp(packet.cdata(), packet.size());
rtcp_delivered = true;
}
for (auto& kv : audio_send_ssrcs_) {
kv.second->DeliverRtcp(packet.cdata(), packet.size());
rtcp_delivered = true;
}
if (rtcp_delivered) {
event_log_->Log(std::make_unique<RtcEventRtcpPacketIncoming>(
rtc::MakeArrayView(packet.cdata(), packet.size())));
}
}));
}
PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
@ -1549,11 +1541,13 @@ PacketReceiver::DeliveryStatus Call::DeliverPacket(
MediaType media_type,
rtc::CopyOnWriteBuffer packet,
int64_t packet_time_us) {
if (IsRtcp(packet.cdata(), packet.size())) {
RTC_DCHECK_RUN_ON(network_thread_);
DeliverRtcp(media_type, std::move(packet));
return DELIVERY_OK;
}
RTC_DCHECK_RUN_ON(worker_thread_);
if (IsRtcp(packet.cdata(), packet.size()))
return DeliverRtcp(media_type, packet.cdata(), packet.size());
return DeliverRtp(media_type, std::move(packet), packet_time_us);
}

14
pc/peer_connection.cc
View File

@ -2869,18 +2869,10 @@ std::function<void(const rtc::CopyOnWriteBuffer& packet,
int64_t packet_time_us)>
PeerConnection::InitializeRtcpCallback() {
RTC_DCHECK_RUN_ON(network_thread());
return [this, flag = worker_thread_safety_](
const rtc::CopyOnWriteBuffer& packet, int64_t packet_time_us) {
return [this](const rtc::CopyOnWriteBuffer& packet, int64_t packet_time_us) {
RTC_DCHECK_RUN_ON(network_thread());
// TODO(bugs.webrtc.org/11993): We should actually be delivering this call
// directly to the Call class somehow directly on the network thread and not
// incur this hop here. The DeliverPacket() method will eventually just have
// to hop back over to the network thread.
worker_thread()->PostTask(ToQueuedTask(flag, [this, packet,
packet_time_us] {
RTC_DCHECK_RUN_ON(worker_thread());
call_->Receiver()->DeliverPacket(MediaType::ANY, packet, packet_time_us);
}));
call_ptr_->Receiver()->DeliverPacket(MediaType::ANY, packet,
packet_time_us);
};
}