rtp_packet_to_send.h (6999B)
1 /* 2 * Copyright (c) 2016 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 #ifndef MODULES_RTP_RTCP_SOURCE_RTP_PACKET_TO_SEND_H_ 11 #define MODULES_RTP_RTCP_SOURCE_RTP_PACKET_TO_SEND_H_ 12 13 #include <stddef.h> 14 #include <stdint.h> 15 16 #include <optional> 17 #include <utility> 18 19 #include "api/ref_counted_base.h" 20 #include "api/scoped_refptr.h" 21 #include "api/units/time_delta.h" 22 #include "api/units/timestamp.h" 23 #include "api/video/video_timing.h" 24 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" 25 #include "modules/rtp_rtcp/source/rtp_header_extensions.h" 26 #include "modules/rtp_rtcp/source/rtp_packet.h" 27 28 namespace webrtc { 29 // Class to hold rtp packet with metadata for sender side. 30 // The metadata is not send over the wire, but packet sender may use it to 31 // create rtp header extensions or other data that is sent over the wire. 32 class RtpPacketToSend : public RtpPacket { 33 public: 34 // RtpPacketToSend::Type is deprecated. Use RtpPacketMediaType directly. 35 using Type = RtpPacketMediaType; 36 37 explicit RtpPacketToSend(const ExtensionManager* extensions); 38 RtpPacketToSend(const ExtensionManager* extensions, size_t capacity); 39 RtpPacketToSend(const RtpPacketToSend& packet); 40 RtpPacketToSend(RtpPacketToSend&& packet); 41 42 RtpPacketToSend& operator=(const RtpPacketToSend& packet); 43 RtpPacketToSend& operator=(RtpPacketToSend&& packet); 44 45 ~RtpPacketToSend(); 46 47 // Time in local time base as close as it can to frame capture time. 48 class Timestamp capture_time() const { return capture_time_; } 49 void set_capture_time(class Timestamp time) { capture_time_ = time; } 50 51 void set_packet_type(RtpPacketMediaType type); 52 53 std::optional<RtpPacketMediaType> packet_type() const { return packet_type_; } 54 55 enum class OriginalType { kAudio, kVideo }; 56 // Original type does not change if packet type is changed to kRetransmission. 57 std::optional<OriginalType> original_packet_type() const { 58 return original_packet_type_; 59 } 60 61 // If this is a retransmission, indicates the sequence number of the original 62 // media packet that this packet represents. If RTX is used this will likely 63 // be different from SequenceNumber(). 64 void set_retransmitted_sequence_number(uint16_t sequence_number) { 65 retransmitted_sequence_number_ = sequence_number; 66 } 67 std::optional<uint16_t> retransmitted_sequence_number() const { 68 return retransmitted_sequence_number_; 69 } 70 71 // If this is a retransmission, indicates the SSRC of the original 72 // media packet that this packet represents. 73 void set_original_ssrc(uint32_t ssrc) { original_ssrc_ = ssrc; } 74 std::optional<uint32_t> original_ssrc() const { return original_ssrc_; } 75 76 void set_allow_retransmission(bool allow_retransmission) { 77 allow_retransmission_ = allow_retransmission; 78 } 79 bool allow_retransmission() const { return allow_retransmission_; } 80 81 // An application can attach arbitrary data to an RTP packet using 82 // `additional_data`. The additional data does not affect WebRTC processing. 83 scoped_refptr<RefCountedBase> additional_data() const { 84 return additional_data_; 85 } 86 void set_additional_data(scoped_refptr<RefCountedBase> data) { 87 additional_data_ = std::move(data); 88 } 89 90 void set_packetization_finish_time(class Timestamp time) { 91 SetExtension<VideoTimingExtension>( 92 VideoSendTiming::GetDeltaCappedMs(time - capture_time_), 93 VideoTimingExtension::kPacketizationFinishDeltaOffset); 94 } 95 96 void set_pacer_exit_time(class Timestamp time) { 97 SetExtension<VideoTimingExtension>( 98 VideoSendTiming::GetDeltaCappedMs(time - capture_time_), 99 VideoTimingExtension::kPacerExitDeltaOffset); 100 } 101 102 void set_network_time(class Timestamp time) { 103 SetExtension<VideoTimingExtension>( 104 VideoSendTiming::GetDeltaCappedMs(time - capture_time_), 105 VideoTimingExtension::kNetworkTimestampDeltaOffset); 106 } 107 108 void set_network2_time(class Timestamp time) { 109 SetExtension<VideoTimingExtension>( 110 VideoSendTiming::GetDeltaCappedMs(time - capture_time_), 111 VideoTimingExtension::kNetwork2TimestampDeltaOffset); 112 } 113 114 // Indicates if packet is the first packet of a video frame. 115 void set_first_packet_of_frame(bool is_first_packet) { 116 is_first_packet_of_frame_ = is_first_packet; 117 } 118 bool is_first_packet_of_frame() const { return is_first_packet_of_frame_; } 119 120 // Indicates if packet contains payload for a video key-frame. 121 void set_is_key_frame(bool is_key_frame) { is_key_frame_ = is_key_frame; } 122 bool is_key_frame() const { return is_key_frame_; } 123 124 // Indicates if packets should be protected by FEC (Forward Error Correction). 125 void set_fec_protect_packet(bool protect) { fec_protect_packet_ = protect; } 126 bool fec_protect_packet() const { return fec_protect_packet_; } 127 128 // Indicates if packet is using RED encapsulation, in accordance with 129 // https://tools.ietf.org/html/rfc2198 130 void set_is_red(bool is_red) { is_red_ = is_red; } 131 bool is_red() const { return is_red_; } 132 133 // The amount of time spent in the send queue, used for totalPacketSendDelay. 134 // https://w3c.github.io/webrtc-stats/#dom-rtcoutboundrtpstreamstats-totalpacketsenddelay 135 void set_time_in_send_queue(TimeDelta time_in_send_queue) { 136 time_in_send_queue_ = time_in_send_queue; 137 } 138 std::optional<TimeDelta> time_in_send_queue() const { 139 return time_in_send_queue_; 140 } 141 // A sequence number guaranteed to be monotically increasing by one for all 142 // packets where transport feedback is expected. 143 std::optional<int64_t> transport_sequence_number() const { 144 return transport_sequence_number_; 145 } 146 void set_transport_sequence_number(int64_t transport_sequence_number) { 147 transport_sequence_number_ = transport_sequence_number; 148 } 149 // Transport is capable of handling explicit congestion notification and the 150 // RTP packet should be sent as ect(1) 151 // https://www.rfc-editor.org/rfc/rfc9331.html 152 bool send_as_ect1() const { return send_as_ect1_; } 153 void set_send_as_ect1() { send_as_ect1_ = true; } 154 155 private: 156 class Timestamp capture_time_ = Timestamp::Zero(); 157 std::optional<RtpPacketMediaType> packet_type_; 158 std::optional<OriginalType> original_packet_type_; 159 std::optional<uint32_t> original_ssrc_; 160 std::optional<int64_t> transport_sequence_number_; 161 bool allow_retransmission_ = false; 162 std::optional<uint16_t> retransmitted_sequence_number_; 163 scoped_refptr<RefCountedBase> additional_data_; 164 bool is_first_packet_of_frame_ = false; 165 bool is_key_frame_ = false; 166 bool fec_protect_packet_ = false; 167 bool is_red_ = false; 168 bool send_as_ect1_ = false; 169 std::optional<TimeDelta> time_in_send_queue_; 170 }; 171 172 } // namespace webrtc 173 #endif // MODULES_RTP_RTCP_SOURCE_RTP_PACKET_TO_SEND_H_