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

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

Issue 2670183002: Reland of Make the new jitter buffer the default jitter buffer. (Closed)
Patch Set: Rebase Created 3 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « webrtc/video/rtp_stream_receiver.h ('k') | webrtc/video/rtp_stream_receiver_unittest.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* 1 /*
2 * Copyright (c) 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
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
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
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
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
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
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
OLDNEW
« no previous file with comments | « webrtc/video/rtp_stream_receiver.h ('k') | webrtc/video/rtp_stream_receiver_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698