admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initialize VideoSendStream members in constructor.

Browse Source 
Removes scoped_ptrs and provides clearer lifetime between objects.

BUG=webrtc:5494
R=stefan@webrtc.org

Review URL: https://codereview.webrtc.org/1674663002 .

Cr-Commit-Position: refs/heads/master@{#11571}
This commit is contained in:
Peter Boström 2016-02-11 13:51:10 +01:00
parent 1e01660899
commit 8c66a00a37
6 changed files with 108 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
webrtc/call/bitrate_estimator_tests.cc
View File

@ -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();

196
webrtc/video/video_send_stream.cc
View File

@ -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<uint32_t>& 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<uint32_t> first_ssrc(1, ssrcs[0]);
vie_encoder_->SetSsrcs(first_ssrc);
vie_encoder_.SetSsrcs(std::vector<uint32_t>(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<size_t>(0xFFFF - 28));
vie_channel_->SetMTU(static_cast<uint16_t>(config_.rtp.max_packet_size + 28));
vie_channel_.SetMTU(static_cast<uint16_t>(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<unsigned char>(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<unsigned char>(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<uint32_t, RtpState> VideoSendStream::GetRtpStates() const {
std::map<uint32_t, RtpState> 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<uint32_t> used_ssrcs = config_.rtp.ssrcs;
used_ssrcs.resize(static_cast<size_t>(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

21
webrtc/video/video_send_stream.h
View File

@ -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<VideoCaptureInput> input_;
PayloadRouter payload_router_;
rtc::scoped_ptr<ViEEncoder> vie_encoder_;
rtc::scoped_ptr<ViEChannel> vie_channel_;
// TODO(pbos): Make proper const.
// const after construction.
VideoCodingModule* vcm_;
rtc::scoped_ptr<EncoderStateFeedback> 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

4
webrtc/video/vie_channel.cc
View File

@ -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<RTCPReportBlock> report_blocks;
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)

4
webrtc/video/vie_channel.h
View File

@ -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(

5
webrtc/video/vie_receiver.cc
View File

@ -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_) {