From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- third_party/libwebrtc/call/rtp_config.h | 172 ++++++++++++++++++++++++++++++++ 1 file changed, 172 insertions(+) create mode 100644 third_party/libwebrtc/call/rtp_config.h (limited to 'third_party/libwebrtc/call/rtp_config.h') diff --git a/third_party/libwebrtc/call/rtp_config.h b/third_party/libwebrtc/call/rtp_config.h new file mode 100644 index 0000000000..0cc9466a9f --- /dev/null +++ b/third_party/libwebrtc/call/rtp_config.h @@ -0,0 +1,172 @@ +/* + * Copyright (c) 2017 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. + */ + +#ifndef CALL_RTP_CONFIG_H_ +#define CALL_RTP_CONFIG_H_ + +#include +#include + +#include +#include + +#include "absl/types/optional.h" +#include "api/rtp_headers.h" +#include "api/rtp_parameters.h" + +namespace webrtc { +// Currently only VP8/VP9 specific. +struct RtpPayloadState { + int16_t picture_id = -1; + uint8_t tl0_pic_idx = 0; + int64_t shared_frame_id = 0; +}; + +// Settings for LNTF (LossNotification). Still highly experimental. +struct LntfConfig { + std::string ToString() const; + + bool enabled{false}; +}; + +// Settings for NACK, see RFC 4585 for details. +struct NackConfig { + NackConfig() : rtp_history_ms(0) {} + std::string ToString() const; + // Send side: the time RTP packets are stored for retransmissions. + // Receive side: the time the receiver is prepared to wait for + // retransmissions. + // Set to '0' to disable. + int rtp_history_ms; +}; + +// Settings for ULPFEC forward error correction. +// Set the payload types to '-1' to disable. +struct UlpfecConfig { + UlpfecConfig() + : ulpfec_payload_type(-1), + red_payload_type(-1), + red_rtx_payload_type(-1) {} + std::string ToString() const; + bool operator==(const UlpfecConfig& other) const; + + // Payload type used for ULPFEC packets. + int ulpfec_payload_type; + + // Payload type used for RED packets. + int red_payload_type; + + // RTX payload type for RED payload. + int red_rtx_payload_type; +}; + +static const size_t kDefaultMaxPacketSize = 1500 - 40; // TCP over IPv4. +struct RtpConfig { + RtpConfig(); + RtpConfig(const RtpConfig&); + ~RtpConfig(); + std::string ToString() const; + + std::vector ssrcs; + + // The Rtp Stream Ids (aka RIDs) to send in the RID RTP header extension + // if the extension is included in the list of extensions. + // If rids are specified, they should correspond to the `ssrcs` vector. + // This means that: + // 1. rids.size() == 0 || rids.size() == ssrcs.size(). + // 2. If rids is not empty, then `rids[i]` should use `ssrcs[i]`. + std::vector rids; + + // The value to send in the MID RTP header extension if the extension is + // included in the list of extensions. + std::string mid; + + // See RtcpMode for description. + RtcpMode rtcp_mode = RtcpMode::kCompound; + + // Max RTP packet size delivered to send transport from VideoEngine. + size_t max_packet_size = kDefaultMaxPacketSize; + + // Corresponds to the SDP attribute extmap-allow-mixed. + bool extmap_allow_mixed = false; + + // RTP header extensions to use for this send stream. + std::vector extensions; + + // TODO(nisse): For now, these are fixed, but we'd like to support + // changing codec without recreating the VideoSendStream. Then these + // fields must be removed, and association between payload type and codec + // must move above the per-stream level. Ownership could be with + // RtpTransportControllerSend, with a reference from RtpVideoSender, where + // the latter would be responsible for mapping the codec type of encoded + // images to the right payload type. + std::string payload_name; + int payload_type = -1; + // Payload should be packetized using raw packetizer (payload header will + // not be added, additional meta data is expected to be present in generic + // frame descriptor RTP header extension). + bool raw_payload = false; + + // See LntfConfig for description. + LntfConfig lntf; + + // See NackConfig for description. + NackConfig nack; + + // See UlpfecConfig for description. + UlpfecConfig ulpfec; + + struct Flexfec { + Flexfec(); + Flexfec(const Flexfec&); + ~Flexfec(); + // Payload type of FlexFEC. Set to -1 to disable sending FlexFEC. + int payload_type = -1; + + // SSRC of FlexFEC stream. + uint32_t ssrc = 0; + + // Vector containing a single element, corresponding to the SSRC of the + // media stream being protected by this FlexFEC stream. + // The vector MUST have size 1. + // + // TODO(brandtr): Update comment above when we support + // multistream protection. + std::vector protected_media_ssrcs; + } flexfec; + + // Settings for RTP retransmission payload format, see RFC 4588 for + // details. + struct Rtx { + Rtx(); + Rtx(const Rtx&); + ~Rtx(); + std::string ToString() const; + // SSRCs to use for the RTX streams. + std::vector ssrcs; + + // Payload type to use for the RTX stream. + int payload_type = -1; + } rtx; + + // RTCP CNAME, see RFC 3550. + std::string c_name; + + bool IsMediaSsrc(uint32_t ssrc) const; + bool IsRtxSsrc(uint32_t ssrc) const; + bool IsFlexfecSsrc(uint32_t ssrc) const; + absl::optional GetRtxSsrcAssociatedWithMediaSsrc( + uint32_t media_ssrc) const; + uint32_t GetMediaSsrcAssociatedWithRtxSsrc(uint32_t rtx_ssrc) const; + uint32_t GetMediaSsrcAssociatedWithFlexfecSsrc(uint32_t flexfec_ssrc) const; + absl::optional GetRidForSsrc(uint32_t ssrc) const; +}; +} // namespace webrtc +#endif // CALL_RTP_CONFIG_H_ -- cgit v1.2.3