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 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
74 rtp_rtcp->SetSendingStatus(false); | 74 rtp_rtcp->SetSendingStatus(false); |
75 rtp_rtcp->SetSendingMediaStatus(false); | 75 rtp_rtcp->SetSendingMediaStatus(false); |
76 rtp_rtcp->SetRTCPStatus(RtcpMode::kCompound); | 76 rtp_rtcp->SetRTCPStatus(RtcpMode::kCompound); |
77 | 77 |
78 return rtp_rtcp; | 78 return rtp_rtcp; |
79 } | 79 } |
80 | 80 |
81 static const int kPacketLogIntervalMs = 10000; | 81 static const int kPacketLogIntervalMs = 10000; |
82 | 82 |
83 RtpStreamReceiver::RtpStreamReceiver( | 83 RtpStreamReceiver::RtpStreamReceiver( |
84 vcm::VideoReceiver* video_receiver, | |
85 RemoteBitrateEstimator* remote_bitrate_estimator, | 84 RemoteBitrateEstimator* remote_bitrate_estimator, |
86 Transport* transport, | 85 Transport* transport, |
87 RtcpRttStats* rtt_stats, | 86 RtcpRttStats* rtt_stats, |
88 PacketRouter* packet_router, | 87 PacketRouter* packet_router, |
89 VieRemb* remb, | 88 VieRemb* remb, |
90 const VideoReceiveStream::Config* config, | 89 const VideoReceiveStream::Config* config, |
91 ReceiveStatisticsProxy* receive_stats_proxy, | 90 ReceiveStatisticsProxy* receive_stats_proxy, |
92 ProcessThread* process_thread, | 91 ProcessThread* process_thread, |
93 NackSender* nack_sender, | 92 NackSender* nack_sender, |
94 KeyFrameRequestSender* keyframe_request_sender, | 93 KeyFrameRequestSender* keyframe_request_sender, |
95 video_coding::OnCompleteFrameCallback* complete_frame_callback, | 94 video_coding::OnCompleteFrameCallback* complete_frame_callback, |
96 VCMTiming* timing) | 95 VCMTiming* timing) |
97 : clock_(Clock::GetRealTimeClock()), | 96 : clock_(Clock::GetRealTimeClock()), |
98 config_(*config), | 97 config_(*config), |
99 video_receiver_(video_receiver), | |
100 remote_bitrate_estimator_(remote_bitrate_estimator), | 98 remote_bitrate_estimator_(remote_bitrate_estimator), |
101 packet_router_(packet_router), | 99 packet_router_(packet_router), |
102 remb_(remb), | 100 remb_(remb), |
103 process_thread_(process_thread), | 101 process_thread_(process_thread), |
104 ntp_estimator_(clock_), | 102 ntp_estimator_(clock_), |
105 rtp_header_parser_(RtpHeaderParser::Create()), | 103 rtp_header_parser_(RtpHeaderParser::Create()), |
106 rtp_receiver_(RtpReceiver::CreateVideoReceiver(clock_, | 104 rtp_receiver_(RtpReceiver::CreateVideoReceiver(clock_, |
107 this, | 105 this, |
108 this, | 106 this, |
109 &rtp_payload_registry_)), | 107 &rtp_payload_registry_)), |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
183 } | 181 } |
184 | 182 |
185 if (config_.rtp.rtcp_xr.receiver_reference_time_report) | 183 if (config_.rtp.rtcp_xr.receiver_reference_time_report) |
186 rtp_rtcp_->SetRtcpXrRrtrStatus(true); | 184 rtp_rtcp_->SetRtcpXrRrtrStatus(true); |
187 | 185 |
188 // Stats callback for CNAME changes. | 186 // Stats callback for CNAME changes. |
189 rtp_rtcp_->RegisterRtcpStatisticsCallback(receive_stats_proxy); | 187 rtp_rtcp_->RegisterRtcpStatisticsCallback(receive_stats_proxy); |
190 | 188 |
191 process_thread_->RegisterModule(rtp_rtcp_.get()); | 189 process_thread_->RegisterModule(rtp_rtcp_.get()); |
192 | 190 |
193 jitter_buffer_experiment_ = | 191 nack_module_.reset( |
194 field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled"; | 192 new NackModule(clock_, nack_sender, keyframe_request_sender)); |
| 193 if (config_.rtp.nack.rtp_history_ms == 0) |
| 194 nack_module_->Stop(); |
| 195 process_thread_->RegisterModule(nack_module_.get()); |
195 | 196 |
196 if (jitter_buffer_experiment_) { | 197 packet_buffer_ = video_coding::PacketBuffer::Create( |
197 nack_module_.reset( | 198 clock_, kPacketBufferStartSize, kPacketBufferMaxSixe, this); |
198 new NackModule(clock_, nack_sender, keyframe_request_sender)); | 199 reference_finder_.reset(new video_coding::RtpFrameReferenceFinder(this)); |
199 process_thread_->RegisterModule(nack_module_.get()); | |
200 | |
201 packet_buffer_ = video_coding::PacketBuffer::Create( | |
202 clock_, kPacketBufferStartSize, kPacketBufferMaxSixe, this); | |
203 reference_finder_.reset(new video_coding::RtpFrameReferenceFinder(this)); | |
204 } | |
205 } | 200 } |
206 | 201 |
207 RtpStreamReceiver::~RtpStreamReceiver() { | 202 RtpStreamReceiver::~RtpStreamReceiver() { |
208 process_thread_->DeRegisterModule(rtp_rtcp_.get()); | 203 process_thread_->DeRegisterModule(rtp_rtcp_.get()); |
209 | 204 |
210 if (jitter_buffer_experiment_) | 205 process_thread_->DeRegisterModule(nack_module_.get()); |
211 process_thread_->DeRegisterModule(nack_module_.get()); | |
212 | 206 |
213 packet_router_->RemoveRtpModule(rtp_rtcp_.get()); | 207 packet_router_->RemoveRtpModule(rtp_rtcp_.get()); |
214 rtp_rtcp_->SetREMBStatus(false); | 208 rtp_rtcp_->SetREMBStatus(false); |
215 if (config_.rtp.remb) { | 209 if (config_.rtp.remb) { |
216 remb_->RemoveReceiveChannel(rtp_rtcp_.get()); | 210 remb_->RemoveReceiveChannel(rtp_rtcp_.get()); |
217 } | 211 } |
218 UpdateHistograms(); | 212 UpdateHistograms(); |
219 } | 213 } |
220 | 214 |
221 bool RtpStreamReceiver::AddReceiveCodec( | 215 bool RtpStreamReceiver::AddReceiveCodec( |
(...skipping 24 matching lines...) Expand all Loading... |
246 return rtp_receiver_.get(); | 240 return rtp_receiver_.get(); |
247 } | 241 } |
248 | 242 |
249 int32_t RtpStreamReceiver::OnReceivedPayloadData( | 243 int32_t RtpStreamReceiver::OnReceivedPayloadData( |
250 const uint8_t* payload_data, | 244 const uint8_t* payload_data, |
251 size_t payload_size, | 245 size_t payload_size, |
252 const WebRtcRTPHeader* rtp_header) { | 246 const WebRtcRTPHeader* rtp_header) { |
253 WebRtcRTPHeader rtp_header_with_ntp = *rtp_header; | 247 WebRtcRTPHeader rtp_header_with_ntp = *rtp_header; |
254 rtp_header_with_ntp.ntp_time_ms = | 248 rtp_header_with_ntp.ntp_time_ms = |
255 ntp_estimator_.Estimate(rtp_header->header.timestamp); | 249 ntp_estimator_.Estimate(rtp_header->header.timestamp); |
256 if (jitter_buffer_experiment_) { | 250 VCMPacket packet(payload_data, payload_size, rtp_header_with_ntp); |
257 VCMPacket packet(payload_data, payload_size, rtp_header_with_ntp); | 251 packet.timesNacked = nack_module_->OnReceivedPacket(packet); |
258 packet.timesNacked = nack_module_->OnReceivedPacket(packet); | |
259 | 252 |
260 if (packet.codec == kVideoCodecH264) { | 253 if (packet.codec == kVideoCodecH264) { |
261 // Only when we start to receive packets will we know what payload type | 254 // Only when we start to receive packets will we know what payload type |
262 // that will be used. When we know the payload type insert the correct | 255 // that will be used. When we know the payload type insert the correct |
263 // sps/pps into the tracker. | 256 // sps/pps into the tracker. |
264 if (packet.payloadType != last_payload_type_) { | 257 if (packet.payloadType != last_payload_type_) { |
265 last_payload_type_ = packet.payloadType; | 258 last_payload_type_ = packet.payloadType; |
266 InsertSpsPpsIntoTracker(packet.payloadType); | 259 InsertSpsPpsIntoTracker(packet.payloadType); |
267 } | |
268 | |
269 switch (tracker_.CopyAndFixBitstream(&packet)) { | |
270 case video_coding::H264SpsPpsTracker::kRequestKeyframe: | |
271 keyframe_request_sender_->RequestKeyFrame(); | |
272 FALLTHROUGH(); | |
273 case video_coding::H264SpsPpsTracker::kDrop: | |
274 return 0; | |
275 case video_coding::H264SpsPpsTracker::kInsert: | |
276 break; | |
277 } | |
278 } else { | |
279 uint8_t* data = new uint8_t[packet.sizeBytes]; | |
280 memcpy(data, packet.dataPtr, packet.sizeBytes); | |
281 packet.dataPtr = data; | |
282 } | 260 } |
283 | 261 |
284 packet_buffer_->InsertPacket(&packet); | 262 switch (tracker_.CopyAndFixBitstream(&packet)) { |
| 263 case video_coding::H264SpsPpsTracker::kRequestKeyframe: |
| 264 keyframe_request_sender_->RequestKeyFrame(); |
| 265 FALLTHROUGH(); |
| 266 case video_coding::H264SpsPpsTracker::kDrop: |
| 267 return 0; |
| 268 case video_coding::H264SpsPpsTracker::kInsert: |
| 269 break; |
| 270 } |
| 271 |
285 } else { | 272 } else { |
286 RTC_DCHECK(video_receiver_); | 273 uint8_t* data = new uint8_t[packet.sizeBytes]; |
287 if (video_receiver_->IncomingPacket(payload_data, payload_size, | 274 memcpy(data, packet.dataPtr, packet.sizeBytes); |
288 rtp_header_with_ntp) != 0) { | 275 packet.dataPtr = data; |
289 // Check this... | |
290 return -1; | |
291 } | |
292 } | 276 } |
| 277 |
| 278 packet_buffer_->InsertPacket(&packet); |
293 return 0; | 279 return 0; |
294 } | 280 } |
295 | 281 |
296 bool RtpStreamReceiver::OnRecoveredPacket(const uint8_t* rtp_packet, | 282 bool RtpStreamReceiver::OnRecoveredPacket(const uint8_t* rtp_packet, |
297 size_t rtp_packet_length) { | 283 size_t rtp_packet_length) { |
298 RTPHeader header; | 284 RTPHeader header; |
299 if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length, &header)) { | 285 if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length, &header)) { |
300 return false; | 286 return false; |
301 } | 287 } |
302 header.payload_type_frequency = kVideoPayloadTypeFrequency; | 288 header.payload_type_frequency = kVideoPayloadTypeFrequency; |
(...skipping 118 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
421 { | 407 { |
422 rtc::CritScope lock(&last_seq_num_cs_); | 408 rtc::CritScope lock(&last_seq_num_cs_); |
423 video_coding::RtpFrameObject* rtp_frame = | 409 video_coding::RtpFrameObject* rtp_frame = |
424 static_cast<video_coding::RtpFrameObject*>(frame.get()); | 410 static_cast<video_coding::RtpFrameObject*>(frame.get()); |
425 last_seq_num_for_pic_id_[rtp_frame->picture_id] = rtp_frame->last_seq_num(); | 411 last_seq_num_for_pic_id_[rtp_frame->picture_id] = rtp_frame->last_seq_num(); |
426 } | 412 } |
427 complete_frame_callback_->OnCompleteFrame(std::move(frame)); | 413 complete_frame_callback_->OnCompleteFrame(std::move(frame)); |
428 } | 414 } |
429 | 415 |
430 void RtpStreamReceiver::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) { | 416 void RtpStreamReceiver::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) { |
431 if (jitter_buffer_experiment_) | 417 nack_module_->UpdateRtt(max_rtt_ms); |
432 nack_module_->UpdateRtt(max_rtt_ms); | |
433 } | 418 } |
434 | 419 |
435 bool RtpStreamReceiver::ReceivePacket(const uint8_t* packet, | 420 bool RtpStreamReceiver::ReceivePacket(const uint8_t* packet, |
436 size_t packet_length, | 421 size_t packet_length, |
437 const RTPHeader& header, | 422 const RTPHeader& header, |
438 bool in_order) { | 423 bool in_order) { |
439 if (rtp_payload_registry_.IsEncapsulated(header)) { | 424 if (rtp_payload_registry_.IsEncapsulated(header)) { |
440 return ParseAndHandleEncapsulatingHeader(packet, packet_length, header); | 425 return ParseAndHandleEncapsulatingHeader(packet, packet_length, header); |
441 } | 426 } |
442 const uint8_t* payload = packet + header.headerLength; | 427 const uint8_t* payload = packet + header.headerLength; |
(...skipping 107 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
550 &rtp_timestamp) != 0) { | 535 &rtp_timestamp) != 0) { |
551 // Waiting for RTCP. | 536 // Waiting for RTCP. |
552 return true; | 537 return true; |
553 } | 538 } |
554 ntp_estimator_.UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp); | 539 ntp_estimator_.UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp); |
555 | 540 |
556 return true; | 541 return true; |
557 } | 542 } |
558 | 543 |
559 void RtpStreamReceiver::FrameContinuous(uint16_t picture_id) { | 544 void RtpStreamReceiver::FrameContinuous(uint16_t picture_id) { |
560 if (jitter_buffer_experiment_) { | 545 int seq_num = -1; |
561 int seq_num = -1; | 546 { |
562 { | 547 rtc::CritScope lock(&last_seq_num_cs_); |
563 rtc::CritScope lock(&last_seq_num_cs_); | 548 auto seq_num_it = last_seq_num_for_pic_id_.find(picture_id); |
564 auto seq_num_it = last_seq_num_for_pic_id_.find(picture_id); | 549 if (seq_num_it != last_seq_num_for_pic_id_.end()) |
565 if (seq_num_it != last_seq_num_for_pic_id_.end()) | 550 seq_num = seq_num_it->second; |
566 seq_num = seq_num_it->second; | |
567 } | |
568 if (seq_num != -1) | |
569 nack_module_->ClearUpTo(seq_num); | |
570 } | 551 } |
| 552 if (seq_num != -1) |
| 553 nack_module_->ClearUpTo(seq_num); |
571 } | 554 } |
572 | 555 |
573 void RtpStreamReceiver::FrameDecoded(uint16_t picture_id) { | 556 void RtpStreamReceiver::FrameDecoded(uint16_t picture_id) { |
574 if (jitter_buffer_experiment_) { | 557 int seq_num = -1; |
575 int seq_num = -1; | 558 { |
576 { | 559 rtc::CritScope lock(&last_seq_num_cs_); |
577 rtc::CritScope lock(&last_seq_num_cs_); | 560 auto seq_num_it = last_seq_num_for_pic_id_.find(picture_id); |
578 auto seq_num_it = last_seq_num_for_pic_id_.find(picture_id); | 561 if (seq_num_it != last_seq_num_for_pic_id_.end()) { |
579 if (seq_num_it != last_seq_num_for_pic_id_.end()) { | 562 seq_num = seq_num_it->second; |
580 seq_num = seq_num_it->second; | 563 last_seq_num_for_pic_id_.erase(last_seq_num_for_pic_id_.begin(), |
581 last_seq_num_for_pic_id_.erase(last_seq_num_for_pic_id_.begin(), | 564 ++seq_num_it); |
582 ++seq_num_it); | |
583 } | |
584 } | 565 } |
585 if (seq_num != -1) { | 566 } |
586 packet_buffer_->ClearTo(seq_num); | 567 if (seq_num != -1) { |
587 reference_finder_->ClearTo(seq_num); | 568 packet_buffer_->ClearTo(seq_num); |
588 } | 569 reference_finder_->ClearTo(seq_num); |
589 } | 570 } |
590 } | 571 } |
591 | 572 |
592 void RtpStreamReceiver::SignalNetworkState(NetworkState state) { | 573 void RtpStreamReceiver::SignalNetworkState(NetworkState state) { |
593 rtp_rtcp_->SetRTCPStatus(state == kNetworkUp ? config_.rtp.rtcp_mode | 574 rtp_rtcp_->SetRTCPStatus(state == kNetworkUp ? config_.rtp.rtcp_mode |
594 : RtcpMode::kOff); | 575 : RtcpMode::kOff); |
595 } | 576 } |
596 | 577 |
597 void RtpStreamReceiver::StartReceive() { | 578 void RtpStreamReceiver::StartReceive() { |
598 rtc::CritScope lock(&receive_cs_); | 579 rtc::CritScope lock(&receive_cs_); |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
676 return; | 657 return; |
677 | 658 |
678 if (!sprop_decoder.DecodeSprop(sprop_base64_it->second.c_str())) | 659 if (!sprop_decoder.DecodeSprop(sprop_base64_it->second.c_str())) |
679 return; | 660 return; |
680 | 661 |
681 tracker_.InsertSpsPpsNalus(sprop_decoder.sps_nalu(), | 662 tracker_.InsertSpsPpsNalus(sprop_decoder.sps_nalu(), |
682 sprop_decoder.pps_nalu()); | 663 sprop_decoder.pps_nalu()); |
683 } | 664 } |
684 | 665 |
685 } // namespace webrtc | 666 } // namespace webrtc |
OLD | NEW |