rtcp_transceiver.cc (5403B)
1 /* 2 * Copyright (c) 2017 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include "modules/rtp_rtcp/source/rtcp_transceiver.h" 12 13 #include <cstdint> 14 #include <memory> 15 #include <utility> 16 #include <vector> 17 18 #include "absl/cleanup/cleanup.h" 19 #include "absl/functional/any_invocable.h" 20 #include "api/units/timestamp.h" 21 #include "modules/rtp_rtcp/source/rtcp_packet.h" 22 #include "modules/rtp_rtcp/source/rtcp_transceiver_config.h" 23 #include "modules/rtp_rtcp/source/rtcp_transceiver_impl.h" 24 #include "rtc_base/checks.h" 25 #include "rtc_base/copy_on_write_buffer.h" 26 #include "system_wrappers/include/clock.h" 27 28 namespace webrtc { 29 30 RtcpTransceiver::RtcpTransceiver(const RtcpTransceiverConfig& config) 31 : clock_(config.clock), 32 task_queue_(config.task_queue), 33 rtcp_transceiver_(std::make_unique<RtcpTransceiverImpl>(config)) { 34 RTC_DCHECK(task_queue_); 35 } 36 37 RtcpTransceiver::~RtcpTransceiver() { 38 if (!rtcp_transceiver_) 39 return; 40 auto rtcp_transceiver = std::move(rtcp_transceiver_); 41 task_queue_->PostTask([rtcp_transceiver = std::move(rtcp_transceiver)] { 42 rtcp_transceiver->StopPeriodicTask(); 43 }); 44 RTC_DCHECK(!rtcp_transceiver_); 45 } 46 47 void RtcpTransceiver::Stop(absl::AnyInvocable<void() &&> on_destroyed) { 48 RTC_DCHECK(rtcp_transceiver_); 49 auto rtcp_transceiver = std::move(rtcp_transceiver_); 50 absl::Cleanup cleanup = std::move(on_destroyed); 51 task_queue_->PostTask( 52 [rtcp_transceiver = std::move(rtcp_transceiver), 53 cleanup = std::move(cleanup)] { rtcp_transceiver->StopPeriodicTask(); }); 54 RTC_DCHECK(!rtcp_transceiver_); 55 } 56 57 void RtcpTransceiver::AddMediaReceiverRtcpObserver( 58 uint32_t remote_ssrc, 59 MediaReceiverRtcpObserver* observer) { 60 RTC_CHECK(rtcp_transceiver_); 61 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get(); 62 task_queue_->PostTask([ptr, remote_ssrc, observer] { 63 ptr->AddMediaReceiverRtcpObserver(remote_ssrc, observer); 64 }); 65 } 66 67 void RtcpTransceiver::RemoveMediaReceiverRtcpObserver( 68 uint32_t remote_ssrc, 69 MediaReceiverRtcpObserver* observer, 70 absl::AnyInvocable<void() &&> on_removed) { 71 RTC_CHECK(rtcp_transceiver_); 72 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get(); 73 absl::Cleanup cleanup = std::move(on_removed); 74 task_queue_->PostTask( 75 [ptr, remote_ssrc, observer, cleanup = std::move(cleanup)] { 76 ptr->RemoveMediaReceiverRtcpObserver(remote_ssrc, observer); 77 }); 78 } 79 80 void RtcpTransceiver::SetReadyToSend(bool ready) { 81 RTC_CHECK(rtcp_transceiver_); 82 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get(); 83 task_queue_->PostTask([ptr, ready] { ptr->SetReadyToSend(ready); }); 84 } 85 86 void RtcpTransceiver::ReceivePacket(CopyOnWriteBuffer packet) { 87 RTC_CHECK(rtcp_transceiver_); 88 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get(); 89 Timestamp now = clock_->CurrentTime(); 90 task_queue_->PostTask( 91 [ptr, packet, now] { ptr->ReceivePacket(packet, now); }); 92 } 93 94 void RtcpTransceiver::SendCompoundPacket() { 95 RTC_CHECK(rtcp_transceiver_); 96 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get(); 97 task_queue_->PostTask([ptr] { ptr->SendCompoundPacket(); }); 98 } 99 100 void RtcpTransceiver::SetRemb(int64_t bitrate_bps, 101 std::vector<uint32_t> ssrcs) { 102 RTC_CHECK(rtcp_transceiver_); 103 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get(); 104 task_queue_->PostTask([ptr, bitrate_bps, ssrcs = std::move(ssrcs)]() mutable { 105 ptr->SetRemb(bitrate_bps, std::move(ssrcs)); 106 }); 107 } 108 109 void RtcpTransceiver::UnsetRemb() { 110 RTC_CHECK(rtcp_transceiver_); 111 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get(); 112 task_queue_->PostTask([ptr] { ptr->UnsetRemb(); }); 113 } 114 115 void RtcpTransceiver::SendCombinedRtcpPacket( 116 std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets) { 117 RTC_CHECK(rtcp_transceiver_); 118 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get(); 119 task_queue_->PostTask( 120 [ptr, rtcp_packets = std::move(rtcp_packets)]() mutable { 121 ptr->SendCombinedRtcpPacket(std::move(rtcp_packets)); 122 }); 123 } 124 125 void RtcpTransceiver::SendNack(uint32_t ssrc, 126 std::vector<uint16_t> sequence_numbers) { 127 RTC_CHECK(rtcp_transceiver_); 128 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get(); 129 task_queue_->PostTask( 130 [ptr, ssrc, sequence_numbers = std::move(sequence_numbers)]() mutable { 131 ptr->SendNack(ssrc, std::move(sequence_numbers)); 132 }); 133 } 134 135 void RtcpTransceiver::SendPictureLossIndication(uint32_t ssrc) { 136 RTC_CHECK(rtcp_transceiver_); 137 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get(); 138 task_queue_->PostTask([ptr, ssrc] { ptr->SendPictureLossIndication(ssrc); }); 139 } 140 141 void RtcpTransceiver::SendFullIntraRequest(std::vector<uint32_t> ssrcs) { 142 return SendFullIntraRequest(std::move(ssrcs), true); 143 } 144 145 void RtcpTransceiver::SendFullIntraRequest(std::vector<uint32_t> ssrcs, 146 bool new_request) { 147 RTC_CHECK(rtcp_transceiver_); 148 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get(); 149 task_queue_->PostTask([ptr, ssrcs = std::move(ssrcs), new_request] { 150 ptr->SendFullIntraRequest(ssrcs, new_request); 151 }); 152 } 153 154 } // namespace webrtc