OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 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 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
77 ViEChannel* owner_; | 77 ViEChannel* owner_; |
78 }; | 78 }; |
79 | 79 |
80 ViEChannel::ViEChannel(int32_t channel_id, | 80 ViEChannel::ViEChannel(int32_t channel_id, |
81 int32_t engine_id, | 81 int32_t engine_id, |
82 uint32_t number_of_cores, | 82 uint32_t number_of_cores, |
83 Transport* transport, | 83 Transport* transport, |
84 ProcessThread* module_process_thread, | 84 ProcessThread* module_process_thread, |
85 RtcpIntraFrameObserver* intra_frame_observer, | 85 RtcpIntraFrameObserver* intra_frame_observer, |
86 RtcpBandwidthObserver* bandwidth_observer, | 86 RtcpBandwidthObserver* bandwidth_observer, |
87 SendTimeObserver* send_time_observer, | 87 TransportFeedbackObserver* transport_feedback_observer, |
88 RemoteBitrateEstimator* remote_bitrate_estimator, | 88 RemoteBitrateEstimator* remote_bitrate_estimator, |
89 RtcpRttStats* rtt_stats, | 89 RtcpRttStats* rtt_stats, |
90 PacedSender* paced_sender, | 90 PacedSender* paced_sender, |
91 PacketRouter* packet_router, | 91 PacketRouter* packet_router, |
92 size_t max_rtp_streams, | 92 size_t max_rtp_streams, |
93 bool sender) | 93 bool sender) |
94 : channel_id_(channel_id), | 94 : channel_id_(channel_id), |
95 engine_id_(engine_id), | 95 engine_id_(engine_id), |
96 number_of_cores_(number_of_cores), | 96 number_of_cores_(number_of_cores), |
97 sender_(sender), | 97 sender_(sender), |
98 module_process_thread_(module_process_thread), | 98 module_process_thread_(module_process_thread), |
99 crit_(CriticalSectionWrapper::CreateCriticalSection()), | 99 crit_(CriticalSectionWrapper::CreateCriticalSection()), |
100 send_payload_router_(new PayloadRouter()), | 100 send_payload_router_(new PayloadRouter()), |
101 vcm_protection_callback_(new ViEChannelProtectionCallback(this)), | 101 vcm_protection_callback_(new ViEChannelProtectionCallback(this)), |
102 vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(), | 102 vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(), |
103 nullptr, | 103 nullptr, |
104 nullptr)), | 104 nullptr)), |
105 vie_receiver_(channel_id, vcm_, remote_bitrate_estimator, this), | 105 vie_receiver_(channel_id, vcm_, remote_bitrate_estimator, this), |
106 vie_sync_(vcm_), | 106 vie_sync_(vcm_), |
107 stats_observer_(new ChannelStatsObserver(this)), | 107 stats_observer_(new ChannelStatsObserver(this)), |
108 receive_stats_callback_(nullptr), | 108 receive_stats_callback_(nullptr), |
109 incoming_video_stream_(nullptr), | 109 incoming_video_stream_(nullptr), |
110 intra_frame_observer_(intra_frame_observer), | 110 intra_frame_observer_(intra_frame_observer), |
111 rtt_stats_(rtt_stats), | 111 rtt_stats_(rtt_stats), |
112 paced_sender_(paced_sender), | 112 paced_sender_(paced_sender), |
113 packet_router_(packet_router), | 113 packet_router_(packet_router), |
114 bandwidth_observer_(bandwidth_observer), | 114 bandwidth_observer_(bandwidth_observer), |
115 send_time_observer_(send_time_observer), | 115 transport_feedback_observer_(transport_feedback_observer), |
116 nack_history_size_sender_(kSendSidePacketHistorySize), | 116 nack_history_size_sender_(kSendSidePacketHistorySize), |
117 max_nack_reordering_threshold_(kMaxPacketAgeToNack), | 117 max_nack_reordering_threshold_(kMaxPacketAgeToNack), |
118 pre_render_callback_(NULL), | 118 pre_render_callback_(NULL), |
119 report_block_stats_sender_(new ReportBlockStats()), | 119 report_block_stats_sender_(new ReportBlockStats()), |
120 time_of_first_rtt_ms_(-1), | 120 time_of_first_rtt_ms_(-1), |
121 rtt_sum_ms_(0), | 121 rtt_sum_ms_(0), |
122 num_rtts_(0), | 122 num_rtts_(0), |
123 rtp_rtcp_modules_( | 123 rtp_rtcp_modules_( |
124 CreateRtpRtcpModules(ViEModuleId(engine_id_, channel_id_), | 124 CreateRtpRtcpModules(ViEModuleId(engine_id_, channel_id_), |
125 !sender, | 125 !sender, |
126 vie_receiver_.GetReceiveStatistics(), | 126 vie_receiver_.GetReceiveStatistics(), |
127 transport, | 127 transport, |
128 sender ? intra_frame_observer_ : nullptr, | 128 sender ? intra_frame_observer_ : nullptr, |
129 sender ? bandwidth_observer_.get() : nullptr, | 129 sender ? bandwidth_observer_.get() : nullptr, |
130 sender ? send_time_observer_ : nullptr, | 130 transport_feedback_observer_, |
131 rtt_stats_, | 131 rtt_stats_, |
132 &rtcp_packet_type_counter_observer_, | 132 &rtcp_packet_type_counter_observer_, |
133 remote_bitrate_estimator, | 133 remote_bitrate_estimator, |
134 paced_sender_, | 134 paced_sender_, |
135 sender_ ? packet_router_ : nullptr, | 135 packet_router_, |
136 &send_bitrate_observer_, | 136 &send_bitrate_observer_, |
137 &send_frame_count_observer_, | 137 &send_frame_count_observer_, |
138 &send_side_delay_observer_, | 138 &send_side_delay_observer_, |
139 max_rtp_streams)), | 139 max_rtp_streams)), |
140 num_active_rtp_rtcp_modules_(1) { | 140 num_active_rtp_rtcp_modules_(1) { |
141 vie_receiver_.SetRtpRtcpModule(rtp_rtcp_modules_[0]); | 141 vie_receiver_.SetRtpRtcpModule(rtp_rtcp_modules_[0]); |
142 vcm_->SetNackSettings(kMaxNackListSize, max_nack_reordering_threshold_, 0); | 142 vcm_->SetNackSettings(kMaxNackListSize, max_nack_reordering_threshold_, 0); |
143 } | 143 } |
144 | 144 |
145 int32_t ViEChannel::Init() { | 145 int32_t ViEChannel::Init() { |
146 module_process_thread_->RegisterModule(vie_receiver_.GetReceiveStatistics()); | 146 module_process_thread_->RegisterModule(vie_receiver_.GetReceiveStatistics()); |
147 | 147 |
148 // RTP/RTCP initialization. | 148 // RTP/RTCP initialization. |
149 module_process_thread_->RegisterModule(rtp_rtcp_modules_[0]); | 149 module_process_thread_->RegisterModule(rtp_rtcp_modules_[0]); |
150 | 150 |
151 rtp_rtcp_modules_[0]->SetKeyFrameRequestMethod(kKeyFrameReqFirRtp); | 151 rtp_rtcp_modules_[0]->SetKeyFrameRequestMethod(kKeyFrameReqFirRtp); |
152 if (paced_sender_) { | 152 if (paced_sender_) { |
153 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) | 153 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) |
154 rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_); | 154 rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_); |
155 } | 155 } |
| 156 packet_router_->AddRtpModule(rtp_rtcp_modules_[0]); |
156 if (sender_) { | 157 if (sender_) { |
157 packet_router_->AddRtpModule(rtp_rtcp_modules_[0]); | |
158 std::list<RtpRtcp*> send_rtp_modules(1, rtp_rtcp_modules_[0]); | 158 std::list<RtpRtcp*> send_rtp_modules(1, rtp_rtcp_modules_[0]); |
159 send_payload_router_->SetSendingRtpModules(send_rtp_modules); | 159 send_payload_router_->SetSendingRtpModules(send_rtp_modules); |
160 DCHECK(!send_payload_router_->active()); | 160 DCHECK(!send_payload_router_->active()); |
161 } | 161 } |
162 if (vcm_->RegisterReceiveCallback(this) != 0) { | 162 if (vcm_->RegisterReceiveCallback(this) != 0) { |
163 return -1; | 163 return -1; |
164 } | 164 } |
165 vcm_->RegisterFrameTypeCallback(this); | 165 vcm_->RegisterFrameTypeCallback(this); |
166 vcm_->RegisterReceiveStatisticsCallback(this); | 166 vcm_->RegisterReceiveStatisticsCallback(this); |
167 vcm_->RegisterDecoderTimingCallback(this); | 167 vcm_->RegisterDecoderTimingCallback(this); |
168 vcm_->SetRenderDelay(kViEDefaultRenderDelayMs); | 168 vcm_->SetRenderDelay(kViEDefaultRenderDelayMs); |
169 | 169 |
170 module_process_thread_->RegisterModule(vcm_); | 170 module_process_thread_->RegisterModule(vcm_); |
171 module_process_thread_->RegisterModule(&vie_sync_); | 171 module_process_thread_->RegisterModule(&vie_sync_); |
172 | 172 |
173 return 0; | 173 return 0; |
174 } | 174 } |
175 | 175 |
176 ViEChannel::~ViEChannel() { | 176 ViEChannel::~ViEChannel() { |
177 UpdateHistograms(); | 177 UpdateHistograms(); |
178 // Make sure we don't get more callbacks from the RTP module. | 178 // Make sure we don't get more callbacks from the RTP module. |
179 module_process_thread_->DeRegisterModule( | 179 module_process_thread_->DeRegisterModule( |
180 vie_receiver_.GetReceiveStatistics()); | 180 vie_receiver_.GetReceiveStatistics()); |
181 module_process_thread_->DeRegisterModule(vcm_); | 181 module_process_thread_->DeRegisterModule(vcm_); |
182 module_process_thread_->DeRegisterModule(&vie_sync_); | 182 module_process_thread_->DeRegisterModule(&vie_sync_); |
183 send_payload_router_->SetSendingRtpModules(std::list<RtpRtcp*>()); | 183 send_payload_router_->SetSendingRtpModules(std::list<RtpRtcp*>()); |
184 if (sender_ && packet_router_) { | 184 for (size_t i = 0; i < num_active_rtp_rtcp_modules_; ++i) |
185 for (size_t i = 0; i < num_active_rtp_rtcp_modules_; ++i) | 185 packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i]); |
186 packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i]); | |
187 } | |
188 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { | 186 for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { |
189 module_process_thread_->DeRegisterModule(rtp_rtcp); | 187 module_process_thread_->DeRegisterModule(rtp_rtcp); |
190 delete rtp_rtcp; | 188 delete rtp_rtcp; |
191 } | 189 } |
192 if (decode_thread_) { | 190 if (decode_thread_) { |
193 StopDecodeThread(); | 191 StopDecodeThread(); |
194 } | 192 } |
195 // Release modules. | 193 // Release modules. |
196 VideoCodingModule::Destroy(vcm_); | 194 VideoCodingModule::Destroy(vcm_); |
197 } | 195 } |
(...skipping 201 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
399 active_send_modules.push_back(rtp_rtcp); | 397 active_send_modules.push_back(rtp_rtcp); |
400 send_payload_router_->SetSendingRtpModules(active_send_modules); | 398 send_payload_router_->SetSendingRtpModules(active_send_modules); |
401 } | 399 } |
402 | 400 |
403 if (router_was_active) | 401 if (router_was_active) |
404 send_payload_router_->set_active(true); | 402 send_payload_router_->set_active(true); |
405 | 403 |
406 // Deregister previously registered modules. | 404 // Deregister previously registered modules. |
407 for (size_t i = num_active_modules; i < num_prev_active_modules; ++i) { | 405 for (size_t i = num_active_modules; i < num_prev_active_modules; ++i) { |
408 module_process_thread_->DeRegisterModule(rtp_rtcp_modules_[i]); | 406 module_process_thread_->DeRegisterModule(rtp_rtcp_modules_[i]); |
409 if (sender_ && packet_router_) | 407 packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i]); |
410 packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i]); | |
411 } | 408 } |
412 // Register new active modules. | 409 // Register new active modules. |
413 for (size_t i = num_prev_active_modules; i < num_active_modules; ++i) { | 410 for (size_t i = num_prev_active_modules; i < num_active_modules; ++i) { |
414 module_process_thread_->RegisterModule(rtp_rtcp_modules_[i]); | 411 module_process_thread_->RegisterModule(rtp_rtcp_modules_[i]); |
415 if (sender_ && packet_router_) | 412 packet_router_->AddRtpModule(rtp_rtcp_modules_[i]); |
416 packet_router_->AddRtpModule(rtp_rtcp_modules_[i]); | |
417 } | 413 } |
418 return 0; | 414 return 0; |
419 } | 415 } |
420 | 416 |
421 int32_t ViEChannel::SetReceiveCodec(const VideoCodec& video_codec) { | 417 int32_t ViEChannel::SetReceiveCodec(const VideoCodec& video_codec) { |
422 DCHECK(!sender_); | 418 DCHECK(!sender_); |
423 if (!vie_receiver_.SetReceiveCodec(video_codec)) { | 419 if (!vie_receiver_.SetReceiveCodec(video_codec)) { |
424 return -1; | 420 return -1; |
425 } | 421 } |
426 | 422 |
427 if (video_codec.codecType != kVideoCodecRED && | 423 if (video_codec.codecType != kVideoCodecRED && |
428 video_codec.codecType != kVideoCodecULPFEC) { | 424 video_codec.codecType != kVideoCodecULPFEC) { |
429 // Register codec type with VCM, but do not register RED or ULPFEC. | 425 // Register codec type with VCM, but do not register RED or ULPFEC. |
430 if (vcm_->RegisterReceiveCodec(&video_codec, number_of_cores_, false) != | 426 if (vcm_->RegisterReceiveCodec(&video_codec, number_of_cores_, false) != |
431 VCM_OK) { | 427 VCM_OK) { |
432 return -1; | 428 return -1; |
433 } | 429 } |
434 } | 430 } |
435 return 0; | 431 return 0; |
436 } | 432 } |
437 | 433 |
| 434 |
438 int32_t ViEChannel::RegisterExternalDecoder(const uint8_t pl_type, | 435 int32_t ViEChannel::RegisterExternalDecoder(const uint8_t pl_type, |
439 VideoDecoder* decoder, | 436 VideoDecoder* decoder, |
440 bool buffered_rendering, | 437 bool buffered_rendering, |
441 int32_t render_delay) { | 438 int32_t render_delay) { |
442 DCHECK(!sender_); | 439 DCHECK(!sender_); |
443 int32_t result; | 440 int32_t result; |
444 result = vcm_->RegisterExternalDecoder(decoder, pl_type, buffered_rendering); | 441 result = vcm_->RegisterExternalDecoder(decoder, pl_type, buffered_rendering); |
445 if (result != VCM_OK) { | 442 if (result != VCM_OK) { |
446 return result; | 443 return result; |
447 } | 444 } |
(...skipping 571 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1019 return stats_observer_.get(); | 1016 return stats_observer_.get(); |
1020 } | 1017 } |
1021 | 1018 |
1022 // Do not acquire the lock of |vcm_| in this function. Decode callback won't | 1019 // Do not acquire the lock of |vcm_| in this function. Decode callback won't |
1023 // necessarily be called from the decoding thread. The decoding thread may have | 1020 // necessarily be called from the decoding thread. The decoding thread may have |
1024 // held the lock when calling VideoDecoder::Decode, Reset, or Release. Acquiring | 1021 // held the lock when calling VideoDecoder::Decode, Reset, or Release. Acquiring |
1025 // the same lock in the path of decode callback can deadlock. | 1022 // the same lock in the path of decode callback can deadlock. |
1026 int32_t ViEChannel::FrameToRender(VideoFrame& video_frame) { // NOLINT | 1023 int32_t ViEChannel::FrameToRender(VideoFrame& video_frame) { // NOLINT |
1027 CriticalSectionScoped cs(crit_.get()); | 1024 CriticalSectionScoped cs(crit_.get()); |
1028 | 1025 |
| 1026 |
1029 if (pre_render_callback_ != NULL) | 1027 if (pre_render_callback_ != NULL) |
1030 pre_render_callback_->FrameCallback(&video_frame); | 1028 pre_render_callback_->FrameCallback(&video_frame); |
1031 | 1029 |
1032 incoming_video_stream_->RenderFrame(channel_id_, video_frame); | 1030 incoming_video_stream_->RenderFrame(channel_id_, video_frame); |
1033 return 0; | 1031 return 0; |
1034 } | 1032 } |
1035 | 1033 |
1036 int32_t ViEChannel::ReceivedDecodedReferenceFrame( | 1034 int32_t ViEChannel::ReceivedDecodedReferenceFrame( |
1037 const uint64_t picture_id) { | 1035 const uint64_t picture_id) { |
1038 return rtp_rtcp_modules_[0]->SendRTCPReferencePictureSelection(picture_id); | 1036 return rtp_rtcp_modules_[0]->SendRTCPReferencePictureSelection(picture_id); |
(...skipping 96 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1135 return 0; | 1133 return 0; |
1136 } | 1134 } |
1137 | 1135 |
1138 std::vector<RtpRtcp*> ViEChannel::CreateRtpRtcpModules( | 1136 std::vector<RtpRtcp*> ViEChannel::CreateRtpRtcpModules( |
1139 int32_t id, | 1137 int32_t id, |
1140 bool receiver_only, | 1138 bool receiver_only, |
1141 ReceiveStatistics* receive_statistics, | 1139 ReceiveStatistics* receive_statistics, |
1142 Transport* outgoing_transport, | 1140 Transport* outgoing_transport, |
1143 RtcpIntraFrameObserver* intra_frame_callback, | 1141 RtcpIntraFrameObserver* intra_frame_callback, |
1144 RtcpBandwidthObserver* bandwidth_callback, | 1142 RtcpBandwidthObserver* bandwidth_callback, |
1145 SendTimeObserver* send_time_callback, | 1143 TransportFeedbackObserver* transport_feedback_callback, |
1146 RtcpRttStats* rtt_stats, | 1144 RtcpRttStats* rtt_stats, |
1147 RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer, | 1145 RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer, |
1148 RemoteBitrateEstimator* remote_bitrate_estimator, | 1146 RemoteBitrateEstimator* remote_bitrate_estimator, |
1149 PacedSender* paced_sender, | 1147 PacedSender* paced_sender, |
1150 PacketRouter* packet_router, | 1148 PacketRouter* packet_router, |
1151 BitrateStatisticsObserver* send_bitrate_observer, | 1149 BitrateStatisticsObserver* send_bitrate_observer, |
1152 FrameCountObserver* send_frame_count_observer, | 1150 FrameCountObserver* send_frame_count_observer, |
1153 SendSideDelayObserver* send_side_delay_observer, | 1151 SendSideDelayObserver* send_side_delay_observer, |
1154 size_t num_modules) { | 1152 size_t num_modules) { |
1155 DCHECK_GT(num_modules, 0u); | 1153 DCHECK_GT(num_modules, 0u); |
1156 RtpRtcp::Configuration configuration; | 1154 RtpRtcp::Configuration configuration; |
1157 ReceiveStatistics* null_receive_statistics = configuration.receive_statistics; | 1155 ReceiveStatistics* null_receive_statistics = configuration.receive_statistics; |
1158 configuration.id = id; | 1156 configuration.id = id; |
1159 configuration.audio = false; | 1157 configuration.audio = false; |
1160 configuration.receiver_only = receiver_only; | 1158 configuration.receiver_only = receiver_only; |
1161 configuration.receive_statistics = receive_statistics; | 1159 configuration.receive_statistics = receive_statistics; |
1162 configuration.outgoing_transport = outgoing_transport; | 1160 configuration.outgoing_transport = outgoing_transport; |
1163 configuration.intra_frame_callback = intra_frame_callback; | 1161 configuration.intra_frame_callback = intra_frame_callback; |
1164 configuration.rtt_stats = rtt_stats; | 1162 configuration.rtt_stats = rtt_stats; |
1165 configuration.rtcp_packet_type_counter_observer = | 1163 configuration.rtcp_packet_type_counter_observer = |
1166 rtcp_packet_type_counter_observer; | 1164 rtcp_packet_type_counter_observer; |
1167 configuration.paced_sender = paced_sender; | 1165 configuration.paced_sender = paced_sender; |
1168 configuration.packet_router = packet_router; | 1166 configuration.packet_router = packet_router; |
1169 configuration.send_bitrate_observer = send_bitrate_observer; | 1167 configuration.send_bitrate_observer = send_bitrate_observer; |
1170 configuration.send_frame_count_observer = send_frame_count_observer; | 1168 configuration.send_frame_count_observer = send_frame_count_observer; |
1171 configuration.send_side_delay_observer = send_side_delay_observer; | 1169 configuration.send_side_delay_observer = send_side_delay_observer; |
1172 configuration.bandwidth_callback = bandwidth_callback; | 1170 configuration.bandwidth_callback = bandwidth_callback; |
1173 configuration.send_time_callback = send_time_callback; | 1171 configuration.transport_feedback_callback = transport_feedback_callback; |
1174 | 1172 |
1175 std::vector<RtpRtcp*> modules; | 1173 std::vector<RtpRtcp*> modules; |
1176 for (size_t i = 0; i < num_modules; ++i) { | 1174 for (size_t i = 0; i < num_modules; ++i) { |
1177 RtpRtcp* rtp_rtcp = RtpRtcp::CreateRtpRtcp(configuration); | 1175 RtpRtcp* rtp_rtcp = RtpRtcp::CreateRtpRtcp(configuration); |
1178 rtp_rtcp->SetSendingStatus(false); | 1176 rtp_rtcp->SetSendingStatus(false); |
1179 rtp_rtcp->SetSendingMediaStatus(false); | 1177 rtp_rtcp->SetSendingMediaStatus(false); |
1180 rtp_rtcp->SetRTCPStatus(kRtcpCompound); | 1178 rtp_rtcp->SetRTCPStatus(kRtcpCompound); |
1181 modules.push_back(rtp_rtcp); | 1179 modules.push_back(rtp_rtcp); |
1182 // Receive statistics and remote bitrate estimator should only be set for | 1180 // Receive statistics and remote bitrate estimator should only be set for |
1183 // the primary (first) module. | 1181 // the primary (first) module. |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1268 CriticalSectionScoped cs(crit_.get()); | 1266 CriticalSectionScoped cs(crit_.get()); |
1269 receive_stats_callback_ = receive_statistics_proxy; | 1267 receive_stats_callback_ = receive_statistics_proxy; |
1270 } | 1268 } |
1271 | 1269 |
1272 void ViEChannel::SetIncomingVideoStream( | 1270 void ViEChannel::SetIncomingVideoStream( |
1273 IncomingVideoStream* incoming_video_stream) { | 1271 IncomingVideoStream* incoming_video_stream) { |
1274 CriticalSectionScoped cs(crit_.get()); | 1272 CriticalSectionScoped cs(crit_.get()); |
1275 incoming_video_stream_ = incoming_video_stream; | 1273 incoming_video_stream_ = incoming_video_stream; |
1276 } | 1274 } |
1277 } // namespace webrtc | 1275 } // namespace webrtc |
OLD | NEW |