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