diff --git a/webrtc/call/bitrate_estimator_tests.cc b/webrtc/call/bitrate_estimator_tests.cc index 50de542a6f..d8ac9b4ba5 100644 --- a/webrtc/call/bitrate_estimator_tests.cc +++ b/webrtc/call/bitrate_estimator_tests.cc @@ -277,8 +277,8 @@ TEST_F(BitrateEstimatorTest, ImmediatelySwitchToASTForVideo) { RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId)); receiver_log_.PushExpectedLogLine(kSingleStreamLog); receiver_log_.PushExpectedLogLine(kSingleStreamLog); - receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE."); receiver_log_.PushExpectedLogLine(kAbsSendTimeLog); + receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE."); streams_.push_back(new Stream(this, false)); EXPECT_TRUE(receiver_log_.Wait()); } @@ -293,8 +293,8 @@ TEST_F(BitrateEstimatorTest, SwitchesToASTForVideo) { video_send_config_.rtp.extensions[0] = RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId); - receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE."); receiver_log_.PushExpectedLogLine(kAbsSendTimeLog); + receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE."); streams_.push_back(new Stream(this, false)); EXPECT_TRUE(receiver_log_.Wait()); } @@ -309,16 +309,16 @@ TEST_F(BitrateEstimatorTest, SwitchesToASTThenBackToTOFForVideo) { video_send_config_.rtp.extensions[0] = RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId); - receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE."); receiver_log_.PushExpectedLogLine(kAbsSendTimeLog); + receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE."); streams_.push_back(new Stream(this, false)); EXPECT_TRUE(receiver_log_.Wait()); video_send_config_.rtp.extensions[0] = RtpExtension(RtpExtension::kTOffset, kTOFExtensionId); + receiver_log_.PushExpectedLogLine(kAbsSendTimeLog); receiver_log_.PushExpectedLogLine( "WrappingBitrateEstimator: Switching to transmission time offset RBE."); - receiver_log_.PushExpectedLogLine(kSingleStreamLog); streams_.push_back(new Stream(this, false)); streams_[0]->StopSending(); streams_[1]->StopSending(); diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc index 927a978aad..9a4c106e28 100644 --- a/webrtc/video/video_send_stream.cc +++ b/webrtc/video/video_send_stream.cc @@ -24,10 +24,7 @@ #include "webrtc/modules/pacing/packet_router.h" #include "webrtc/modules/utility/include/process_thread.h" #include "webrtc/video/call_stats.h" -#include "webrtc/video/encoder_state_feedback.h" #include "webrtc/video/video_capture_input.h" -#include "webrtc/video/vie_channel.h" -#include "webrtc/video/vie_encoder.h" #include "webrtc/video/vie_remb.h" #include "webrtc/video_send_stream.h" @@ -148,8 +145,33 @@ VideoSendStream::VideoSendStream( this, config.post_encode_callback, &stats_proxy_), - encoder_feedback_(new EncoderStateFeedback()), - use_config_bitrate_(true) { + vie_encoder_(num_cpu_cores, + module_process_thread_, + &stats_proxy_, + config.pre_encode_callback, + &overuse_detector_, + congestion_controller_->pacer(), + &payload_router_, + bitrate_allocator), + vcm_(vie_encoder_.vcm()), + vie_channel_(config.send_transport, + module_process_thread_, + &payload_router_, + nullptr, + encoder_feedback_.GetRtcpIntraFrameObserver(), + congestion_controller_->GetBitrateController() + ->CreateRtcpBandwidthObserver(), + congestion_controller_->GetTransportFeedbackObserver(), + nullptr, + call_stats_->rtcp_rtt_stats(), + congestion_controller_->pacer(), + congestion_controller_->packet_router(), + config_.rtp.ssrcs.size(), + true), + input_(&vie_encoder_, + config_.local_renderer, + &stats_proxy_, + &overuse_detector_) { LOG(LS_INFO) << "VideoSendStream: " << config_.ToString(); RTC_DCHECK(!config_.rtp.ssrcs.empty()); @@ -158,42 +180,14 @@ VideoSendStream::VideoSendStream( RTC_DCHECK(congestion_controller_); RTC_DCHECK(remb_); - // Set up Call-wide sequence numbers, if configured for this send stream. - TransportFeedbackObserver* transport_feedback_observer = nullptr; - for (const RtpExtension& extension : config.rtp.extensions) { - if (extension.name == RtpExtension::kTransportSequenceNumber) { - transport_feedback_observer = - congestion_controller_->GetTransportFeedbackObserver(); - break; - } - } + RTC_CHECK(vie_encoder_.Init()); + RTC_CHECK(vie_channel_.Init() == 0); - const std::vector& ssrcs = config.rtp.ssrcs; + vcm_->RegisterProtectionCallback(vie_channel_.vcm_protection_callback()); - vie_encoder_.reset(new ViEEncoder( - num_cpu_cores, module_process_thread_, &stats_proxy_, - config.pre_encode_callback, &overuse_detector_, - congestion_controller_->pacer(), &payload_router_, bitrate_allocator)); - vcm_ = vie_encoder_->vcm(); - RTC_CHECK(vie_encoder_->Init()); + call_stats_->RegisterStatsObserver(vie_channel_.GetStatsObserver()); - vie_channel_.reset(new ViEChannel( - config.send_transport, module_process_thread_, &payload_router_, nullptr, - encoder_feedback_->GetRtcpIntraFrameObserver(), - congestion_controller_->GetBitrateController() - ->CreateRtcpBandwidthObserver(), - transport_feedback_observer, - congestion_controller_->GetRemoteBitrateEstimator(false), - call_stats_->rtcp_rtt_stats(), congestion_controller_->pacer(), - congestion_controller_->packet_router(), ssrcs.size(), true)); - RTC_CHECK(vie_channel_->Init() == 0); - - vcm_->RegisterProtectionCallback(vie_channel_->vcm_protection_callback()); - - call_stats_->RegisterStatsObserver(vie_channel_->GetStatsObserver()); - - std::vector first_ssrc(1, ssrcs[0]); - vie_encoder_->SetSsrcs(first_ssrc); + vie_encoder_.SetSsrcs(std::vector(1, config_.rtp.ssrcs[0])); for (size_t i = 0; i < config_.rtp.extensions.size(); ++i) { const std::string& extension = config_.rtp.extensions[i].name; @@ -202,19 +196,19 @@ VideoSendStream::VideoSendStream( RTC_DCHECK_GE(id, 1); RTC_DCHECK_LE(id, 14); if (extension == RtpExtension::kTOffset) { - RTC_CHECK_EQ(0, vie_channel_->SetSendTimestampOffsetStatus(true, id)); + RTC_CHECK_EQ(0, vie_channel_.SetSendTimestampOffsetStatus(true, id)); } else if (extension == RtpExtension::kAbsSendTime) { - RTC_CHECK_EQ(0, vie_channel_->SetSendAbsoluteSendTimeStatus(true, id)); + RTC_CHECK_EQ(0, vie_channel_.SetSendAbsoluteSendTimeStatus(true, id)); } else if (extension == RtpExtension::kVideoRotation) { - RTC_CHECK_EQ(0, vie_channel_->SetSendVideoRotationStatus(true, id)); + RTC_CHECK_EQ(0, vie_channel_.SetSendVideoRotationStatus(true, id)); } else if (extension == RtpExtension::kTransportSequenceNumber) { - RTC_CHECK_EQ(0, vie_channel_->SetSendTransportSequenceNumber(true, id)); + RTC_CHECK_EQ(0, vie_channel_.SetSendTransportSequenceNumber(true, id)); } else { RTC_NOTREACHED() << "Registering unsupported RTP extension."; } } - RtpRtcp* rtp_module = vie_channel_->rtp_rtcp(); + RtpRtcp* rtp_module = vie_channel_.rtp_rtcp(); remb_->AddRembSender(rtp_module); rtp_module->SetREMBStatus(true); @@ -222,49 +216,45 @@ VideoSendStream::VideoSendStream( const bool enable_protection_nack = config_.rtp.nack.rtp_history_ms > 0; const bool enable_protection_fec = config_.rtp.fec.red_payload_type != -1; // TODO(changbin): Should set RTX for RED mapping in RTP sender in future. - vie_channel_->SetProtectionMode(enable_protection_nack, enable_protection_fec, + vie_channel_.SetProtectionMode(enable_protection_nack, enable_protection_fec, config_.rtp.fec.red_payload_type, config_.rtp.fec.ulpfec_payload_type); - vie_encoder_->SetProtectionMethod(enable_protection_nack, + vie_encoder_.SetProtectionMethod(enable_protection_nack, enable_protection_fec); ConfigureSsrcs(); - vie_channel_->SetRTCPCName(config_.rtp.c_name.c_str()); - - input_.reset(new internal::VideoCaptureInput( - vie_encoder_.get(), config_.local_renderer, &stats_proxy_, - &overuse_detector_)); + vie_channel_.SetRTCPCName(config_.rtp.c_name.c_str()); // 28 to match packet overhead in ModuleRtpRtcpImpl. RTC_DCHECK_LE(config_.rtp.max_packet_size, static_cast(0xFFFF - 28)); - vie_channel_->SetMTU(static_cast(config_.rtp.max_packet_size + 28)); + vie_channel_.SetMTU(static_cast(config_.rtp.max_packet_size + 28)); RTC_DCHECK(config.encoder_settings.encoder != nullptr); RTC_DCHECK_GE(config.encoder_settings.payload_type, 0); RTC_DCHECK_LE(config.encoder_settings.payload_type, 127); - RTC_CHECK_EQ(0, vie_encoder_->RegisterExternalEncoder( + RTC_CHECK_EQ(0, vie_encoder_.RegisterExternalEncoder( config.encoder_settings.encoder, config.encoder_settings.payload_type, config.encoder_settings.internal_source)); RTC_CHECK(ReconfigureVideoEncoder(encoder_config)); - vie_channel_->RegisterSendSideDelayObserver(&stats_proxy_); + vie_channel_.RegisterSendSideDelayObserver(&stats_proxy_); if (config_.post_encode_callback) - vie_encoder_->RegisterPostEncodeImageCallback(&encoded_frame_proxy_); + vie_encoder_.RegisterPostEncodeImageCallback(&encoded_frame_proxy_); if (config_.suspend_below_min_bitrate) - vie_encoder_->SuspendBelowMinBitrate(); + vie_encoder_.SuspendBelowMinBitrate(); - encoder_feedback_->AddEncoder(ssrcs, vie_encoder_.get()); + encoder_feedback_.AddEncoder(config_.rtp.ssrcs, &vie_encoder_); - vie_channel_->RegisterSendChannelRtcpStatisticsCallback(&stats_proxy_); - vie_channel_->RegisterSendChannelRtpStatisticsCallback(&stats_proxy_); - vie_channel_->RegisterRtcpPacketTypeCounterObserver(&stats_proxy_); - vie_channel_->RegisterSendBitrateObserver(&stats_proxy_); - vie_channel_->RegisterSendFrameCountObserver(&stats_proxy_); + vie_channel_.RegisterSendChannelRtcpStatisticsCallback(&stats_proxy_); + vie_channel_.RegisterSendChannelRtpStatisticsCallback(&stats_proxy_); + vie_channel_.RegisterRtcpPacketTypeCounterObserver(&stats_proxy_); + vie_channel_.RegisterSendBitrateObserver(&stats_proxy_); + vie_channel_.RegisterSendFrameCountObserver(&stats_proxy_); module_process_thread_->RegisterModule(&overuse_detector_); } @@ -276,53 +266,49 @@ VideoSendStream::~VideoSendStream() { // ViEChannel. vcm_ is owned by ViEEncoder and the registered callback does // not outlive it. vcm_->RegisterProtectionCallback(nullptr); - vie_channel_->RegisterSendFrameCountObserver(nullptr); - vie_channel_->RegisterSendBitrateObserver(nullptr); - vie_channel_->RegisterRtcpPacketTypeCounterObserver(nullptr); - vie_channel_->RegisterSendChannelRtpStatisticsCallback(nullptr); - vie_channel_->RegisterSendChannelRtcpStatisticsCallback(nullptr); + vie_channel_.RegisterSendFrameCountObserver(nullptr); + vie_channel_.RegisterSendBitrateObserver(nullptr); + vie_channel_.RegisterRtcpPacketTypeCounterObserver(nullptr); + vie_channel_.RegisterSendChannelRtpStatisticsCallback(nullptr); + vie_channel_.RegisterSendChannelRtcpStatisticsCallback(nullptr); - // Remove capture input (thread) so that it's not running after the current - // channel is deleted. - input_.reset(); - - vie_encoder_->DeRegisterExternalEncoder( + vie_encoder_.DeRegisterExternalEncoder( config_.encoder_settings.payload_type); - call_stats_->DeregisterStatsObserver(vie_channel_->GetStatsObserver()); + call_stats_->DeregisterStatsObserver(vie_channel_.GetStatsObserver()); - RtpRtcp* rtp_module = vie_channel_->rtp_rtcp(); + RtpRtcp* rtp_module = vie_channel_.rtp_rtcp(); rtp_module->SetREMBStatus(false); remb_->RemoveRembSender(rtp_module); // Remove the feedback, stop all encoding threads and processing. This must be // done before deleting the channel. - encoder_feedback_->RemoveEncoder(vie_encoder_.get()); + encoder_feedback_.RemoveEncoder(&vie_encoder_); - uint32_t remote_ssrc = vie_channel_->GetRemoteSSRC(); + uint32_t remote_ssrc = vie_channel_.GetRemoteSSRC(); congestion_controller_->GetRemoteBitrateEstimator(false)->RemoveStream( remote_ssrc); } VideoCaptureInput* VideoSendStream::Input() { - return input_.get(); + return &input_; } void VideoSendStream::Start() { transport_adapter_.Enable(); - vie_encoder_->Pause(); - if (vie_channel_->StartSend() == 0) { + vie_encoder_.Pause(); + if (vie_channel_.StartSend() == 0) { // Was not already started, trigger a keyframe. - vie_encoder_->SendKeyFrame(); + vie_encoder_.SendKeyFrame(); } - vie_encoder_->Restart(); - vie_channel_->StartReceive(); + vie_encoder_.Restart(); + vie_channel_.StartReceive(); } void VideoSendStream::Stop() { // TODO(pbos): Make sure the encoder stops here. - vie_channel_->StopSend(); - vie_channel_->StopReceive(); + vie_channel_.StopSend(); + vie_channel_.StopReceive(); transport_adapter_.Disable(); } @@ -472,15 +458,14 @@ bool VideoSendStream::ReconfigureVideoEncoder( stats_proxy_.SetContentType(config.content_type); RTC_DCHECK_GE(config.min_transmit_bitrate_bps, 0); - vie_encoder_->SetMinTransmitBitrate(config.min_transmit_bitrate_bps / 1000); + vie_encoder_.SetMinTransmitBitrate(config.min_transmit_bitrate_bps / 1000); encoder_config_ = config; - use_config_bitrate_ = false; return true; } bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) { - return vie_channel_->ReceivedRTCPPacket(packet, length) == 0; + return vie_channel_.ReceivedRTCPPacket(packet, length) == 0; } VideoSendStream::Stats VideoSendStream::GetStats() { @@ -498,14 +483,14 @@ void VideoSendStream::NormalUsage() { } void VideoSendStream::ConfigureSsrcs() { - vie_channel_->SetSSRC(config_.rtp.ssrcs.front(), kViEStreamTypeNormal, 0); + vie_channel_.SetSSRC(config_.rtp.ssrcs.front(), kViEStreamTypeNormal, 0); for (size_t i = 0; i < config_.rtp.ssrcs.size(); ++i) { uint32_t ssrc = config_.rtp.ssrcs[i]; - vie_channel_->SetSSRC(ssrc, kViEStreamTypeNormal, + vie_channel_.SetSSRC(ssrc, kViEStreamTypeNormal, static_cast(i)); RtpStateMap::iterator it = suspended_ssrcs_.find(ssrc); if (it != suspended_ssrcs_.end()) - vie_channel_->SetRtpStateForSsrc(ssrc, it->second); + vie_channel_.SetRtpStateForSsrc(ssrc, it->second); } if (config_.rtp.rtx.ssrcs.empty()) { @@ -516,19 +501,19 @@ void VideoSendStream::ConfigureSsrcs() { RTC_DCHECK_EQ(config_.rtp.rtx.ssrcs.size(), config_.rtp.ssrcs.size()); for (size_t i = 0; i < config_.rtp.rtx.ssrcs.size(); ++i) { uint32_t ssrc = config_.rtp.rtx.ssrcs[i]; - vie_channel_->SetSSRC(config_.rtp.rtx.ssrcs[i], kViEStreamTypeRtx, + vie_channel_.SetSSRC(config_.rtp.rtx.ssrcs[i], kViEStreamTypeRtx, static_cast(i)); RtpStateMap::iterator it = suspended_ssrcs_.find(ssrc); if (it != suspended_ssrcs_.end()) - vie_channel_->SetRtpStateForSsrc(ssrc, it->second); + vie_channel_.SetRtpStateForSsrc(ssrc, it->second); } RTC_DCHECK_GE(config_.rtp.rtx.payload_type, 0); - vie_channel_->SetRtxSendPayloadType(config_.rtp.rtx.payload_type, + vie_channel_.SetRtxSendPayloadType(config_.rtp.rtx.payload_type, config_.encoder_settings.payload_type); if (config_.rtp.fec.red_payload_type != -1 && config_.rtp.fec.red_rtx_payload_type != -1) { - vie_channel_->SetRtxSendPayloadType(config_.rtp.fec.red_rtx_payload_type, + vie_channel_.SetRtxSendPayloadType(config_.rtp.fec.red_rtx_payload_type, config_.rtp.fec.red_payload_type); } } @@ -537,12 +522,12 @@ std::map VideoSendStream::GetRtpStates() const { std::map rtp_states; for (size_t i = 0; i < config_.rtp.ssrcs.size(); ++i) { uint32_t ssrc = config_.rtp.ssrcs[i]; - rtp_states[ssrc] = vie_channel_->GetRtpStateForSsrc(ssrc); + rtp_states[ssrc] = vie_channel_.GetRtpStateForSsrc(ssrc); } for (size_t i = 0; i < config_.rtp.rtx.ssrcs.size(); ++i) { uint32_t ssrc = config_.rtp.rtx.ssrcs[i]; - rtp_states[ssrc] = vie_channel_->GetRtpStateForSsrc(ssrc); + rtp_states[ssrc] = vie_channel_.GetRtpStateForSsrc(ssrc); } return rtp_states; @@ -553,10 +538,10 @@ void VideoSendStream::SignalNetworkState(NetworkState state) { // When it goes down, disable RTCP afterwards. This ensures that any packets // sent due to the network state changed will not be dropped. if (state == kNetworkUp) - vie_channel_->SetRTCPMode(config_.rtp.rtcp_mode); - vie_encoder_->SetNetworkTransmissionState(state == kNetworkUp); + vie_channel_.SetRTCPMode(config_.rtp.rtcp_mode); + vie_encoder_.SetNetworkTransmissionState(state == kNetworkUp); if (state == kNetworkDown) - vie_channel_->SetRTCPMode(RtcpMode::kOff); + vie_channel_.SetRTCPMode(RtcpMode::kOff); } int64_t VideoSendStream::GetRtt() const { @@ -566,7 +551,7 @@ int64_t VideoSendStream::GetRtt() const { uint32_t extended_max_sequence_number; uint32_t jitter; int64_t rtt_ms; - if (vie_channel_->GetSendRtcpStatistics(&frac_lost, &cumulative_lost, + if (vie_channel_.GetSendRtcpStatistics(&frac_lost, &cumulative_lost, &extended_max_sequence_number, &jitter, &rtt_ms) == 0) { return rtt_ms; @@ -575,7 +560,7 @@ int64_t VideoSendStream::GetRtt() const { } int VideoSendStream::GetPaddingNeededBps() const { - return vie_encoder_->GetPaddingNeededBps(); + return vie_encoder_.GetPaddingNeededBps(); } bool VideoSendStream::SetSendCodec(VideoCodec video_codec) { @@ -593,14 +578,14 @@ bool VideoSendStream::SetSendCodec(VideoCodec video_codec) { video_codec.maxBitrate = kEncoderMinBitrate; // Stop the media flow while reconfiguring. - vie_encoder_->Pause(); + vie_encoder_.Pause(); - if (vie_encoder_->SetEncoder(video_codec) != 0) { + if (vie_encoder_.SetEncoder(video_codec) != 0) { LOG(LS_ERROR) << "Failed to set encoder."; return false; } - if (vie_channel_->SetSendCodec(video_codec, false) != 0) { + if (vie_channel_.SetSendCodec(video_codec, false) != 0) { LOG(LS_ERROR) << "Failed to set send codec."; return false; } @@ -609,13 +594,12 @@ bool VideoSendStream::SetSendCodec(VideoCodec video_codec) { // to send on all SSRCs at once etc.) std::vector used_ssrcs = config_.rtp.ssrcs; used_ssrcs.resize(static_cast(video_codec.numberOfSimulcastStreams)); - vie_encoder_->SetSsrcs(used_ssrcs); + vie_encoder_.SetSsrcs(used_ssrcs); // Restart the media flow - vie_encoder_->Restart(); + vie_encoder_.Restart(); return true; } - } // namespace internal } // namespace webrtc diff --git a/webrtc/video/video_send_stream.h b/webrtc/video/video_send_stream.h index 11d5e6ddf6..4359e604b4 100644 --- a/webrtc/video/video_send_stream.h +++ b/webrtc/video/video_send_stream.h @@ -19,9 +19,12 @@ #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "webrtc/video/encoded_frame_callback_adapter.h" +#include "webrtc/video/encoder_state_feedback.h" #include "webrtc/video/payload_router.h" #include "webrtc/video/send_statistics_proxy.h" #include "webrtc/video/video_capture_input.h" +#include "webrtc/video/vie_channel.h" +#include "webrtc/video/vie_encoder.h" #include "webrtc/video_receive_stream.h" #include "webrtc/video_send_stream.h" @@ -30,7 +33,6 @@ namespace webrtc { class BitrateAllocator; class CallStats; class CongestionController; -class EncoderStateFeedback; class ProcessThread; class ViEChannel; class ViEEncoder; @@ -91,19 +93,12 @@ class VideoSendStream : public webrtc::VideoSendStream, VieRemb* const remb_; OveruseFrameDetector overuse_detector_; - rtc::scoped_ptr input_; PayloadRouter payload_router_; - rtc::scoped_ptr vie_encoder_; - rtc::scoped_ptr vie_channel_; - // TODO(pbos): Make proper const. - // const after construction. - VideoCodingModule* vcm_; - rtc::scoped_ptr encoder_feedback_; - - // Used as a workaround to indicate that we should be using the configured - // start bitrate initially, instead of the one reported by VideoEngine (which - // defaults to too high). - bool use_config_bitrate_; + ViEEncoder vie_encoder_; + VideoCodingModule* const vcm_; + EncoderStateFeedback encoder_feedback_; + ViEChannel vie_channel_; + VideoCaptureInput input_; }; } // namespace internal } // namespace webrtc diff --git a/webrtc/video/vie_channel.cc b/webrtc/video/vie_channel.cc index 532979dda7..1ac22780c7 100644 --- a/webrtc/video/vie_channel.cc +++ b/webrtc/video/vie_channel.cc @@ -638,7 +638,7 @@ void ViEChannel::SetRtpStateForSsrc(uint32_t ssrc, const RtpState& rtp_state) { } } -RtpState ViEChannel::GetRtpStateForSsrc(uint32_t ssrc) { +RtpState ViEChannel::GetRtpStateForSsrc(uint32_t ssrc) const { RTC_DCHECK(!rtp_rtcp_modules_[0]->Sending()); RtpState rtp_state; for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { @@ -664,7 +664,7 @@ int32_t ViEChannel::GetSendRtcpStatistics(uint16_t* fraction_lost, uint32_t* cumulative_lost, uint32_t* extended_max, uint32_t* jitter_samples, - int64_t* rtt_ms) { + int64_t* rtt_ms) const { // Aggregate the report blocks associated with streams sent on this channel. std::vector report_blocks; for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) diff --git a/webrtc/video/vie_channel.h b/webrtc/video/vie_channel.h index f7fc7b2a2e..e9f380ec05 100644 --- a/webrtc/video/vie_channel.h +++ b/webrtc/video/vie_channel.h @@ -112,7 +112,7 @@ class ViEChannel : public VCMFrameTypeCallback, int SetRtxSendPayloadType(int payload_type, int associated_payload_type); void SetRtpStateForSsrc(uint32_t ssrc, const RtpState& rtp_state); - RtpState GetRtpStateForSsrc(uint32_t ssrc); + RtpState GetRtpStateForSsrc(uint32_t ssrc) const; // Sets the CName for the outgoing stream on the channel. int32_t SetRTCPCName(const char* rtcp_cname); @@ -126,7 +126,7 @@ class ViEChannel : public VCMFrameTypeCallback, uint32_t* cumulative_lost, uint32_t* extended_max, uint32_t* jitter_samples, - int64_t* rtt_ms); + int64_t* rtt_ms) const; // Called on receipt of RTCP report block from remote side. void RegisterSendChannelRtcpStatisticsCallback( diff --git a/webrtc/video/vie_receiver.cc b/webrtc/video/vie_receiver.cc index 24c9aad3f1..8fcb380f92 100644 --- a/webrtc/video/vie_receiver.cc +++ b/webrtc/video/vie_receiver.cc @@ -55,9 +55,7 @@ ViEReceiver::ViEReceiver(VideoCodingModule* module_vcm, receiving_ast_enabled_(false), receiving_cvo_enabled_(false), receiving_tsn_enabled_(false), - last_packet_log_ms_(-1) { - assert(remote_bitrate_estimator); -} + last_packet_log_ms_(-1) {} ViEReceiver::~ViEReceiver() { UpdateHistograms(); @@ -246,6 +244,7 @@ bool ViEReceiver::OnRecoveredPacket(const uint8_t* rtp_packet, bool ViEReceiver::DeliverRtp(const uint8_t* rtp_packet, size_t rtp_packet_length, const PacketTime& packet_time) { + RTC_DCHECK(remote_bitrate_estimator_); { rtc::CritScope lock(&receive_cs_); if (!receiving_) {