OLD | NEW |
(Empty) | |
| 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 |
| 11 #include "webrtc/modules/rtp_rtcp/include/flexfec_sender.h" |
| 12 |
| 13 #include <utility> |
| 14 |
| 15 #include "webrtc/base/logging.h" |
| 16 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" |
| 17 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h" |
| 18 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h" |
| 19 |
| 20 namespace webrtc { |
| 21 |
| 22 namespace { |
| 23 |
| 24 // Let first sequence number be in the first half of the interval. |
| 25 constexpr uint16_t kMaxInitRtpSeqNumber = 0x7fff; |
| 26 |
| 27 // See breakdown in flexfec_header_reader_writer.cc. |
| 28 constexpr size_t kFlexfecMaxHeaderSize = 32; |
| 29 |
| 30 // Since we will mainly use FlexFEC to protect video streams, we use a 90 kHz |
| 31 // clock for the RTP timestamps. (This is according to the RFC, which states |
| 32 // that it is RECOMMENDED to use the same clock frequency for FlexFEC as for |
| 33 // the protected media stream.) |
| 34 // The constant converts from clock millisecond timestamps to the 90 kHz |
| 35 // RTP timestamp. |
| 36 const int kMsToRtpTimestamp = kVideoPayloadTypeFrequency / 1000; |
| 37 |
| 38 // How often to log the generated FEC packets to the text log. |
| 39 constexpr int64_t kPacketLogIntervalMs = 10000; |
| 40 |
| 41 } // namespace |
| 42 |
| 43 FlexfecSender::FlexfecSender( |
| 44 int payload_type, |
| 45 uint32_t ssrc, |
| 46 uint32_t protected_media_ssrc, |
| 47 const std::vector<RtpExtension>& rtp_header_extensions, |
| 48 Clock* clock) |
| 49 : clock_(clock), |
| 50 random_(clock_->TimeInMicroseconds()), |
| 51 last_generated_packet_ms_(-1), |
| 52 payload_type_(payload_type), |
| 53 // Initialize the timestamp offset and RTP sequence numbers randomly. |
| 54 // (This is not intended to be cryptographically strong.) |
| 55 timestamp_offset_(random_.Rand<uint32_t>()), |
| 56 ssrc_(ssrc), |
| 57 protected_media_ssrc_(protected_media_ssrc), |
| 58 seq_num_(random_.Rand(1, kMaxInitRtpSeqNumber)), |
| 59 ulpfec_generator_(ForwardErrorCorrection::CreateFlexfec()), |
| 60 rtp_header_extension_map_() { |
| 61 // This object should not have been instantiated if FlexFEC is disabled. |
| 62 RTC_DCHECK_GE(payload_type, 0); |
| 63 RTC_DCHECK_LE(payload_type, 127); |
| 64 |
| 65 // It's OK to create this object on a different thread/task queue than |
| 66 // the one used during main operation. |
| 67 sequence_checker_.Detach(); |
| 68 |
| 69 // Register RTP header extensions for BWE. |
| 70 for (const auto& extension : rtp_header_extensions) { |
| 71 if (extension.uri == RtpExtension::kTransportSequenceNumberUri) { |
| 72 rtp_header_extension_map_.Register(kRtpExtensionTransportSequenceNumber, |
| 73 extension.id); |
| 74 } else if (extension.uri == RtpExtension::kAbsSendTimeUri) { |
| 75 rtp_header_extension_map_.Register(kRtpExtensionAbsoluteSendTime, |
| 76 extension.id); |
| 77 } else if (extension.uri == RtpExtension::kTimestampOffsetUri) { |
| 78 rtp_header_extension_map_.Register(kRtpExtensionTransmissionTimeOffset, |
| 79 extension.id); |
| 80 } else { |
| 81 LOG(LS_WARNING) << "RTP header extension with id: " << extension.id |
| 82 << ", uri: " << extension.uri |
| 83 << ", is unsupported by FlexfecSender."; |
| 84 } |
| 85 } |
| 86 } |
| 87 |
| 88 FlexfecSender::~FlexfecSender() = default; |
| 89 |
| 90 // We are reusing the implementation from UlpfecGenerator for SetFecParameters, |
| 91 // AddRtpPacketAndGenerateFec, and FecAvailable. |
| 92 void FlexfecSender::SetFecParameters(const FecProtectionParams& params) { |
| 93 RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); |
| 94 ulpfec_generator_.SetFecParameters(¶ms); |
| 95 } |
| 96 |
| 97 bool FlexfecSender::AddRtpPacketAndGenerateFec( |
| 98 const RtpPacketToSend& packet) { |
| 99 RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); |
| 100 // TODO(brandtr): Generalize this SSRC check when we support multistream |
| 101 // protection. |
| 102 RTC_DCHECK_EQ(packet.Ssrc(), protected_media_ssrc_); |
| 103 return ulpfec_generator_.AddRtpPacketAndGenerateFec( |
| 104 packet.data(), packet.payload_size(), packet.headers_size()) == 0; |
| 105 } |
| 106 |
| 107 bool FlexfecSender::FecAvailable() const { |
| 108 RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); |
| 109 return ulpfec_generator_.FecAvailable(); |
| 110 } |
| 111 |
| 112 std::vector<std::unique_ptr<RtpPacketToSend>> |
| 113 FlexfecSender::GetFecPackets() { |
| 114 RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); |
| 115 |
| 116 std::vector<std::unique_ptr<RtpPacketToSend>> fec_packets_to_send; |
| 117 fec_packets_to_send.reserve(ulpfec_generator_.generated_fec_packets_.size()); |
| 118 for (const auto& fec_packet : ulpfec_generator_.generated_fec_packets_) { |
| 119 std::unique_ptr<RtpPacketToSend> fec_packet_to_send( |
| 120 new RtpPacketToSend(&rtp_header_extension_map_)); |
| 121 |
| 122 // RTP header. |
| 123 fec_packet_to_send->SetMarker(false); |
| 124 fec_packet_to_send->SetPayloadType(payload_type_); |
| 125 fec_packet_to_send->SetSequenceNumber(seq_num_++); |
| 126 fec_packet_to_send->SetTimestamp( |
| 127 timestamp_offset_ + |
| 128 static_cast<uint32_t>(kMsToRtpTimestamp * |
| 129 clock_->TimeInMilliseconds())); |
| 130 // Set "capture time" so that the TransmissionOffset header extension |
| 131 // can be set by the RTPSender. |
| 132 fec_packet_to_send->set_capture_time_ms(clock_->TimeInMilliseconds()); |
| 133 fec_packet_to_send->SetSsrc(ssrc_); |
| 134 // Reserve extensions, if registered. These will be set by the RTPSender. |
| 135 fec_packet_to_send->ReserveExtension<AbsoluteSendTime>(); |
| 136 fec_packet_to_send->ReserveExtension<TransmissionOffset>(); |
| 137 fec_packet_to_send->ReserveExtension<TransportSequenceNumber>(); |
| 138 |
| 139 // RTP payload. |
| 140 uint8_t* payload = fec_packet_to_send->AllocatePayload(fec_packet->length); |
| 141 memcpy(payload, fec_packet->data, fec_packet->length); |
| 142 |
| 143 fec_packets_to_send.push_back(std::move(fec_packet_to_send)); |
| 144 } |
| 145 ulpfec_generator_.ResetState(); |
| 146 |
| 147 // TODO(brandtr): Remove this log output when the FlexFEC subsystem is |
| 148 // properly wired up in a robust way. |
| 149 int64_t now_ms = clock_->TimeInMilliseconds(); |
| 150 if (!fec_packets_to_send.empty() && |
| 151 now_ms - last_generated_packet_ms_ > kPacketLogIntervalMs) { |
| 152 LOG(LS_INFO) << "Generated " << fec_packets_to_send.size() |
| 153 << " FlexFEC packets with payload type: " << payload_type_ |
| 154 << " and SSRC: " << ssrc_ << "."; |
| 155 last_generated_packet_ms_ = now_ms; |
| 156 } |
| 157 |
| 158 return fec_packets_to_send; |
| 159 } |
| 160 |
| 161 size_t FlexfecSender::MaxPacketOverhead() const { |
| 162 return kFlexfecMaxHeaderSize; |
| 163 } |
| 164 |
| 165 } // namespace webrtc |
OLD | NEW |