Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(95)

Side by Side Diff: webrtc/video/video_send_stream.cc

Issue 1600973002: Initialize VideoEncoder objects asynchronously. (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master
Patch Set: rename new_codec_settings Created 4 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « webrtc/video/video_send_stream.h ('k') | webrtc/video/video_send_stream_tests.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* 1 /*
2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. 2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
3 * 3 *
4 * Use of this source code is governed by a BSD-style license 4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source 5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found 6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may 7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree. 8 * be found in the AUTHORS file in the root of the source tree.
9 */ 9 */
10 10
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after
85 ss << ", rtx: " << rtx.ToString(); 85 ss << ", rtx: " << rtx.ToString();
86 ss << ", c_name: " << c_name; 86 ss << ", c_name: " << c_name;
87 ss << '}'; 87 ss << '}';
88 return ss.str(); 88 return ss.str();
89 } 89 }
90 90
91 std::string VideoSendStream::Config::ToString() const { 91 std::string VideoSendStream::Config::ToString() const {
92 std::stringstream ss; 92 std::stringstream ss;
93 ss << "{encoder_settings: " << encoder_settings.ToString(); 93 ss << "{encoder_settings: " << encoder_settings.ToString();
94 ss << ", rtp: " << rtp.ToString(); 94 ss << ", rtp: " << rtp.ToString();
95 ss << ", pre_encode_callback: " 95 if (pre_encode_callback)
96 << (pre_encode_callback != nullptr ? "(I420FrameCallback)" : "nullptr"); 96 ss << ", pre_encode_effects: (I420FrameCallback)";
97 ss << ", post_encode_callback: " << (post_encode_callback != nullptr 97 if (post_encode_callback)
98 ? "(EncodedFrameObserver)" 98 ss << ", post_encode_callback: (EncodedFrameObserver)";
99 : "nullptr"); 99 if (local_renderer)
100 ss << ", local_renderer: " << (local_renderer != nullptr ? "(VideoRenderer)" 100 ss << ", local_renderer: (VideoRenderer)";
101 : "nullptr");
102 ss << ", render_delay_ms: " << render_delay_ms; 101 ss << ", render_delay_ms: " << render_delay_ms;
103 ss << ", target_delay_ms: " << target_delay_ms; 102 ss << ", target_delay_ms: " << target_delay_ms;
104 ss << ", suspend_below_min_bitrate: " << (suspend_below_min_bitrate ? "on" 103 ss << ", suspend_below_min_bitrate: " << (suspend_below_min_bitrate ? "on"
105 : "off"); 104 : "off");
106 ss << '}'; 105 ss << '}';
107 return ss.str(); 106 return ss.str();
108 } 107 }
109 108
110 namespace internal { 109 namespace internal {
111 VideoSendStream::VideoSendStream( 110 VideoSendStream::VideoSendStream(
112 int num_cpu_cores, 111 int num_cpu_cores,
113 ProcessThread* module_process_thread, 112 ProcessThread* module_process_thread,
114 CallStats* call_stats, 113 CallStats* call_stats,
115 CongestionController* congestion_controller, 114 CongestionController* congestion_controller,
116 BitrateAllocator* bitrate_allocator, 115 BitrateAllocator* bitrate_allocator,
117 const VideoSendStream::Config& config, 116 const VideoSendStream::Config& config,
118 const VideoEncoderConfig& encoder_config, 117 const VideoEncoderConfig& encoder_config,
119 const std::map<uint32_t, RtpState>& suspended_ssrcs) 118 const std::map<uint32_t, RtpState>& suspended_ssrcs)
120 : stats_proxy_(Clock::GetRealTimeClock(), 119 : stats_proxy_(Clock::GetRealTimeClock(),
121 config, 120 config,
122 encoder_config.content_type), 121 encoder_config.content_type),
123 transport_adapter_(config.send_transport), 122 transport_adapter_(config.send_transport),
124 encoded_frame_proxy_(config.post_encode_callback), 123 encoded_frame_proxy_(config.post_encode_callback),
125 config_(config), 124 config_(config),
126 suspended_ssrcs_(suspended_ssrcs), 125 suspended_ssrcs_(suspended_ssrcs),
127 module_process_thread_(module_process_thread), 126 module_process_thread_(module_process_thread),
128 call_stats_(call_stats), 127 call_stats_(call_stats),
129 congestion_controller_(congestion_controller), 128 congestion_controller_(congestion_controller),
130 encoder_feedback_(new EncoderStateFeedback()), 129 encoder_feedback_(new EncoderStateFeedback()) {
131 use_config_bitrate_(true) {
132 LOG(LS_INFO) << "VideoSendStream: " << config_.ToString(); 130 LOG(LS_INFO) << "VideoSendStream: " << config_.ToString();
133 RTC_DCHECK(!config_.rtp.ssrcs.empty()); 131 RTC_DCHECK(!config_.rtp.ssrcs.empty());
134 132
135 // Set up Call-wide sequence numbers, if configured for this send stream. 133 // Set up Call-wide sequence numbers, if configured for this send stream.
136 TransportFeedbackObserver* transport_feedback_observer = nullptr; 134 TransportFeedbackObserver* transport_feedback_observer = nullptr;
137 for (const RtpExtension& extension : config.rtp.extensions) { 135 for (const RtpExtension& extension : config.rtp.extensions) {
138 if (extension.name == RtpExtension::kTransportSequenceNumber) { 136 if (extension.name == RtpExtension::kTransportSequenceNumber) {
139 transport_feedback_observer = 137 transport_feedback_observer =
140 congestion_controller_->GetTransportFeedbackObserver(); 138 congestion_controller_->GetTransportFeedbackObserver();
141 break; 139 break;
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after
200 config_.rtp.fec.red_payload_type, 198 config_.rtp.fec.red_payload_type,
201 config_.rtp.fec.ulpfec_payload_type); 199 config_.rtp.fec.ulpfec_payload_type);
202 vie_encoder_->SetProtectionMethod(enable_protection_nack, 200 vie_encoder_->SetProtectionMethod(enable_protection_nack,
203 enable_protection_fec); 201 enable_protection_fec);
204 202
205 ConfigureSsrcs(); 203 ConfigureSsrcs();
206 204
207 vie_channel_->SetRTCPCName(config_.rtp.c_name.c_str()); 205 vie_channel_->SetRTCPCName(config_.rtp.c_name.c_str());
208 206
209 input_.reset(new internal::VideoCaptureInput( 207 input_.reset(new internal::VideoCaptureInput(
210 module_process_thread_, vie_encoder_.get(), config_.local_renderer, 208 module_process_thread_, vie_encoder_.get(), vie_encoder_->vcm(), this,
211 &stats_proxy_, this, config_.encoding_time_observer)); 209 config_, &stats_proxy_, this));
212 210
213 // 28 to match packet overhead in ModuleRtpRtcpImpl. 211 // 28 to match packet overhead in ModuleRtpRtcpImpl.
214 RTC_DCHECK_LE(config_.rtp.max_packet_size, static_cast<size_t>(0xFFFF - 28)); 212 RTC_DCHECK_LE(config_.rtp.max_packet_size, static_cast<size_t>(0xFFFF - 28));
215 vie_channel_->SetMTU(static_cast<uint16_t>(config_.rtp.max_packet_size + 28)); 213 vie_channel_->SetMTU(static_cast<uint16_t>(config_.rtp.max_packet_size + 28));
216 214
217 RTC_DCHECK(config.encoder_settings.encoder != nullptr); 215 ReconfigureVideoEncoder(encoder_config);
218 RTC_DCHECK_GE(config.encoder_settings.payload_type, 0);
219 RTC_DCHECK_LE(config.encoder_settings.payload_type, 127);
220 RTC_CHECK_EQ(0, vie_encoder_->RegisterExternalEncoder(
221 config.encoder_settings.encoder,
222 config.encoder_settings.payload_type,
223 config.encoder_settings.internal_source));
224
225 RTC_CHECK(ReconfigureVideoEncoder(encoder_config));
226 216
227 vie_channel_->RegisterSendSideDelayObserver(&stats_proxy_); 217 vie_channel_->RegisterSendSideDelayObserver(&stats_proxy_);
228 218
229 if (config_.post_encode_callback) 219 if (config_.post_encode_callback)
230 vie_encoder_->RegisterPostEncodeImageCallback(&encoded_frame_proxy_); 220 vie_encoder_->RegisterPostEncodeImageCallback(&encoded_frame_proxy_);
231 221
232 if (config_.suspend_below_min_bitrate) 222 if (config_.suspend_below_min_bitrate)
233 vie_encoder_->SuspendBelowMinBitrate(); 223 bitrate_allocator->EnforceMinBitrate(false);
234 224
235 congestion_controller_->AddEncoder(vie_encoder_.get()); 225 congestion_controller_->AddEncoder(vie_encoder_.get());
236 encoder_feedback_->AddEncoder(ssrcs, vie_encoder_.get()); 226 encoder_feedback_->AddEncoder(ssrcs, vie_encoder_.get());
237 227
238 vie_channel_->RegisterSendChannelRtcpStatisticsCallback(&stats_proxy_); 228 vie_channel_->RegisterSendChannelRtcpStatisticsCallback(&stats_proxy_);
239 vie_channel_->RegisterSendChannelRtpStatisticsCallback(&stats_proxy_); 229 vie_channel_->RegisterSendChannelRtpStatisticsCallback(&stats_proxy_);
240 vie_channel_->RegisterRtcpPacketTypeCounterObserver(&stats_proxy_); 230 vie_channel_->RegisterRtcpPacketTypeCounterObserver(&stats_proxy_);
241 vie_channel_->RegisterSendBitrateObserver(&stats_proxy_); 231 vie_channel_->RegisterSendBitrateObserver(&stats_proxy_);
242 vie_channel_->RegisterSendFrameCountObserver(&stats_proxy_); 232 vie_channel_->RegisterSendFrameCountObserver(&stats_proxy_);
243 } 233 }
244 234
245 VideoSendStream::~VideoSendStream() { 235 VideoSendStream::~VideoSendStream() {
246 LOG(LS_INFO) << "~VideoSendStream: " << config_.ToString(); 236 LOG(LS_INFO) << "~VideoSendStream: " << config_.ToString();
247 vie_channel_->RegisterSendFrameCountObserver(nullptr); 237 vie_channel_->RegisterSendFrameCountObserver(nullptr);
248 vie_channel_->RegisterSendBitrateObserver(nullptr); 238 vie_channel_->RegisterSendBitrateObserver(nullptr);
249 vie_channel_->RegisterRtcpPacketTypeCounterObserver(nullptr); 239 vie_channel_->RegisterRtcpPacketTypeCounterObserver(nullptr);
250 vie_channel_->RegisterSendChannelRtpStatisticsCallback(nullptr); 240 vie_channel_->RegisterSendChannelRtpStatisticsCallback(nullptr);
251 vie_channel_->RegisterSendChannelRtcpStatisticsCallback(nullptr); 241 vie_channel_->RegisterSendChannelRtcpStatisticsCallback(nullptr);
252 242
253 // Remove capture input (thread) so that it's not running after the current 243 // Remove capture input (thread) so that it's not running after the current
254 // channel is deleted. 244 // channel is deleted.
255 input_.reset(); 245 input_.reset();
256 246
257 vie_encoder_->DeRegisterExternalEncoder(
258 config_.encoder_settings.payload_type);
259
260 call_stats_->DeregisterStatsObserver(vie_channel_->GetStatsObserver()); 247 call_stats_->DeregisterStatsObserver(vie_channel_->GetStatsObserver());
261 congestion_controller_->SetChannelRembStatus(false, false, 248 congestion_controller_->SetChannelRembStatus(false, false,
262 vie_channel_->rtp_rtcp()); 249 vie_channel_->rtp_rtcp());
263 250
264 // Remove the feedback, stop all encoding threads and processing. This must be 251 // Remove the feedback, stop all encoding threads and processing. This must be
265 // done before deleting the channel. 252 // done before deleting the channel.
266 congestion_controller_->RemoveEncoder(vie_encoder_.get()); 253 congestion_controller_->RemoveEncoder(vie_encoder_.get());
267 encoder_feedback_->RemoveEncoder(vie_encoder_.get()); 254 encoder_feedback_->RemoveEncoder(vie_encoder_.get());
268 vie_encoder_->StopThreadsAndRemoveSharedMembers(); 255 vie_encoder_->StopThreadsAndRemoveSharedMembers();
269 256
(...skipping 17 matching lines...) Expand all
287 vie_channel_->StartReceive(); 274 vie_channel_->StartReceive();
288 } 275 }
289 276
290 void VideoSendStream::Stop() { 277 void VideoSendStream::Stop() {
291 // TODO(pbos): Make sure the encoder stops here. 278 // TODO(pbos): Make sure the encoder stops here.
292 vie_channel_->StopSend(); 279 vie_channel_->StopSend();
293 vie_channel_->StopReceive(); 280 vie_channel_->StopReceive();
294 transport_adapter_.Disable(); 281 transport_adapter_.Disable();
295 } 282 }
296 283
297 bool VideoSendStream::ReconfigureVideoEncoder( 284 void VideoSendStream::ReconfigureVideoEncoder(
298 const VideoEncoderConfig& config) { 285 const VideoEncoderConfig& config) {
299 TRACE_EVENT0("webrtc", "VideoSendStream::(Re)configureVideoEncoder"); 286 TRACE_EVENT0("webrtc", "VideoSendStream::(Re)configureVideoEncoder");
300 LOG(LS_INFO) << "(Re)configureVideoEncoder: " << config.ToString(); 287 LOG(LS_INFO) << "(Re)configureVideoEncoder: " << config.ToString();
301 const std::vector<VideoStream>& streams = config.streams; 288 const std::vector<VideoStream>& streams = config.streams;
302 RTC_DCHECK(!streams.empty()); 289 RTC_DCHECK(!streams.empty());
303 RTC_DCHECK_GE(config_.rtp.ssrcs.size(), streams.size()); 290 RTC_DCHECK_GE(config_.rtp.ssrcs.size(), streams.size());
304 291
305 VideoCodec video_codec; 292 VideoCodec video_codec;
306 memset(&video_codec, 0, sizeof(video_codec)); 293 memset(&video_codec, 0, sizeof(video_codec));
307 if (config_.encoder_settings.payload_name == "VP8") { 294 if (config_.encoder_settings.payload_name == "VP8") {
(...skipping 113 matching lines...) Expand 10 before | Expand all | Expand 10 after
421 static_cast<unsigned int>(streams[i].max_qp)); 408 static_cast<unsigned int>(streams[i].max_qp));
422 } 409 }
423 410
424 // Set to zero to not update the bitrate controller from ViEEncoder, as 411 // Set to zero to not update the bitrate controller from ViEEncoder, as
425 // the bitrate controller is already set from Call. 412 // the bitrate controller is already set from Call.
426 video_codec.startBitrate = 0; 413 video_codec.startBitrate = 0;
427 414
428 RTC_DCHECK_GT(streams[0].max_framerate, 0); 415 RTC_DCHECK_GT(streams[0].max_framerate, 0);
429 video_codec.maxFramerate = streams[0].max_framerate; 416 video_codec.maxFramerate = streams[0].max_framerate;
430 417
431 if (!SetSendCodec(video_codec)) 418 input_->TriggerSetSendCodec(video_codec);
432 return false;
433
434 // Clear stats for disabled layers.
435 for (size_t i = video_codec.numberOfSimulcastStreams;
436 i < config_.rtp.ssrcs.size(); ++i) {
437 stats_proxy_.OnInactiveSsrc(config_.rtp.ssrcs[i]);
438 }
439
440 stats_proxy_.SetContentType(config.content_type);
441 419
442 RTC_DCHECK_GE(config.min_transmit_bitrate_bps, 0); 420 RTC_DCHECK_GE(config.min_transmit_bitrate_bps, 0);
443 vie_encoder_->SetMinTransmitBitrate(config.min_transmit_bitrate_bps / 1000); 421 vie_encoder_->SetMinTransmitBitrate(config.min_transmit_bitrate_bps / 1000);
444 422
445 encoder_config_ = config; 423 encoder_config_ = config;
446 use_config_bitrate_ = false;
447 return true;
448 } 424 }
449 425
450 bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) { 426 bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
451 return vie_channel_->ReceivedRTCPPacket(packet, length) == 0; 427 return vie_channel_->ReceivedRTCPPacket(packet, length) == 0;
452 } 428 }
453 429
454 VideoSendStream::Stats VideoSendStream::GetStats() { 430 VideoSendStream::Stats VideoSendStream::GetStats() {
455 return stats_proxy_.GetStats(); 431 return stats_proxy_.GetStats();
456 } 432 }
457 433
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after
534 &jitter, &rtt_ms) == 0) { 510 &jitter, &rtt_ms) == 0) {
535 return rtt_ms; 511 return rtt_ms;
536 } 512 }
537 return -1; 513 return -1;
538 } 514 }
539 515
540 int VideoSendStream::GetPaddingNeededBps() const { 516 int VideoSendStream::GetPaddingNeededBps() const {
541 return vie_encoder_->GetPaddingNeededBps(); 517 return vie_encoder_->GetPaddingNeededBps();
542 } 518 }
543 519
544 bool VideoSendStream::SetSendCodec(VideoCodec video_codec) { 520 void VideoSendStream::SetSendCodec(VideoCodec video_codec) {
545 static const int kEncoderMinBitrate = 30; 521 static const int kEncoderMinBitrate = 30;
546 if (video_codec.maxBitrate == 0) { 522 if (video_codec.maxBitrate == 0) {
547 // Unset max bitrate -> cap to one bit per pixel. 523 // Unset max bitrate -> cap to one bit per pixel.
548 video_codec.maxBitrate = 524 video_codec.maxBitrate =
549 (video_codec.width * video_codec.height * video_codec.maxFramerate) / 525 (video_codec.width * video_codec.height * video_codec.maxFramerate) /
550 1000; 526 1000;
551 } 527 }
552 528
553 if (video_codec.minBitrate < kEncoderMinBitrate) 529 if (video_codec.minBitrate < kEncoderMinBitrate)
554 video_codec.minBitrate = kEncoderMinBitrate; 530 video_codec.minBitrate = kEncoderMinBitrate;
555 if (video_codec.maxBitrate < kEncoderMinBitrate) 531 if (video_codec.maxBitrate < kEncoderMinBitrate)
556 video_codec.maxBitrate = kEncoderMinBitrate; 532 video_codec.maxBitrate = kEncoderMinBitrate;
557 533
558 // Stop the media flow while reconfiguring. 534 // Stop the media flow while reconfiguring.
559 vie_encoder_->Pause(); 535 vie_encoder_->Pause();
560 536
561 if (vie_encoder_->SetEncoder(video_codec) != 0) { 537 vie_encoder_->SetEncoder(video_codec);
562 LOG(LS_ERROR) << "Failed to set encoder."; 538 vie_channel_->SetSendCodec(video_codec);
563 return false;
564 }
565
566 if (vie_channel_->SetSendCodec(video_codec, false) != 0) {
567 LOG(LS_ERROR) << "Failed to set send codec.";
568 return false;
569 }
570 539
571 // Not all configured SSRCs have to be utilized (simulcast senders don't have 540 // Not all configured SSRCs have to be utilized (simulcast senders don't have
572 // to send on all SSRCs at once etc.) 541 // to send on all SSRCs at once etc.)
573 std::vector<uint32_t> used_ssrcs = config_.rtp.ssrcs; 542 std::vector<uint32_t> used_ssrcs = config_.rtp.ssrcs;
574 used_ssrcs.resize(static_cast<size_t>(video_codec.numberOfSimulcastStreams)); 543 used_ssrcs.resize(static_cast<size_t>(video_codec.numberOfSimulcastStreams));
575 vie_encoder_->SetSsrcs(used_ssrcs); 544 vie_encoder_->SetSsrcs(used_ssrcs);
576 545
577 // Restart the media flow 546 // Restart the media flow
578 vie_encoder_->Restart(); 547 vie_encoder_->Restart();
548 // Clear stats for disabled layers.
549 for (size_t i = video_codec.numberOfSimulcastStreams;
550 i < config_.rtp.ssrcs.size(); ++i) {
551 stats_proxy_.OnInactiveSsrc(config_.rtp.ssrcs[i]);
552 }
579 553
580 return true; 554 VideoEncoderConfig::ContentType content_type =
555 video_codec.mode == kRealtimeVideo
556 ? VideoEncoderConfig::ContentType::kRealtimeVideo
557 : VideoEncoderConfig::ContentType::kScreen;
558 stats_proxy_.SetContentType(content_type);
581 } 559 }
582 560
583 } // namespace internal 561 } // namespace internal
584 } // namespace webrtc 562 } // namespace webrtc
OLDNEW
« no previous file with comments | « webrtc/video/video_send_stream.h ('k') | webrtc/video/video_send_stream_tests.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698