zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make ReconfigureVideoEncoder void.

Browse Source 
Also moves and simplifies SetSendCodec from VideoSendStream to mostly
inside ViEEncoder. This is necessary for making
ReconfigureVideoEncoder asynchronous as we don't post any result back.

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

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

Cr-Commit-Position: refs/heads/master@{#11847}
This commit is contained in:
Peter Boström
2016-03-02 16:59:56 +01:00
parent 25359e0cc2
commit 905f8e7e9d
9 changed files with 39 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
webrtc/call/call_perf_tests.cc
View File

@ -765,7 +765,7 @@ TEST_F(CallPerfTest, KeepsHighBitrateWhenReconfiguringSender) {
<< "Timed out before receiving an initial high bitrate.";
encoder_config_.streams[0].width *= 2;
encoder_config_.streams[0].height *= 2;
EXPECT_TRUE(send_stream_->ReconfigureVideoEncoder(encoder_config_));
send_stream_->ReconfigureVideoEncoder(encoder_config_);
EXPECT_TRUE(Wait())
<< "Timed out while waiting for a couple of high bitrate estimates "
"after reconfiguring the send stream.";

3
webrtc/media/engine/fakewebrtccall.cc
View File

@ -159,7 +159,7 @@ webrtc::VideoSendStream::Stats FakeVideoSendStream::GetStats() {
return stats_;
}
bool FakeVideoSendStream::ReconfigureVideoEncoder(
void FakeVideoSendStream::ReconfigureVideoEncoder(
const webrtc::VideoEncoderConfig& config) {
encoder_config_ = config;
if (config.encoder_specific_settings != NULL) {
@ -175,7 +175,6 @@ bool FakeVideoSendStream::ReconfigureVideoEncoder(
}
}
codec_settings_set_ = config.encoder_specific_settings != NULL;
return true;
}
webrtc::VideoCaptureInput* FakeVideoSendStream::Input() {

2
webrtc/media/engine/fakewebrtccall.h
View File

@ -131,7 +131,7 @@ class FakeVideoSendStream final : public webrtc::VideoSendStream,
// webrtc::VideoSendStream implementation.
webrtc::VideoSendStream::Stats GetStats() override;
bool ReconfigureVideoEncoder(
void ReconfigureVideoEncoder(
const webrtc::VideoEncoderConfig& config) override;
webrtc::VideoCaptureInput* Input() override;

6
webrtc/media/engine/webrtcvideoengine2.cc
View File

@ -1881,15 +1881,11 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions(
encoder_config.encoder_specific_settings = ConfigureVideoEncoderSettings(
codec_settings.codec);
bool stream_reconfigured = stream_->ReconfigureVideoEncoder(encoder_config);
stream_->ReconfigureVideoEncoder(encoder_config);
encoder_config.encoder_specific_settings = NULL;
pending_encoder_reconfiguration_ = false;
if (!stream_reconfigured) {
return;
}
parameters_.encoder_config = encoder_config;
}

61
webrtc/video/video_send_stream.cc
View File

@ -288,7 +288,7 @@ VideoSendStream::VideoSendStream(
config.encoder_settings.payload_type,
config.encoder_settings.internal_source));
RTC_CHECK(ReconfigureVideoEncoder(encoder_config));
ReconfigureVideoEncoder(encoder_config);
vie_channel_.RegisterSendSideDelayObserver(&stats_proxy_);
@ -351,11 +351,12 @@ void VideoSendStream::Stop() {
vie_receiver_->StopReceive();
}
bool VideoSendStream::ReconfigureVideoEncoder(
void VideoSendStream::ReconfigureVideoEncoder(
const VideoEncoderConfig& config) {
TRACE_EVENT0("webrtc", "VideoSendStream::(Re)configureVideoEncoder");
LOG(LS_INFO) << "(Re)configureVideoEncoder: " << config.ToString();
const std::vector<VideoStream>& streams = config.streams;
static const int kEncoderMinBitrateKbps = 30;
RTC_DCHECK(!streams.empty());
RTC_DCHECK_GE(config_.rtp.ssrcs.size(), streams.size());
@ -427,6 +428,8 @@ bool VideoSendStream::ReconfigureVideoEncoder(
video_codec.numberOfSimulcastStreams =
static_cast<unsigned char>(streams.size());
video_codec.minBitrate = streams[0].min_bitrate_bps / 1000;
if (video_codec.minBitrate < kEncoderMinBitrateKbps)
video_codec.minBitrate = kEncoderMinBitrateKbps;
RTC_DCHECK_LE(streams.size(), static_cast<size_t>(kMaxSimulcastStreams));
if (video_codec.codecType == kVideoCodecVP9) {
// If the vector is empty, bitrates will be configured automatically.
@ -471,19 +474,20 @@ bool VideoSendStream::ReconfigureVideoEncoder(
static_cast<unsigned int>(streams[i].max_qp));
}
// Set to zero to not update the bitrate controller from ViEEncoder, as
// the bitrate controller is already set from Call.
video_codec.startBitrate = 0;
if (video_codec.maxBitrate == 0) {
// Unset max bitrate -> cap to one bit per pixel.
video_codec.maxBitrate =
(video_codec.width * video_codec.height * video_codec.maxFramerate) /
1000;
}
if (video_codec.maxBitrate < kEncoderMinBitrateKbps)
video_codec.maxBitrate = kEncoderMinBitrateKbps;
RTC_DCHECK_GT(streams[0].max_framerate, 0);
video_codec.maxFramerate = streams[0].max_framerate;
if (!SetSendCodec(video_codec)) {
LOG(LS_WARNING) << "(Re)configureVideoEncoder: SetSendCodec failed "
"for config: "
<< config.ToString();
return false;
}
vie_encoder_.SetEncoder(video_codec);
// Clear stats for disabled layers.
for (size_t i = video_codec.numberOfSimulcastStreams;
i < config_.rtp.ssrcs.size(); ++i) {
@ -494,8 +498,6 @@ bool VideoSendStream::ReconfigureVideoEncoder(
RTC_DCHECK_GE(config.min_transmit_bitrate_bps, 0);
vie_encoder_.SetMinTransmitBitrate(config.min_transmit_bitrate_bps / 1000);
return true;
}
bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
@ -593,38 +595,5 @@ void VideoSendStream::SignalNetworkState(NetworkState state) {
int VideoSendStream::GetPaddingNeededBps() const {
return vie_encoder_.GetPaddingNeededBps();
}
bool VideoSendStream::SetSendCodec(VideoCodec video_codec) {
static const int kEncoderMinBitrate = 30;
if (video_codec.maxBitrate == 0) {
// Unset max bitrate -> cap to one bit per pixel.
video_codec.maxBitrate =
(video_codec.width * video_codec.height * video_codec.maxFramerate) /
1000;
}
if (video_codec.minBitrate < kEncoderMinBitrate)
video_codec.minBitrate = kEncoderMinBitrate;
if (video_codec.maxBitrate < kEncoderMinBitrate)
video_codec.maxBitrate = kEncoderMinBitrate;
// Stop the media flow while reconfiguring.
vie_encoder_.Pause();
if (vie_encoder_.SetEncoder(video_codec) != 0) {
LOG(LS_ERROR) << "Failed to set encoder.";
return false;
}
size_t num_streams = video_codec.numberOfSimulcastStreams > 0
? video_codec.numberOfSimulcastStreams
: 1;
payload_router_.SetSendingRtpModules(num_streams);
// Restart the media flow
vie_encoder_.Restart();
return true;
}
} // namespace internal
} // namespace webrtc

3
webrtc/video/video_send_stream.h
View File

@ -62,7 +62,7 @@ class VideoSendStream : public webrtc::VideoSendStream,
// webrtc::VideoSendStream implementation.
VideoCaptureInput* Input() override;
bool ReconfigureVideoEncoder(const VideoEncoderConfig& config) override;
void ReconfigureVideoEncoder(const VideoEncoderConfig& config) override;
Stats GetStats() override;
// webrtc::CpuOveruseObserver implementation.
@ -75,7 +75,6 @@ class VideoSendStream : public webrtc::VideoSendStream,
int GetPaddingNeededBps() const;
private:
bool SetSendCodec(VideoCodec video_codec);
void ConfigureSsrcs();
SendStatisticsProxy stats_proxy_;

28
webrtc/video/vie_encoder.cc
View File

@ -194,20 +194,19 @@ int32_t ViEEncoder::DeRegisterExternalEncoder(uint8_t pl_type) {
}
return 0;
}
int32_t ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) {
void ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) {
RTC_DCHECK(send_payload_router_ != NULL);
// Setting target width and height for VPM.
if (vp_->SetTargetResolution(video_codec.width, video_codec.height,
video_codec.maxFramerate) != VPM_OK) {
return -1;
}
RTC_CHECK_EQ(VPM_OK,
vp_->SetTargetResolution(video_codec.width, video_codec.height,
video_codec.maxFramerate));
// Cache codec before calling AddBitrateObserver (which calls OnNetworkChanged
// that makes use of the number of simulcast streams configured).
{
rtc::CritScope lock(&data_cs_);
encoder_config_ = video_codec;
encoder_paused_ = true;
}
// Add a bitrate observer to the allocator and update the start, max and
@ -220,12 +219,19 @@ int32_t ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) {
modified_video_codec.startBitrate = allocated_bitrate_bps / 1000;
size_t max_data_payload_length = send_payload_router_->MaxPayloadLength();
if (vcm_->RegisterSendCodec(&modified_video_codec, number_of_cores_,
static_cast<uint32_t>(max_data_payload_length)) !=
VCM_OK) {
return -1;
bool success = vcm_->RegisterSendCodec(
&modified_video_codec, number_of_cores_,
static_cast<uint32_t>(max_data_payload_length)) == VCM_OK;
if (!success) {
LOG(LS_ERROR) << "Failed to configure encoder.";
RTC_DCHECK(success);
}
return 0;
send_payload_router_->SetSendingRtpModules(
video_codec.numberOfSimulcastStreams);
// Restart the media flow
Restart();
}
int ViEEncoder::GetPaddingNeededBps() const {

2
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);
int32_t SetEncoder(const VideoCodec& video_codec);
void SetEncoder(const VideoCodec& video_codec);
// Implementing VideoCaptureCallback.
void DeliverFrame(VideoFrame video_frame) override;

2
webrtc/video_send_stream.h
View File

@ -173,7 +173,7 @@ class VideoSendStream : public SendStream {
// Set which streams to send. Must have at least as many SSRCs as configured
// in the config. Encoder settings are passed on to the encoder instance along
// with the VideoStream settings.
virtual bool ReconfigureVideoEncoder(const VideoEncoderConfig& config) = 0;
virtual void ReconfigureVideoEncoder(const VideoEncoderConfig& config) = 0;
virtual Stats GetStats() = 0;
};