diff options
Diffstat (limited to 'webrtc/video/vie_receiver.cc')
| -rw-r--r-- | webrtc/video/vie_receiver.cc | 483 |
1 files changed, 483 insertions, 0 deletions
diff --git a/webrtc/video/vie_receiver.cc b/webrtc/video/vie_receiver.cc new file mode 100644 index 0000000000..4fb706c764 --- /dev/null +++ b/webrtc/video/vie_receiver.cc @@ -0,0 +1,483 @@ +/* + * Copyright (c) 2012 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. + */ + +#include "webrtc/video/vie_receiver.h" + +#include <vector> + +#include "webrtc/base/logging.h" +#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h" +#include "webrtc/modules/rtp_rtcp/include/fec_receiver.h" +#include "webrtc/modules/rtp_rtcp/include/receive_statistics.h" +#include "webrtc/modules/rtp_rtcp/include/remote_ntp_time_estimator.h" +#include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h" +#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" +#include "webrtc/modules/rtp_rtcp/include/rtp_payload_registry.h" +#include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h" +#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h" +#include "webrtc/modules/video_coding/include/video_coding.h" +#include "webrtc/system_wrappers/include/critical_section_wrapper.h" +#include "webrtc/system_wrappers/include/metrics.h" +#include "webrtc/system_wrappers/include/tick_util.h" +#include "webrtc/system_wrappers/include/timestamp_extrapolator.h" +#include "webrtc/system_wrappers/include/trace.h" + +namespace webrtc { + +static const int kPacketLogIntervalMs = 10000; + +ViEReceiver::ViEReceiver(VideoCodingModule* module_vcm, + RemoteBitrateEstimator* remote_bitrate_estimator, + RtpFeedback* rtp_feedback) + : receive_cs_(CriticalSectionWrapper::CreateCriticalSection()), + clock_(Clock::GetRealTimeClock()), + rtp_header_parser_(RtpHeaderParser::Create()), + rtp_payload_registry_( + new RTPPayloadRegistry(RTPPayloadStrategy::CreateStrategy(false))), + rtp_receiver_( + RtpReceiver::CreateVideoReceiver(clock_, + this, + rtp_feedback, + rtp_payload_registry_.get())), + rtp_receive_statistics_(ReceiveStatistics::Create(clock_)), + fec_receiver_(FecReceiver::Create(this)), + rtp_rtcp_(NULL), + vcm_(module_vcm), + remote_bitrate_estimator_(remote_bitrate_estimator), + ntp_estimator_(new RemoteNtpTimeEstimator(clock_)), + receiving_(false), + restored_packet_in_use_(false), + receiving_ast_enabled_(false), + receiving_cvo_enabled_(false), + receiving_tsn_enabled_(false), + last_packet_log_ms_(-1) { + assert(remote_bitrate_estimator); +} + +ViEReceiver::~ViEReceiver() { + UpdateHistograms(); +} + +void ViEReceiver::UpdateHistograms() { + FecPacketCounter counter = fec_receiver_->GetPacketCounter(); + if (counter.num_packets > 0) { + RTC_HISTOGRAM_PERCENTAGE_SPARSE( + "WebRTC.Video.ReceivedFecPacketsInPercent", + static_cast<int>(counter.num_fec_packets * 100 / counter.num_packets)); + } + if (counter.num_fec_packets > 0) { + RTC_HISTOGRAM_PERCENTAGE_SPARSE( + "WebRTC.Video.RecoveredMediaPacketsInPercentOfFec", + static_cast<int>(counter.num_recovered_packets * 100 / + counter.num_fec_packets)); + } +} + +bool ViEReceiver::SetReceiveCodec(const VideoCodec& video_codec) { + int8_t old_pltype = -1; + if (rtp_payload_registry_->ReceivePayloadType(video_codec.plName, + kVideoPayloadTypeFrequency, + 0, + video_codec.maxBitrate, + &old_pltype) != -1) { + rtp_payload_registry_->DeRegisterReceivePayload(old_pltype); + } + + return RegisterPayload(video_codec); +} + +bool ViEReceiver::RegisterPayload(const VideoCodec& video_codec) { + return rtp_receiver_->RegisterReceivePayload(video_codec.plName, + video_codec.plType, + kVideoPayloadTypeFrequency, + 0, + video_codec.maxBitrate) == 0; +} + +void ViEReceiver::SetNackStatus(bool enable, + int max_nack_reordering_threshold) { + if (!enable) { + // Reset the threshold back to the lower default threshold when NACK is + // disabled since we no longer will be receiving retransmissions. + max_nack_reordering_threshold = kDefaultMaxReorderingThreshold; + } + rtp_receive_statistics_->SetMaxReorderingThreshold( + max_nack_reordering_threshold); + rtp_receiver_->SetNACKStatus(enable ? kNackRtcp : kNackOff); +} + +void ViEReceiver::SetRtxPayloadType(int payload_type, + int associated_payload_type) { + rtp_payload_registry_->SetRtxPayloadType(payload_type, + associated_payload_type); +} + +void ViEReceiver::SetUseRtxPayloadMappingOnRestore(bool val) { + rtp_payload_registry_->set_use_rtx_payload_mapping_on_restore(val); +} + +void ViEReceiver::SetRtxSsrc(uint32_t ssrc) { + rtp_payload_registry_->SetRtxSsrc(ssrc); +} + +bool ViEReceiver::GetRtxSsrc(uint32_t* ssrc) const { + return rtp_payload_registry_->GetRtxSsrc(ssrc); +} + +bool ViEReceiver::IsFecEnabled() const { + return rtp_payload_registry_->ulpfec_payload_type() > -1; +} + +uint32_t ViEReceiver::GetRemoteSsrc() const { + return rtp_receiver_->SSRC(); +} + +int ViEReceiver::GetCsrcs(uint32_t* csrcs) const { + return rtp_receiver_->CSRCs(csrcs); +} + +void ViEReceiver::SetRtpRtcpModule(RtpRtcp* module) { + rtp_rtcp_ = module; +} + +RtpReceiver* ViEReceiver::GetRtpReceiver() const { + return rtp_receiver_.get(); +} + +void ViEReceiver::RegisterRtpRtcpModules( + const std::vector<RtpRtcp*>& rtp_modules) { + CriticalSectionScoped cs(receive_cs_.get()); + // Only change the "simulcast" modules, the base module can be accessed + // without a lock whereas the simulcast modules require locking as they can be + // changed in runtime. + rtp_rtcp_simulcast_ = + std::vector<RtpRtcp*>(rtp_modules.begin() + 1, rtp_modules.end()); +} + +bool ViEReceiver::SetReceiveTimestampOffsetStatus(bool enable, int id) { + if (enable) { + return rtp_header_parser_->RegisterRtpHeaderExtension( + kRtpExtensionTransmissionTimeOffset, id); + } else { + return rtp_header_parser_->DeregisterRtpHeaderExtension( + kRtpExtensionTransmissionTimeOffset); + } +} + +bool ViEReceiver::SetReceiveAbsoluteSendTimeStatus(bool enable, int id) { + if (enable) { + if (rtp_header_parser_->RegisterRtpHeaderExtension( + kRtpExtensionAbsoluteSendTime, id)) { + receiving_ast_enabled_ = true; + return true; + } else { + return false; + } + } else { + receiving_ast_enabled_ = false; + return rtp_header_parser_->DeregisterRtpHeaderExtension( + kRtpExtensionAbsoluteSendTime); + } +} + +bool ViEReceiver::SetReceiveVideoRotationStatus(bool enable, int id) { + if (enable) { + if (rtp_header_parser_->RegisterRtpHeaderExtension( + kRtpExtensionVideoRotation, id)) { + receiving_cvo_enabled_ = true; + return true; + } else { + return false; + } + } else { + receiving_cvo_enabled_ = false; + return rtp_header_parser_->DeregisterRtpHeaderExtension( + kRtpExtensionVideoRotation); + } +} + +bool ViEReceiver::SetReceiveTransportSequenceNumber(bool enable, int id) { + if (enable) { + if (rtp_header_parser_->RegisterRtpHeaderExtension( + kRtpExtensionTransportSequenceNumber, id)) { + receiving_tsn_enabled_ = true; + return true; + } else { + return false; + } + } else { + receiving_tsn_enabled_ = false; + return rtp_header_parser_->DeregisterRtpHeaderExtension( + kRtpExtensionTransportSequenceNumber); + } +} + +int ViEReceiver::ReceivedRTPPacket(const void* rtp_packet, + size_t rtp_packet_length, + const PacketTime& packet_time) { + return InsertRTPPacket(static_cast<const uint8_t*>(rtp_packet), + rtp_packet_length, packet_time); +} + +int ViEReceiver::ReceivedRTCPPacket(const void* rtcp_packet, + size_t rtcp_packet_length) { + return InsertRTCPPacket(static_cast<const uint8_t*>(rtcp_packet), + rtcp_packet_length); +} + +int32_t ViEReceiver::OnReceivedPayloadData(const uint8_t* payload_data, + const size_t payload_size, + const WebRtcRTPHeader* rtp_header) { + WebRtcRTPHeader rtp_header_with_ntp = *rtp_header; + rtp_header_with_ntp.ntp_time_ms = + ntp_estimator_->Estimate(rtp_header->header.timestamp); + if (vcm_->IncomingPacket(payload_data, + payload_size, + rtp_header_with_ntp) != 0) { + // Check this... + return -1; + } + return 0; +} + +bool ViEReceiver::OnRecoveredPacket(const uint8_t* rtp_packet, + size_t rtp_packet_length) { + RTPHeader header; + if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length, &header)) { + return false; + } + header.payload_type_frequency = kVideoPayloadTypeFrequency; + bool in_order = IsPacketInOrder(header); + return ReceivePacket(rtp_packet, rtp_packet_length, header, in_order); +} + +int ViEReceiver::InsertRTPPacket(const uint8_t* rtp_packet, + size_t rtp_packet_length, + const PacketTime& packet_time) { + { + CriticalSectionScoped cs(receive_cs_.get()); + if (!receiving_) { + return -1; + } + } + + RTPHeader header; + if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length, + &header)) { + return -1; + } + size_t payload_length = rtp_packet_length - header.headerLength; + int64_t arrival_time_ms; + int64_t now_ms = clock_->TimeInMilliseconds(); + if (packet_time.timestamp != -1) + arrival_time_ms = (packet_time.timestamp + 500) / 1000; + else + arrival_time_ms = now_ms; + + { + // Periodically log the RTP header of incoming packets. + CriticalSectionScoped cs(receive_cs_.get()); + if (now_ms - last_packet_log_ms_ > kPacketLogIntervalMs) { + std::stringstream ss; + ss << "Packet received on SSRC: " << header.ssrc << " with payload type: " + << static_cast<int>(header.payloadType) << ", timestamp: " + << header.timestamp << ", sequence number: " << header.sequenceNumber + << ", arrival time: " << arrival_time_ms; + if (header.extension.hasTransmissionTimeOffset) + ss << ", toffset: " << header.extension.transmissionTimeOffset; + if (header.extension.hasAbsoluteSendTime) + ss << ", abs send time: " << header.extension.absoluteSendTime; + LOG(LS_INFO) << ss.str(); + last_packet_log_ms_ = now_ms; + } + } + + remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_length, + header, true); + header.payload_type_frequency = kVideoPayloadTypeFrequency; + + bool in_order = IsPacketInOrder(header); + rtp_payload_registry_->SetIncomingPayloadType(header); + int ret = ReceivePacket(rtp_packet, rtp_packet_length, header, in_order) + ? 0 + : -1; + // Update receive statistics after ReceivePacket. + // Receive statistics will be reset if the payload type changes (make sure + // that the first packet is included in the stats). + rtp_receive_statistics_->IncomingPacket( + header, rtp_packet_length, IsPacketRetransmitted(header, in_order)); + return ret; +} + +bool ViEReceiver::ReceivePacket(const uint8_t* packet, + size_t packet_length, + const RTPHeader& header, + bool in_order) { + if (rtp_payload_registry_->IsEncapsulated(header)) { + return ParseAndHandleEncapsulatingHeader(packet, packet_length, header); + } + const uint8_t* payload = packet + header.headerLength; + assert(packet_length >= header.headerLength); + size_t payload_length = packet_length - header.headerLength; + PayloadUnion payload_specific; + if (!rtp_payload_registry_->GetPayloadSpecifics(header.payloadType, + &payload_specific)) { + return false; + } + return rtp_receiver_->IncomingRtpPacket(header, payload, payload_length, + payload_specific, in_order); +} + +bool ViEReceiver::ParseAndHandleEncapsulatingHeader(const uint8_t* packet, + size_t packet_length, + const RTPHeader& header) { + if (rtp_payload_registry_->IsRed(header)) { + int8_t ulpfec_pt = rtp_payload_registry_->ulpfec_payload_type(); + if (packet[header.headerLength] == ulpfec_pt) { + rtp_receive_statistics_->FecPacketReceived(header, packet_length); + // Notify vcm about received FEC packets to avoid NACKing these packets. + NotifyReceiverOfFecPacket(header); + } + if (fec_receiver_->AddReceivedRedPacket( + header, packet, packet_length, ulpfec_pt) != 0) { + return false; + } + return fec_receiver_->ProcessReceivedFec() == 0; + } else if (rtp_payload_registry_->IsRtx(header)) { + if (header.headerLength + header.paddingLength == packet_length) { + // This is an empty packet and should be silently dropped before trying to + // parse the RTX header. + return true; + } + // Remove the RTX header and parse the original RTP header. + if (packet_length < header.headerLength) + return false; + if (packet_length > sizeof(restored_packet_)) + return false; + CriticalSectionScoped cs(receive_cs_.get()); + if (restored_packet_in_use_) { + LOG(LS_WARNING) << "Multiple RTX headers detected, dropping packet."; + return false; + } + if (!rtp_payload_registry_->RestoreOriginalPacket( + restored_packet_, packet, &packet_length, rtp_receiver_->SSRC(), + header)) { + LOG(LS_WARNING) << "Incoming RTX packet: Invalid RTP header"; + return false; + } + restored_packet_in_use_ = true; + bool ret = OnRecoveredPacket(restored_packet_, packet_length); + restored_packet_in_use_ = false; + return ret; + } + return false; +} + +void ViEReceiver::NotifyReceiverOfFecPacket(const RTPHeader& header) { + int8_t last_media_payload_type = + rtp_payload_registry_->last_received_media_payload_type(); + if (last_media_payload_type < 0) { + LOG(LS_WARNING) << "Failed to get last media payload type."; + return; + } + // Fake an empty media packet. + WebRtcRTPHeader rtp_header = {}; + rtp_header.header = header; + rtp_header.header.payloadType = last_media_payload_type; + rtp_header.header.paddingLength = 0; + PayloadUnion payload_specific; + if (!rtp_payload_registry_->GetPayloadSpecifics(last_media_payload_type, + &payload_specific)) { + LOG(LS_WARNING) << "Failed to get payload specifics."; + return; + } + rtp_header.type.Video.codec = payload_specific.Video.videoCodecType; + rtp_header.type.Video.rotation = kVideoRotation_0; + if (header.extension.hasVideoRotation) { + rtp_header.type.Video.rotation = + ConvertCVOByteToVideoRotation(header.extension.videoRotation); + } + OnReceivedPayloadData(NULL, 0, &rtp_header); +} + +int ViEReceiver::InsertRTCPPacket(const uint8_t* rtcp_packet, + size_t rtcp_packet_length) { + { + CriticalSectionScoped cs(receive_cs_.get()); + if (!receiving_) { + return -1; + } + + for (RtpRtcp* rtp_rtcp : rtp_rtcp_simulcast_) + rtp_rtcp->IncomingRtcpPacket(rtcp_packet, rtcp_packet_length); + } + assert(rtp_rtcp_); // Should be set by owner at construction time. + int ret = rtp_rtcp_->IncomingRtcpPacket(rtcp_packet, rtcp_packet_length); + if (ret != 0) { + return ret; + } + + int64_t rtt = 0; + rtp_rtcp_->RTT(rtp_receiver_->SSRC(), &rtt, NULL, NULL, NULL); + if (rtt == 0) { + // Waiting for valid rtt. + return 0; + } + uint32_t ntp_secs = 0; + uint32_t ntp_frac = 0; + uint32_t rtp_timestamp = 0; + if (0 != rtp_rtcp_->RemoteNTP(&ntp_secs, &ntp_frac, NULL, NULL, + &rtp_timestamp)) { + // Waiting for RTCP. + return 0; + } + ntp_estimator_->UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp); + + return 0; +} + +void ViEReceiver::StartReceive() { + CriticalSectionScoped cs(receive_cs_.get()); + receiving_ = true; +} + +void ViEReceiver::StopReceive() { + CriticalSectionScoped cs(receive_cs_.get()); + receiving_ = false; +} + +ReceiveStatistics* ViEReceiver::GetReceiveStatistics() const { + return rtp_receive_statistics_.get(); +} + +bool ViEReceiver::IsPacketInOrder(const RTPHeader& header) const { + StreamStatistician* statistician = + rtp_receive_statistics_->GetStatistician(header.ssrc); + if (!statistician) + return false; + return statistician->IsPacketInOrder(header.sequenceNumber); +} + +bool ViEReceiver::IsPacketRetransmitted(const RTPHeader& header, + bool in_order) const { + // Retransmissions are handled separately if RTX is enabled. + if (rtp_payload_registry_->RtxEnabled()) + return false; + StreamStatistician* statistician = + rtp_receive_statistics_->GetStatistician(header.ssrc); + if (!statistician) + return false; + // Check if this is a retransmission. + int64_t min_rtt = 0; + rtp_rtcp_->RTT(rtp_receiver_->SSRC(), NULL, NULL, &min_rtt, NULL); + return !in_order && + statistician->IsRetransmitOfOldPacket(header, min_rtt); +} +} // namespace webrtc |