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

Move all calls after SetEncoder into SetEncoder.

Browse Source 
Intended to make SetEncoder callable from another thread so that
ReconfigureVideoEncoder can post SetEncoder over and return earlier to
prevent blocking the calling thread.

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

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

Cr-Commit-Position: refs/heads/master@{#11856}
This commit is contained in:
Peter Boström 2016-03-03 11:36:18 +01:00
parent 81e8e374ec
commit a03785e924
3 changed files with 30 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
webrtc/video/video_send_stream.cc
View File

@ -359,6 +359,7 @@ void VideoSendStream::ReconfigureVideoEncoder(
static const int kEncoderMinBitrateKbps = 30;
RTC_DCHECK(!streams.empty());
RTC_DCHECK_GE(config_.rtp.ssrcs.size(), streams.size());
RTC_DCHECK_GE(config.min_transmit_bitrate_bps, 0);
VideoCodec video_codec;
memset(&video_codec, 0, sizeof(video_codec));
@ -486,18 +487,7 @@ void VideoSendStream::ReconfigureVideoEncoder(
RTC_DCHECK_GT(streams[0].max_framerate, 0);
video_codec.maxFramerate = streams[0].max_framerate;
vie_encoder_.SetEncoder(video_codec);
// Clear stats for disabled layers.
for (size_t i = video_codec.numberOfSimulcastStreams;
i < config_.rtp.ssrcs.size(); ++i) {
stats_proxy_.OnInactiveSsrc(config_.rtp.ssrcs[i]);
}
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_.SetEncoder(video_codec, config.min_transmit_bitrate_bps);
}
bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {

36
webrtc/video/vie_encoder.cc
View File

@ -120,7 +120,7 @@ ViEEncoder::ViEEncoder(uint32_t number_of_cores,
bitrate_allocator_(bitrate_allocator),
time_of_last_frame_activity_ms_(0),
encoder_config_(),
min_transmit_bitrate_kbps_(0),
min_transmit_bitrate_bps_(0),
last_observed_bitrate_bps_(0),
network_is_transmitting_(true),
encoder_paused_(false),
@ -194,7 +194,8 @@ int32_t ViEEncoder::DeRegisterExternalEncoder(uint8_t pl_type) {
}
return 0;
}
void ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) {
void ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec,
int min_transmit_bitrate_bps) {
RTC_DCHECK(send_payload_router_ != NULL);
// Setting target width and height for VPM.
RTC_CHECK_EQ(VPM_OK,
@ -207,6 +208,7 @@ void ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) {
rtc::CritScope lock(&data_cs_);
encoder_config_ = video_codec;
encoder_paused_ = true;
min_transmit_bitrate_bps_ = min_transmit_bitrate_bps;
}
// Add a bitrate observer to the allocator and update the start, max and
@ -232,6 +234,26 @@ void ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) {
// Restart the media flow
Restart();
if (stats_proxy_) {
// Clear stats for disabled layers.
for (size_t i = video_codec.numberOfSimulcastStreams; i < ssrcs_.size();
++i) {
stats_proxy_->OnInactiveSsrc(ssrcs_[i]);
}
VideoEncoderConfig::ContentType content_type;
switch (video_codec.mode) {
case kRealtimeVideo:
content_type = VideoEncoderConfig::ContentType::kRealtimeVideo;
break;
case kScreensharing:
content_type = VideoEncoderConfig::ContentType::kScreen;
break;
default:
RTC_NOTREACHED();
break;
}
stats_proxy_->SetContentType(content_type);
}
}
int ViEEncoder::GetPaddingNeededBps() const {
@ -242,11 +264,11 @@ int ViEEncoder::GetPaddingNeededBps() const {
{
rtc::CritScope lock(&data_cs_);
bool send_padding = encoder_config_.numberOfSimulcastStreams > 1 ||
video_suspended_ || min_transmit_bitrate_kbps_ > 0;
video_suspended_ || min_transmit_bitrate_bps_ > 0;
if (!send_padding)
return 0;
time_of_last_frame_activity_ms = time_of_last_frame_activity_ms_;
min_transmit_bitrate_bps = 1000 * min_transmit_bitrate_kbps_;
min_transmit_bitrate_bps = min_transmit_bitrate_bps_;
bitrate_bps = last_observed_bitrate_bps_;
send_codec = encoder_config_;
}
@ -488,12 +510,6 @@ void ViEEncoder::OnReceivedIntraFrameRequest(uint32_t ssrc) {
RTC_NOTREACHED() << "Should not receive keyframe requests on unknown SSRCs.";
}
void ViEEncoder::SetMinTransmitBitrate(int min_transmit_bitrate_kbps) {
assert(min_transmit_bitrate_kbps >= 0);
rtc::CritScope lock(&data_cs_);
min_transmit_bitrate_kbps_ = min_transmit_bitrate_kbps;
}
// Called from ViEBitrateObserver.
void ViEEncoder::OnNetworkChanged(uint32_t bitrate_bps,
uint8_t fraction_lost,

6
webrtc/video/vie_encoder.h
View File

@ -78,7 +78,7 @@ class ViEEncoder : public VideoEncoderRateObserver,
uint8_t pl_type,
bool internal_source);
int32_t DeRegisterExternalEncoder(uint8_t pl_type);
void SetEncoder(const VideoCodec& video_codec);
void SetEncoder(const VideoCodec& video_codec, int min_transmit_bitrate_bps);
// Implementing VideoCaptureCallback.
void DeliverFrame(VideoFrame video_frame) override;
@ -112,8 +112,6 @@ class ViEEncoder : public VideoEncoderRateObserver,
virtual void OnReceivedSLI(uint32_t ssrc, uint8_t picture_id);
virtual void OnReceivedRPSI(uint32_t ssrc, uint64_t picture_id);
void SetMinTransmitBitrate(int min_transmit_bitrate_kbps);
// Lets the sender suspend video when the rate drops below
// |threshold_bps|, and turns back on when the rate goes back up above
// |threshold_bps| + |window_bps|.
@ -158,7 +156,7 @@ class ViEEncoder : public VideoEncoderRateObserver,
// padding.
int64_t time_of_last_frame_activity_ms_ GUARDED_BY(data_cs_);
VideoCodec encoder_config_ GUARDED_BY(data_cs_);
int min_transmit_bitrate_kbps_ GUARDED_BY(data_cs_);
int min_transmit_bitrate_bps_ GUARDED_BY(data_cs_);
uint32_t last_observed_bitrate_bps_ GUARDED_BY(data_cs_);
bool network_is_transmitting_ GUARDED_BY(data_cs_);
bool encoder_paused_ GUARDED_BY(data_cs_);