diff options
Diffstat (limited to 'chromium/third_party/webrtc/video_engine/vie_receiver.cc')
| -rw-r--r-- | chromium/third_party/webrtc/video_engine/vie_receiver.cc | 224 |
1 files changed, 80 insertions, 144 deletions
diff --git a/chromium/third_party/webrtc/video_engine/vie_receiver.cc b/chromium/third_party/webrtc/video_engine/vie_receiver.cc index 2946c4a08f9..5d90ac678ab 100644 --- a/chromium/third_party/webrtc/video_engine/vie_receiver.cc +++ b/chromium/third_party/webrtc/video_engine/vie_receiver.cc @@ -15,6 +15,7 @@ #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h" #include "webrtc/modules/rtp_rtcp/interface/fec_receiver.h" #include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h" +#include "webrtc/modules/rtp_rtcp/interface/remote_ntp_time_estimator.h" #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h" #include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h" #include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h" @@ -22,7 +23,9 @@ #include "webrtc/modules/utility/interface/rtp_dump.h" #include "webrtc/modules/video_coding/main/interface/video_coding.h" #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" +#include "webrtc/system_wrappers/interface/logging.h" #include "webrtc/system_wrappers/interface/tick_util.h" +#include "webrtc/system_wrappers/interface/timestamp_extrapolator.h" #include "webrtc/system_wrappers/interface/trace.h" namespace webrtc { @@ -32,32 +35,27 @@ ViEReceiver::ViEReceiver(const int32_t channel_id, RemoteBitrateEstimator* remote_bitrate_estimator, RtpFeedback* rtp_feedback) : receive_cs_(CriticalSectionWrapper::CreateCriticalSection()), - channel_id_(channel_id), rtp_header_parser_(RtpHeaderParser::Create()), rtp_payload_registry_(new RTPPayloadRegistry( - channel_id, RTPPayloadStrategy::CreateStrategy(false))), + RTPPayloadStrategy::CreateStrategy(false))), rtp_receiver_(RtpReceiver::CreateVideoReceiver( channel_id, Clock::GetRealTimeClock(), this, rtp_feedback, rtp_payload_registry_.get())), rtp_receive_statistics_(ReceiveStatistics::Create( Clock::GetRealTimeClock())), - fec_receiver_(FecReceiver::Create(channel_id, this)), + fec_receiver_(FecReceiver::Create(this)), rtp_rtcp_(NULL), vcm_(module_vcm), remote_bitrate_estimator_(remote_bitrate_estimator), - external_decryption_(NULL), - decryption_buffer_(NULL), + ntp_estimator_(new RemoteNtpTimeEstimator(Clock::GetRealTimeClock())), rtp_dump_(NULL), receiving_(false), - restored_packet_in_use_(false) { + restored_packet_in_use_(false), + receiving_ast_enabled_(false) { assert(remote_bitrate_estimator); } ViEReceiver::~ViEReceiver() { - if (decryption_buffer_) { - delete[] decryption_buffer_; - decryption_buffer_ = NULL; - } if (rtp_dump_) { rtp_dump_->Stop(); RtpDump::DestroyRtpDump(rtp_dump_); @@ -98,12 +96,12 @@ void ViEReceiver::SetNackStatus(bool enable, rtp_receiver_->SetNACKStatus(enable ? kNackRtcp : kNackOff); } -void ViEReceiver::SetRtxStatus(bool enable, uint32_t ssrc) { - rtp_payload_registry_->SetRtxStatus(enable, ssrc); +void ViEReceiver::SetRtxPayloadType(int payload_type) { + rtp_payload_registry_->SetRtxPayloadType(payload_type); } -void ViEReceiver::SetRtxPayloadType(uint32_t payload_type) { - rtp_payload_registry_->SetRtxPayloadType(payload_type); +void ViEReceiver::SetRtxSsrc(uint32_t ssrc) { + rtp_payload_registry_->SetRtxSsrc(ssrc); } uint32_t ViEReceiver::GetRemoteSsrc() const { @@ -114,28 +112,6 @@ int ViEReceiver::GetCsrcs(uint32_t* csrcs) const { return rtp_receiver_->CSRCs(csrcs); } -int ViEReceiver::RegisterExternalDecryption(Encryption* decryption) { - CriticalSectionScoped cs(receive_cs_.get()); - if (external_decryption_) { - return -1; - } - decryption_buffer_ = new uint8_t[kViEMaxMtu]; - if (decryption_buffer_ == NULL) { - return -1; - } - external_decryption_ = decryption; - return 0; -} - -int ViEReceiver::DeregisterExternalDecryption() { - CriticalSectionScoped cs(receive_cs_.get()); - if (external_decryption_ == NULL) { - return -1; - } - external_decryption_ = NULL; - return 0; -} - void ViEReceiver::SetRtpRtcpModule(RtpRtcp* module) { rtp_rtcp_ = module; } @@ -168,9 +144,15 @@ bool ViEReceiver::SetReceiveTimestampOffsetStatus(bool enable, int id) { bool ViEReceiver::SetReceiveAbsoluteSendTimeStatus(bool enable, int id) { if (enable) { - return rtp_header_parser_->RegisterRtpHeaderExtension( - kRtpExtensionAbsoluteSendTime, id); + 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); } @@ -179,20 +161,25 @@ bool ViEReceiver::SetReceiveAbsoluteSendTimeStatus(bool enable, int id) { int ViEReceiver::ReceivedRTPPacket(const void* rtp_packet, int rtp_packet_length, const PacketTime& packet_time) { - return InsertRTPPacket(static_cast<const int8_t*>(rtp_packet), + return InsertRTPPacket(static_cast<const uint8_t*>(rtp_packet), rtp_packet_length, packet_time); } int ViEReceiver::ReceivedRTCPPacket(const void* rtcp_packet, int rtcp_packet_length) { - return InsertRTCPPacket(static_cast<const int8_t*>(rtcp_packet), + return InsertRTCPPacket(static_cast<const uint8_t*>(rtcp_packet), rtcp_packet_length); } int32_t ViEReceiver::OnReceivedPayloadData( const uint8_t* payload_data, const uint16_t payload_size, const WebRtcRTPHeader* rtp_header) { - if (vcm_->IncomingPacket(payload_data, payload_size, *rtp_header) != 0) { + 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; } @@ -203,61 +190,43 @@ bool ViEReceiver::OnRecoveredPacket(const uint8_t* rtp_packet, int rtp_packet_length) { RTPHeader header; if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length, &header)) { - WEBRTC_TRACE(kTraceDebug, webrtc::kTraceVideo, channel_id_, - "IncomingPacket invalid RTP header"); return false; } header.payload_type_frequency = kVideoPayloadTypeFrequency; return ReceivePacket(rtp_packet, rtp_packet_length, header, false); } -int ViEReceiver::InsertRTPPacket(const int8_t* rtp_packet, +void ViEReceiver::ReceivedBWEPacket( + int64_t arrival_time_ms, int payload_size, const RTPHeader& header) { + // Only forward if the incoming packet *and* the channel are both configured + // to receive absolute sender time. RTP time stamps may have different rates + // for audio and video and shouldn't be mixed. + if (header.extension.hasAbsoluteSendTime && receiving_ast_enabled_) { + remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_size, + header); + } +} + +int ViEReceiver::InsertRTPPacket(const uint8_t* rtp_packet, int rtp_packet_length, const PacketTime& packet_time) { - // TODO(mflodman) Change decrypt to get rid of this cast. - int8_t* tmp_ptr = const_cast<int8_t*>(rtp_packet); - unsigned char* received_packet = reinterpret_cast<unsigned char*>(tmp_ptr); - int received_packet_length = rtp_packet_length; - { CriticalSectionScoped cs(receive_cs_.get()); if (!receiving_) { return -1; } - - if (external_decryption_) { - int decrypted_length = kViEMaxMtu; - external_decryption_->decrypt(channel_id_, received_packet, - decryption_buffer_, received_packet_length, - &decrypted_length); - if (decrypted_length <= 0) { - WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, channel_id_, - "RTP decryption failed"); - return -1; - } else if (decrypted_length > kViEMaxMtu) { - WEBRTC_TRACE(webrtc::kTraceCritical, webrtc::kTraceVideo, channel_id_, - "InsertRTPPacket: %d bytes is allocated as RTP decrytption" - " output, external decryption used %d bytes. => memory is " - " now corrupted", kViEMaxMtu, decrypted_length); - return -1; - } - received_packet = decryption_buffer_; - received_packet_length = decrypted_length; - } - if (rtp_dump_) { - rtp_dump_->DumpPacket(received_packet, - static_cast<uint16_t>(received_packet_length)); + rtp_dump_->DumpPacket(rtp_packet, + static_cast<uint16_t>(rtp_packet_length)); } } + RTPHeader header; - if (!rtp_header_parser_->Parse(received_packet, received_packet_length, + if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length, &header)) { - WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideo, channel_id_, - "Incoming packet: Invalid RTP header"); return -1; } - int payload_length = received_packet_length - header.headerLength; + int payload_length = rtp_packet_length - header.headerLength; int64_t arrival_time_ms; if (packet_time.timestamp != -1) arrival_time_ms = (packet_time.timestamp + 500) / 1000; @@ -269,11 +238,16 @@ int ViEReceiver::InsertRTPPacket(const int8_t* rtp_packet, header.payload_type_frequency = kVideoPayloadTypeFrequency; bool in_order = IsPacketInOrder(header); - rtp_receive_statistics_->IncomingPacket(header, received_packet_length, - IsPacketRetransmitted(header, in_order)); rtp_payload_registry_->SetIncomingPayloadType(header); - return ReceivePacket(received_packet, received_packet_length, header, - in_order) ? 0 : -1; + 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, @@ -299,15 +273,20 @@ bool ViEReceiver::ParseAndHandleEncapsulatingHeader(const uint8_t* packet, int 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.ssrc); if (fec_receiver_->AddReceivedRedPacket( - header, packet, packet_length, - rtp_payload_registry_->ulpfec_payload_type()) != 0) { - WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideo, channel_id_, - "Incoming RED packet error"); + 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; @@ -315,16 +294,14 @@ bool ViEReceiver::ParseAndHandleEncapsulatingHeader(const uint8_t* packet, return false; CriticalSectionScoped cs(receive_cs_.get()); if (restored_packet_in_use_) { - WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideo, channel_id_, - "Multiple RTX headers detected, dropping packet"); + LOG(LS_WARNING) << "Multiple RTX headers detected, dropping packet."; return false; } uint8_t* restored_packet_ptr = restored_packet_; if (!rtp_payload_registry_->RestoreOriginalPacket( &restored_packet_ptr, packet, &packet_length, rtp_receiver_->SSRC(), header)) { - WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideo, channel_id_, - "Incoming RTX packet: invalid RTP header"); + LOG(LS_WARNING) << "Incoming RTX packet: Invalid RTP header"; return false; } restored_packet_in_use_ = true; @@ -335,55 +312,34 @@ bool ViEReceiver::ParseAndHandleEncapsulatingHeader(const uint8_t* packet, return false; } -int ViEReceiver::InsertRTCPPacket(const int8_t* rtcp_packet, +int ViEReceiver::InsertRTCPPacket(const uint8_t* rtcp_packet, int rtcp_packet_length) { - // TODO(mflodman) Change decrypt to get rid of this cast. - int8_t* tmp_ptr = const_cast<int8_t*>(rtcp_packet); - unsigned char* received_packet = reinterpret_cast<unsigned char*>(tmp_ptr); - int received_packet_length = rtcp_packet_length; { CriticalSectionScoped cs(receive_cs_.get()); if (!receiving_) { return -1; } - if (external_decryption_) { - int decrypted_length = kViEMaxMtu; - external_decryption_->decrypt_rtcp(channel_id_, received_packet, - decryption_buffer_, - received_packet_length, - &decrypted_length); - if (decrypted_length <= 0) { - WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, channel_id_, - "RTP decryption failed"); - return -1; - } else if (decrypted_length > kViEMaxMtu) { - WEBRTC_TRACE(webrtc::kTraceCritical, webrtc::kTraceVideo, channel_id_, - "InsertRTCPPacket: %d bytes is allocated as RTP " - " decrytption output, external decryption used %d bytes. " - " => memory is now corrupted", - kViEMaxMtu, decrypted_length); - return -1; - } - received_packet = decryption_buffer_; - received_packet_length = decrypted_length; - } - if (rtp_dump_) { rtp_dump_->DumpPacket( - received_packet, static_cast<uint16_t>(received_packet_length)); + rtcp_packet, static_cast<uint16_t>(rtcp_packet_length)); } - } - { - CriticalSectionScoped cs(receive_cs_.get()); + std::list<RtpRtcp*>::iterator it = rtp_rtcp_simulcast_.begin(); while (it != rtp_rtcp_simulcast_.end()) { RtpRtcp* rtp_rtcp = *it++; - rtp_rtcp->IncomingRtcpPacket(received_packet, received_packet_length); + rtp_rtcp->IncomingRtcpPacket(rtcp_packet, rtcp_packet_length); } } assert(rtp_rtcp_); // Should be set by owner at construction time. - return rtp_rtcp_->IncomingRtcpPacket(received_packet, received_packet_length); + int ret = rtp_rtcp_->IncomingRtcpPacket(rtcp_packet, rtcp_packet_length); + if (ret != 0) { + return ret; + } + + ntp_estimator_->UpdateRtcpTimestamp(rtp_receiver_->SSRC(), rtp_rtcp_); + + return 0; } void ViEReceiver::StartReceive() { @@ -404,16 +360,12 @@ int ViEReceiver::StartRTPDump(const char file_nameUTF8[1024]) { } else { rtp_dump_ = RtpDump::CreateRtpDump(); if (rtp_dump_ == NULL) { - WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, channel_id_, - "StartRTPDump: Failed to create RTP dump"); return -1; } } if (rtp_dump_->Start(file_nameUTF8) != 0) { RtpDump::DestroyRtpDump(rtp_dump_); rtp_dump_ = NULL; - WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, channel_id_, - "StartRTPDump: Failed to start RTP dump"); return -1; } return 0; @@ -424,34 +376,18 @@ int ViEReceiver::StopRTPDump() { if (rtp_dump_) { if (rtp_dump_->IsActive()) { rtp_dump_->Stop(); - } else { - WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, channel_id_, - "StopRTPDump: Dump not active"); } RtpDump::DestroyRtpDump(rtp_dump_); rtp_dump_ = NULL; } else { - WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, channel_id_, - "StopRTPDump: RTP dump not started"); return -1; } return 0; } -// TODO(holmer): To be moved to ViEChannelGroup. -void ViEReceiver::EstimatedReceiveBandwidth( - unsigned int* available_bandwidth) const { - std::vector<unsigned int> ssrcs; - - // LatestEstimate returns an error if there is no valid bitrate estimate, but - // ViEReceiver instead returns a zero estimate. - remote_bitrate_estimator_->LatestEstimate(&ssrcs, available_bandwidth); - if (std::find(ssrcs.begin(), ssrcs.end(), rtp_receiver_->SSRC()) != - ssrcs.end()) { - *available_bandwidth /= ssrcs.size(); - } else { - *available_bandwidth = 0; - } +void ViEReceiver::GetReceiveBandwidthEstimatorStats( + ReceiveBandwidthEstimatorStats* output) const { + remote_bitrate_estimator_->GetStats(output); } ReceiveStatistics* ViEReceiver::GetReceiveStatistics() const { |