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 <memory>
14 #include <utility>
15 #include <vector>
16
17 #include "absl/cleanup/cleanup.h"
18 #include "api/units/timestamp.h"
19 #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
20 #include "rtc_base/checks.h"
21 #include "rtc_base/event.h"
22 #include "system_wrappers/include/clock.h"
23
24 namespace webrtc {
25
RtcpTransceiver(const RtcpTransceiverConfig & config)26 RtcpTransceiver::RtcpTransceiver(const RtcpTransceiverConfig& config)
27 : clock_(config.clock),
28 task_queue_(config.task_queue),
29 rtcp_transceiver_(std::make_unique<RtcpTransceiverImpl>(config)) {
30 RTC_DCHECK(task_queue_);
31 }
32
~RtcpTransceiver()33 RtcpTransceiver::~RtcpTransceiver() {
34 if (!rtcp_transceiver_)
35 return;
36 auto rtcp_transceiver = std::move(rtcp_transceiver_);
37 task_queue_->PostTask([rtcp_transceiver = std::move(rtcp_transceiver)] {
38 rtcp_transceiver->StopPeriodicTask();
39 });
40 RTC_DCHECK(!rtcp_transceiver_);
41 }
42
Stop(absl::AnyInvocable<void ()&&> on_destroyed)43 void RtcpTransceiver::Stop(absl::AnyInvocable<void() &&> on_destroyed) {
44 RTC_DCHECK(rtcp_transceiver_);
45 auto rtcp_transceiver = std::move(rtcp_transceiver_);
46 absl::Cleanup cleanup = std::move(on_destroyed);
47 task_queue_->PostTask(
48 [rtcp_transceiver = std::move(rtcp_transceiver),
49 cleanup = std::move(cleanup)] { rtcp_transceiver->StopPeriodicTask(); });
50 RTC_DCHECK(!rtcp_transceiver_);
51 }
52
AddMediaReceiverRtcpObserver(uint32_t remote_ssrc,MediaReceiverRtcpObserver * observer)53 void RtcpTransceiver::AddMediaReceiverRtcpObserver(
54 uint32_t remote_ssrc,
55 MediaReceiverRtcpObserver* observer) {
56 RTC_CHECK(rtcp_transceiver_);
57 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
58 task_queue_->PostTask([ptr, remote_ssrc, observer] {
59 ptr->AddMediaReceiverRtcpObserver(remote_ssrc, observer);
60 });
61 }
62
RemoveMediaReceiverRtcpObserver(uint32_t remote_ssrc,MediaReceiverRtcpObserver * observer,absl::AnyInvocable<void ()&&> on_removed)63 void RtcpTransceiver::RemoveMediaReceiverRtcpObserver(
64 uint32_t remote_ssrc,
65 MediaReceiverRtcpObserver* observer,
66 absl::AnyInvocable<void() &&> on_removed) {
67 RTC_CHECK(rtcp_transceiver_);
68 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
69 absl::Cleanup cleanup = std::move(on_removed);
70 task_queue_->PostTask(
71 [ptr, remote_ssrc, observer, cleanup = std::move(cleanup)] {
72 ptr->RemoveMediaReceiverRtcpObserver(remote_ssrc, observer);
73 });
74 }
75
SetReadyToSend(bool ready)76 void RtcpTransceiver::SetReadyToSend(bool ready) {
77 RTC_CHECK(rtcp_transceiver_);
78 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
79 task_queue_->PostTask([ptr, ready] { ptr->SetReadyToSend(ready); });
80 }
81
ReceivePacket(rtc::CopyOnWriteBuffer packet)82 void RtcpTransceiver::ReceivePacket(rtc::CopyOnWriteBuffer packet) {
83 RTC_CHECK(rtcp_transceiver_);
84 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
85 Timestamp now = clock_->CurrentTime();
86 task_queue_->PostTask(
87 [ptr, packet, now] { ptr->ReceivePacket(packet, now); });
88 }
89
SendCompoundPacket()90 void RtcpTransceiver::SendCompoundPacket() {
91 RTC_CHECK(rtcp_transceiver_);
92 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
93 task_queue_->PostTask([ptr] { ptr->SendCompoundPacket(); });
94 }
95
SetRemb(int64_t bitrate_bps,std::vector<uint32_t> ssrcs)96 void RtcpTransceiver::SetRemb(int64_t bitrate_bps,
97 std::vector<uint32_t> ssrcs) {
98 RTC_CHECK(rtcp_transceiver_);
99 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
100 task_queue_->PostTask([ptr, bitrate_bps, ssrcs = std::move(ssrcs)]() mutable {
101 ptr->SetRemb(bitrate_bps, std::move(ssrcs));
102 });
103 }
104
UnsetRemb()105 void RtcpTransceiver::UnsetRemb() {
106 RTC_CHECK(rtcp_transceiver_);
107 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
108 task_queue_->PostTask([ptr] { ptr->UnsetRemb(); });
109 }
110
SendCombinedRtcpPacket(std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets)111 void RtcpTransceiver::SendCombinedRtcpPacket(
112 std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets) {
113 RTC_CHECK(rtcp_transceiver_);
114 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
115 task_queue_->PostTask(
116 [ptr, rtcp_packets = std::move(rtcp_packets)]() mutable {
117 ptr->SendCombinedRtcpPacket(std::move(rtcp_packets));
118 });
119 }
120
SendNack(uint32_t ssrc,std::vector<uint16_t> sequence_numbers)121 void RtcpTransceiver::SendNack(uint32_t ssrc,
122 std::vector<uint16_t> sequence_numbers) {
123 RTC_CHECK(rtcp_transceiver_);
124 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
125 task_queue_->PostTask(
126 [ptr, ssrc, sequence_numbers = std::move(sequence_numbers)]() mutable {
127 ptr->SendNack(ssrc, std::move(sequence_numbers));
128 });
129 }
130
SendPictureLossIndication(uint32_t ssrc)131 void RtcpTransceiver::SendPictureLossIndication(uint32_t ssrc) {
132 RTC_CHECK(rtcp_transceiver_);
133 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
134 task_queue_->PostTask([ptr, ssrc] { ptr->SendPictureLossIndication(ssrc); });
135 }
136
SendFullIntraRequest(std::vector<uint32_t> ssrcs)137 void RtcpTransceiver::SendFullIntraRequest(std::vector<uint32_t> ssrcs) {
138 return SendFullIntraRequest(std::move(ssrcs), true);
139 }
140
SendFullIntraRequest(std::vector<uint32_t> ssrcs,bool new_request)141 void RtcpTransceiver::SendFullIntraRequest(std::vector<uint32_t> ssrcs,
142 bool new_request) {
143 RTC_CHECK(rtcp_transceiver_);
144 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
145 task_queue_->PostTask([ptr, ssrcs = std::move(ssrcs), new_request] {
146 ptr->SendFullIntraRequest(ssrcs, new_request);
147 });
148 }
149
150 } // namespace webrtc
151