summaryrefslogtreecommitdiffstats
path: root/third_party/libwebrtc/call/flexfec_receive_stream_impl.cc
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:22:09 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:22:09 +0000
commit43a97878ce14b72f0981164f87f2e35e14151312 (patch)
tree620249daf56c0258faa40cbdcf9cfba06de2a846 /third_party/libwebrtc/call/flexfec_receive_stream_impl.cc
parentInitial commit. (diff)
downloadfirefox-43a97878ce14b72f0981164f87f2e35e14151312.tar.xz
firefox-43a97878ce14b72f0981164f87f2e35e14151312.zip
Adding upstream version 110.0.1.upstream/110.0.1upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/libwebrtc/call/flexfec_receive_stream_impl.cc')
-rw-r--r--third_party/libwebrtc/call/flexfec_receive_stream_impl.cc223
1 files changed, 223 insertions, 0 deletions
diff --git a/third_party/libwebrtc/call/flexfec_receive_stream_impl.cc b/third_party/libwebrtc/call/flexfec_receive_stream_impl.cc
new file mode 100644
index 0000000000..9e00078f96
--- /dev/null
+++ b/third_party/libwebrtc/call/flexfec_receive_stream_impl.cc
@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "call/flexfec_receive_stream_impl.h"
+
+#include <stddef.h>
+
+#include <cstdint>
+#include <string>
+#include <utility>
+
+#include "api/array_view.h"
+#include "api/call/transport.h"
+#include "api/rtp_parameters.h"
+#include "call/rtp_stream_receiver_controller_interface.h"
+#include "modules/rtp_rtcp/include/flexfec_receiver.h"
+#include "modules/rtp_rtcp/include/receive_statistics.h"
+#include "modules/rtp_rtcp/source/rtp_packet_received.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/location.h"
+#include "rtc_base/logging.h"
+#include "rtc_base/strings/string_builder.h"
+#include "system_wrappers/include/clock.h"
+
+namespace webrtc {
+
+std::string FlexfecReceiveStream::Config::ToString() const {
+ char buf[1024];
+ rtc::SimpleStringBuilder ss(buf);
+ ss << "{payload_type: " << payload_type;
+ ss << ", remote_ssrc: " << rtp.remote_ssrc;
+ ss << ", local_ssrc: " << rtp.local_ssrc;
+ ss << ", protected_media_ssrcs: [";
+ size_t i = 0;
+ for (; i + 1 < protected_media_ssrcs.size(); ++i)
+ ss << protected_media_ssrcs[i] << ", ";
+ if (!protected_media_ssrcs.empty())
+ ss << protected_media_ssrcs[i];
+ ss << "], transport_cc: " << (rtp.transport_cc ? "on" : "off");
+ ss << ", rtp.extensions: [";
+ i = 0;
+ for (; i + 1 < rtp.extensions.size(); ++i)
+ ss << rtp.extensions[i].ToString() << ", ";
+ if (!rtp.extensions.empty())
+ ss << rtp.extensions[i].ToString();
+ ss << "]}";
+ return ss.str();
+}
+
+bool FlexfecReceiveStream::Config::IsCompleteAndEnabled() const {
+ // Check if FlexFEC is enabled.
+ if (payload_type < 0)
+ return false;
+ // Do we have the necessary SSRC information?
+ if (rtp.remote_ssrc == 0)
+ return false;
+ // TODO(brandtr): Update this check when we support multistream protection.
+ if (protected_media_ssrcs.size() != 1u)
+ return false;
+ return true;
+}
+
+namespace {
+
+// TODO(brandtr): Update this function when we support multistream protection.
+std::unique_ptr<FlexfecReceiver> MaybeCreateFlexfecReceiver(
+ Clock* clock,
+ const FlexfecReceiveStream::Config& config,
+ RecoveredPacketReceiver* recovered_packet_receiver) {
+ if (config.payload_type < 0) {
+ RTC_LOG(LS_WARNING)
+ << "Invalid FlexFEC payload type given. "
+ "This FlexfecReceiveStream will therefore be useless.";
+ return nullptr;
+ }
+ RTC_DCHECK_GE(config.payload_type, 0);
+ RTC_DCHECK_LE(config.payload_type, 127);
+ if (config.rtp.remote_ssrc == 0) {
+ RTC_LOG(LS_WARNING)
+ << "Invalid FlexFEC SSRC given. "
+ "This FlexfecReceiveStream will therefore be useless.";
+ return nullptr;
+ }
+ if (config.protected_media_ssrcs.empty()) {
+ RTC_LOG(LS_WARNING)
+ << "No protected media SSRC supplied. "
+ "This FlexfecReceiveStream will therefore be useless.";
+ return nullptr;
+ }
+
+ if (config.protected_media_ssrcs.size() > 1) {
+ RTC_LOG(LS_WARNING)
+ << "The supplied FlexfecConfig contained multiple protected "
+ "media streams, but our implementation currently only "
+ "supports protecting a single media stream. "
+ "To avoid confusion, disabling FlexFEC completely.";
+ return nullptr;
+ }
+ RTC_DCHECK_EQ(1U, config.protected_media_ssrcs.size());
+ return std::unique_ptr<FlexfecReceiver>(new FlexfecReceiver(
+ clock, config.rtp.remote_ssrc, config.protected_media_ssrcs[0],
+ recovered_packet_receiver));
+}
+
+std::unique_ptr<ModuleRtpRtcpImpl2> CreateRtpRtcpModule(
+ Clock* clock,
+ ReceiveStatistics* receive_statistics,
+ const FlexfecReceiveStreamImpl::Config& config,
+ RtcpRttStats* rtt_stats) {
+ RtpRtcpInterface::Configuration configuration;
+ configuration.audio = false;
+ configuration.receiver_only = true;
+ configuration.clock = clock;
+ configuration.receive_statistics = receive_statistics;
+ configuration.outgoing_transport = config.rtcp_send_transport;
+ configuration.rtt_stats = rtt_stats;
+ configuration.local_media_ssrc = config.rtp.local_ssrc;
+ return ModuleRtpRtcpImpl2::Create(configuration);
+}
+
+} // namespace
+
+FlexfecReceiveStreamImpl::FlexfecReceiveStreamImpl(
+ Clock* clock,
+ Config config,
+ RecoveredPacketReceiver* recovered_packet_receiver,
+ RtcpRttStats* rtt_stats)
+ : extension_map_(std::move(config.rtp.extensions)),
+ remote_ssrc_(config.rtp.remote_ssrc),
+ transport_cc_(config.rtp.transport_cc),
+ payload_type_(config.payload_type),
+ receiver_(
+ MaybeCreateFlexfecReceiver(clock, config, recovered_packet_receiver)),
+ rtp_receive_statistics_(ReceiveStatistics::Create(clock)),
+ rtp_rtcp_(CreateRtpRtcpModule(clock,
+ rtp_receive_statistics_.get(),
+ config,
+ rtt_stats)) {
+ RTC_LOG(LS_INFO) << "FlexfecReceiveStreamImpl: " << config.ToString();
+ RTC_DCHECK_GE(payload_type_, -1);
+
+ packet_sequence_checker_.Detach();
+
+ // RTCP reporting.
+ rtp_rtcp_->SetRTCPStatus(config.rtcp_mode);
+}
+
+FlexfecReceiveStreamImpl::~FlexfecReceiveStreamImpl() {
+ RTC_DLOG(LS_INFO) << "~FlexfecReceiveStreamImpl: ssrc: " << remote_ssrc_;
+}
+
+void FlexfecReceiveStreamImpl::RegisterWithTransport(
+ RtpStreamReceiverControllerInterface* receiver_controller) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
+ RTC_DCHECK(!rtp_stream_receiver_);
+
+ if (!receiver_)
+ return;
+
+ // TODO(nisse): OnRtpPacket in this class delegates all real work to
+ // `receiver_`. So maybe we don't need to implement RtpPacketSinkInterface
+ // here at all, we'd then delete the OnRtpPacket method and instead register
+ // `receiver_` as the RtpPacketSinkInterface for this stream.
+ rtp_stream_receiver_ =
+ receiver_controller->CreateReceiver(remote_ssrc(), this);
+}
+
+void FlexfecReceiveStreamImpl::UnregisterFromTransport() {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
+ rtp_stream_receiver_.reset();
+}
+
+void FlexfecReceiveStreamImpl::OnRtpPacket(const RtpPacketReceived& packet) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
+ if (!receiver_)
+ return;
+
+ receiver_->OnRtpPacket(packet);
+
+ // Do not report media packets in the RTCP RRs generated by `rtp_rtcp_`.
+ if (packet.Ssrc() == remote_ssrc()) {
+ rtp_receive_statistics_->OnRtpPacket(packet);
+ }
+}
+
+void FlexfecReceiveStreamImpl::SetPayloadType(int payload_type) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
+ RTC_DCHECK_GE(payload_type, -1);
+ payload_type_ = payload_type;
+}
+
+int FlexfecReceiveStreamImpl::payload_type() const {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
+ return payload_type_;
+}
+
+void FlexfecReceiveStreamImpl::SetRtpExtensions(
+ std::vector<RtpExtension> extensions) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
+ extension_map_.Reset(extensions);
+}
+
+RtpHeaderExtensionMap FlexfecReceiveStreamImpl::GetRtpExtensionMap() const {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
+ return extension_map_;
+}
+
+void FlexfecReceiveStreamImpl::SetLocalSsrc(uint32_t local_ssrc) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
+ if (local_ssrc == rtp_rtcp_->local_media_ssrc())
+ return;
+
+ rtp_rtcp_->SetLocalSsrc(local_ssrc);
+}
+
+} // namespace webrtc