1 /* 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. 3 * 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 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include "webrtc/video/vie_channel.h" 12 13 #include <algorithm> 14 #include <map> 15 #include <vector> 16 17 #include "webrtc/base/checks.h" 18 #include "webrtc/base/logging.h" 19 #include "webrtc/base/platform_thread.h" 20 #include "webrtc/common.h" 21 #include "webrtc/common_video/include/incoming_video_stream.h" 22 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" 23 #include "webrtc/frame_callback.h" 24 #include "webrtc/modules/pacing/paced_sender.h" 25 #include "webrtc/modules/pacing/packet_router.h" 26 #include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h" 27 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h" 28 #include "webrtc/modules/utility/include/process_thread.h" 29 #include "webrtc/modules/video_coding/include/video_coding.h" 30 #include "webrtc/modules/video_processing/include/video_processing.h" 31 #include "webrtc/modules/video_render/video_render_defines.h" 32 #include "webrtc/system_wrappers/include/critical_section_wrapper.h" 33 #include "webrtc/system_wrappers/include/metrics.h" 34 #include "webrtc/video/call_stats.h" 35 #include "webrtc/video/payload_router.h" 36 #include "webrtc/video/receive_statistics_proxy.h" 37 #include "webrtc/video/report_block_stats.h" 38 39 namespace webrtc { 40 41 const int kMaxDecodeWaitTimeMs = 50; 42 static const int kMaxTargetDelayMs = 10000; 43 const int kMinSendSidePacketHistorySize = 600; 44 const int kMaxPacketAgeToNack = 450; 45 const int kMaxNackListSize = 250; 46 47 // Helper class receiving statistics callbacks. 48 class ChannelStatsObserver : public CallStatsObserver { 49 public: 50 explicit ChannelStatsObserver(ViEChannel* owner) : owner_(owner) {} 51 virtual ~ChannelStatsObserver() {} 52 53 // Implements StatsObserver. 54 virtual void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) { 55 owner_->OnRttUpdate(avg_rtt_ms, max_rtt_ms); 56 } 57 58 private: 59 ViEChannel* const owner_; 60 }; 61 62 class ViEChannelProtectionCallback : public VCMProtectionCallback { 63 public: 64 explicit ViEChannelProtectionCallback(ViEChannel* owner) : owner_(owner) {} 65 ~ViEChannelProtectionCallback() {} 66 67 68 int ProtectionRequest( 69 const FecProtectionParams* delta_fec_params, 70 const FecProtectionParams* key_fec_params, 71 uint32_t* sent_video_rate_bps, 72 uint32_t* sent_nack_rate_bps, 73 uint32_t* sent_fec_rate_bps) override { 74 return owner_->ProtectionRequest(delta_fec_params, key_fec_params, 75 sent_video_rate_bps, sent_nack_rate_bps, 76 sent_fec_rate_bps); 77 } 78 private: 79 ViEChannel* owner_; 80 }; 81 82 ViEChannel::ViEChannel(uint32_t number_of_cores, 83 Transport* transport, 84 ProcessThread* module_process_thread, 85 RtcpIntraFrameObserver* intra_frame_observer, 86 RtcpBandwidthObserver* bandwidth_observer, 87 TransportFeedbackObserver* transport_feedback_observer, 88 RemoteBitrateEstimator* remote_bitrate_estimator, 89 RtcpRttStats* rtt_stats, 90 PacedSender* paced_sender, 91 PacketRouter* packet_router, 92 size_t max_rtp_streams, 93 bool sender) 94 : number_of_cores_(number_of_cores), 95 sender_(sender), 96 module_process_thread_(module_process_thread), 97 crit_(CriticalSectionWrapper::CreateCriticalSection()), 98 send_payload_router_(new PayloadRouter()), 99 vcm_protection_callback_(new ViEChannelProtectionCallback(this)), 100 vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(), 101 nullptr, 102 nullptr)), 103 vie_receiver_(vcm_, remote_bitrate_estimator, this), 104 vie_sync_(vcm_), 105 stats_observer_(new ChannelStatsObserver(this)), 106 receive_stats_callback_(nullptr), 107 incoming_video_stream_(nullptr), 108 intra_frame_observer_(intra_frame_observer), 109 rtt_stats_(rtt_stats), 110 paced_sender_(paced_sender), 111 packet_router_(packet_router), 112 bandwidth_observer_(bandwidth_observer), 113 transport_feedback_observer_(transport_feedback_observer), 114 decode_thread_(ChannelDecodeThreadFunction, this, "DecodingThread"), 115 nack_history_size_sender_(kMinSendSidePacketHistorySize), 116 max_nack_reordering_threshold_(kMaxPacketAgeToNack), 117 pre_render_callback_(NULL), 118 report_block_stats_sender_(new ReportBlockStats()), 119 time_of_first_rtt_ms_(-1), 120 rtt_sum_ms_(0), 121 last_rtt_ms_(0), 122 num_rtts_(0), 123 rtp_rtcp_modules_( 124 CreateRtpRtcpModules(!sender, 125 vie_receiver_.GetReceiveStatistics(), 126 transport, 127 intra_frame_observer_, 128 bandwidth_observer_.get(), 129 transport_feedback_observer_, 130 rtt_stats_, 131 &rtcp_packet_type_counter_observer_, 132 remote_bitrate_estimator, 133 paced_sender_, 134 packet_router_, 135 &send_bitrate_observer_, 136 &send_frame_count_observer_, 137 &send_side_delay_observer_, 138 max_rtp_streams)), 139 num_active_rtp_rtcp_modules_(1) { 140 vie_receiver_.SetRtpRtcpModule(rtp_rtcp_modules_[0]); 141 vcm_->SetNackSettings(kMaxNackListSize, max_nack_reordering_threshold_, 0); 142 } 143 144 int32_t ViEChannel::Init() { 145 static const int kDefaultRenderDelayMs = 10; 146 module_process_thread_->RegisterModule(vie_receiver_.GetReceiveStatistics()); 147 148 // RTP/RTCP initialization. 149 module_process_thread_->RegisterModule(rtp_rtcp_modules_[0]); 150 151 rtp_rtcp_modules_[0]->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp); 152 if (paced_sender_) { 153 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) 154 rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_); 155 } 156 packet_router_->AddRtpModule(rtp_rtcp_modules_[0]); 157 if (sender_) { 158 std::list<RtpRtcp*> send_rtp_modules(1, rtp_rtcp_modules_[0]); 159 send_payload_router_->SetSendingRtpModules(send_rtp_modules); 160 RTC_DCHECK(!send_payload_router_->active()); 161 } 162 if (vcm_->RegisterReceiveCallback(this) != 0) { 163 return -1; 164 } 165 vcm_->RegisterFrameTypeCallback(this); 166 vcm_->RegisterReceiveStatisticsCallback(this); 167 vcm_->RegisterDecoderTimingCallback(this); 168 vcm_->SetRenderDelay(kDefaultRenderDelayMs); 169 170 module_process_thread_->RegisterModule(vcm_); 171 module_process_thread_->RegisterModule(&vie_sync_); 172 173 return 0; 174 } 175 176 ViEChannel::~ViEChannel() { 177 UpdateHistograms(); 178 // Make sure we don't get more callbacks from the RTP module. 179 module_process_thread_->DeRegisterModule( 180 vie_receiver_.GetReceiveStatistics()); 181 module_process_thread_->DeRegisterModule(vcm_); 182 module_process_thread_->DeRegisterModule(&vie_sync_); 183 send_payload_router_->SetSendingRtpModules(std::list<RtpRtcp*>()); 184 for (size_t i = 0; i < num_active_rtp_rtcp_modules_; ++i) 185 packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i]); 186 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { 187 module_process_thread_->DeRegisterModule(rtp_rtcp); 188 delete rtp_rtcp; 189 } 190 if (!sender_) 191 StopDecodeThread(); 192 // Release modules. 193 VideoCodingModule::Destroy(vcm_); 194 } 195 196 void ViEChannel::UpdateHistograms() { 197 int64_t now = Clock::GetRealTimeClock()->TimeInMilliseconds(); 198 199 { 200 CriticalSectionScoped cs(crit_.get()); 201 int64_t elapsed_sec = (now - time_of_first_rtt_ms_) / 1000; 202 if (time_of_first_rtt_ms_ != -1 && num_rtts_ > 0 && 203 elapsed_sec > metrics::kMinRunTimeInSeconds) { 204 int64_t avg_rtt_ms = (rtt_sum_ms_ + num_rtts_ / 2) / num_rtts_; 205 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 206 "WebRTC.Video.AverageRoundTripTimeInMilliseconds", avg_rtt_ms); 207 } 208 } 209 210 if (sender_) { 211 RtcpPacketTypeCounter rtcp_counter; 212 GetSendRtcpPacketTypeCounter(&rtcp_counter); 213 int64_t elapsed_sec = rtcp_counter.TimeSinceFirstPacketInMs(now) / 1000; 214 if (elapsed_sec > metrics::kMinRunTimeInSeconds) { 215 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 216 "WebRTC.Video.NackPacketsReceivedPerMinute", 217 rtcp_counter.nack_packets * 60 / elapsed_sec); 218 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 219 "WebRTC.Video.FirPacketsReceivedPerMinute", 220 rtcp_counter.fir_packets * 60 / elapsed_sec); 221 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 222 "WebRTC.Video.PliPacketsReceivedPerMinute", 223 rtcp_counter.pli_packets * 60 / elapsed_sec); 224 if (rtcp_counter.nack_requests > 0) { 225 RTC_HISTOGRAM_PERCENTAGE_SPARSE( 226 "WebRTC.Video.UniqueNackRequestsReceivedInPercent", 227 rtcp_counter.UniqueNackRequestsInPercent()); 228 } 229 int fraction_lost = report_block_stats_sender_->FractionLostInPercent(); 230 if (fraction_lost != -1) { 231 RTC_HISTOGRAM_PERCENTAGE_SPARSE("WebRTC.Video.SentPacketsLostInPercent", 232 fraction_lost); 233 } 234 } 235 236 StreamDataCounters rtp; 237 StreamDataCounters rtx; 238 GetSendStreamDataCounters(&rtp, &rtx); 239 StreamDataCounters rtp_rtx = rtp; 240 rtp_rtx.Add(rtx); 241 elapsed_sec = rtp_rtx.TimeSinceFirstPacketInMs( 242 Clock::GetRealTimeClock()->TimeInMilliseconds()) / 243 1000; 244 if (elapsed_sec > metrics::kMinRunTimeInSeconds) { 245 RTC_HISTOGRAM_COUNTS_SPARSE_100000( 246 "WebRTC.Video.BitrateSentInKbps", 247 static_cast<int>(rtp_rtx.transmitted.TotalBytes() * 8 / elapsed_sec / 248 1000)); 249 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 250 "WebRTC.Video.MediaBitrateSentInKbps", 251 static_cast<int>(rtp.MediaPayloadBytes() * 8 / elapsed_sec / 1000)); 252 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 253 "WebRTC.Video.PaddingBitrateSentInKbps", 254 static_cast<int>(rtp_rtx.transmitted.padding_bytes * 8 / elapsed_sec / 255 1000)); 256 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 257 "WebRTC.Video.RetransmittedBitrateSentInKbps", 258 static_cast<int>(rtp_rtx.retransmitted.TotalBytes() * 8 / 259 elapsed_sec / 1000)); 260 if (rtp_rtcp_modules_[0]->RtxSendStatus() != kRtxOff) { 261 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 262 "WebRTC.Video.RtxBitrateSentInKbps", 263 static_cast<int>(rtx.transmitted.TotalBytes() * 8 / elapsed_sec / 264 1000)); 265 } 266 bool fec_enabled = false; 267 uint8_t pltype_red; 268 uint8_t pltype_fec; 269 rtp_rtcp_modules_[0]->GenericFECStatus(&fec_enabled, &pltype_red, 270 &pltype_fec); 271 if (fec_enabled) { 272 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 273 "WebRTC.Video.FecBitrateSentInKbps", 274 static_cast<int>(rtp_rtx.fec.TotalBytes() * 8 / elapsed_sec / 275 1000)); 276 } 277 } 278 } else if (vie_receiver_.GetRemoteSsrc() > 0) { 279 // Get receive stats if we are receiving packets, i.e. there is a remote 280 // ssrc. 281 RtcpPacketTypeCounter rtcp_counter; 282 GetReceiveRtcpPacketTypeCounter(&rtcp_counter); 283 int64_t elapsed_sec = rtcp_counter.TimeSinceFirstPacketInMs(now) / 1000; 284 if (elapsed_sec > metrics::kMinRunTimeInSeconds) { 285 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 286 "WebRTC.Video.NackPacketsSentPerMinute", 287 rtcp_counter.nack_packets * 60 / elapsed_sec); 288 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 289 "WebRTC.Video.FirPacketsSentPerMinute", 290 rtcp_counter.fir_packets * 60 / elapsed_sec); 291 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 292 "WebRTC.Video.PliPacketsSentPerMinute", 293 rtcp_counter.pli_packets * 60 / elapsed_sec); 294 if (rtcp_counter.nack_requests > 0) { 295 RTC_HISTOGRAM_PERCENTAGE_SPARSE( 296 "WebRTC.Video.UniqueNackRequestsSentInPercent", 297 rtcp_counter.UniqueNackRequestsInPercent()); 298 } 299 } 300 301 StreamDataCounters rtp; 302 StreamDataCounters rtx; 303 GetReceiveStreamDataCounters(&rtp, &rtx); 304 StreamDataCounters rtp_rtx = rtp; 305 rtp_rtx.Add(rtx); 306 elapsed_sec = rtp_rtx.TimeSinceFirstPacketInMs(now) / 1000; 307 if (elapsed_sec > metrics::kMinRunTimeInSeconds) { 308 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 309 "WebRTC.Video.BitrateReceivedInKbps", 310 static_cast<int>(rtp_rtx.transmitted.TotalBytes() * 8 / elapsed_sec / 311 1000)); 312 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 313 "WebRTC.Video.MediaBitrateReceivedInKbps", 314 static_cast<int>(rtp.MediaPayloadBytes() * 8 / elapsed_sec / 1000)); 315 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 316 "WebRTC.Video.PaddingBitrateReceivedInKbps", 317 static_cast<int>(rtp_rtx.transmitted.padding_bytes * 8 / elapsed_sec / 318 1000)); 319 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 320 "WebRTC.Video.RetransmittedBitrateReceivedInKbps", 321 static_cast<int>(rtp_rtx.retransmitted.TotalBytes() * 8 / 322 elapsed_sec / 1000)); 323 uint32_t ssrc = 0; 324 if (vie_receiver_.GetRtxSsrc(&ssrc)) { 325 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 326 "WebRTC.Video.RtxBitrateReceivedInKbps", 327 static_cast<int>(rtx.transmitted.TotalBytes() * 8 / elapsed_sec / 328 1000)); 329 } 330 if (vie_receiver_.IsFecEnabled()) { 331 RTC_HISTOGRAM_COUNTS_SPARSE_10000( 332 "WebRTC.Video.FecBitrateReceivedInKbps", 333 static_cast<int>(rtp_rtx.fec.TotalBytes() * 8 / elapsed_sec / 334 1000)); 335 } 336 } 337 } 338 } 339 340 int32_t ViEChannel::SetSendCodec(const VideoCodec& video_codec, 341 bool new_stream) { 342 RTC_DCHECK(sender_); 343 if (video_codec.codecType == kVideoCodecRED || 344 video_codec.codecType == kVideoCodecULPFEC) { 345 LOG_F(LS_ERROR) << "Not a valid send codec " << video_codec.codecType; 346 return -1; 347 } 348 if (kMaxSimulcastStreams < video_codec.numberOfSimulcastStreams) { 349 LOG_F(LS_ERROR) << "Incorrect config " 350 << video_codec.numberOfSimulcastStreams; 351 return -1; 352 } 353 // Update the RTP module with the settings. 354 // Stop and Start the RTP module -> trigger new SSRC, if an SSRC hasn't been 355 // set explicitly. 356 // The first layer is always active, so the first module can be checked for 357 // sending status. 358 bool is_sending = rtp_rtcp_modules_[0]->Sending(); 359 bool router_was_active = send_payload_router_->active(); 360 send_payload_router_->set_active(false); 361 send_payload_router_->SetSendingRtpModules(std::list<RtpRtcp*>()); 362 363 std::vector<RtpRtcp*> registered_modules; 364 std::vector<RtpRtcp*> deregistered_modules; 365 size_t num_active_modules = video_codec.numberOfSimulcastStreams > 0 366 ? video_codec.numberOfSimulcastStreams 367 : 1; 368 size_t num_prev_active_modules; 369 { 370 // Cache which modules are active so StartSend can know which ones to start. 371 CriticalSectionScoped cs(crit_.get()); 372 num_prev_active_modules = num_active_rtp_rtcp_modules_; 373 num_active_rtp_rtcp_modules_ = num_active_modules; 374 } 375 for (size_t i = 0; i < num_active_modules; ++i) 376 registered_modules.push_back(rtp_rtcp_modules_[i]); 377 378 for (size_t i = num_active_modules; i < rtp_rtcp_modules_.size(); ++i) 379 deregistered_modules.push_back(rtp_rtcp_modules_[i]); 380 381 // Disable inactive modules. 382 for (RtpRtcp* rtp_rtcp : deregistered_modules) { 383 rtp_rtcp->SetSendingStatus(false); 384 rtp_rtcp->SetSendingMediaStatus(false); 385 } 386 387 // Configure active modules. 388 for (RtpRtcp* rtp_rtcp : registered_modules) { 389 rtp_rtcp->DeRegisterSendPayload(video_codec.plType); 390 if (rtp_rtcp->RegisterSendPayload(video_codec) != 0) { 391 return -1; 392 } 393 rtp_rtcp->SetSendingStatus(is_sending); 394 rtp_rtcp->SetSendingMediaStatus(is_sending); 395 } 396 397 // |RegisterSimulcastRtpRtcpModules| resets all old weak pointers and old 398 // modules can be deleted after this step. 399 vie_receiver_.RegisterRtpRtcpModules(registered_modules); 400 401 // Update the packet and payload routers with the sending RtpRtcp modules. 402 if (sender_) { 403 std::list<RtpRtcp*> active_send_modules; 404 for (RtpRtcp* rtp_rtcp : registered_modules) 405 active_send_modules.push_back(rtp_rtcp); 406 send_payload_router_->SetSendingRtpModules(active_send_modules); 407 } 408 409 if (router_was_active) 410 send_payload_router_->set_active(true); 411 412 // Deregister previously registered modules. 413 for (size_t i = num_active_modules; i < num_prev_active_modules; ++i) { 414 module_process_thread_->DeRegisterModule(rtp_rtcp_modules_[i]); 415 packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i]); 416 } 417 // Register new active modules. 418 for (size_t i = num_prev_active_modules; i < num_active_modules; ++i) { 419 module_process_thread_->RegisterModule(rtp_rtcp_modules_[i]); 420 packet_router_->AddRtpModule(rtp_rtcp_modules_[i]); 421 } 422 return 0; 423 } 424 425 int32_t ViEChannel::SetReceiveCodec(const VideoCodec& video_codec) { 426 RTC_DCHECK(!sender_); 427 if (!vie_receiver_.SetReceiveCodec(video_codec)) { 428 return -1; 429 } 430 431 if (video_codec.codecType != kVideoCodecRED && 432 video_codec.codecType != kVideoCodecULPFEC) { 433 // Register codec type with VCM, but do not register RED or ULPFEC. 434 if (vcm_->RegisterReceiveCodec(&video_codec, number_of_cores_, false) != 435 VCM_OK) { 436 return -1; 437 } 438 } 439 return 0; 440 } 441 442 void ViEChannel::RegisterExternalDecoder(const uint8_t pl_type, 443 VideoDecoder* decoder) { 444 RTC_DCHECK(!sender_); 445 vcm_->RegisterExternalDecoder(decoder, pl_type); 446 } 447 448 int32_t ViEChannel::ReceiveCodecStatistics(uint32_t* num_key_frames, 449 uint32_t* num_delta_frames) { 450 CriticalSectionScoped cs(crit_.get()); 451 *num_key_frames = receive_frame_counts_.key_frames; 452 *num_delta_frames = receive_frame_counts_.delta_frames; 453 return 0; 454 } 455 456 uint32_t ViEChannel::DiscardedPackets() const { 457 return vcm_->DiscardedPackets(); 458 } 459 460 int ViEChannel::ReceiveDelay() const { 461 return vcm_->Delay(); 462 } 463 464 void ViEChannel::SetExpectedRenderDelay(int delay_ms) { 465 vcm_->SetRenderDelay(delay_ms); 466 } 467 468 void ViEChannel::SetRTCPMode(const RtcpMode rtcp_mode) { 469 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) 470 rtp_rtcp->SetRTCPStatus(rtcp_mode); 471 } 472 473 void ViEChannel::SetProtectionMode(bool enable_nack, 474 bool enable_fec, 475 int payload_type_red, 476 int payload_type_fec) { 477 // Validate payload types. 478 if (enable_fec) { 479 RTC_DCHECK_GE(payload_type_red, 0); 480 RTC_DCHECK_GE(payload_type_fec, 0); 481 RTC_DCHECK_LE(payload_type_red, 127); 482 RTC_DCHECK_LE(payload_type_fec, 127); 483 } else { 484 RTC_DCHECK_EQ(payload_type_red, -1); 485 RTC_DCHECK_EQ(payload_type_fec, -1); 486 // Set to valid uint8_ts to be castable later without signed overflows. 487 payload_type_red = 0; 488 payload_type_fec = 0; 489 } 490 491 VCMVideoProtection protection_method; 492 if (enable_nack) { 493 protection_method = enable_fec ? kProtectionNackFEC : kProtectionNack; 494 } else { 495 protection_method = kProtectionNone; 496 } 497 498 vcm_->SetVideoProtection(protection_method, true); 499 500 // Set NACK. 501 ProcessNACKRequest(enable_nack); 502 503 // Set FEC. 504 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { 505 rtp_rtcp->SetGenericFECStatus(enable_fec, 506 static_cast<uint8_t>(payload_type_red), 507 static_cast<uint8_t>(payload_type_fec)); 508 } 509 } 510 511 void ViEChannel::ProcessNACKRequest(const bool enable) { 512 if (enable) { 513 // Turn on NACK. 514 if (rtp_rtcp_modules_[0]->RTCP() == RtcpMode::kOff) 515 return; 516 vie_receiver_.SetNackStatus(true, max_nack_reordering_threshold_); 517 518 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) 519 rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_); 520 521 vcm_->RegisterPacketRequestCallback(this); 522 // Don't introduce errors when NACK is enabled. 523 vcm_->SetDecodeErrorMode(kNoErrors); 524 } else { 525 vcm_->RegisterPacketRequestCallback(NULL); 526 if (paced_sender_ == nullptr) { 527 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) 528 rtp_rtcp->SetStorePacketsStatus(false, 0); 529 } 530 vie_receiver_.SetNackStatus(false, max_nack_reordering_threshold_); 531 // When NACK is off, allow decoding with errors. Otherwise, the video 532 // will freeze, and will only recover with a complete key frame. 533 vcm_->SetDecodeErrorMode(kWithErrors); 534 } 535 } 536 537 bool ViEChannel::IsSendingFecEnabled() { 538 bool fec_enabled = false; 539 uint8_t pltype_red = 0; 540 uint8_t pltype_fec = 0; 541 542 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { 543 rtp_rtcp->GenericFECStatus(&fec_enabled, &pltype_red, &pltype_fec); 544 if (fec_enabled) 545 return true; 546 } 547 return false; 548 } 549 550 int ViEChannel::SetSenderBufferingMode(int target_delay_ms) { 551 if ((target_delay_ms < 0) || (target_delay_ms > kMaxTargetDelayMs)) { 552 LOG(LS_ERROR) << "Invalid send buffer value."; 553 return -1; 554 } 555 if (target_delay_ms == 0) { 556 // Real-time mode. 557 nack_history_size_sender_ = kMinSendSidePacketHistorySize; 558 } else { 559 nack_history_size_sender_ = GetRequiredNackListSize(target_delay_ms); 560 // Don't allow a number lower than the default value. 561 if (nack_history_size_sender_ < kMinSendSidePacketHistorySize) { 562 nack_history_size_sender_ = kMinSendSidePacketHistorySize; 563 } 564 } 565 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) 566 rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_); 567 return 0; 568 } 569 570 int ViEChannel::GetRequiredNackListSize(int target_delay_ms) { 571 // The max size of the nack list should be large enough to accommodate the 572 // the number of packets (frames) resulting from the increased delay. 573 // Roughly estimating for ~40 packets per frame @ 30fps. 574 return target_delay_ms * 40 * 30 / 1000; 575 } 576 577 int ViEChannel::SetSendTimestampOffsetStatus(bool enable, int id) { 578 // Disable any previous registrations of this extension to avoid errors. 579 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { 580 rtp_rtcp->DeregisterSendRtpHeaderExtension( 581 kRtpExtensionTransmissionTimeOffset); 582 } 583 if (!enable) 584 return 0; 585 // Enable the extension. 586 int error = 0; 587 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { 588 error |= rtp_rtcp->RegisterSendRtpHeaderExtension( 589 kRtpExtensionTransmissionTimeOffset, id); 590 } 591 return error; 592 } 593 594 int ViEChannel::SetReceiveTimestampOffsetStatus(bool enable, int id) { 595 return vie_receiver_.SetReceiveTimestampOffsetStatus(enable, id) ? 0 : -1; 596 } 597 598 int ViEChannel::SetSendAbsoluteSendTimeStatus(bool enable, int id) { 599 // Disable any previous registrations of this extension to avoid errors. 600 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) 601 rtp_rtcp->DeregisterSendRtpHeaderExtension(kRtpExtensionAbsoluteSendTime); 602 if (!enable) 603 return 0; 604 // Enable the extension. 605 int error = 0; 606 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { 607 error |= rtp_rtcp->RegisterSendRtpHeaderExtension( 608 kRtpExtensionAbsoluteSendTime, id); 609 } 610 return error; 611 } 612 613 int ViEChannel::SetReceiveAbsoluteSendTimeStatus(bool enable, int id) { 614 return vie_receiver_.SetReceiveAbsoluteSendTimeStatus(enable, id) ? 0 : -1; 615 } 616 617 int ViEChannel::SetSendVideoRotationStatus(bool enable, int id) { 618 // Disable any previous registrations of this extension to avoid errors. 619 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) 620 rtp_rtcp->DeregisterSendRtpHeaderExtension(kRtpExtensionVideoRotation); 621 if (!enable) 622 return 0; 623 // Enable the extension. 624 int error = 0; 625 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { 626 error |= rtp_rtcp->RegisterSendRtpHeaderExtension( 627 kRtpExtensionVideoRotation, id); 628 } 629 return error; 630 } 631 632 int ViEChannel::SetReceiveVideoRotationStatus(bool enable, int id) { 633 return vie_receiver_.SetReceiveVideoRotationStatus(enable, id) ? 0 : -1; 634 } 635 636 int ViEChannel::SetSendTransportSequenceNumber(bool enable, int id) { 637 // Disable any previous registrations of this extension to avoid errors. 638 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { 639 rtp_rtcp->DeregisterSendRtpHeaderExtension( 640 kRtpExtensionTransportSequenceNumber); 641 } 642 if (!enable) 643 return 0; 644 // Enable the extension. 645 int error = 0; 646 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { 647 error |= rtp_rtcp->RegisterSendRtpHeaderExtension( 648 kRtpExtensionTransportSequenceNumber, id); 649 } 650 return error; 651 } 652 653 int ViEChannel::SetReceiveTransportSequenceNumber(bool enable, int id) { 654 return vie_receiver_.SetReceiveTransportSequenceNumber(enable, id) ? 0 : -1; 655 } 656 657 void ViEChannel::SetRtcpXrRrtrStatus(bool enable) { 658 rtp_rtcp_modules_[0]->SetRtcpXrRrtrStatus(enable); 659 } 660 661 void ViEChannel::EnableTMMBR(bool enable) { 662 rtp_rtcp_modules_[0]->SetTMMBRStatus(enable); 663 } 664 665 int32_t ViEChannel::SetSSRC(const uint32_t SSRC, 666 const StreamType usage, 667 const uint8_t simulcast_idx) { 668 RtpRtcp* rtp_rtcp = rtp_rtcp_modules_[simulcast_idx]; 669 if (usage == kViEStreamTypeRtx) { 670 rtp_rtcp->SetRtxSsrc(SSRC); 671 } else { 672 rtp_rtcp->SetSSRC(SSRC); 673 } 674 return 0; 675 } 676 677 int32_t ViEChannel::SetRemoteSSRCType(const StreamType usage, 678 const uint32_t SSRC) { 679 vie_receiver_.SetRtxSsrc(SSRC); 680 return 0; 681 } 682 683 int32_t ViEChannel::GetLocalSSRC(uint8_t idx, unsigned int* ssrc) { 684 RTC_DCHECK_LE(idx, rtp_rtcp_modules_.size()); 685 *ssrc = rtp_rtcp_modules_[idx]->SSRC(); 686 return 0; 687 } 688 689 uint32_t ViEChannel::GetRemoteSSRC() { 690 return vie_receiver_.GetRemoteSsrc(); 691 } 692 693 int ViEChannel::SetRtxSendPayloadType(int payload_type, 694 int associated_payload_type) { 695 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) 696 rtp_rtcp->SetRtxSendPayloadType(payload_type, associated_payload_type); 697 SetRtxSendStatus(true); 698 return 0; 699 } 700 701 void ViEChannel::SetRtxSendStatus(bool enable) { 702 int rtx_settings = 703 enable ? kRtxRetransmitted | kRtxRedundantPayloads : kRtxOff; 704 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) 705 rtp_rtcp->SetRtxSendStatus(rtx_settings); 706 } 707 708 void ViEChannel::SetRtxReceivePayloadType(int payload_type, 709 int associated_payload_type) { 710 vie_receiver_.SetRtxPayloadType(payload_type, associated_payload_type); 711 } 712 713 void ViEChannel::SetUseRtxPayloadMappingOnRestore(bool val) { 714 vie_receiver_.SetUseRtxPayloadMappingOnRestore(val); 715 } 716 717 void ViEChannel::SetRtpStateForSsrc(uint32_t ssrc, const RtpState& rtp_state) { 718 RTC_DCHECK(!rtp_rtcp_modules_[0]->Sending()); 719 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { 720 if (rtp_rtcp->SetRtpStateForSsrc(ssrc, rtp_state)) 721 return; 722 } 723 } 724 725 RtpState ViEChannel::GetRtpStateForSsrc(uint32_t ssrc) { 726 RTC_DCHECK(!rtp_rtcp_modules_[0]->Sending()); 727 RtpState rtp_state; 728 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { 729 if (rtp_rtcp->GetRtpStateForSsrc(ssrc, &rtp_state)) 730 return rtp_state; 731 } 732 LOG(LS_ERROR) << "Couldn't get RTP state for ssrc: " << ssrc; 733 return rtp_state; 734 } 735 736 // TODO(pbos): Set CNAME on all modules. 737 int32_t ViEChannel::SetRTCPCName(const char* rtcp_cname) { 738 RTC_DCHECK(!rtp_rtcp_modules_[0]->Sending()); 739 return rtp_rtcp_modules_[0]->SetCNAME(rtcp_cname); 740 } 741 742 int32_t ViEChannel::GetRemoteRTCPCName(char rtcp_cname[]) { 743 uint32_t remoteSSRC = vie_receiver_.GetRemoteSsrc(); 744 return rtp_rtcp_modules_[0]->RemoteCNAME(remoteSSRC, rtcp_cname); 745 } 746 747 int32_t ViEChannel::GetSendRtcpStatistics(uint16_t* fraction_lost, 748 uint32_t* cumulative_lost, 749 uint32_t* extended_max, 750 uint32_t* jitter_samples, 751 int64_t* rtt_ms) { 752 // Aggregate the report blocks associated with streams sent on this channel. 753 std::vector<RTCPReportBlock> report_blocks; 754 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) 755 rtp_rtcp->RemoteRTCPStat(&report_blocks); 756 757 if (report_blocks.empty()) 758 return -1; 759 760 uint32_t remote_ssrc = vie_receiver_.GetRemoteSsrc(); 761 std::vector<RTCPReportBlock>::const_iterator it = report_blocks.begin(); 762 for (; it != report_blocks.end(); ++it) { 763 if (it->remoteSSRC == remote_ssrc) 764 break; 765 } 766 if (it == report_blocks.end()) { 767 // We have not received packets with an SSRC matching the report blocks. To 768 // have a chance of calculating an RTT we will try with the SSRC of the 769 // first report block received. 770 // This is very important for send-only channels where we don't know the 771 // SSRC of the other end. 772 remote_ssrc = report_blocks[0].remoteSSRC; 773 } 774 775 // TODO(asapersson): Change report_block_stats to not rely on 776 // GetSendRtcpStatistics to be called. 777 RTCPReportBlock report = 778 report_block_stats_sender_->AggregateAndStore(report_blocks); 779 *fraction_lost = report.fractionLost; 780 *cumulative_lost = report.cumulativeLost; 781 *extended_max = report.extendedHighSeqNum; 782 *jitter_samples = report.jitter; 783 784 int64_t dummy; 785 int64_t rtt = 0; 786 if (rtp_rtcp_modules_[0]->RTT(remote_ssrc, &rtt, &dummy, &dummy, &dummy) != 787 0) { 788 return -1; 789 } 790 *rtt_ms = rtt; 791 return 0; 792 } 793 794 void ViEChannel::RegisterSendChannelRtcpStatisticsCallback( 795 RtcpStatisticsCallback* callback) { 796 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) 797 rtp_rtcp->RegisterRtcpStatisticsCallback(callback); 798 } 799 800 void ViEChannel::RegisterReceiveChannelRtcpStatisticsCallback( 801 RtcpStatisticsCallback* callback) { 802 vie_receiver_.GetReceiveStatistics()->RegisterRtcpStatisticsCallback( 803 callback); 804 rtp_rtcp_modules_[0]->RegisterRtcpStatisticsCallback(callback); 805 } 806 807 void ViEChannel::RegisterRtcpPacketTypeCounterObserver( 808 RtcpPacketTypeCounterObserver* observer) { 809 rtcp_packet_type_counter_observer_.Set(observer); 810 } 811 812 void ViEChannel::GetSendStreamDataCounters( 813 StreamDataCounters* rtp_counters, 814 StreamDataCounters* rtx_counters) const { 815 *rtp_counters = StreamDataCounters(); 816 *rtx_counters = StreamDataCounters(); 817 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { 818 StreamDataCounters rtp_data; 819 StreamDataCounters rtx_data; 820 rtp_rtcp->GetSendStreamDataCounters(&rtp_data, &rtx_data); 821 rtp_counters->Add(rtp_data); 822 rtx_counters->Add(rtx_data); 823 } 824 } 825 826 void ViEChannel::GetReceiveStreamDataCounters( 827 StreamDataCounters* rtp_counters, 828 StreamDataCounters* rtx_counters) const { 829 StreamStatistician* statistician = vie_receiver_.GetReceiveStatistics()-> 830 GetStatistician(vie_receiver_.GetRemoteSsrc()); 831 if (statistician) { 832 statistician->GetReceiveStreamDataCounters(rtp_counters); 833 } 834 uint32_t rtx_ssrc = 0; 835 if (vie_receiver_.GetRtxSsrc(&rtx_ssrc)) { 836 StreamStatistician* statistician = 837 vie_receiver_.GetReceiveStatistics()->GetStatistician(rtx_ssrc); 838 if (statistician) { 839 statistician->GetReceiveStreamDataCounters(rtx_counters); 840 } 841 } 842 } 843 844 void ViEChannel::RegisterSendChannelRtpStatisticsCallback( 845 StreamDataCountersCallback* callback) { 846 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) 847 rtp_rtcp->RegisterSendChannelRtpStatisticsCallback(callback); 848 } 849 850 void ViEChannel::RegisterReceiveChannelRtpStatisticsCallback( 851 StreamDataCountersCallback* callback) { 852 vie_receiver_.GetReceiveStatistics()->RegisterRtpStatisticsCallback(callback); 853 } 854 855 void ViEChannel::GetSendRtcpPacketTypeCounter( 856 RtcpPacketTypeCounter* packet_counter) const { 857 std::map<uint32_t, RtcpPacketTypeCounter> counter_map = 858 rtcp_packet_type_counter_observer_.GetPacketTypeCounterMap(); 859 860 RtcpPacketTypeCounter counter; 861 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) 862 counter.Add(counter_map[rtp_rtcp->SSRC()]); 863 *packet_counter = counter; 864 } 865 866 void ViEChannel::GetReceiveRtcpPacketTypeCounter( 867 RtcpPacketTypeCounter* packet_counter) const { 868 std::map<uint32_t, RtcpPacketTypeCounter> counter_map = 869 rtcp_packet_type_counter_observer_.GetPacketTypeCounterMap(); 870 871 RtcpPacketTypeCounter counter; 872 counter.Add(counter_map[vie_receiver_.GetRemoteSsrc()]); 873 874 *packet_counter = counter; 875 } 876 877 void ViEChannel::RegisterSendSideDelayObserver( 878 SendSideDelayObserver* observer) { 879 send_side_delay_observer_.Set(observer); 880 } 881 882 void ViEChannel::RegisterSendBitrateObserver( 883 BitrateStatisticsObserver* observer) { 884 send_bitrate_observer_.Set(observer); 885 } 886 887 int32_t ViEChannel::StartSend() { 888 CriticalSectionScoped cs(crit_.get()); 889 890 if (rtp_rtcp_modules_[0]->Sending()) 891 return -1; 892 893 for (size_t i = 0; i < num_active_rtp_rtcp_modules_; ++i) { 894 RtpRtcp* rtp_rtcp = rtp_rtcp_modules_[i]; 895 rtp_rtcp->SetSendingMediaStatus(true); 896 rtp_rtcp->SetSendingStatus(true); 897 } 898 send_payload_router_->set_active(true); 899 return 0; 900 } 901 902 int32_t ViEChannel::StopSend() { 903 send_payload_router_->set_active(false); 904 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) 905 rtp_rtcp->SetSendingMediaStatus(false); 906 907 if (!rtp_rtcp_modules_[0]->Sending()) { 908 return -1; 909 } 910 911 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { 912 rtp_rtcp->SetSendingStatus(false); 913 } 914 return 0; 915 } 916 917 bool ViEChannel::Sending() { 918 return rtp_rtcp_modules_[0]->Sending(); 919 } 920 921 void ViEChannel::StartReceive() { 922 if (!sender_) 923 StartDecodeThread(); 924 vie_receiver_.StartReceive(); 925 } 926 927 void ViEChannel::StopReceive() { 928 vie_receiver_.StopReceive(); 929 if (!sender_) { 930 StopDecodeThread(); 931 vcm_->ResetDecoder(); 932 } 933 } 934 935 int32_t ViEChannel::ReceivedRTPPacket(const void* rtp_packet, 936 size_t rtp_packet_length, 937 const PacketTime& packet_time) { 938 return vie_receiver_.ReceivedRTPPacket( 939 rtp_packet, rtp_packet_length, packet_time); 940 } 941 942 int32_t ViEChannel::ReceivedRTCPPacket(const void* rtcp_packet, 943 size_t rtcp_packet_length) { 944 return vie_receiver_.ReceivedRTCPPacket(rtcp_packet, rtcp_packet_length); 945 } 946 947 int32_t ViEChannel::SetMTU(uint16_t mtu) { 948 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) 949 rtp_rtcp->SetMaxTransferUnit(mtu); 950 return 0; 951 } 952 953 RtpRtcp* ViEChannel::rtp_rtcp() { 954 return rtp_rtcp_modules_[0]; 955 } 956 957 rtc::scoped_refptr<PayloadRouter> ViEChannel::send_payload_router() { 958 return send_payload_router_; 959 } 960 961 VCMProtectionCallback* ViEChannel::vcm_protection_callback() { 962 return vcm_protection_callback_.get(); 963 } 964 965 CallStatsObserver* ViEChannel::GetStatsObserver() { 966 return stats_observer_.get(); 967 } 968 969 // Do not acquire the lock of |vcm_| in this function. Decode callback won't 970 // necessarily be called from the decoding thread. The decoding thread may have 971 // held the lock when calling VideoDecoder::Decode, Reset, or Release. Acquiring 972 // the same lock in the path of decode callback can deadlock. 973 int32_t ViEChannel::FrameToRender(VideoFrame& video_frame) { // NOLINT 974 CriticalSectionScoped cs(crit_.get()); 975 976 if (pre_render_callback_ != NULL) 977 pre_render_callback_->FrameCallback(&video_frame); 978 979 // TODO(pbos): Remove stream id argument. 980 incoming_video_stream_->RenderFrame(0xFFFFFFFF, video_frame); 981 return 0; 982 } 983 984 int32_t ViEChannel::ReceivedDecodedReferenceFrame( 985 const uint64_t picture_id) { 986 return rtp_rtcp_modules_[0]->SendRTCPReferencePictureSelection(picture_id); 987 } 988 989 void ViEChannel::OnIncomingPayloadType(int payload_type) { 990 CriticalSectionScoped cs(crit_.get()); 991 if (receive_stats_callback_) 992 receive_stats_callback_->OnIncomingPayloadType(payload_type); 993 } 994 995 void ViEChannel::OnDecoderImplementationName(const char* implementation_name) { 996 CriticalSectionScoped cs(crit_.get()); 997 if (receive_stats_callback_) 998 receive_stats_callback_->OnDecoderImplementationName(implementation_name); 999 } 1000 1001 void ViEChannel::OnReceiveRatesUpdated(uint32_t bit_rate, uint32_t frame_rate) { 1002 CriticalSectionScoped cs(crit_.get()); 1003 if (receive_stats_callback_) 1004 receive_stats_callback_->OnIncomingRate(frame_rate, bit_rate); 1005 } 1006 1007 void ViEChannel::OnDiscardedPacketsUpdated(int discarded_packets) { 1008 CriticalSectionScoped cs(crit_.get()); 1009 if (receive_stats_callback_) 1010 receive_stats_callback_->OnDiscardedPacketsUpdated(discarded_packets); 1011 } 1012 1013 void ViEChannel::OnFrameCountsUpdated(const FrameCounts& frame_counts) { 1014 CriticalSectionScoped cs(crit_.get()); 1015 receive_frame_counts_ = frame_counts; 1016 if (receive_stats_callback_) 1017 receive_stats_callback_->OnFrameCountsUpdated(frame_counts); 1018 } 1019 1020 void ViEChannel::OnDecoderTiming(int decode_ms, 1021 int max_decode_ms, 1022 int current_delay_ms, 1023 int target_delay_ms, 1024 int jitter_buffer_ms, 1025 int min_playout_delay_ms, 1026 int render_delay_ms) { 1027 CriticalSectionScoped cs(crit_.get()); 1028 if (!receive_stats_callback_) 1029 return; 1030 receive_stats_callback_->OnDecoderTiming( 1031 decode_ms, max_decode_ms, current_delay_ms, target_delay_ms, 1032 jitter_buffer_ms, min_playout_delay_ms, render_delay_ms, last_rtt_ms_); 1033 } 1034 1035 int32_t ViEChannel::RequestKeyFrame() { 1036 return rtp_rtcp_modules_[0]->RequestKeyFrame(); 1037 } 1038 1039 int32_t ViEChannel::SliceLossIndicationRequest( 1040 const uint64_t picture_id) { 1041 return rtp_rtcp_modules_[0]->SendRTCPSliceLossIndication( 1042 static_cast<uint8_t>(picture_id)); 1043 } 1044 1045 int32_t ViEChannel::ResendPackets(const uint16_t* sequence_numbers, 1046 uint16_t length) { 1047 return rtp_rtcp_modules_[0]->SendNACK(sequence_numbers, length); 1048 } 1049 1050 bool ViEChannel::ChannelDecodeThreadFunction(void* obj) { 1051 return static_cast<ViEChannel*>(obj)->ChannelDecodeProcess(); 1052 } 1053 1054 bool ViEChannel::ChannelDecodeProcess() { 1055 vcm_->Decode(kMaxDecodeWaitTimeMs); 1056 return true; 1057 } 1058 1059 void ViEChannel::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) { 1060 vcm_->SetReceiveChannelParameters(max_rtt_ms); 1061 1062 CriticalSectionScoped cs(crit_.get()); 1063 if (time_of_first_rtt_ms_ == -1) 1064 time_of_first_rtt_ms_ = Clock::GetRealTimeClock()->TimeInMilliseconds(); 1065 rtt_sum_ms_ += avg_rtt_ms; 1066 last_rtt_ms_ = avg_rtt_ms; 1067 ++num_rtts_; 1068 } 1069 1070 int ViEChannel::ProtectionRequest(const FecProtectionParams* delta_fec_params, 1071 const FecProtectionParams* key_fec_params, 1072 uint32_t* video_rate_bps, 1073 uint32_t* nack_rate_bps, 1074 uint32_t* fec_rate_bps) { 1075 *video_rate_bps = 0; 1076 *nack_rate_bps = 0; 1077 *fec_rate_bps = 0; 1078 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { 1079 uint32_t not_used = 0; 1080 uint32_t module_video_rate = 0; 1081 uint32_t module_fec_rate = 0; 1082 uint32_t module_nack_rate = 0; 1083 rtp_rtcp->SetFecParameters(delta_fec_params, key_fec_params); 1084 rtp_rtcp->BitrateSent(¬_used, &module_video_rate, &module_fec_rate, 1085 &module_nack_rate); 1086 *video_rate_bps += module_video_rate; 1087 *nack_rate_bps += module_nack_rate; 1088 *fec_rate_bps += module_fec_rate; 1089 } 1090 return 0; 1091 } 1092 1093 std::vector<RtpRtcp*> ViEChannel::CreateRtpRtcpModules( 1094 bool receiver_only, 1095 ReceiveStatistics* receive_statistics, 1096 Transport* outgoing_transport, 1097 RtcpIntraFrameObserver* intra_frame_callback, 1098 RtcpBandwidthObserver* bandwidth_callback, 1099 TransportFeedbackObserver* transport_feedback_callback, 1100 RtcpRttStats* rtt_stats, 1101 RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer, 1102 RemoteBitrateEstimator* remote_bitrate_estimator, 1103 RtpPacketSender* paced_sender, 1104 TransportSequenceNumberAllocator* transport_sequence_number_allocator, 1105 BitrateStatisticsObserver* send_bitrate_observer, 1106 FrameCountObserver* send_frame_count_observer, 1107 SendSideDelayObserver* send_side_delay_observer, 1108 size_t num_modules) { 1109 RTC_DCHECK_GT(num_modules, 0u); 1110 RtpRtcp::Configuration configuration; 1111 ReceiveStatistics* null_receive_statistics = configuration.receive_statistics; 1112 configuration.audio = false; 1113 configuration.receiver_only = receiver_only; 1114 configuration.receive_statistics = receive_statistics; 1115 configuration.outgoing_transport = outgoing_transport; 1116 configuration.intra_frame_callback = intra_frame_callback; 1117 configuration.rtt_stats = rtt_stats; 1118 configuration.rtcp_packet_type_counter_observer = 1119 rtcp_packet_type_counter_observer; 1120 configuration.paced_sender = paced_sender; 1121 configuration.transport_sequence_number_allocator = 1122 transport_sequence_number_allocator; 1123 configuration.send_bitrate_observer = send_bitrate_observer; 1124 configuration.send_frame_count_observer = send_frame_count_observer; 1125 configuration.send_side_delay_observer = send_side_delay_observer; 1126 configuration.bandwidth_callback = bandwidth_callback; 1127 configuration.transport_feedback_callback = transport_feedback_callback; 1128 1129 std::vector<RtpRtcp*> modules; 1130 for (size_t i = 0; i < num_modules; ++i) { 1131 RtpRtcp* rtp_rtcp = RtpRtcp::CreateRtpRtcp(configuration); 1132 rtp_rtcp->SetSendingStatus(false); 1133 rtp_rtcp->SetSendingMediaStatus(false); 1134 rtp_rtcp->SetRTCPStatus(RtcpMode::kCompound); 1135 modules.push_back(rtp_rtcp); 1136 // Receive statistics and remote bitrate estimator should only be set for 1137 // the primary (first) module. 1138 configuration.receive_statistics = null_receive_statistics; 1139 configuration.remote_bitrate_estimator = nullptr; 1140 } 1141 return modules; 1142 } 1143 1144 void ViEChannel::StartDecodeThread() { 1145 RTC_DCHECK(!sender_); 1146 if (decode_thread_.IsRunning()) 1147 return; 1148 // Start the decode thread 1149 decode_thread_.Start(); 1150 decode_thread_.SetPriority(rtc::kHighestPriority); 1151 } 1152 1153 void ViEChannel::StopDecodeThread() { 1154 vcm_->TriggerDecoderShutdown(); 1155 1156 decode_thread_.Stop(); 1157 } 1158 1159 int32_t ViEChannel::SetVoiceChannel(int32_t ve_channel_id, 1160 VoEVideoSync* ve_sync_interface) { 1161 return vie_sync_.ConfigureSync(ve_channel_id, ve_sync_interface, 1162 rtp_rtcp_modules_[0], 1163 vie_receiver_.GetRtpReceiver()); 1164 } 1165 1166 int32_t ViEChannel::VoiceChannel() { 1167 return vie_sync_.VoiceChannel(); 1168 } 1169 1170 void ViEChannel::RegisterPreRenderCallback( 1171 I420FrameCallback* pre_render_callback) { 1172 CriticalSectionScoped cs(crit_.get()); 1173 pre_render_callback_ = pre_render_callback; 1174 } 1175 1176 void ViEChannel::RegisterPreDecodeImageCallback( 1177 EncodedImageCallback* pre_decode_callback) { 1178 vcm_->RegisterPreDecodeImageCallback(pre_decode_callback); 1179 } 1180 1181 // TODO(pbos): Remove OnInitializeDecoder which is called from the RTP module, 1182 // any decoder resetting should be handled internally within the VCM. 1183 int32_t ViEChannel::OnInitializeDecoder( 1184 const int8_t payload_type, 1185 const char payload_name[RTP_PAYLOAD_NAME_SIZE], 1186 const int frequency, 1187 const size_t channels, 1188 const uint32_t rate) { 1189 LOG(LS_INFO) << "OnInitializeDecoder " << static_cast<int>(payload_type) 1190 << " " << payload_name; 1191 vcm_->ResetDecoder(); 1192 1193 return 0; 1194 } 1195 1196 void ViEChannel::OnIncomingSSRCChanged(const uint32_t ssrc) { 1197 rtp_rtcp_modules_[0]->SetRemoteSSRC(ssrc); 1198 } 1199 1200 void ViEChannel::OnIncomingCSRCChanged(const uint32_t CSRC, const bool added) {} 1201 1202 void ViEChannel::RegisterSendFrameCountObserver( 1203 FrameCountObserver* observer) { 1204 send_frame_count_observer_.Set(observer); 1205 } 1206 1207 void ViEChannel::RegisterReceiveStatisticsProxy( 1208 ReceiveStatisticsProxy* receive_statistics_proxy) { 1209 CriticalSectionScoped cs(crit_.get()); 1210 receive_stats_callback_ = receive_statistics_proxy; 1211 } 1212 1213 void ViEChannel::SetIncomingVideoStream( 1214 IncomingVideoStream* incoming_video_stream) { 1215 CriticalSectionScoped cs(crit_.get()); 1216 incoming_video_stream_ = incoming_video_stream; 1217 } 1218 } // namespace webrtc 1219
