andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2012 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 | |
pbos@webrtc.org | 281cff8 | 2013-05-17 13:44:48 +0000 | [diff] [blame] | 11 | #include "webrtc/video_engine/vie_receiver.h" |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 12 | |
mflodman@webrtc.org | cd1ac8b | 2013-02-06 17:46:39 +0000 | [diff] [blame] | 13 | #include <vector> |
| 14 | |
pbos@webrtc.org | 281cff8 | 2013-05-17 13:44:48 +0000 | [diff] [blame] | 15 | #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h" |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 16 | #include "webrtc/modules/rtp_rtcp/interface/fec_receiver.h" |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 17 | #include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h" |
wu@webrtc.org | 2fae0d1 | 2014-05-14 16:53:51 +0000 | [diff] [blame] | 18 | #include "webrtc/modules/rtp_rtcp/interface/remote_ntp_time_estimator.h" |
stefan@webrtc.org | 6696fba | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 19 | #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h" |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 20 | #include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h" |
| 21 | #include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h" |
pbos@webrtc.org | 281cff8 | 2013-05-17 13:44:48 +0000 | [diff] [blame] | 22 | #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h" |
| 23 | #include "webrtc/modules/utility/interface/rtp_dump.h" |
| 24 | #include "webrtc/modules/video_coding/main/interface/video_coding.h" |
| 25 | #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" |
wu@webrtc.org | 093fc0b | 2014-04-24 22:10:24 +0000 | [diff] [blame] | 26 | #include "webrtc/system_wrappers/interface/logging.h" |
pbos@webrtc.org | 281cff8 | 2013-05-17 13:44:48 +0000 | [diff] [blame] | 27 | #include "webrtc/system_wrappers/interface/tick_util.h" |
wu@webrtc.org | d2fb259 | 2014-05-07 17:09:44 +0000 | [diff] [blame] | 28 | #include "webrtc/system_wrappers/interface/timestamp_extrapolator.h" |
wu@webrtc.org | 2fae0d1 | 2014-05-14 16:53:51 +0000 | [diff] [blame] | 29 | #include "webrtc/system_wrappers/interface/trace.h" |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 30 | |
| 31 | namespace webrtc { |
| 32 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 33 | ViEReceiver::ViEReceiver(const int32_t channel_id, |
| 34 | VideoCodingModule* module_vcm, |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 35 | RemoteBitrateEstimator* remote_bitrate_estimator, |
| 36 | RtpFeedback* rtp_feedback) |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 37 | : receive_cs_(CriticalSectionWrapper::CreateCriticalSection()), |
stefan@webrtc.org | 6696fba | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 38 | rtp_header_parser_(RtpHeaderParser::Create()), |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 39 | rtp_payload_registry_(new RTPPayloadRegistry( |
andresp@webrtc.org | 9968131 | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 40 | RTPPayloadStrategy::CreateStrategy(false))), |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 41 | rtp_receiver_(RtpReceiver::CreateVideoReceiver( |
| 42 | channel_id, Clock::GetRealTimeClock(), this, rtp_feedback, |
| 43 | rtp_payload_registry_.get())), |
| 44 | rtp_receive_statistics_(ReceiveStatistics::Create( |
| 45 | Clock::GetRealTimeClock())), |
andresp@webrtc.org | 9968131 | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 46 | fec_receiver_(FecReceiver::Create(this)), |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 47 | rtp_rtcp_(NULL), |
| 48 | vcm_(module_vcm), |
| 49 | remote_bitrate_estimator_(remote_bitrate_estimator), |
wu@webrtc.org | 2fae0d1 | 2014-05-14 16:53:51 +0000 | [diff] [blame] | 50 | ntp_estimator_(new RemoteNtpTimeEstimator(Clock::GetRealTimeClock())), |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 51 | rtp_dump_(NULL), |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 52 | receiving_(false), |
solenberg@webrtc.org | 2d3624c | 2014-03-24 20:28:11 +0000 | [diff] [blame] | 53 | restored_packet_in_use_(false), |
| 54 | receiving_ast_enabled_(false) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 55 | assert(remote_bitrate_estimator); |
| 56 | } |
| 57 | |
| 58 | ViEReceiver::~ViEReceiver() { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 59 | if (rtp_dump_) { |
| 60 | rtp_dump_->Stop(); |
| 61 | RtpDump::DestroyRtpDump(rtp_dump_); |
| 62 | rtp_dump_ = NULL; |
| 63 | } |
| 64 | } |
| 65 | |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 66 | bool ViEReceiver::SetReceiveCodec(const VideoCodec& video_codec) { |
| 67 | int8_t old_pltype = -1; |
| 68 | if (rtp_payload_registry_->ReceivePayloadType(video_codec.plName, |
| 69 | kVideoPayloadTypeFrequency, |
| 70 | 0, |
| 71 | video_codec.maxBitrate, |
| 72 | &old_pltype) != -1) { |
| 73 | rtp_payload_registry_->DeRegisterReceivePayload(old_pltype); |
| 74 | } |
| 75 | |
| 76 | return RegisterPayload(video_codec); |
| 77 | } |
| 78 | |
| 79 | bool ViEReceiver::RegisterPayload(const VideoCodec& video_codec) { |
| 80 | return rtp_receiver_->RegisterReceivePayload(video_codec.plName, |
| 81 | video_codec.plType, |
| 82 | kVideoPayloadTypeFrequency, |
| 83 | 0, |
| 84 | video_codec.maxBitrate) == 0; |
| 85 | } |
| 86 | |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 87 | void ViEReceiver::SetNackStatus(bool enable, |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 88 | int max_nack_reordering_threshold) { |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 89 | if (!enable) { |
| 90 | // Reset the threshold back to the lower default threshold when NACK is |
| 91 | // disabled since we no longer will be receiving retransmissions. |
| 92 | max_nack_reordering_threshold = kDefaultMaxReorderingThreshold; |
| 93 | } |
| 94 | rtp_receive_statistics_->SetMaxReorderingThreshold( |
| 95 | max_nack_reordering_threshold); |
| 96 | rtp_receiver_->SetNACKStatus(enable ? kNackRtcp : kNackOff); |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 97 | } |
| 98 | |
stefan@webrtc.org | 903e746 | 2014-06-05 08:25:29 +0000 | [diff] [blame^] | 99 | void ViEReceiver::SetRtxPayloadType(int payload_type) { |
| 100 | rtp_payload_registry_->SetRtxPayloadType(payload_type); |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 101 | } |
| 102 | |
stefan@webrtc.org | 903e746 | 2014-06-05 08:25:29 +0000 | [diff] [blame^] | 103 | void ViEReceiver::SetRtxSsrc(uint32_t ssrc) { |
| 104 | rtp_payload_registry_->SetRtxSsrc(ssrc); |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 105 | } |
| 106 | |
| 107 | uint32_t ViEReceiver::GetRemoteSsrc() const { |
| 108 | return rtp_receiver_->SSRC(); |
| 109 | } |
| 110 | |
| 111 | int ViEReceiver::GetCsrcs(uint32_t* csrcs) const { |
| 112 | return rtp_receiver_->CSRCs(csrcs); |
| 113 | } |
| 114 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 115 | void ViEReceiver::SetRtpRtcpModule(RtpRtcp* module) { |
| 116 | rtp_rtcp_ = module; |
| 117 | } |
| 118 | |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 119 | RtpReceiver* ViEReceiver::GetRtpReceiver() const { |
| 120 | return rtp_receiver_.get(); |
| 121 | } |
| 122 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 123 | void ViEReceiver::RegisterSimulcastRtpRtcpModules( |
| 124 | const std::list<RtpRtcp*>& rtp_modules) { |
| 125 | CriticalSectionScoped cs(receive_cs_.get()); |
| 126 | rtp_rtcp_simulcast_.clear(); |
| 127 | |
| 128 | if (!rtp_modules.empty()) { |
| 129 | rtp_rtcp_simulcast_.insert(rtp_rtcp_simulcast_.begin(), |
| 130 | rtp_modules.begin(), |
| 131 | rtp_modules.end()); |
| 132 | } |
| 133 | } |
| 134 | |
stefan@webrtc.org | 4e5f983 | 2013-05-29 13:28:21 +0000 | [diff] [blame] | 135 | bool ViEReceiver::SetReceiveTimestampOffsetStatus(bool enable, int id) { |
stefan@webrtc.org | 6696fba | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 136 | if (enable) { |
| 137 | return rtp_header_parser_->RegisterRtpHeaderExtension( |
| 138 | kRtpExtensionTransmissionTimeOffset, id); |
| 139 | } else { |
| 140 | return rtp_header_parser_->DeregisterRtpHeaderExtension( |
| 141 | kRtpExtensionTransmissionTimeOffset); |
| 142 | } |
| 143 | } |
| 144 | |
stefan@webrtc.org | 4e5f983 | 2013-05-29 13:28:21 +0000 | [diff] [blame] | 145 | bool ViEReceiver::SetReceiveAbsoluteSendTimeStatus(bool enable, int id) { |
stefan@webrtc.org | 6696fba | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 146 | if (enable) { |
solenberg@webrtc.org | 2d3624c | 2014-03-24 20:28:11 +0000 | [diff] [blame] | 147 | if (rtp_header_parser_->RegisterRtpHeaderExtension( |
| 148 | kRtpExtensionAbsoluteSendTime, id)) { |
| 149 | receiving_ast_enabled_ = true; |
| 150 | return true; |
| 151 | } else { |
| 152 | return false; |
| 153 | } |
stefan@webrtc.org | 6696fba | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 154 | } else { |
solenberg@webrtc.org | 2d3624c | 2014-03-24 20:28:11 +0000 | [diff] [blame] | 155 | receiving_ast_enabled_ = false; |
stefan@webrtc.org | 6696fba | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 156 | return rtp_header_parser_->DeregisterRtpHeaderExtension( |
| 157 | kRtpExtensionAbsoluteSendTime); |
| 158 | } |
| 159 | } |
| 160 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 161 | int ViEReceiver::ReceivedRTPPacket(const void* rtp_packet, |
wu@webrtc.org | efeb8ce | 2013-12-13 00:21:03 +0000 | [diff] [blame] | 162 | int rtp_packet_length, |
| 163 | const PacketTime& packet_time) { |
solenberg@webrtc.org | 800136d | 2014-02-11 15:27:49 +0000 | [diff] [blame] | 164 | return InsertRTPPacket(static_cast<const uint8_t*>(rtp_packet), |
wu@webrtc.org | efeb8ce | 2013-12-13 00:21:03 +0000 | [diff] [blame] | 165 | rtp_packet_length, packet_time); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 166 | } |
| 167 | |
| 168 | int ViEReceiver::ReceivedRTCPPacket(const void* rtcp_packet, |
| 169 | int rtcp_packet_length) { |
solenberg@webrtc.org | 800136d | 2014-02-11 15:27:49 +0000 | [diff] [blame] | 170 | return InsertRTCPPacket(static_cast<const uint8_t*>(rtcp_packet), |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 171 | rtcp_packet_length); |
| 172 | } |
| 173 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 174 | int32_t ViEReceiver::OnReceivedPayloadData( |
| 175 | const uint8_t* payload_data, const uint16_t payload_size, |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 176 | const WebRtcRTPHeader* rtp_header) { |
wu@webrtc.org | 093fc0b | 2014-04-24 22:10:24 +0000 | [diff] [blame] | 177 | WebRtcRTPHeader rtp_header_with_ntp = *rtp_header; |
wu@webrtc.org | 2fae0d1 | 2014-05-14 16:53:51 +0000 | [diff] [blame] | 178 | rtp_header_with_ntp.ntp_time_ms = |
| 179 | ntp_estimator_->Estimate(rtp_header->header.timestamp); |
wu@webrtc.org | 093fc0b | 2014-04-24 22:10:24 +0000 | [diff] [blame] | 180 | if (vcm_->IncomingPacket(payload_data, |
| 181 | payload_size, |
| 182 | rtp_header_with_ntp) != 0) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 183 | // Check this... |
| 184 | return -1; |
| 185 | } |
| 186 | return 0; |
| 187 | } |
| 188 | |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 189 | bool ViEReceiver::OnRecoveredPacket(const uint8_t* rtp_packet, |
| 190 | int rtp_packet_length) { |
| 191 | RTPHeader header; |
| 192 | if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length, &header)) { |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 193 | return false; |
| 194 | } |
| 195 | header.payload_type_frequency = kVideoPayloadTypeFrequency; |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 196 | return ReceivePacket(rtp_packet, rtp_packet_length, header, false); |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 197 | } |
| 198 | |
solenberg@webrtc.org | 2d3624c | 2014-03-24 20:28:11 +0000 | [diff] [blame] | 199 | void ViEReceiver::ReceivedBWEPacket( |
| 200 | int64_t arrival_time_ms, int payload_size, const RTPHeader& header) { |
| 201 | // Only forward if the incoming packet *and* the channel are both configured |
| 202 | // to receive absolute sender time. RTP time stamps may have different rates |
| 203 | // for audio and video and shouldn't be mixed. |
| 204 | if (header.extension.hasAbsoluteSendTime && receiving_ast_enabled_) { |
| 205 | remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_size, |
| 206 | header); |
| 207 | } |
| 208 | } |
| 209 | |
solenberg@webrtc.org | 800136d | 2014-02-11 15:27:49 +0000 | [diff] [blame] | 210 | int ViEReceiver::InsertRTPPacket(const uint8_t* rtp_packet, |
wu@webrtc.org | efeb8ce | 2013-12-13 00:21:03 +0000 | [diff] [blame] | 211 | int rtp_packet_length, |
| 212 | const PacketTime& packet_time) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 213 | { |
| 214 | CriticalSectionScoped cs(receive_cs_.get()); |
braveyao@webrtc.org | d69e2f4 | 2013-07-26 09:02:46 +0000 | [diff] [blame] | 215 | if (!receiving_) { |
| 216 | return -1; |
| 217 | } |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 218 | if (rtp_dump_) { |
solenberg@webrtc.org | 800136d | 2014-02-11 15:27:49 +0000 | [diff] [blame] | 219 | rtp_dump_->DumpPacket(rtp_packet, |
| 220 | static_cast<uint16_t>(rtp_packet_length)); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 221 | } |
| 222 | } |
solenberg@webrtc.org | 800136d | 2014-02-11 15:27:49 +0000 | [diff] [blame] | 223 | |
stefan@webrtc.org | 6696fba | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 224 | RTPHeader header; |
solenberg@webrtc.org | 800136d | 2014-02-11 15:27:49 +0000 | [diff] [blame] | 225 | if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length, |
stefan@webrtc.org | 6696fba | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 226 | &header)) { |
stefan@webrtc.org | 6696fba | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 227 | return -1; |
| 228 | } |
solenberg@webrtc.org | 800136d | 2014-02-11 15:27:49 +0000 | [diff] [blame] | 229 | int payload_length = rtp_packet_length - header.headerLength; |
wu@webrtc.org | efeb8ce | 2013-12-13 00:21:03 +0000 | [diff] [blame] | 230 | int64_t arrival_time_ms; |
| 231 | if (packet_time.timestamp != -1) |
| 232 | arrival_time_ms = (packet_time.timestamp + 500) / 1000; |
| 233 | else |
| 234 | arrival_time_ms = TickTime::MillisecondTimestamp(); |
| 235 | |
| 236 | remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 237 | payload_length, header); |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 238 | header.payload_type_frequency = kVideoPayloadTypeFrequency; |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 239 | |
stefan@webrtc.org | 7e97e4c | 2013-11-08 15:18:52 +0000 | [diff] [blame] | 240 | bool in_order = IsPacketInOrder(header); |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 241 | rtp_payload_registry_->SetIncomingPayloadType(header); |
asapersson@webrtc.org | 99153ba | 2014-05-26 13:06:04 +0000 | [diff] [blame] | 242 | int ret = ReceivePacket(rtp_packet, rtp_packet_length, header, in_order) |
solenberg@webrtc.org | 800136d | 2014-02-11 15:27:49 +0000 | [diff] [blame] | 243 | ? 0 |
| 244 | : -1; |
asapersson@webrtc.org | 99153ba | 2014-05-26 13:06:04 +0000 | [diff] [blame] | 245 | // Update receive statistics after ReceivePacket. |
| 246 | // Receive statistics will be reset if the payload type changes (make sure |
| 247 | // that the first packet is included in the stats). |
| 248 | rtp_receive_statistics_->IncomingPacket( |
| 249 | header, rtp_packet_length, IsPacketRetransmitted(header, in_order)); |
| 250 | return ret; |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 251 | } |
| 252 | |
| 253 | bool ViEReceiver::ReceivePacket(const uint8_t* packet, |
| 254 | int packet_length, |
| 255 | const RTPHeader& header, |
| 256 | bool in_order) { |
| 257 | if (rtp_payload_registry_->IsEncapsulated(header)) { |
| 258 | return ParseAndHandleEncapsulatingHeader(packet, packet_length, header); |
| 259 | } |
| 260 | const uint8_t* payload = packet + header.headerLength; |
| 261 | int payload_length = packet_length - header.headerLength; |
| 262 | assert(payload_length >= 0); |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 263 | PayloadUnion payload_specific; |
| 264 | if (!rtp_payload_registry_->GetPayloadSpecifics(header.payloadType, |
| 265 | &payload_specific)) { |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 266 | return false; |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 267 | } |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 268 | return rtp_receiver_->IncomingRtpPacket(header, payload, payload_length, |
| 269 | payload_specific, in_order); |
| 270 | } |
| 271 | |
| 272 | bool ViEReceiver::ParseAndHandleEncapsulatingHeader(const uint8_t* packet, |
| 273 | int packet_length, |
| 274 | const RTPHeader& header) { |
| 275 | if (rtp_payload_registry_->IsRed(header)) { |
sprang@webrtc.org | 7d99cd4 | 2014-01-23 10:00:39 +0000 | [diff] [blame] | 276 | int8_t ulpfec_pt = rtp_payload_registry_->ulpfec_payload_type(); |
| 277 | if (packet[header.headerLength] == ulpfec_pt) |
| 278 | rtp_receive_statistics_->FecPacketReceived(header.ssrc); |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 279 | if (fec_receiver_->AddReceivedRedPacket( |
sprang@webrtc.org | 7d99cd4 | 2014-01-23 10:00:39 +0000 | [diff] [blame] | 280 | header, packet, packet_length, ulpfec_pt) != 0) { |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 281 | return false; |
| 282 | } |
| 283 | return fec_receiver_->ProcessReceivedFec() == 0; |
| 284 | } else if (rtp_payload_registry_->IsRtx(header)) { |
stefan@webrtc.org | fbd6f47 | 2014-03-19 18:14:52 +0000 | [diff] [blame] | 285 | if (header.headerLength + header.paddingLength == packet_length) { |
| 286 | // This is an empty packet and should be silently dropped before trying to |
| 287 | // parse the RTX header. |
| 288 | return true; |
| 289 | } |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 290 | // Remove the RTX header and parse the original RTP header. |
| 291 | if (packet_length < header.headerLength) |
| 292 | return false; |
| 293 | if (packet_length > static_cast<int>(sizeof(restored_packet_))) |
| 294 | return false; |
| 295 | CriticalSectionScoped cs(receive_cs_.get()); |
| 296 | if (restored_packet_in_use_) { |
pbos@webrtc.org | 3468f20 | 2014-05-14 08:02:22 +0000 | [diff] [blame] | 297 | LOG(LS_WARNING) << "Multiple RTX headers detected, dropping packet."; |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 298 | return false; |
| 299 | } |
| 300 | uint8_t* restored_packet_ptr = restored_packet_; |
| 301 | if (!rtp_payload_registry_->RestoreOriginalPacket( |
| 302 | &restored_packet_ptr, packet, &packet_length, rtp_receiver_->SSRC(), |
| 303 | header)) { |
pbos@webrtc.org | 3468f20 | 2014-05-14 08:02:22 +0000 | [diff] [blame] | 304 | LOG(LS_WARNING) << "Incoming RTX packet: Invalid RTP header"; |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 305 | return false; |
| 306 | } |
| 307 | restored_packet_in_use_ = true; |
| 308 | bool ret = OnRecoveredPacket(restored_packet_ptr, packet_length); |
| 309 | restored_packet_in_use_ = false; |
| 310 | return ret; |
| 311 | } |
| 312 | return false; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 313 | } |
| 314 | |
solenberg@webrtc.org | 800136d | 2014-02-11 15:27:49 +0000 | [diff] [blame] | 315 | int ViEReceiver::InsertRTCPPacket(const uint8_t* rtcp_packet, |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 316 | int rtcp_packet_length) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 317 | { |
| 318 | CriticalSectionScoped cs(receive_cs_.get()); |
braveyao@webrtc.org | d69e2f4 | 2013-07-26 09:02:46 +0000 | [diff] [blame] | 319 | if (!receiving_) { |
| 320 | return -1; |
| 321 | } |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 322 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 323 | if (rtp_dump_) { |
| 324 | rtp_dump_->DumpPacket( |
solenberg@webrtc.org | 800136d | 2014-02-11 15:27:49 +0000 | [diff] [blame] | 325 | rtcp_packet, static_cast<uint16_t>(rtcp_packet_length)); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 326 | } |
solenberg@webrtc.org | 800136d | 2014-02-11 15:27:49 +0000 | [diff] [blame] | 327 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 328 | std::list<RtpRtcp*>::iterator it = rtp_rtcp_simulcast_.begin(); |
| 329 | while (it != rtp_rtcp_simulcast_.end()) { |
| 330 | RtpRtcp* rtp_rtcp = *it++; |
solenberg@webrtc.org | 800136d | 2014-02-11 15:27:49 +0000 | [diff] [blame] | 331 | rtp_rtcp->IncomingRtcpPacket(rtcp_packet, rtcp_packet_length); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 332 | } |
| 333 | } |
| 334 | assert(rtp_rtcp_); // Should be set by owner at construction time. |
wu@webrtc.org | 093fc0b | 2014-04-24 22:10:24 +0000 | [diff] [blame] | 335 | int ret = rtp_rtcp_->IncomingRtcpPacket(rtcp_packet, rtcp_packet_length); |
| 336 | if (ret != 0) { |
| 337 | return ret; |
| 338 | } |
| 339 | |
wu@webrtc.org | dd0f8b2 | 2014-05-14 23:06:23 +0000 | [diff] [blame] | 340 | ntp_estimator_->UpdateRtcpTimestamp(rtp_receiver_->SSRC(), rtp_rtcp_); |
wu@webrtc.org | 093fc0b | 2014-04-24 22:10:24 +0000 | [diff] [blame] | 341 | |
| 342 | return 0; |
| 343 | } |
| 344 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 345 | void ViEReceiver::StartReceive() { |
braveyao@webrtc.org | d69e2f4 | 2013-07-26 09:02:46 +0000 | [diff] [blame] | 346 | CriticalSectionScoped cs(receive_cs_.get()); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 347 | receiving_ = true; |
| 348 | } |
| 349 | |
| 350 | void ViEReceiver::StopReceive() { |
braveyao@webrtc.org | d69e2f4 | 2013-07-26 09:02:46 +0000 | [diff] [blame] | 351 | CriticalSectionScoped cs(receive_cs_.get()); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 352 | receiving_ = false; |
| 353 | } |
| 354 | |
| 355 | int ViEReceiver::StartRTPDump(const char file_nameUTF8[1024]) { |
| 356 | CriticalSectionScoped cs(receive_cs_.get()); |
| 357 | if (rtp_dump_) { |
| 358 | // Restart it if it already exists and is started |
| 359 | rtp_dump_->Stop(); |
| 360 | } else { |
| 361 | rtp_dump_ = RtpDump::CreateRtpDump(); |
| 362 | if (rtp_dump_ == NULL) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 363 | return -1; |
| 364 | } |
| 365 | } |
| 366 | if (rtp_dump_->Start(file_nameUTF8) != 0) { |
| 367 | RtpDump::DestroyRtpDump(rtp_dump_); |
| 368 | rtp_dump_ = NULL; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 369 | return -1; |
| 370 | } |
| 371 | return 0; |
| 372 | } |
| 373 | |
| 374 | int ViEReceiver::StopRTPDump() { |
| 375 | CriticalSectionScoped cs(receive_cs_.get()); |
| 376 | if (rtp_dump_) { |
| 377 | if (rtp_dump_->IsActive()) { |
| 378 | rtp_dump_->Stop(); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 379 | } |
| 380 | RtpDump::DestroyRtpDump(rtp_dump_); |
| 381 | rtp_dump_ = NULL; |
| 382 | } else { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 383 | return -1; |
| 384 | } |
| 385 | return 0; |
| 386 | } |
| 387 | |
jiayl@webrtc.org | d1e7fac | 2014-02-10 19:12:14 +0000 | [diff] [blame] | 388 | void ViEReceiver::GetReceiveBandwidthEstimatorStats( |
| 389 | ReceiveBandwidthEstimatorStats* output) const { |
| 390 | remote_bitrate_estimator_->GetStats(output); |
| 391 | } |
| 392 | |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 393 | ReceiveStatistics* ViEReceiver::GetReceiveStatistics() const { |
| 394 | return rtp_receive_statistics_.get(); |
| 395 | } |
| 396 | |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 397 | bool ViEReceiver::IsPacketInOrder(const RTPHeader& header) const { |
| 398 | StreamStatistician* statistician = |
| 399 | rtp_receive_statistics_->GetStatistician(header.ssrc); |
| 400 | if (!statistician) |
| 401 | return false; |
| 402 | return statistician->IsPacketInOrder(header.sequenceNumber); |
| 403 | } |
| 404 | |
stefan@webrtc.org | 7e97e4c | 2013-11-08 15:18:52 +0000 | [diff] [blame] | 405 | bool ViEReceiver::IsPacketRetransmitted(const RTPHeader& header, |
| 406 | bool in_order) const { |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 407 | // Retransmissions are handled separately if RTX is enabled. |
| 408 | if (rtp_payload_registry_->RtxEnabled()) |
| 409 | return false; |
| 410 | StreamStatistician* statistician = |
| 411 | rtp_receive_statistics_->GetStatistician(header.ssrc); |
| 412 | if (!statistician) |
| 413 | return false; |
| 414 | // Check if this is a retransmission. |
| 415 | uint16_t min_rtt = 0; |
| 416 | rtp_rtcp_->RTT(rtp_receiver_->SSRC(), NULL, NULL, &min_rtt, NULL); |
stefan@webrtc.org | 7e97e4c | 2013-11-08 15:18:52 +0000 | [diff] [blame] | 417 | return !in_order && |
stefan@webrtc.org | db74c61 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 418 | statistician->IsRetransmitOfOldPacket(header, min_rtt); |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 419 | } |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 420 | } // namespace webrtc |