diff options
Diffstat (limited to 'webrtc/video_engine/vie_channel.cc')
| -rw-r--r-- | webrtc/video_engine/vie_channel.cc | 1253 |
1 files changed, 0 insertions, 1253 deletions
diff --git a/webrtc/video_engine/vie_channel.cc b/webrtc/video_engine/vie_channel.cc deleted file mode 100644 index 147ecb1456..0000000000 --- a/webrtc/video_engine/vie_channel.cc +++ /dev/null @@ -1,1253 +0,0 @@ -/* - * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#include "webrtc/video_engine/vie_channel.h" - -#include <algorithm> -#include <vector> - -#include "webrtc/base/checks.h" -#include "webrtc/base/logging.h" -#include "webrtc/common.h" -#include "webrtc/common_video/interface/incoming_video_stream.h" -#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" -#include "webrtc/frame_callback.h" -#include "webrtc/modules/pacing/include/paced_sender.h" -#include "webrtc/modules/pacing/include/packet_router.h" -#include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h" -#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h" -#include "webrtc/modules/utility/interface/process_thread.h" -#include "webrtc/modules/video_coding/main/interface/video_coding.h" -#include "webrtc/modules/video_processing/main/interface/video_processing.h" -#include "webrtc/modules/video_render/include/video_render_defines.h" -#include "webrtc/system_wrappers/include/critical_section_wrapper.h" -#include "webrtc/system_wrappers/include/metrics.h" -#include "webrtc/system_wrappers/include/thread_wrapper.h" -#include "webrtc/video/receive_statistics_proxy.h" -#include "webrtc/video_engine/call_stats.h" -#include "webrtc/video_engine/payload_router.h" -#include "webrtc/video_engine/report_block_stats.h" -#include "webrtc/video_engine/vie_defines.h" - -namespace webrtc { - -const int kMaxDecodeWaitTimeMs = 50; -static const int kMaxTargetDelayMs = 10000; -static const float kMaxIncompleteTimeMultiplier = 3.5f; - -// Helper class receiving statistics callbacks. -class ChannelStatsObserver : public CallStatsObserver { - public: - explicit ChannelStatsObserver(ViEChannel* owner) : owner_(owner) {} - virtual ~ChannelStatsObserver() {} - - // Implements StatsObserver. - virtual void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) { - owner_->OnRttUpdate(avg_rtt_ms, max_rtt_ms); - } - - private: - ViEChannel* const owner_; -}; - -class ViEChannelProtectionCallback : public VCMProtectionCallback { - public: - ViEChannelProtectionCallback(ViEChannel* owner) : owner_(owner) {} - ~ViEChannelProtectionCallback() {} - - - int ProtectionRequest( - const FecProtectionParams* delta_fec_params, - const FecProtectionParams* key_fec_params, - uint32_t* sent_video_rate_bps, - uint32_t* sent_nack_rate_bps, - uint32_t* sent_fec_rate_bps) override { - return owner_->ProtectionRequest(delta_fec_params, key_fec_params, - sent_video_rate_bps, sent_nack_rate_bps, - sent_fec_rate_bps); - } - private: - ViEChannel* owner_; -}; - -ViEChannel::ViEChannel(uint32_t number_of_cores, - Transport* transport, - ProcessThread* module_process_thread, - RtcpIntraFrameObserver* intra_frame_observer, - RtcpBandwidthObserver* bandwidth_observer, - TransportFeedbackObserver* transport_feedback_observer, - RemoteBitrateEstimator* remote_bitrate_estimator, - RtcpRttStats* rtt_stats, - PacedSender* paced_sender, - PacketRouter* packet_router, - size_t max_rtp_streams, - bool sender) - : number_of_cores_(number_of_cores), - sender_(sender), - module_process_thread_(module_process_thread), - crit_(CriticalSectionWrapper::CreateCriticalSection()), - send_payload_router_(new PayloadRouter()), - vcm_protection_callback_(new ViEChannelProtectionCallback(this)), - vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(), - nullptr, - nullptr)), - vie_receiver_(vcm_, remote_bitrate_estimator, this), - vie_sync_(vcm_), - stats_observer_(new ChannelStatsObserver(this)), - receive_stats_callback_(nullptr), - incoming_video_stream_(nullptr), - intra_frame_observer_(intra_frame_observer), - rtt_stats_(rtt_stats), - paced_sender_(paced_sender), - packet_router_(packet_router), - bandwidth_observer_(bandwidth_observer), - transport_feedback_observer_(transport_feedback_observer), - nack_history_size_sender_(kSendSidePacketHistorySize), - max_nack_reordering_threshold_(kMaxPacketAgeToNack), - pre_render_callback_(NULL), - report_block_stats_sender_(new ReportBlockStats()), - time_of_first_rtt_ms_(-1), - rtt_sum_ms_(0), - last_rtt_ms_(0), - num_rtts_(0), - rtp_rtcp_modules_( - CreateRtpRtcpModules(!sender, - vie_receiver_.GetReceiveStatistics(), - transport, - sender ? intra_frame_observer_ : nullptr, - sender ? bandwidth_observer_.get() : nullptr, - transport_feedback_observer_, - rtt_stats_, - &rtcp_packet_type_counter_observer_, - remote_bitrate_estimator, - paced_sender_, - packet_router_, - &send_bitrate_observer_, - &send_frame_count_observer_, - &send_side_delay_observer_, - max_rtp_streams)), - num_active_rtp_rtcp_modules_(1) { - vie_receiver_.SetRtpRtcpModule(rtp_rtcp_modules_[0]); - vcm_->SetNackSettings(kMaxNackListSize, max_nack_reordering_threshold_, 0); -} - -int32_t ViEChannel::Init() { - module_process_thread_->RegisterModule(vie_receiver_.GetReceiveStatistics()); - - // RTP/RTCP initialization. - module_process_thread_->RegisterModule(rtp_rtcp_modules_[0]); - - rtp_rtcp_modules_[0]->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp); - if (paced_sender_) { - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_); - } - packet_router_->AddRtpModule(rtp_rtcp_modules_[0]); - if (sender_) { - std::list<RtpRtcp*> send_rtp_modules(1, rtp_rtcp_modules_[0]); - send_payload_router_->SetSendingRtpModules(send_rtp_modules); - RTC_DCHECK(!send_payload_router_->active()); - } - if (vcm_->RegisterReceiveCallback(this) != 0) { - return -1; - } - vcm_->RegisterFrameTypeCallback(this); - vcm_->RegisterReceiveStatisticsCallback(this); - vcm_->RegisterDecoderTimingCallback(this); - vcm_->SetRenderDelay(kViEDefaultRenderDelayMs); - - module_process_thread_->RegisterModule(vcm_); - module_process_thread_->RegisterModule(&vie_sync_); - - return 0; -} - -ViEChannel::~ViEChannel() { - UpdateHistograms(); - // Make sure we don't get more callbacks from the RTP module. - module_process_thread_->DeRegisterModule( - vie_receiver_.GetReceiveStatistics()); - module_process_thread_->DeRegisterModule(vcm_); - module_process_thread_->DeRegisterModule(&vie_sync_); - send_payload_router_->SetSendingRtpModules(std::list<RtpRtcp*>()); - for (size_t i = 0; i < num_active_rtp_rtcp_modules_; ++i) - packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i]); - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { - module_process_thread_->DeRegisterModule(rtp_rtcp); - delete rtp_rtcp; - } - if (decode_thread_) { - StopDecodeThread(); - } - // Release modules. - VideoCodingModule::Destroy(vcm_); -} - -void ViEChannel::UpdateHistograms() { - int64_t now = Clock::GetRealTimeClock()->TimeInMilliseconds(); - - { - CriticalSectionScoped cs(crit_.get()); - int64_t elapsed_sec = (now - time_of_first_rtt_ms_) / 1000; - if (time_of_first_rtt_ms_ != -1 && num_rtts_ > 0 && - elapsed_sec > metrics::kMinRunTimeInSeconds) { - int64_t avg_rtt_ms = (rtt_sum_ms_ + num_rtts_ / 2) / num_rtts_; - RTC_HISTOGRAM_COUNTS_10000( - "WebRTC.Video.AverageRoundTripTimeInMilliseconds", avg_rtt_ms); - } - } - - if (sender_) { - RtcpPacketTypeCounter rtcp_counter; - GetSendRtcpPacketTypeCounter(&rtcp_counter); - int64_t elapsed_sec = rtcp_counter.TimeSinceFirstPacketInMs(now) / 1000; - if (elapsed_sec > metrics::kMinRunTimeInSeconds) { - RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.NackPacketsReceivedPerMinute", - rtcp_counter.nack_packets * 60 / elapsed_sec); - RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.FirPacketsReceivedPerMinute", - rtcp_counter.fir_packets * 60 / elapsed_sec); - RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.PliPacketsReceivedPerMinute", - rtcp_counter.pli_packets * 60 / elapsed_sec); - if (rtcp_counter.nack_requests > 0) { - RTC_HISTOGRAM_PERCENTAGE( - "WebRTC.Video.UniqueNackRequestsReceivedInPercent", - rtcp_counter.UniqueNackRequestsInPercent()); - } - int fraction_lost = report_block_stats_sender_->FractionLostInPercent(); - if (fraction_lost != -1) { - RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.SentPacketsLostInPercent", - fraction_lost); - } - } - - StreamDataCounters rtp; - StreamDataCounters rtx; - GetSendStreamDataCounters(&rtp, &rtx); - StreamDataCounters rtp_rtx = rtp; - rtp_rtx.Add(rtx); - elapsed_sec = rtp_rtx.TimeSinceFirstPacketInMs( - Clock::GetRealTimeClock()->TimeInMilliseconds()) / - 1000; - if (elapsed_sec > metrics::kMinRunTimeInSeconds) { - RTC_HISTOGRAM_COUNTS_100000( - "WebRTC.Video.BitrateSentInKbps", - static_cast<int>(rtp_rtx.transmitted.TotalBytes() * 8 / elapsed_sec / - 1000)); - RTC_HISTOGRAM_COUNTS_10000( - "WebRTC.Video.MediaBitrateSentInKbps", - static_cast<int>(rtp.MediaPayloadBytes() * 8 / elapsed_sec / 1000)); - RTC_HISTOGRAM_COUNTS_10000( - "WebRTC.Video.PaddingBitrateSentInKbps", - static_cast<int>(rtp_rtx.transmitted.padding_bytes * 8 / elapsed_sec / - 1000)); - RTC_HISTOGRAM_COUNTS_10000( - "WebRTC.Video.RetransmittedBitrateSentInKbps", - static_cast<int>(rtp_rtx.retransmitted.TotalBytes() * 8 / - elapsed_sec / 1000)); - if (rtp_rtcp_modules_[0]->RtxSendStatus() != kRtxOff) { - RTC_HISTOGRAM_COUNTS_10000( - "WebRTC.Video.RtxBitrateSentInKbps", - static_cast<int>(rtx.transmitted.TotalBytes() * 8 / elapsed_sec / - 1000)); - } - bool fec_enabled = false; - uint8_t pltype_red; - uint8_t pltype_fec; - rtp_rtcp_modules_[0]->GenericFECStatus(fec_enabled, pltype_red, - pltype_fec); - if (fec_enabled) { - RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.FecBitrateSentInKbps", - static_cast<int>(rtp_rtx.fec.TotalBytes() * - 8 / elapsed_sec / 1000)); - } - } - } else if (vie_receiver_.GetRemoteSsrc() > 0) { - // Get receive stats if we are receiving packets, i.e. there is a remote - // ssrc. - RtcpPacketTypeCounter rtcp_counter; - GetReceiveRtcpPacketTypeCounter(&rtcp_counter); - int64_t elapsed_sec = rtcp_counter.TimeSinceFirstPacketInMs(now) / 1000; - if (elapsed_sec > metrics::kMinRunTimeInSeconds) { - RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.NackPacketsSentPerMinute", - rtcp_counter.nack_packets * 60 / elapsed_sec); - RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.FirPacketsSentPerMinute", - rtcp_counter.fir_packets * 60 / elapsed_sec); - RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.PliPacketsSentPerMinute", - rtcp_counter.pli_packets * 60 / elapsed_sec); - if (rtcp_counter.nack_requests > 0) { - RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.UniqueNackRequestsSentInPercent", - rtcp_counter.UniqueNackRequestsInPercent()); - } - } - - StreamDataCounters rtp; - StreamDataCounters rtx; - GetReceiveStreamDataCounters(&rtp, &rtx); - StreamDataCounters rtp_rtx = rtp; - rtp_rtx.Add(rtx); - elapsed_sec = rtp_rtx.TimeSinceFirstPacketInMs(now) / 1000; - if (elapsed_sec > metrics::kMinRunTimeInSeconds) { - RTC_HISTOGRAM_COUNTS_10000( - "WebRTC.Video.BitrateReceivedInKbps", - static_cast<int>(rtp_rtx.transmitted.TotalBytes() * 8 / elapsed_sec / - 1000)); - RTC_HISTOGRAM_COUNTS_10000( - "WebRTC.Video.MediaBitrateReceivedInKbps", - static_cast<int>(rtp.MediaPayloadBytes() * 8 / elapsed_sec / 1000)); - RTC_HISTOGRAM_COUNTS_10000( - "WebRTC.Video.PaddingBitrateReceivedInKbps", - static_cast<int>(rtp_rtx.transmitted.padding_bytes * 8 / elapsed_sec / - 1000)); - RTC_HISTOGRAM_COUNTS_10000( - "WebRTC.Video.RetransmittedBitrateReceivedInKbps", - static_cast<int>(rtp_rtx.retransmitted.TotalBytes() * 8 / - elapsed_sec / 1000)); - uint32_t ssrc = 0; - if (vie_receiver_.GetRtxSsrc(&ssrc)) { - RTC_HISTOGRAM_COUNTS_10000( - "WebRTC.Video.RtxBitrateReceivedInKbps", - static_cast<int>(rtx.transmitted.TotalBytes() * 8 / elapsed_sec / - 1000)); - } - if (vie_receiver_.IsFecEnabled()) { - RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.FecBitrateReceivedInKbps", - static_cast<int>(rtp_rtx.fec.TotalBytes() * - 8 / elapsed_sec / 1000)); - } - } - } -} - -int32_t ViEChannel::SetSendCodec(const VideoCodec& video_codec, - bool new_stream) { - RTC_DCHECK(sender_); - if (video_codec.codecType == kVideoCodecRED || - video_codec.codecType == kVideoCodecULPFEC) { - LOG_F(LS_ERROR) << "Not a valid send codec " << video_codec.codecType; - return -1; - } - if (kMaxSimulcastStreams < video_codec.numberOfSimulcastStreams) { - LOG_F(LS_ERROR) << "Incorrect config " - << video_codec.numberOfSimulcastStreams; - return -1; - } - // Update the RTP module with the settings. - // Stop and Start the RTP module -> trigger new SSRC, if an SSRC hasn't been - // set explicitly. - // The first layer is always active, so the first module can be checked for - // sending status. - bool is_sending = rtp_rtcp_modules_[0]->Sending(); - bool router_was_active = send_payload_router_->active(); - send_payload_router_->set_active(false); - send_payload_router_->SetSendingRtpModules(std::list<RtpRtcp*>()); - - std::vector<RtpRtcp*> registered_modules; - std::vector<RtpRtcp*> deregistered_modules; - size_t num_active_modules = video_codec.numberOfSimulcastStreams > 0 - ? video_codec.numberOfSimulcastStreams - : 1; - size_t num_prev_active_modules; - { - // Cache which modules are active so StartSend can know which ones to start. - CriticalSectionScoped cs(crit_.get()); - num_prev_active_modules = num_active_rtp_rtcp_modules_; - num_active_rtp_rtcp_modules_ = num_active_modules; - } - for (size_t i = 0; i < num_active_modules; ++i) - registered_modules.push_back(rtp_rtcp_modules_[i]); - - for (size_t i = num_active_modules; i < rtp_rtcp_modules_.size(); ++i) - deregistered_modules.push_back(rtp_rtcp_modules_[i]); - - // Disable inactive modules. - for (RtpRtcp* rtp_rtcp : deregistered_modules) { - rtp_rtcp->SetSendingStatus(false); - rtp_rtcp->SetSendingMediaStatus(false); - } - - // Configure active modules. - for (RtpRtcp* rtp_rtcp : registered_modules) { - rtp_rtcp->DeRegisterSendPayload(video_codec.plType); - if (rtp_rtcp->RegisterSendPayload(video_codec) != 0) { - return -1; - } - rtp_rtcp->SetSendingStatus(is_sending); - rtp_rtcp->SetSendingMediaStatus(is_sending); - } - - // |RegisterSimulcastRtpRtcpModules| resets all old weak pointers and old - // modules can be deleted after this step. - vie_receiver_.RegisterRtpRtcpModules(registered_modules); - - // Update the packet and payload routers with the sending RtpRtcp modules. - if (sender_) { - std::list<RtpRtcp*> active_send_modules; - for (RtpRtcp* rtp_rtcp : registered_modules) - active_send_modules.push_back(rtp_rtcp); - send_payload_router_->SetSendingRtpModules(active_send_modules); - } - - if (router_was_active) - send_payload_router_->set_active(true); - - // Deregister previously registered modules. - for (size_t i = num_active_modules; i < num_prev_active_modules; ++i) { - module_process_thread_->DeRegisterModule(rtp_rtcp_modules_[i]); - packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i]); - } - // Register new active modules. - for (size_t i = num_prev_active_modules; i < num_active_modules; ++i) { - module_process_thread_->RegisterModule(rtp_rtcp_modules_[i]); - packet_router_->AddRtpModule(rtp_rtcp_modules_[i]); - } - return 0; -} - -int32_t ViEChannel::SetReceiveCodec(const VideoCodec& video_codec) { - RTC_DCHECK(!sender_); - if (!vie_receiver_.SetReceiveCodec(video_codec)) { - return -1; - } - - if (video_codec.codecType != kVideoCodecRED && - video_codec.codecType != kVideoCodecULPFEC) { - // Register codec type with VCM, but do not register RED or ULPFEC. - if (vcm_->RegisterReceiveCodec(&video_codec, number_of_cores_, false) != - VCM_OK) { - return -1; - } - } - return 0; -} - - -int32_t ViEChannel::RegisterExternalDecoder(const uint8_t pl_type, - VideoDecoder* decoder, - bool buffered_rendering, - int32_t render_delay) { - RTC_DCHECK(!sender_); - int32_t result; - result = vcm_->RegisterExternalDecoder(decoder, pl_type, buffered_rendering); - if (result != VCM_OK) { - return result; - } - return vcm_->SetRenderDelay(render_delay); -} - -int32_t ViEChannel::DeRegisterExternalDecoder(const uint8_t pl_type) { - RTC_DCHECK(!sender_); - VideoCodec current_receive_codec; - int32_t result = 0; - result = vcm_->ReceiveCodec(¤t_receive_codec); - if (vcm_->RegisterExternalDecoder(NULL, pl_type, false) != VCM_OK) { - return -1; - } - - if (result == 0 && current_receive_codec.plType == pl_type) { - result = vcm_->RegisterReceiveCodec(¤t_receive_codec, - number_of_cores_, false); - } - return result; -} - -int32_t ViEChannel::ReceiveCodecStatistics(uint32_t* num_key_frames, - uint32_t* num_delta_frames) { - CriticalSectionScoped cs(crit_.get()); - *num_key_frames = receive_frame_counts_.key_frames; - *num_delta_frames = receive_frame_counts_.delta_frames; - return 0; -} - -uint32_t ViEChannel::DiscardedPackets() const { - return vcm_->DiscardedPackets(); -} - -int ViEChannel::ReceiveDelay() const { - return vcm_->Delay(); -} - -void ViEChannel::SetRTCPMode(const RtcpMode rtcp_mode) { - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - rtp_rtcp->SetRTCPStatus(rtcp_mode); -} - -void ViEChannel::SetProtectionMode(bool enable_nack, - bool enable_fec, - int payload_type_red, - int payload_type_fec) { - // Validate payload types. - if (enable_fec) { - RTC_DCHECK_GE(payload_type_red, 0); - RTC_DCHECK_GE(payload_type_fec, 0); - RTC_DCHECK_LE(payload_type_red, 127); - RTC_DCHECK_LE(payload_type_fec, 127); - } else { - RTC_DCHECK_EQ(payload_type_red, -1); - RTC_DCHECK_EQ(payload_type_fec, -1); - // Set to valid uint8_ts to be castable later without signed overflows. - payload_type_red = 0; - payload_type_fec = 0; - } - - VCMVideoProtection protection_method; - if (enable_nack) { - protection_method = enable_fec ? kProtectionNackFEC : kProtectionNack; - } else { - protection_method = kProtectionNone; - } - - vcm_->SetVideoProtection(protection_method, true); - - // Set NACK. - ProcessNACKRequest(enable_nack); - - // Set FEC. - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { - rtp_rtcp->SetGenericFECStatus(enable_fec, - static_cast<uint8_t>(payload_type_red), - static_cast<uint8_t>(payload_type_fec)); - } -} - -void ViEChannel::ProcessNACKRequest(const bool enable) { - if (enable) { - // Turn on NACK. - if (rtp_rtcp_modules_[0]->RTCP() == RtcpMode::kOff) - return; - vie_receiver_.SetNackStatus(true, max_nack_reordering_threshold_); - - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_); - - vcm_->RegisterPacketRequestCallback(this); - // Don't introduce errors when NACK is enabled. - vcm_->SetDecodeErrorMode(kNoErrors); - } else { - vcm_->RegisterPacketRequestCallback(NULL); - if (paced_sender_ == nullptr) { - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - rtp_rtcp->SetStorePacketsStatus(false, 0); - } - vie_receiver_.SetNackStatus(false, max_nack_reordering_threshold_); - // When NACK is off, allow decoding with errors. Otherwise, the video - // will freeze, and will only recover with a complete key frame. - vcm_->SetDecodeErrorMode(kWithErrors); - } -} - -bool ViEChannel::IsSendingFecEnabled() { - bool fec_enabled = false; - uint8_t pltype_red = 0; - uint8_t pltype_fec = 0; - - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { - rtp_rtcp->GenericFECStatus(fec_enabled, pltype_red, pltype_fec); - if (fec_enabled) - return true; - } - return false; -} - -int ViEChannel::SetSenderBufferingMode(int target_delay_ms) { - if ((target_delay_ms < 0) || (target_delay_ms > kMaxTargetDelayMs)) { - LOG(LS_ERROR) << "Invalid send buffer value."; - return -1; - } - if (target_delay_ms == 0) { - // Real-time mode. - nack_history_size_sender_ = kSendSidePacketHistorySize; - } else { - nack_history_size_sender_ = GetRequiredNackListSize(target_delay_ms); - // Don't allow a number lower than the default value. - if (nack_history_size_sender_ < kSendSidePacketHistorySize) { - nack_history_size_sender_ = kSendSidePacketHistorySize; - } - } - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_); - return 0; -} - -int ViEChannel::SetReceiverBufferingMode(int target_delay_ms) { - if ((target_delay_ms < 0) || (target_delay_ms > kMaxTargetDelayMs)) { - LOG(LS_ERROR) << "Invalid receive buffer delay value."; - return -1; - } - int max_nack_list_size; - int max_incomplete_time_ms; - if (target_delay_ms == 0) { - // Real-time mode - restore default settings. - max_nack_reordering_threshold_ = kMaxPacketAgeToNack; - max_nack_list_size = kMaxNackListSize; - max_incomplete_time_ms = 0; - } else { - max_nack_list_size = 3 * GetRequiredNackListSize(target_delay_ms) / 4; - max_nack_reordering_threshold_ = max_nack_list_size; - // Calculate the max incomplete time and round to int. - max_incomplete_time_ms = static_cast<int>(kMaxIncompleteTimeMultiplier * - target_delay_ms + 0.5f); - } - vcm_->SetNackSettings(max_nack_list_size, max_nack_reordering_threshold_, - max_incomplete_time_ms); - vcm_->SetMinReceiverDelay(target_delay_ms); - if (vie_sync_.SetTargetBufferingDelay(target_delay_ms) < 0) - return -1; - return 0; -} - -int ViEChannel::GetRequiredNackListSize(int target_delay_ms) { - // The max size of the nack list should be large enough to accommodate the - // the number of packets (frames) resulting from the increased delay. - // Roughly estimating for ~40 packets per frame @ 30fps. - return target_delay_ms * 40 * 30 / 1000; -} - -int ViEChannel::SetSendTimestampOffsetStatus(bool enable, int id) { - // Disable any previous registrations of this extension to avoid errors. - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { - rtp_rtcp->DeregisterSendRtpHeaderExtension( - kRtpExtensionTransmissionTimeOffset); - } - if (!enable) - return 0; - // Enable the extension. - int error = 0; - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { - error |= rtp_rtcp->RegisterSendRtpHeaderExtension( - kRtpExtensionTransmissionTimeOffset, id); - } - return error; -} - -int ViEChannel::SetReceiveTimestampOffsetStatus(bool enable, int id) { - return vie_receiver_.SetReceiveTimestampOffsetStatus(enable, id) ? 0 : -1; -} - -int ViEChannel::SetSendAbsoluteSendTimeStatus(bool enable, int id) { - // Disable any previous registrations of this extension to avoid errors. - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - rtp_rtcp->DeregisterSendRtpHeaderExtension(kRtpExtensionAbsoluteSendTime); - if (!enable) - return 0; - // Enable the extension. - int error = 0; - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { - error |= rtp_rtcp->RegisterSendRtpHeaderExtension( - kRtpExtensionAbsoluteSendTime, id); - } - return error; -} - -int ViEChannel::SetReceiveAbsoluteSendTimeStatus(bool enable, int id) { - return vie_receiver_.SetReceiveAbsoluteSendTimeStatus(enable, id) ? 0 : -1; -} - -int ViEChannel::SetSendVideoRotationStatus(bool enable, int id) { - // Disable any previous registrations of this extension to avoid errors. - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - rtp_rtcp->DeregisterSendRtpHeaderExtension(kRtpExtensionVideoRotation); - if (!enable) - return 0; - // Enable the extension. - int error = 0; - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { - error |= rtp_rtcp->RegisterSendRtpHeaderExtension( - kRtpExtensionVideoRotation, id); - } - return error; -} - -int ViEChannel::SetReceiveVideoRotationStatus(bool enable, int id) { - return vie_receiver_.SetReceiveVideoRotationStatus(enable, id) ? 0 : -1; -} - -int ViEChannel::SetSendTransportSequenceNumber(bool enable, int id) { - // Disable any previous registrations of this extension to avoid errors. - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { - rtp_rtcp->DeregisterSendRtpHeaderExtension( - kRtpExtensionTransportSequenceNumber); - } - if (!enable) - return 0; - // Enable the extension. - int error = 0; - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { - error |= rtp_rtcp->RegisterSendRtpHeaderExtension( - kRtpExtensionTransportSequenceNumber, id); - } - return error; -} - -int ViEChannel::SetReceiveTransportSequenceNumber(bool enable, int id) { - return vie_receiver_.SetReceiveTransportSequenceNumber(enable, id) ? 0 : -1; -} - -void ViEChannel::SetRtcpXrRrtrStatus(bool enable) { - rtp_rtcp_modules_[0]->SetRtcpXrRrtrStatus(enable); -} - -void ViEChannel::EnableTMMBR(bool enable) { - rtp_rtcp_modules_[0]->SetTMMBRStatus(enable); -} - -int32_t ViEChannel::SetSSRC(const uint32_t SSRC, - const StreamType usage, - const uint8_t simulcast_idx) { - RtpRtcp* rtp_rtcp = rtp_rtcp_modules_[simulcast_idx]; - if (usage == kViEStreamTypeRtx) { - rtp_rtcp->SetRtxSsrc(SSRC); - } else { - rtp_rtcp->SetSSRC(SSRC); - } - return 0; -} - -int32_t ViEChannel::SetRemoteSSRCType(const StreamType usage, - const uint32_t SSRC) { - vie_receiver_.SetRtxSsrc(SSRC); - return 0; -} - -int32_t ViEChannel::GetLocalSSRC(uint8_t idx, unsigned int* ssrc) { - RTC_DCHECK_LE(idx, rtp_rtcp_modules_.size()); - *ssrc = rtp_rtcp_modules_[idx]->SSRC(); - return 0; -} - -uint32_t ViEChannel::GetRemoteSSRC() { - return vie_receiver_.GetRemoteSsrc(); -} - -int ViEChannel::SetRtxSendPayloadType(int payload_type, - int associated_payload_type) { - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - rtp_rtcp->SetRtxSendPayloadType(payload_type, associated_payload_type); - SetRtxSendStatus(true); - return 0; -} - -void ViEChannel::SetRtxSendStatus(bool enable) { - int rtx_settings = - enable ? kRtxRetransmitted | kRtxRedundantPayloads : kRtxOff; - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - rtp_rtcp->SetRtxSendStatus(rtx_settings); -} - -void ViEChannel::SetRtxReceivePayloadType(int payload_type, - int associated_payload_type) { - vie_receiver_.SetRtxPayloadType(payload_type, associated_payload_type); -} - -void ViEChannel::SetUseRtxPayloadMappingOnRestore(bool val) { - vie_receiver_.SetUseRtxPayloadMappingOnRestore(val); -} - -void ViEChannel::SetRtpStateForSsrc(uint32_t ssrc, const RtpState& rtp_state) { - RTC_DCHECK(!rtp_rtcp_modules_[0]->Sending()); - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { - if (rtp_rtcp->SetRtpStateForSsrc(ssrc, rtp_state)) - return; - } -} - -RtpState ViEChannel::GetRtpStateForSsrc(uint32_t ssrc) { - RTC_DCHECK(!rtp_rtcp_modules_[0]->Sending()); - RtpState rtp_state; - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { - if (rtp_rtcp->GetRtpStateForSsrc(ssrc, &rtp_state)) - return rtp_state; - } - LOG(LS_ERROR) << "Couldn't get RTP state for ssrc: " << ssrc; - return rtp_state; -} - -// TODO(pbos): Set CNAME on all modules. -int32_t ViEChannel::SetRTCPCName(const char* rtcp_cname) { - RTC_DCHECK(!rtp_rtcp_modules_[0]->Sending()); - return rtp_rtcp_modules_[0]->SetCNAME(rtcp_cname); -} - -int32_t ViEChannel::GetRemoteRTCPCName(char rtcp_cname[]) { - uint32_t remoteSSRC = vie_receiver_.GetRemoteSsrc(); - return rtp_rtcp_modules_[0]->RemoteCNAME(remoteSSRC, rtcp_cname); -} - -int32_t ViEChannel::GetSendRtcpStatistics(uint16_t* fraction_lost, - uint32_t* cumulative_lost, - uint32_t* extended_max, - uint32_t* jitter_samples, - int64_t* rtt_ms) { - // Aggregate the report blocks associated with streams sent on this channel. - std::vector<RTCPReportBlock> report_blocks; - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - rtp_rtcp->RemoteRTCPStat(&report_blocks); - - if (report_blocks.empty()) - return -1; - - uint32_t remote_ssrc = vie_receiver_.GetRemoteSsrc(); - std::vector<RTCPReportBlock>::const_iterator it = report_blocks.begin(); - for (; it != report_blocks.end(); ++it) { - if (it->remoteSSRC == remote_ssrc) - break; - } - if (it == report_blocks.end()) { - // We have not received packets with an SSRC matching the report blocks. To - // have a chance of calculating an RTT we will try with the SSRC of the - // first report block received. - // This is very important for send-only channels where we don't know the - // SSRC of the other end. - remote_ssrc = report_blocks[0].remoteSSRC; - } - - // TODO(asapersson): Change report_block_stats to not rely on - // GetSendRtcpStatistics to be called. - RTCPReportBlock report = - report_block_stats_sender_->AggregateAndStore(report_blocks); - *fraction_lost = report.fractionLost; - *cumulative_lost = report.cumulativeLost; - *extended_max = report.extendedHighSeqNum; - *jitter_samples = report.jitter; - - int64_t dummy; - int64_t rtt = 0; - if (rtp_rtcp_modules_[0]->RTT(remote_ssrc, &rtt, &dummy, &dummy, &dummy) != - 0) { - return -1; - } - *rtt_ms = rtt; - return 0; -} - -void ViEChannel::RegisterSendChannelRtcpStatisticsCallback( - RtcpStatisticsCallback* callback) { - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - rtp_rtcp->RegisterRtcpStatisticsCallback(callback); -} - -void ViEChannel::RegisterReceiveChannelRtcpStatisticsCallback( - RtcpStatisticsCallback* callback) { - vie_receiver_.GetReceiveStatistics()->RegisterRtcpStatisticsCallback( - callback); - rtp_rtcp_modules_[0]->RegisterRtcpStatisticsCallback(callback); -} - -void ViEChannel::RegisterRtcpPacketTypeCounterObserver( - RtcpPacketTypeCounterObserver* observer) { - rtcp_packet_type_counter_observer_.Set(observer); -} - -void ViEChannel::GetSendStreamDataCounters( - StreamDataCounters* rtp_counters, - StreamDataCounters* rtx_counters) const { - *rtp_counters = StreamDataCounters(); - *rtx_counters = StreamDataCounters(); - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { - StreamDataCounters rtp_data; - StreamDataCounters rtx_data; - rtp_rtcp->GetSendStreamDataCounters(&rtp_data, &rtx_data); - rtp_counters->Add(rtp_data); - rtx_counters->Add(rtx_data); - } -} - -void ViEChannel::GetReceiveStreamDataCounters( - StreamDataCounters* rtp_counters, - StreamDataCounters* rtx_counters) const { - StreamStatistician* statistician = vie_receiver_.GetReceiveStatistics()-> - GetStatistician(vie_receiver_.GetRemoteSsrc()); - if (statistician) { - statistician->GetReceiveStreamDataCounters(rtp_counters); - } - uint32_t rtx_ssrc = 0; - if (vie_receiver_.GetRtxSsrc(&rtx_ssrc)) { - StreamStatistician* statistician = - vie_receiver_.GetReceiveStatistics()->GetStatistician(rtx_ssrc); - if (statistician) { - statistician->GetReceiveStreamDataCounters(rtx_counters); - } - } -} - -void ViEChannel::RegisterSendChannelRtpStatisticsCallback( - StreamDataCountersCallback* callback) { - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - rtp_rtcp->RegisterSendChannelRtpStatisticsCallback(callback); -} - -void ViEChannel::RegisterReceiveChannelRtpStatisticsCallback( - StreamDataCountersCallback* callback) { - vie_receiver_.GetReceiveStatistics()->RegisterRtpStatisticsCallback(callback); -} - -void ViEChannel::GetSendRtcpPacketTypeCounter( - RtcpPacketTypeCounter* packet_counter) const { - std::map<uint32_t, RtcpPacketTypeCounter> counter_map = - rtcp_packet_type_counter_observer_.GetPacketTypeCounterMap(); - - RtcpPacketTypeCounter counter; - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - counter.Add(counter_map[rtp_rtcp->SSRC()]); - *packet_counter = counter; -} - -void ViEChannel::GetReceiveRtcpPacketTypeCounter( - RtcpPacketTypeCounter* packet_counter) const { - std::map<uint32_t, RtcpPacketTypeCounter> counter_map = - rtcp_packet_type_counter_observer_.GetPacketTypeCounterMap(); - - RtcpPacketTypeCounter counter; - counter.Add(counter_map[vie_receiver_.GetRemoteSsrc()]); - - *packet_counter = counter; -} - -void ViEChannel::RegisterSendSideDelayObserver( - SendSideDelayObserver* observer) { - send_side_delay_observer_.Set(observer); -} - -void ViEChannel::RegisterSendBitrateObserver( - BitrateStatisticsObserver* observer) { - send_bitrate_observer_.Set(observer); -} - -int32_t ViEChannel::StartSend() { - CriticalSectionScoped cs(crit_.get()); - - if (rtp_rtcp_modules_[0]->Sending()) - return -1; - - for (size_t i = 0; i < num_active_rtp_rtcp_modules_; ++i) { - RtpRtcp* rtp_rtcp = rtp_rtcp_modules_[i]; - rtp_rtcp->SetSendingMediaStatus(true); - rtp_rtcp->SetSendingStatus(true); - } - send_payload_router_->set_active(true); - return 0; -} - -int32_t ViEChannel::StopSend() { - send_payload_router_->set_active(false); - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - rtp_rtcp->SetSendingMediaStatus(false); - - if (!rtp_rtcp_modules_[0]->Sending()) { - return -1; - } - - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { - rtp_rtcp->SetSendingStatus(false); - } - return 0; -} - -bool ViEChannel::Sending() { - return rtp_rtcp_modules_[0]->Sending(); -} - -void ViEChannel::StartReceive() { - if (!sender_) - StartDecodeThread(); - vie_receiver_.StartReceive(); -} - -void ViEChannel::StopReceive() { - vie_receiver_.StopReceive(); - if (!sender_) { - StopDecodeThread(); - vcm_->ResetDecoder(); - } -} - -int32_t ViEChannel::ReceivedRTPPacket(const void* rtp_packet, - size_t rtp_packet_length, - const PacketTime& packet_time) { - return vie_receiver_.ReceivedRTPPacket( - rtp_packet, rtp_packet_length, packet_time); -} - -int32_t ViEChannel::ReceivedRTCPPacket(const void* rtcp_packet, - size_t rtcp_packet_length) { - return vie_receiver_.ReceivedRTCPPacket(rtcp_packet, rtcp_packet_length); -} - -int32_t ViEChannel::SetMTU(uint16_t mtu) { - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - rtp_rtcp->SetMaxTransferUnit(mtu); - return 0; -} - -RtpRtcp* ViEChannel::rtp_rtcp() { - return rtp_rtcp_modules_[0]; -} - -rtc::scoped_refptr<PayloadRouter> ViEChannel::send_payload_router() { - return send_payload_router_; -} - -VCMProtectionCallback* ViEChannel::vcm_protection_callback() { - return vcm_protection_callback_.get(); -} - -CallStatsObserver* ViEChannel::GetStatsObserver() { - return stats_observer_.get(); -} - -// Do not acquire the lock of |vcm_| in this function. Decode callback won't -// necessarily be called from the decoding thread. The decoding thread may have -// held the lock when calling VideoDecoder::Decode, Reset, or Release. Acquiring -// the same lock in the path of decode callback can deadlock. -int32_t ViEChannel::FrameToRender(VideoFrame& video_frame) { // NOLINT - CriticalSectionScoped cs(crit_.get()); - - if (pre_render_callback_ != NULL) - pre_render_callback_->FrameCallback(&video_frame); - - // TODO(pbos): Remove stream id argument. - incoming_video_stream_->RenderFrame(0xFFFFFFFF, video_frame); - return 0; -} - -int32_t ViEChannel::ReceivedDecodedReferenceFrame( - const uint64_t picture_id) { - return rtp_rtcp_modules_[0]->SendRTCPReferencePictureSelection(picture_id); -} - -void ViEChannel::OnIncomingPayloadType(int payload_type) { - CriticalSectionScoped cs(crit_.get()); - if (receive_stats_callback_) - receive_stats_callback_->OnIncomingPayloadType(payload_type); -} - -void ViEChannel::OnReceiveRatesUpdated(uint32_t bit_rate, uint32_t frame_rate) { - CriticalSectionScoped cs(crit_.get()); - if (receive_stats_callback_) - receive_stats_callback_->OnIncomingRate(frame_rate, bit_rate); -} - -void ViEChannel::OnDiscardedPacketsUpdated(int discarded_packets) { - CriticalSectionScoped cs(crit_.get()); - if (receive_stats_callback_) - receive_stats_callback_->OnDiscardedPacketsUpdated(discarded_packets); -} - -void ViEChannel::OnFrameCountsUpdated(const FrameCounts& frame_counts) { - CriticalSectionScoped cs(crit_.get()); - receive_frame_counts_ = frame_counts; - if (receive_stats_callback_) - receive_stats_callback_->OnFrameCountsUpdated(frame_counts); -} - -void ViEChannel::OnDecoderTiming(int decode_ms, - int max_decode_ms, - int current_delay_ms, - int target_delay_ms, - int jitter_buffer_ms, - int min_playout_delay_ms, - int render_delay_ms) { - CriticalSectionScoped cs(crit_.get()); - if (!receive_stats_callback_) - return; - receive_stats_callback_->OnDecoderTiming( - decode_ms, max_decode_ms, current_delay_ms, target_delay_ms, - jitter_buffer_ms, min_playout_delay_ms, render_delay_ms, last_rtt_ms_); -} - -int32_t ViEChannel::RequestKeyFrame() { - return rtp_rtcp_modules_[0]->RequestKeyFrame(); -} - -int32_t ViEChannel::SliceLossIndicationRequest( - const uint64_t picture_id) { - return rtp_rtcp_modules_[0]->SendRTCPSliceLossIndication( - static_cast<uint8_t>(picture_id)); -} - -int32_t ViEChannel::ResendPackets(const uint16_t* sequence_numbers, - uint16_t length) { - return rtp_rtcp_modules_[0]->SendNACK(sequence_numbers, length); -} - -bool ViEChannel::ChannelDecodeThreadFunction(void* obj) { - return static_cast<ViEChannel*>(obj)->ChannelDecodeProcess(); -} - -bool ViEChannel::ChannelDecodeProcess() { - vcm_->Decode(kMaxDecodeWaitTimeMs); - return true; -} - -void ViEChannel::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) { - vcm_->SetReceiveChannelParameters(max_rtt_ms); - - CriticalSectionScoped cs(crit_.get()); - if (time_of_first_rtt_ms_ == -1) - time_of_first_rtt_ms_ = Clock::GetRealTimeClock()->TimeInMilliseconds(); - rtt_sum_ms_ += avg_rtt_ms; - last_rtt_ms_ = avg_rtt_ms; - ++num_rtts_; -} - -int ViEChannel::ProtectionRequest(const FecProtectionParams* delta_fec_params, - const FecProtectionParams* key_fec_params, - uint32_t* video_rate_bps, - uint32_t* nack_rate_bps, - uint32_t* fec_rate_bps) { - *video_rate_bps = 0; - *nack_rate_bps = 0; - *fec_rate_bps = 0; - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { - uint32_t not_used = 0; - uint32_t module_video_rate = 0; - uint32_t module_fec_rate = 0; - uint32_t module_nack_rate = 0; - rtp_rtcp->SetFecParameters(delta_fec_params, key_fec_params); - rtp_rtcp->BitrateSent(¬_used, &module_video_rate, &module_fec_rate, - &module_nack_rate); - *video_rate_bps += module_video_rate; - *nack_rate_bps += module_nack_rate; - *fec_rate_bps += module_fec_rate; - } - return 0; -} - -std::vector<RtpRtcp*> ViEChannel::CreateRtpRtcpModules( - bool receiver_only, - ReceiveStatistics* receive_statistics, - Transport* outgoing_transport, - RtcpIntraFrameObserver* intra_frame_callback, - RtcpBandwidthObserver* bandwidth_callback, - TransportFeedbackObserver* transport_feedback_callback, - RtcpRttStats* rtt_stats, - RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer, - RemoteBitrateEstimator* remote_bitrate_estimator, - RtpPacketSender* paced_sender, - TransportSequenceNumberAllocator* transport_sequence_number_allocator, - BitrateStatisticsObserver* send_bitrate_observer, - FrameCountObserver* send_frame_count_observer, - SendSideDelayObserver* send_side_delay_observer, - size_t num_modules) { - RTC_DCHECK_GT(num_modules, 0u); - RtpRtcp::Configuration configuration; - ReceiveStatistics* null_receive_statistics = configuration.receive_statistics; - configuration.audio = false; - configuration.receiver_only = receiver_only; - configuration.receive_statistics = receive_statistics; - configuration.outgoing_transport = outgoing_transport; - configuration.intra_frame_callback = intra_frame_callback; - configuration.rtt_stats = rtt_stats; - configuration.rtcp_packet_type_counter_observer = - rtcp_packet_type_counter_observer; - configuration.paced_sender = paced_sender; - configuration.transport_sequence_number_allocator = - transport_sequence_number_allocator; - configuration.send_bitrate_observer = send_bitrate_observer; - configuration.send_frame_count_observer = send_frame_count_observer; - configuration.send_side_delay_observer = send_side_delay_observer; - configuration.bandwidth_callback = bandwidth_callback; - configuration.transport_feedback_callback = transport_feedback_callback; - - std::vector<RtpRtcp*> modules; - for (size_t i = 0; i < num_modules; ++i) { - RtpRtcp* rtp_rtcp = RtpRtcp::CreateRtpRtcp(configuration); - rtp_rtcp->SetSendingStatus(false); - rtp_rtcp->SetSendingMediaStatus(false); - rtp_rtcp->SetRTCPStatus(RtcpMode::kCompound); - modules.push_back(rtp_rtcp); - // Receive statistics and remote bitrate estimator should only be set for - // the primary (first) module. - configuration.receive_statistics = null_receive_statistics; - configuration.remote_bitrate_estimator = nullptr; - } - return modules; -} - -void ViEChannel::StartDecodeThread() { - RTC_DCHECK(!sender_); - // Start the decode thread - if (decode_thread_) - return; - decode_thread_ = ThreadWrapper::CreateThread(ChannelDecodeThreadFunction, - this, "DecodingThread"); - decode_thread_->Start(); - decode_thread_->SetPriority(kHighestPriority); -} - -void ViEChannel::StopDecodeThread() { - if (!decode_thread_) - return; - - vcm_->TriggerDecoderShutdown(); - - decode_thread_->Stop(); - decode_thread_.reset(); -} - -int32_t ViEChannel::SetVoiceChannel(int32_t ve_channel_id, - VoEVideoSync* ve_sync_interface) { - return vie_sync_.ConfigureSync(ve_channel_id, ve_sync_interface, - rtp_rtcp_modules_[0], - vie_receiver_.GetRtpReceiver()); -} - -int32_t ViEChannel::VoiceChannel() { - return vie_sync_.VoiceChannel(); -} - -void ViEChannel::RegisterPreRenderCallback( - I420FrameCallback* pre_render_callback) { - CriticalSectionScoped cs(crit_.get()); - pre_render_callback_ = pre_render_callback; -} - -void ViEChannel::RegisterPreDecodeImageCallback( - EncodedImageCallback* pre_decode_callback) { - vcm_->RegisterPreDecodeImageCallback(pre_decode_callback); -} - -// TODO(pbos): Remove OnInitializeDecoder which is called from the RTP module, -// any decoder resetting should be handled internally within the VCM. -int32_t ViEChannel::OnInitializeDecoder( - const int8_t payload_type, - const char payload_name[RTP_PAYLOAD_NAME_SIZE], - const int frequency, - const uint8_t channels, - const uint32_t rate) { - LOG(LS_INFO) << "OnInitializeDecoder " << static_cast<int>(payload_type) - << " " << payload_name; - vcm_->ResetDecoder(); - - return 0; -} - -void ViEChannel::OnIncomingSSRCChanged(const uint32_t ssrc) { - rtp_rtcp_modules_[0]->SetRemoteSSRC(ssrc); -} - -void ViEChannel::OnIncomingCSRCChanged(const uint32_t CSRC, const bool added) {} - -void ViEChannel::RegisterSendFrameCountObserver( - FrameCountObserver* observer) { - send_frame_count_observer_.Set(observer); -} - -void ViEChannel::RegisterReceiveStatisticsProxy( - ReceiveStatisticsProxy* receive_statistics_proxy) { - CriticalSectionScoped cs(crit_.get()); - receive_stats_callback_ = receive_statistics_proxy; -} - -void ViEChannel::SetIncomingVideoStream( - IncomingVideoStream* incoming_video_stream) { - CriticalSectionScoped cs(crit_.get()); - incoming_video_stream_ = incoming_video_stream; -} -} // namespace webrtc |