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 "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
18 #include "rtc_base/checks.h"
19 #include "rtc_base/event.h"
20 #include "rtc_base/task_utils/to_queued_task.h"
21 #include "rtc_base/time_utils.h"
22
23 namespace webrtc {
24
RtcpTransceiver(const RtcpTransceiverConfig & config)25 RtcpTransceiver::RtcpTransceiver(const RtcpTransceiverConfig& config)
26 : task_queue_(config.task_queue),
27 rtcp_transceiver_(std::make_unique<RtcpTransceiverImpl>(config)) {
28 RTC_DCHECK(task_queue_);
29 }
30
~RtcpTransceiver()31 RtcpTransceiver::~RtcpTransceiver() {
32 if (!rtcp_transceiver_)
33 return;
34 auto rtcp_transceiver = std::move(rtcp_transceiver_);
35 task_queue_->PostTask(
36 ToQueuedTask([rtcp_transceiver = std::move(rtcp_transceiver)] {
37 rtcp_transceiver->StopPeriodicTask();
38 }));
39 RTC_DCHECK(!rtcp_transceiver_);
40 }
41
Stop(std::function<void ()> on_destroyed)42 void RtcpTransceiver::Stop(std::function<void()> on_destroyed) {
43 RTC_DCHECK(rtcp_transceiver_);
44 auto rtcp_transceiver = std::move(rtcp_transceiver_);
45 task_queue_->PostTask(ToQueuedTask(
46 [rtcp_transceiver = std::move(rtcp_transceiver)] {
47 rtcp_transceiver->StopPeriodicTask();
48 },
49 std::move(on_destroyed)));
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(ToQueuedTask([ptr, remote_ssrc, observer] {
59 ptr->AddMediaReceiverRtcpObserver(remote_ssrc, observer);
60 }));
61 }
62
RemoveMediaReceiverRtcpObserver(uint32_t remote_ssrc,MediaReceiverRtcpObserver * observer,std::function<void ()> on_removed)63 void RtcpTransceiver::RemoveMediaReceiverRtcpObserver(
64 uint32_t remote_ssrc,
65 MediaReceiverRtcpObserver* observer,
66 std::function<void()> on_removed) {
67 RTC_CHECK(rtcp_transceiver_);
68 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
69 auto remove = [ptr, remote_ssrc, observer] {
70 ptr->RemoveMediaReceiverRtcpObserver(remote_ssrc, observer);
71 };
72 task_queue_->PostTask(ToQueuedTask(std::move(remove), std::move(on_removed)));
73 }
74
SetReadyToSend(bool ready)75 void RtcpTransceiver::SetReadyToSend(bool ready) {
76 RTC_CHECK(rtcp_transceiver_);
77 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
78 task_queue_->PostTask(
79 ToQueuedTask([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 int64_t now_us = rtc::TimeMicros();
86 task_queue_->PostTask(ToQueuedTask(
87 [ptr, packet, now_us] { ptr->ReceivePacket(packet, now_us); }));
88 }
89
SendCompoundPacket()90 void RtcpTransceiver::SendCompoundPacket() {
91 RTC_CHECK(rtcp_transceiver_);
92 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
93 task_queue_->PostTask(ToQueuedTask([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(
101 ToQueuedTask([ptr, bitrate_bps, ssrcs = std::move(ssrcs)]() mutable {
102 ptr->SetRemb(bitrate_bps, std::move(ssrcs));
103 }));
104 }
105
UnsetRemb()106 void RtcpTransceiver::UnsetRemb() {
107 RTC_CHECK(rtcp_transceiver_);
108 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
109 task_queue_->PostTask(ToQueuedTask([ptr] { ptr->UnsetRemb(); }));
110 }
111
SendCombinedRtcpPacket(std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets)112 void RtcpTransceiver::SendCombinedRtcpPacket(
113 std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets) {
114 RTC_CHECK(rtcp_transceiver_);
115 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
116 task_queue_->PostTask(
117 ToQueuedTask([ptr, rtcp_packets = std::move(rtcp_packets)]() mutable {
118 ptr->SendCombinedRtcpPacket(std::move(rtcp_packets));
119 }));
120 }
121
SendNack(uint32_t ssrc,std::vector<uint16_t> sequence_numbers)122 void RtcpTransceiver::SendNack(uint32_t ssrc,
123 std::vector<uint16_t> sequence_numbers) {
124 RTC_CHECK(rtcp_transceiver_);
125 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
126 task_queue_->PostTask(ToQueuedTask(
127 [ptr, ssrc, sequence_numbers = std::move(sequence_numbers)]() mutable {
128 ptr->SendNack(ssrc, std::move(sequence_numbers));
129 }));
130 }
131
SendPictureLossIndication(uint32_t ssrc)132 void RtcpTransceiver::SendPictureLossIndication(uint32_t ssrc) {
133 RTC_CHECK(rtcp_transceiver_);
134 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
135 task_queue_->PostTask(
136 ToQueuedTask([ptr, ssrc] { ptr->SendPictureLossIndication(ssrc); }));
137 }
138
SendFullIntraRequest(std::vector<uint32_t> ssrcs)139 void RtcpTransceiver::SendFullIntraRequest(std::vector<uint32_t> ssrcs) {
140 return SendFullIntraRequest(std::move(ssrcs), true);
141 }
142
SendFullIntraRequest(std::vector<uint32_t> ssrcs,bool new_request)143 void RtcpTransceiver::SendFullIntraRequest(std::vector<uint32_t> ssrcs,
144 bool new_request) {
145 RTC_CHECK(rtcp_transceiver_);
146 RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
147 task_queue_->PostTask(
148 ToQueuedTask([ptr, ssrcs = std::move(ssrcs), new_request] {
149 ptr->SendFullIntraRequest(ssrcs, new_request);
150 }));
151 }
152
153 } // namespace webrtc
154