1 /* 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 #include "webrtc/modules/video_coding/main/source/jitter_buffer.h" 11 12 #include <assert.h> 13 14 #include <algorithm> 15 #include <utility> 16 17 #include "webrtc/modules/video_coding/main/interface/video_coding.h" 18 #include "webrtc/modules/video_coding/main/source/frame_buffer.h" 19 #include "webrtc/modules/video_coding/main/source/inter_frame_delay.h" 20 #include "webrtc/modules/video_coding/main/source/internal_defines.h" 21 #include "webrtc/modules/video_coding/main/source/jitter_buffer_common.h" 22 #include "webrtc/modules/video_coding/main/source/jitter_estimator.h" 23 #include "webrtc/modules/video_coding/main/source/packet.h" 24 #include "webrtc/system_wrappers/interface/clock.h" 25 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" 26 #include "webrtc/system_wrappers/interface/event_wrapper.h" 27 #include "webrtc/system_wrappers/interface/logging.h" 28 #include "webrtc/system_wrappers/interface/trace_event.h" 29 30 namespace webrtc { 31 32 // Use this rtt if no value has been reported. 33 static const uint32_t kDefaultRtt = 200; 34 35 typedef std::pair<uint32_t, VCMFrameBuffer*> FrameListPair; 36 37 bool IsKeyFrame(FrameListPair pair) { 38 return pair.second->FrameType() == kVideoFrameKey; 39 } 40 41 bool HasNonEmptyState(FrameListPair pair) { 42 return pair.second->GetState() != kStateEmpty; 43 } 44 45 void FrameList::InsertFrame(VCMFrameBuffer* frame) { 46 insert(rbegin().base(), FrameListPair(frame->TimeStamp(), frame)); 47 } 48 49 VCMFrameBuffer* FrameList::FindFrame(uint32_t timestamp) const { 50 FrameList::const_iterator it = find(timestamp); 51 if (it == end()) 52 return NULL; 53 return it->second; 54 } 55 56 VCMFrameBuffer* FrameList::PopFrame(uint32_t timestamp) { 57 FrameList::iterator it = find(timestamp); 58 if (it == end()) 59 return NULL; 60 VCMFrameBuffer* frame = it->second; 61 erase(it); 62 return frame; 63 } 64 65 VCMFrameBuffer* FrameList::Front() const { 66 return begin()->second; 67 } 68 69 VCMFrameBuffer* FrameList::Back() const { 70 return rbegin()->second; 71 } 72 73 int FrameList::RecycleFramesUntilKeyFrame(FrameList::iterator* key_frame_it, 74 UnorderedFrameList* free_frames) { 75 int drop_count = 0; 76 FrameList::iterator it = begin(); 77 while (!empty()) { 78 // Throw at least one frame. 79 it->second->Reset(); 80 free_frames->push_back(it->second); 81 erase(it++); 82 ++drop_count; 83 if (it != end() && it->second->FrameType() == kVideoFrameKey) { 84 *key_frame_it = it; 85 return drop_count; 86 } 87 } 88 *key_frame_it = end(); 89 return drop_count; 90 } 91 92 int FrameList::CleanUpOldOrEmptyFrames(VCMDecodingState* decoding_state, 93 UnorderedFrameList* free_frames) { 94 int drop_count = 0; 95 while (!empty()) { 96 VCMFrameBuffer* oldest_frame = Front(); 97 bool remove_frame = false; 98 if (oldest_frame->GetState() == kStateEmpty && size() > 1) { 99 // This frame is empty, try to update the last decoded state and drop it 100 // if successful. 101 remove_frame = decoding_state->UpdateEmptyFrame(oldest_frame); 102 } else { 103 remove_frame = decoding_state->IsOldFrame(oldest_frame); 104 } 105 if (!remove_frame) { 106 break; 107 } 108 free_frames->push_back(oldest_frame); 109 ++drop_count; 110 TRACE_EVENT_INSTANT1("webrtc", "JB::OldOrEmptyFrameDropped", "timestamp", 111 oldest_frame->TimeStamp()); 112 erase(begin()); 113 } 114 return drop_count; 115 } 116 117 void FrameList::Reset(UnorderedFrameList* free_frames) { 118 while (!empty()) { 119 begin()->second->Reset(); 120 free_frames->push_back(begin()->second); 121 erase(begin()); 122 } 123 } 124 125 VCMJitterBuffer::VCMJitterBuffer(Clock* clock, 126 EventFactory* event_factory) 127 : clock_(clock), 128 running_(false), 129 crit_sect_(CriticalSectionWrapper::CreateCriticalSection()), 130 frame_event_(event_factory->CreateEvent()), 131 packet_event_(event_factory->CreateEvent()), 132 max_number_of_frames_(kStartNumberOfFrames), 133 frame_buffers_(), 134 free_frames_(), 135 decodable_frames_(), 136 incomplete_frames_(), 137 last_decoded_state_(), 138 first_packet_since_reset_(true), 139 incoming_frame_rate_(0), 140 incoming_frame_count_(0), 141 time_last_incoming_frame_count_(0), 142 incoming_bit_count_(0), 143 incoming_bit_rate_(0), 144 drop_count_(0), 145 num_consecutive_old_frames_(0), 146 num_consecutive_old_packets_(0), 147 num_discarded_packets_(0), 148 jitter_estimate_(), 149 inter_frame_delay_(clock_->TimeInMilliseconds()), 150 rtt_ms_(kDefaultRtt), 151 nack_mode_(kNoNack), 152 low_rtt_nack_threshold_ms_(-1), 153 high_rtt_nack_threshold_ms_(-1), 154 missing_sequence_numbers_(SequenceNumberLessThan()), 155 nack_seq_nums_(), 156 max_nack_list_size_(0), 157 max_packet_age_to_nack_(0), 158 max_incomplete_time_ms_(0), 159 decode_error_mode_(kNoErrors), 160 average_packets_per_frame_(0.0f), 161 frame_counter_(0) { 162 memset(frame_buffers_, 0, sizeof(frame_buffers_)); 163 164 for (int i = 0; i < kStartNumberOfFrames; i++) { 165 frame_buffers_[i] = new VCMFrameBuffer(); 166 free_frames_.push_back(frame_buffers_[i]); 167 } 168 } 169 170 VCMJitterBuffer::~VCMJitterBuffer() { 171 Stop(); 172 for (int i = 0; i < kMaxNumberOfFrames; i++) { 173 if (frame_buffers_[i]) { 174 delete frame_buffers_[i]; 175 } 176 } 177 delete crit_sect_; 178 } 179 180 void VCMJitterBuffer::CopyFrom(const VCMJitterBuffer& rhs) { 181 if (this != &rhs) { 182 crit_sect_->Enter(); 183 rhs.crit_sect_->Enter(); 184 running_ = rhs.running_; 185 max_number_of_frames_ = rhs.max_number_of_frames_; 186 incoming_frame_rate_ = rhs.incoming_frame_rate_; 187 incoming_frame_count_ = rhs.incoming_frame_count_; 188 time_last_incoming_frame_count_ = rhs.time_last_incoming_frame_count_; 189 incoming_bit_count_ = rhs.incoming_bit_count_; 190 incoming_bit_rate_ = rhs.incoming_bit_rate_; 191 drop_count_ = rhs.drop_count_; 192 num_consecutive_old_frames_ = rhs.num_consecutive_old_frames_; 193 num_consecutive_old_packets_ = rhs.num_consecutive_old_packets_; 194 num_discarded_packets_ = rhs.num_discarded_packets_; 195 jitter_estimate_ = rhs.jitter_estimate_; 196 inter_frame_delay_ = rhs.inter_frame_delay_; 197 waiting_for_completion_ = rhs.waiting_for_completion_; 198 rtt_ms_ = rhs.rtt_ms_; 199 first_packet_since_reset_ = rhs.first_packet_since_reset_; 200 last_decoded_state_ = rhs.last_decoded_state_; 201 decode_error_mode_ = rhs.decode_error_mode_; 202 assert(max_nack_list_size_ == rhs.max_nack_list_size_); 203 assert(max_packet_age_to_nack_ == rhs.max_packet_age_to_nack_); 204 assert(max_incomplete_time_ms_ == rhs.max_incomplete_time_ms_); 205 receive_statistics_ = rhs.receive_statistics_; 206 nack_seq_nums_.resize(rhs.nack_seq_nums_.size()); 207 missing_sequence_numbers_ = rhs.missing_sequence_numbers_; 208 latest_received_sequence_number_ = rhs.latest_received_sequence_number_; 209 average_packets_per_frame_ = rhs.average_packets_per_frame_; 210 for (int i = 0; i < kMaxNumberOfFrames; i++) { 211 if (frame_buffers_[i] != NULL) { 212 delete frame_buffers_[i]; 213 frame_buffers_[i] = NULL; 214 } 215 } 216 free_frames_.clear(); 217 decodable_frames_.clear(); 218 incomplete_frames_.clear(); 219 int i = 0; 220 for (UnorderedFrameList::const_iterator it = rhs.free_frames_.begin(); 221 it != rhs.free_frames_.end(); ++it, ++i) { 222 frame_buffers_[i] = new VCMFrameBuffer; 223 free_frames_.push_back(frame_buffers_[i]); 224 } 225 CopyFrames(&decodable_frames_, rhs.decodable_frames_, &i); 226 CopyFrames(&incomplete_frames_, rhs.incomplete_frames_, &i); 227 rhs.crit_sect_->Leave(); 228 crit_sect_->Leave(); 229 } 230 } 231 232 void VCMJitterBuffer::CopyFrames(FrameList* to_list, 233 const FrameList& from_list, int* index) { 234 to_list->clear(); 235 for (FrameList::const_iterator it = from_list.begin(); 236 it != from_list.end(); ++it, ++*index) { 237 frame_buffers_[*index] = new VCMFrameBuffer(*it->second); 238 to_list->InsertFrame(frame_buffers_[*index]); 239 } 240 } 241 242 void VCMJitterBuffer::Start() { 243 CriticalSectionScoped cs(crit_sect_); 244 running_ = true; 245 incoming_frame_count_ = 0; 246 incoming_frame_rate_ = 0; 247 incoming_bit_count_ = 0; 248 incoming_bit_rate_ = 0; 249 time_last_incoming_frame_count_ = clock_->TimeInMilliseconds(); 250 receive_statistics_.clear(); 251 252 num_consecutive_old_frames_ = 0; 253 num_consecutive_old_packets_ = 0; 254 num_discarded_packets_ = 0; 255 256 // Start in a non-signaled state. 257 frame_event_->Reset(); 258 packet_event_->Reset(); 259 waiting_for_completion_.frame_size = 0; 260 waiting_for_completion_.timestamp = 0; 261 waiting_for_completion_.latest_packet_time = -1; 262 first_packet_since_reset_ = true; 263 rtt_ms_ = kDefaultRtt; 264 last_decoded_state_.Reset(); 265 } 266 267 void VCMJitterBuffer::Stop() { 268 crit_sect_->Enter(); 269 running_ = false; 270 last_decoded_state_.Reset(); 271 free_frames_.clear(); 272 decodable_frames_.clear(); 273 incomplete_frames_.clear(); 274 // Make sure all frames are reset and free. 275 for (int i = 0; i < kMaxNumberOfFrames; i++) { 276 if (frame_buffers_[i] != NULL) { 277 static_cast<VCMFrameBuffer*>(frame_buffers_[i])->Reset(); 278 free_frames_.push_back(frame_buffers_[i]); 279 } 280 } 281 crit_sect_->Leave(); 282 // Make sure we wake up any threads waiting on these events. 283 frame_event_->Set(); 284 packet_event_->Set(); 285 } 286 287 bool VCMJitterBuffer::Running() const { 288 CriticalSectionScoped cs(crit_sect_); 289 return running_; 290 } 291 292 void VCMJitterBuffer::Flush() { 293 CriticalSectionScoped cs(crit_sect_); 294 decodable_frames_.Reset(&free_frames_); 295 incomplete_frames_.Reset(&free_frames_); 296 last_decoded_state_.Reset(); // TODO(mikhal): sync reset. 297 frame_event_->Reset(); 298 packet_event_->Reset(); 299 num_consecutive_old_frames_ = 0; 300 num_consecutive_old_packets_ = 0; 301 // Also reset the jitter and delay estimates 302 jitter_estimate_.Reset(); 303 inter_frame_delay_.Reset(clock_->TimeInMilliseconds()); 304 waiting_for_completion_.frame_size = 0; 305 waiting_for_completion_.timestamp = 0; 306 waiting_for_completion_.latest_packet_time = -1; 307 first_packet_since_reset_ = true; 308 missing_sequence_numbers_.clear(); 309 } 310 311 // Get received key and delta frames 312 std::map<FrameType, uint32_t> VCMJitterBuffer::FrameStatistics() const { 313 CriticalSectionScoped cs(crit_sect_); 314 return receive_statistics_; 315 } 316 317 int VCMJitterBuffer::num_discarded_packets() const { 318 CriticalSectionScoped cs(crit_sect_); 319 return num_discarded_packets_; 320 } 321 322 // Calculate framerate and bitrate. 323 void VCMJitterBuffer::IncomingRateStatistics(unsigned int* framerate, 324 unsigned int* bitrate) { 325 assert(framerate); 326 assert(bitrate); 327 CriticalSectionScoped cs(crit_sect_); 328 const int64_t now = clock_->TimeInMilliseconds(); 329 int64_t diff = now - time_last_incoming_frame_count_; 330 if (diff < 1000 && incoming_frame_rate_ > 0 && incoming_bit_rate_ > 0) { 331 // Make sure we report something even though less than 332 // 1 second has passed since last update. 333 *framerate = incoming_frame_rate_; 334 *bitrate = incoming_bit_rate_; 335 } else if (incoming_frame_count_ != 0) { 336 // We have received frame(s) since last call to this function 337 338 // Prepare calculations 339 if (diff <= 0) { 340 diff = 1; 341 } 342 // we add 0.5f for rounding 343 float rate = 0.5f + ((incoming_frame_count_ * 1000.0f) / diff); 344 if (rate < 1.0f) { 345 rate = 1.0f; 346 } 347 348 // Calculate frame rate 349 // Let r be rate. 350 // r(0) = 1000*framecount/delta_time. 351 // (I.e. frames per second since last calculation.) 352 // frame_rate = r(0)/2 + r(-1)/2 353 // (I.e. fr/s average this and the previous calculation.) 354 *framerate = (incoming_frame_rate_ + static_cast<unsigned int>(rate)) / 2; 355 incoming_frame_rate_ = static_cast<unsigned int>(rate); 356 357 // Calculate bit rate 358 if (incoming_bit_count_ == 0) { 359 *bitrate = 0; 360 } else { 361 *bitrate = 10 * ((100 * incoming_bit_count_) / 362 static_cast<unsigned int>(diff)); 363 } 364 incoming_bit_rate_ = *bitrate; 365 366 // Reset count 367 incoming_frame_count_ = 0; 368 incoming_bit_count_ = 0; 369 time_last_incoming_frame_count_ = now; 370 371 } else { 372 // No frames since last call 373 time_last_incoming_frame_count_ = clock_->TimeInMilliseconds(); 374 *framerate = 0; 375 *bitrate = 0; 376 incoming_frame_rate_ = 0; 377 incoming_bit_rate_ = 0; 378 } 379 } 380 381 // Answers the question: 382 // Will the packet sequence be complete if the next frame is grabbed for 383 // decoding right now? That is, have we lost a frame between the last decoded 384 // frame and the next, or is the next 385 // frame missing one or more packets? 386 bool VCMJitterBuffer::CompleteSequenceWithNextFrame() { 387 CriticalSectionScoped cs(crit_sect_); 388 // Finding oldest frame ready for decoder, check sequence number and size 389 CleanUpOldOrEmptyFrames(); 390 if (!decodable_frames_.empty()) { 391 if (decodable_frames_.Front()->GetState() == kStateComplete) { 392 return true; 393 } 394 } else if (incomplete_frames_.size() <= 1) { 395 // Frame not ready to be decoded. 396 return true; 397 } 398 return false; 399 } 400 401 // Returns immediately or a |max_wait_time_ms| ms event hang waiting for a 402 // complete frame, |max_wait_time_ms| decided by caller. 403 bool VCMJitterBuffer::NextCompleteTimestamp( 404 uint32_t max_wait_time_ms, uint32_t* timestamp) { 405 crit_sect_->Enter(); 406 if (!running_) { 407 crit_sect_->Leave(); 408 return false; 409 } 410 CleanUpOldOrEmptyFrames(); 411 412 if (decodable_frames_.empty() || 413 decodable_frames_.Front()->GetState() != kStateComplete) { 414 const int64_t end_wait_time_ms = clock_->TimeInMilliseconds() + 415 max_wait_time_ms; 416 int64_t wait_time_ms = max_wait_time_ms; 417 while (wait_time_ms > 0) { 418 crit_sect_->Leave(); 419 const EventTypeWrapper ret = 420 frame_event_->Wait(static_cast<uint32_t>(wait_time_ms)); 421 crit_sect_->Enter(); 422 if (ret == kEventSignaled) { 423 // Are we shutting down the jitter buffer? 424 if (!running_) { 425 crit_sect_->Leave(); 426 return false; 427 } 428 // Finding oldest frame ready for decoder. 429 CleanUpOldOrEmptyFrames(); 430 if (decodable_frames_.empty() || 431 decodable_frames_.Front()->GetState() != kStateComplete) { 432 wait_time_ms = end_wait_time_ms - clock_->TimeInMilliseconds(); 433 } else { 434 break; 435 } 436 } else { 437 break; 438 } 439 } 440 // Inside |crit_sect_|. 441 } else { 442 // We already have a frame, reset the event. 443 frame_event_->Reset(); 444 } 445 if (decodable_frames_.empty() || 446 decodable_frames_.Front()->GetState() != kStateComplete) { 447 crit_sect_->Leave(); 448 return false; 449 } 450 *timestamp = decodable_frames_.Front()->TimeStamp(); 451 crit_sect_->Leave(); 452 return true; 453 } 454 455 bool VCMJitterBuffer::NextMaybeIncompleteTimestamp(uint32_t* timestamp) { 456 CriticalSectionScoped cs(crit_sect_); 457 if (!running_) { 458 return false; 459 } 460 if (decode_error_mode_ == kNoErrors) { 461 // No point to continue, as we are not decoding with errors. 462 return false; 463 } 464 465 CleanUpOldOrEmptyFrames(); 466 467 if (decodable_frames_.empty()) { 468 return false; 469 } 470 VCMFrameBuffer* oldest_frame = decodable_frames_.Front(); 471 // If we have exactly one frame in the buffer, release it only if it is 472 // complete. We know decodable_frames_ is not empty due to the previous 473 // check. 474 if (decodable_frames_.size() == 1 && incomplete_frames_.empty() 475 && oldest_frame->GetState() != kStateComplete) { 476 return false; 477 } 478 479 *timestamp = oldest_frame->TimeStamp(); 480 return true; 481 } 482 483 VCMEncodedFrame* VCMJitterBuffer::ExtractAndSetDecode(uint32_t timestamp) { 484 CriticalSectionScoped cs(crit_sect_); 485 486 if (!running_) { 487 return NULL; 488 } 489 // Extract the frame with the desired timestamp. 490 VCMFrameBuffer* frame = decodable_frames_.PopFrame(timestamp); 491 bool continuous = true; 492 if (!frame) { 493 frame = incomplete_frames_.PopFrame(timestamp); 494 if (frame) 495 continuous = last_decoded_state_.ContinuousFrame(frame); 496 else 497 return NULL; 498 } 499 TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", timestamp, "Extract"); 500 // Frame pulled out from jitter buffer, update the jitter estimate. 501 const bool retransmitted = (frame->GetNackCount() > 0); 502 if (retransmitted) { 503 jitter_estimate_.FrameNacked(); 504 } else if (frame->Length() > 0) { 505 // Ignore retransmitted and empty frames. 506 if (waiting_for_completion_.latest_packet_time >= 0) { 507 UpdateJitterEstimate(waiting_for_completion_, true); 508 } 509 if (frame->GetState() == kStateComplete) { 510 UpdateJitterEstimate(*frame, false); 511 } else { 512 // Wait for this one to get complete. 513 waiting_for_completion_.frame_size = frame->Length(); 514 waiting_for_completion_.latest_packet_time = 515 frame->LatestPacketTimeMs(); 516 waiting_for_completion_.timestamp = frame->TimeStamp(); 517 } 518 } 519 520 // The state must be changed to decoding before cleaning up zero sized 521 // frames to avoid empty frames being cleaned up and then given to the 522 // decoder. Propagates the missing_frame bit. 523 frame->PrepareForDecode(continuous); 524 525 // We have a frame - update the last decoded state and nack list. 526 last_decoded_state_.SetState(frame); 527 DropPacketsFromNackList(last_decoded_state_.sequence_num()); 528 529 if ((*frame).IsSessionComplete()) 530 UpdateAveragePacketsPerFrame(frame->NumPackets()); 531 532 return frame; 533 } 534 535 // Release frame when done with decoding. Should never be used to release 536 // frames from within the jitter buffer. 537 void VCMJitterBuffer::ReleaseFrame(VCMEncodedFrame* frame) { 538 CriticalSectionScoped cs(crit_sect_); 539 VCMFrameBuffer* frame_buffer = static_cast<VCMFrameBuffer*>(frame); 540 if (frame_buffer) { 541 free_frames_.push_back(frame_buffer); 542 } 543 } 544 545 // Gets frame to use for this timestamp. If no match, get empty frame. 546 VCMFrameBufferEnum VCMJitterBuffer::GetFrame(const VCMPacket& packet, 547 VCMFrameBuffer** frame) { 548 // Does this packet belong to an old frame? 549 if (last_decoded_state_.IsOldPacket(&packet)) { 550 // Account only for media packets. 551 if (packet.sizeBytes > 0) { 552 num_discarded_packets_++; 553 num_consecutive_old_packets_++; 554 } 555 // Update last decoded sequence number if the packet arrived late and 556 // belongs to a frame with a timestamp equal to the last decoded 557 // timestamp. 558 last_decoded_state_.UpdateOldPacket(&packet); 559 DropPacketsFromNackList(last_decoded_state_.sequence_num()); 560 561 if (num_consecutive_old_packets_ > kMaxConsecutiveOldPackets) { 562 LOG(LS_WARNING) << num_consecutive_old_packets_ << " consecutive old " 563 "packets received. Flushing the jitter buffer."; 564 Flush(); 565 return kFlushIndicator; 566 } 567 return kOldPacket; 568 } 569 num_consecutive_old_packets_ = 0; 570 571 *frame = incomplete_frames_.FindFrame(packet.timestamp); 572 if (*frame) 573 return kNoError; 574 *frame = decodable_frames_.FindFrame(packet.timestamp); 575 if (*frame) 576 return kNoError; 577 578 // No match, return empty frame. 579 *frame = GetEmptyFrame(); 580 VCMFrameBufferEnum ret = kNoError; 581 if (!*frame) { 582 // No free frame! Try to reclaim some... 583 LOG(LS_WARNING) << "Unable to get empty frame; Recycling."; 584 bool found_key_frame = RecycleFramesUntilKeyFrame(); 585 *frame = GetEmptyFrame(); 586 assert(*frame); 587 if (!found_key_frame) { 588 ret = kFlushIndicator; 589 } 590 } 591 (*frame)->Reset(); 592 return ret; 593 } 594 595 int64_t VCMJitterBuffer::LastPacketTime(const VCMEncodedFrame* frame, 596 bool* retransmitted) const { 597 assert(retransmitted); 598 CriticalSectionScoped cs(crit_sect_); 599 const VCMFrameBuffer* frame_buffer = 600 static_cast<const VCMFrameBuffer*>(frame); 601 *retransmitted = (frame_buffer->GetNackCount() > 0); 602 return frame_buffer->LatestPacketTimeMs(); 603 } 604 605 VCMFrameBufferEnum VCMJitterBuffer::InsertPacket(const VCMPacket& packet, 606 bool* retransmitted) { 607 CriticalSectionScoped cs(crit_sect_); 608 609 VCMFrameBuffer* frame = NULL; 610 const VCMFrameBufferEnum error = GetFrame(packet, &frame); 611 if (error != kNoError && frame == NULL) { 612 return error; 613 } 614 615 int64_t now_ms = clock_->TimeInMilliseconds(); 616 // We are keeping track of the first and latest seq numbers, and 617 // the number of wraps to be able to calculate how many packets we expect. 618 if (first_packet_since_reset_) { 619 // Now it's time to start estimating jitter 620 // reset the delay estimate. 621 inter_frame_delay_.Reset(now_ms); 622 } 623 if (last_decoded_state_.IsOldPacket(&packet)) { 624 // This packet belongs to an old, already decoded frame, we want to update 625 // the last decoded sequence number. 626 last_decoded_state_.UpdateOldPacket(&packet); 627 drop_count_++; 628 // Flush if this happens consistently. 629 num_consecutive_old_frames_++; 630 if (num_consecutive_old_frames_ > kMaxConsecutiveOldFrames) { 631 LOG(LS_WARNING) << num_consecutive_old_packets_ << " consecutive old " 632 "frames received. Flushing the jitter buffer."; 633 Flush(); 634 return kFlushIndicator; 635 } 636 return kNoError; 637 } 638 639 num_consecutive_old_frames_ = 0; 640 641 // Empty packets may bias the jitter estimate (lacking size component), 642 // therefore don't let empty packet trigger the following updates: 643 if (packet.frameType != kFrameEmpty) { 644 if (waiting_for_completion_.timestamp == packet.timestamp) { 645 // This can get bad if we have a lot of duplicate packets, 646 // we will then count some packet multiple times. 647 waiting_for_completion_.frame_size += packet.sizeBytes; 648 waiting_for_completion_.latest_packet_time = now_ms; 649 } else if (waiting_for_completion_.latest_packet_time >= 0 && 650 waiting_for_completion_.latest_packet_time + 2000 <= now_ms) { 651 // A packet should never be more than two seconds late 652 UpdateJitterEstimate(waiting_for_completion_, true); 653 waiting_for_completion_.latest_packet_time = -1; 654 waiting_for_completion_.frame_size = 0; 655 waiting_for_completion_.timestamp = 0; 656 } 657 } 658 659 VCMFrameBufferStateEnum previous_state = frame->GetState(); 660 // Insert packet. 661 // Check for first packet. High sequence number will be -1 if neither an empty 662 // packet nor a media packet has been inserted. 663 bool first = (frame->GetHighSeqNum() == -1); 664 FrameData frame_data; 665 frame_data.rtt_ms = rtt_ms_; 666 frame_data.rolling_average_packets_per_frame = average_packets_per_frame_; 667 VCMFrameBufferEnum buffer_return = frame->InsertPacket(packet, 668 now_ms, 669 decode_error_mode_, 670 frame_data); 671 if (!frame->GetCountedFrame()) { 672 TRACE_EVENT_ASYNC_BEGIN1("webrtc", "Video", frame->TimeStamp(), 673 "timestamp", frame->TimeStamp()); 674 } 675 676 if (buffer_return > 0) { 677 incoming_bit_count_ += packet.sizeBytes << 3; 678 if (first_packet_since_reset_) { 679 latest_received_sequence_number_ = packet.seqNum; 680 first_packet_since_reset_ = false; 681 } else { 682 if (IsPacketRetransmitted(packet)) { 683 frame->IncrementNackCount(); 684 } 685 if (!UpdateNackList(packet.seqNum) && 686 packet.frameType != kVideoFrameKey) { 687 buffer_return = kFlushIndicator; 688 } 689 latest_received_sequence_number_ = LatestSequenceNumber( 690 latest_received_sequence_number_, packet.seqNum); 691 } 692 } 693 694 // Is the frame already in the decodable list? 695 bool update_decodable_list = (previous_state != kStateDecodable && 696 previous_state != kStateComplete); 697 bool continuous = IsContinuous(*frame); 698 switch (buffer_return) { 699 case kGeneralError: 700 case kTimeStampError: 701 case kSizeError: { 702 // This frame will be cleaned up later from the frame list. 703 frame->Reset(); 704 break; 705 } 706 case kCompleteSession: { 707 if (update_decodable_list) { 708 CountFrame(*frame); 709 frame->SetCountedFrame(true); 710 if (continuous) { 711 // Signal that we have a complete session. 712 frame_event_->Set(); 713 } 714 } 715 } 716 // Note: There is no break here - continuing to kDecodableSession. 717 case kDecodableSession: { 718 *retransmitted = (frame->GetNackCount() > 0); 719 // Signal that we have a received packet. 720 packet_event_->Set(); 721 if (!update_decodable_list) { 722 break; 723 } 724 if (continuous) { 725 if (!first) { 726 incomplete_frames_.PopFrame(packet.timestamp); 727 } 728 decodable_frames_.InsertFrame(frame); 729 FindAndInsertContinuousFrames(*frame); 730 } else if (first) { 731 incomplete_frames_.InsertFrame(frame); 732 } 733 break; 734 } 735 case kIncomplete: { 736 // No point in storing empty continuous frames. 737 if (frame->GetState() == kStateEmpty && 738 last_decoded_state_.UpdateEmptyFrame(frame)) { 739 free_frames_.push_back(frame); 740 frame->Reset(); 741 frame = NULL; 742 return kNoError; 743 } else if (first) { 744 incomplete_frames_.InsertFrame(frame); 745 } 746 // Signal that we have received a packet. 747 packet_event_->Set(); 748 break; 749 } 750 case kNoError: 751 case kOutOfBoundsPacket: 752 case kDuplicatePacket: { 753 break; 754 } 755 case kFlushIndicator: 756 return kFlushIndicator; 757 default: { 758 assert(false && "JitterBuffer::InsertPacket: Undefined value"); 759 } 760 } 761 return buffer_return; 762 } 763 764 bool VCMJitterBuffer::IsContinuousInState(const VCMFrameBuffer& frame, 765 const VCMDecodingState& decoding_state) const { 766 if (decode_error_mode_ == kWithErrors) 767 return true; 768 // Is this frame (complete or decodable) and continuous? 769 // kStateDecodable will never be set when decode_error_mode_ is false 770 // as SessionInfo determines this state based on the error mode (and frame 771 // completeness). 772 if ((frame.GetState() == kStateComplete || 773 frame.GetState() == kStateDecodable) && 774 decoding_state.ContinuousFrame(&frame)) { 775 return true; 776 } else { 777 return false; 778 } 779 } 780 781 bool VCMJitterBuffer::IsContinuous(const VCMFrameBuffer& frame) const { 782 if (IsContinuousInState(frame, last_decoded_state_)) { 783 return true; 784 } 785 VCMDecodingState decoding_state; 786 decoding_state.CopyFrom(last_decoded_state_); 787 for (FrameList::const_iterator it = decodable_frames_.begin(); 788 it != decodable_frames_.end(); ++it) { 789 VCMFrameBuffer* decodable_frame = it->second; 790 if (IsNewerTimestamp(decodable_frame->TimeStamp(), frame.TimeStamp())) { 791 break; 792 } 793 decoding_state.SetState(decodable_frame); 794 if (IsContinuousInState(frame, decoding_state)) { 795 return true; 796 } 797 } 798 return false; 799 } 800 801 void VCMJitterBuffer::FindAndInsertContinuousFrames( 802 const VCMFrameBuffer& new_frame) { 803 VCMDecodingState decoding_state; 804 decoding_state.CopyFrom(last_decoded_state_); 805 decoding_state.SetState(&new_frame); 806 // When temporal layers are available, we search for a complete or decodable 807 // frame until we hit one of the following: 808 // 1. Continuous base or sync layer. 809 // 2. The end of the list was reached. 810 for (FrameList::iterator it = incomplete_frames_.begin(); 811 it != incomplete_frames_.end();) { 812 VCMFrameBuffer* frame = it->second; 813 if (IsNewerTimestamp(new_frame.TimeStamp(), frame->TimeStamp())) { 814 ++it; 815 continue; 816 } 817 if (IsContinuousInState(*frame, decoding_state)) { 818 decodable_frames_.InsertFrame(frame); 819 incomplete_frames_.erase(it++); 820 decoding_state.SetState(frame); 821 } else if (frame->TemporalId() <= 0) { 822 break; 823 } else { 824 ++it; 825 } 826 } 827 } 828 829 uint32_t VCMJitterBuffer::EstimatedJitterMs() { 830 CriticalSectionScoped cs(crit_sect_); 831 // Compute RTT multiplier for estimation. 832 // low_rtt_nackThresholdMs_ == -1 means no FEC. 833 double rtt_mult = 1.0f; 834 if (low_rtt_nack_threshold_ms_ >= 0 && 835 static_cast<int>(rtt_ms_) >= low_rtt_nack_threshold_ms_) { 836 // For RTTs above low_rtt_nack_threshold_ms_ we don't apply extra delay 837 // when waiting for retransmissions. 838 rtt_mult = 0.0f; 839 } 840 return jitter_estimate_.GetJitterEstimate(rtt_mult); 841 } 842 843 void VCMJitterBuffer::UpdateRtt(uint32_t rtt_ms) { 844 CriticalSectionScoped cs(crit_sect_); 845 rtt_ms_ = rtt_ms; 846 jitter_estimate_.UpdateRtt(rtt_ms); 847 } 848 849 void VCMJitterBuffer::SetNackMode(VCMNackMode mode, 850 int low_rtt_nack_threshold_ms, 851 int high_rtt_nack_threshold_ms) { 852 CriticalSectionScoped cs(crit_sect_); 853 nack_mode_ = mode; 854 if (mode == kNoNack) { 855 missing_sequence_numbers_.clear(); 856 } 857 assert(low_rtt_nack_threshold_ms >= -1 && high_rtt_nack_threshold_ms >= -1); 858 assert(high_rtt_nack_threshold_ms == -1 || 859 low_rtt_nack_threshold_ms <= high_rtt_nack_threshold_ms); 860 assert(low_rtt_nack_threshold_ms > -1 || high_rtt_nack_threshold_ms == -1); 861 low_rtt_nack_threshold_ms_ = low_rtt_nack_threshold_ms; 862 high_rtt_nack_threshold_ms_ = high_rtt_nack_threshold_ms; 863 // Don't set a high start rtt if high_rtt_nack_threshold_ms_ is used, to not 864 // disable NACK in hybrid mode. 865 if (rtt_ms_ == kDefaultRtt && high_rtt_nack_threshold_ms_ != -1) { 866 rtt_ms_ = 0; 867 } 868 if (!WaitForRetransmissions()) { 869 jitter_estimate_.ResetNackCount(); 870 } 871 } 872 873 void VCMJitterBuffer::SetNackSettings(size_t max_nack_list_size, 874 int max_packet_age_to_nack, 875 int max_incomplete_time_ms) { 876 CriticalSectionScoped cs(crit_sect_); 877 assert(max_packet_age_to_nack >= 0); 878 assert(max_incomplete_time_ms_ >= 0); 879 max_nack_list_size_ = max_nack_list_size; 880 max_packet_age_to_nack_ = max_packet_age_to_nack; 881 max_incomplete_time_ms_ = max_incomplete_time_ms; 882 nack_seq_nums_.resize(max_nack_list_size_); 883 } 884 885 VCMNackMode VCMJitterBuffer::nack_mode() const { 886 CriticalSectionScoped cs(crit_sect_); 887 return nack_mode_; 888 } 889 890 int VCMJitterBuffer::NonContinuousOrIncompleteDuration() { 891 if (incomplete_frames_.empty()) { 892 return 0; 893 } 894 uint32_t start_timestamp = incomplete_frames_.Front()->TimeStamp(); 895 if (!decodable_frames_.empty()) { 896 start_timestamp = decodable_frames_.Back()->TimeStamp(); 897 } 898 return incomplete_frames_.Back()->TimeStamp() - start_timestamp; 899 } 900 901 uint16_t VCMJitterBuffer::EstimatedLowSequenceNumber( 902 const VCMFrameBuffer& frame) const { 903 assert(frame.GetLowSeqNum() >= 0); 904 if (frame.HaveFirstPacket()) 905 return frame.GetLowSeqNum(); 906 907 // This estimate is not accurate if more than one packet with lower sequence 908 // number is lost. 909 return frame.GetLowSeqNum() - 1; 910 } 911 912 uint16_t* VCMJitterBuffer::GetNackList(uint16_t* nack_list_size, 913 bool* request_key_frame) { 914 CriticalSectionScoped cs(crit_sect_); 915 *request_key_frame = false; 916 if (nack_mode_ == kNoNack) { 917 *nack_list_size = 0; 918 return NULL; 919 } 920 if (last_decoded_state_.in_initial_state()) { 921 VCMFrameBuffer* next_frame = NextFrame(); 922 const bool first_frame_is_key = next_frame && 923 next_frame->FrameType() == kVideoFrameKey && 924 next_frame->HaveFirstPacket(); 925 if (!first_frame_is_key) { 926 bool have_non_empty_frame = decodable_frames_.end() != find_if( 927 decodable_frames_.begin(), decodable_frames_.end(), 928 HasNonEmptyState); 929 if (!have_non_empty_frame) { 930 have_non_empty_frame = incomplete_frames_.end() != find_if( 931 incomplete_frames_.begin(), incomplete_frames_.end(), 932 HasNonEmptyState); 933 } 934 bool found_key_frame = RecycleFramesUntilKeyFrame(); 935 if (!found_key_frame) { 936 *request_key_frame = have_non_empty_frame; 937 *nack_list_size = 0; 938 return NULL; 939 } 940 } 941 } 942 if (TooLargeNackList()) { 943 *request_key_frame = !HandleTooLargeNackList(); 944 } 945 if (max_incomplete_time_ms_ > 0) { 946 int non_continuous_incomplete_duration = 947 NonContinuousOrIncompleteDuration(); 948 if (non_continuous_incomplete_duration > 90 * max_incomplete_time_ms_) { 949 LOG_F(LS_WARNING) << "Too long non-decodable duration: " 950 << non_continuous_incomplete_duration << " > " 951 << 90 * max_incomplete_time_ms_; 952 FrameList::reverse_iterator rit = find_if(incomplete_frames_.rbegin(), 953 incomplete_frames_.rend(), IsKeyFrame); 954 if (rit == incomplete_frames_.rend()) { 955 // Request a key frame if we don't have one already. 956 *request_key_frame = true; 957 *nack_list_size = 0; 958 return NULL; 959 } else { 960 // Skip to the last key frame. If it's incomplete we will start 961 // NACKing it. 962 // Note that the estimated low sequence number is correct for VP8 963 // streams because only the first packet of a key frame is marked. 964 last_decoded_state_.Reset(); 965 DropPacketsFromNackList(EstimatedLowSequenceNumber(*rit->second)); 966 } 967 } 968 } 969 unsigned int i = 0; 970 SequenceNumberSet::iterator it = missing_sequence_numbers_.begin(); 971 for (; it != missing_sequence_numbers_.end(); ++it, ++i) { 972 nack_seq_nums_[i] = *it; 973 } 974 *nack_list_size = i; 975 return &nack_seq_nums_[0]; 976 } 977 978 void VCMJitterBuffer::SetDecodeErrorMode(VCMDecodeErrorMode error_mode) { 979 CriticalSectionScoped cs(crit_sect_); 980 decode_error_mode_ = error_mode; 981 } 982 983 VCMFrameBuffer* VCMJitterBuffer::NextFrame() const { 984 if (!decodable_frames_.empty()) 985 return decodable_frames_.Front(); 986 if (!incomplete_frames_.empty()) 987 return incomplete_frames_.Front(); 988 return NULL; 989 } 990 991 bool VCMJitterBuffer::UpdateNackList(uint16_t sequence_number) { 992 if (nack_mode_ == kNoNack) { 993 return true; 994 } 995 // Make sure we don't add packets which are already too old to be decoded. 996 if (!last_decoded_state_.in_initial_state()) { 997 latest_received_sequence_number_ = LatestSequenceNumber( 998 latest_received_sequence_number_, 999 last_decoded_state_.sequence_num()); 1000 } 1001 if (IsNewerSequenceNumber(sequence_number, 1002 latest_received_sequence_number_)) { 1003 // Push any missing sequence numbers to the NACK list. 1004 for (uint16_t i = latest_received_sequence_number_ + 1; 1005 IsNewerSequenceNumber(sequence_number, i); ++i) { 1006 missing_sequence_numbers_.insert(missing_sequence_numbers_.end(), i); 1007 TRACE_EVENT_INSTANT1("webrtc", "AddNack", "seqnum", i); 1008 } 1009 if (TooLargeNackList() && !HandleTooLargeNackList()) { 1010 LOG(LS_WARNING) << "Requesting key frame due to too large NACK list."; 1011 return false; 1012 } 1013 if (MissingTooOldPacket(sequence_number) && 1014 !HandleTooOldPackets(sequence_number)) { 1015 LOG(LS_WARNING) << "Requesting key frame due to missing too old packets"; 1016 return false; 1017 } 1018 } else { 1019 missing_sequence_numbers_.erase(sequence_number); 1020 TRACE_EVENT_INSTANT1("webrtc", "RemoveNack", "seqnum", sequence_number); 1021 } 1022 return true; 1023 } 1024 1025 bool VCMJitterBuffer::TooLargeNackList() const { 1026 return missing_sequence_numbers_.size() > max_nack_list_size_; 1027 } 1028 1029 bool VCMJitterBuffer::HandleTooLargeNackList() { 1030 // Recycle frames until the NACK list is small enough. It is likely cheaper to 1031 // request a key frame than to retransmit this many missing packets. 1032 LOG_F(LS_WARNING) << "NACK list has grown too large: " 1033 << missing_sequence_numbers_.size() << " > " 1034 << max_nack_list_size_; 1035 bool key_frame_found = false; 1036 while (TooLargeNackList()) { 1037 key_frame_found = RecycleFramesUntilKeyFrame(); 1038 } 1039 return key_frame_found; 1040 } 1041 1042 bool VCMJitterBuffer::MissingTooOldPacket( 1043 uint16_t latest_sequence_number) const { 1044 if (missing_sequence_numbers_.empty()) { 1045 return false; 1046 } 1047 const uint16_t age_of_oldest_missing_packet = latest_sequence_number - 1048 *missing_sequence_numbers_.begin(); 1049 // Recycle frames if the NACK list contains too old sequence numbers as 1050 // the packets may have already been dropped by the sender. 1051 return age_of_oldest_missing_packet > max_packet_age_to_nack_; 1052 } 1053 1054 bool VCMJitterBuffer::HandleTooOldPackets(uint16_t latest_sequence_number) { 1055 bool key_frame_found = false; 1056 const uint16_t age_of_oldest_missing_packet = latest_sequence_number - 1057 *missing_sequence_numbers_.begin(); 1058 LOG_F(LS_WARNING) << "NACK list contains too old sequence numbers: " 1059 << age_of_oldest_missing_packet << " > " 1060 << max_packet_age_to_nack_; 1061 while (MissingTooOldPacket(latest_sequence_number)) { 1062 key_frame_found = RecycleFramesUntilKeyFrame(); 1063 } 1064 return key_frame_found; 1065 } 1066 1067 void VCMJitterBuffer::DropPacketsFromNackList( 1068 uint16_t last_decoded_sequence_number) { 1069 // Erase all sequence numbers from the NACK list which we won't need any 1070 // longer. 1071 missing_sequence_numbers_.erase(missing_sequence_numbers_.begin(), 1072 missing_sequence_numbers_.upper_bound( 1073 last_decoded_sequence_number)); 1074 } 1075 1076 int64_t VCMJitterBuffer::LastDecodedTimestamp() const { 1077 CriticalSectionScoped cs(crit_sect_); 1078 return last_decoded_state_.time_stamp(); 1079 } 1080 1081 void VCMJitterBuffer::RenderBufferSize(uint32_t* timestamp_start, 1082 uint32_t* timestamp_end) { 1083 CriticalSectionScoped cs(crit_sect_); 1084 CleanUpOldOrEmptyFrames(); 1085 *timestamp_start = 0; 1086 *timestamp_end = 0; 1087 if (decodable_frames_.empty()) { 1088 return; 1089 } 1090 *timestamp_start = decodable_frames_.Front()->TimeStamp(); 1091 *timestamp_end = decodable_frames_.Back()->TimeStamp(); 1092 } 1093 1094 VCMFrameBuffer* VCMJitterBuffer::GetEmptyFrame() { 1095 if (free_frames_.empty()) { 1096 if (!TryToIncreaseJitterBufferSize()) { 1097 return NULL; 1098 } 1099 } 1100 VCMFrameBuffer* frame = free_frames_.front(); 1101 free_frames_.pop_front(); 1102 return frame; 1103 } 1104 1105 bool VCMJitterBuffer::TryToIncreaseJitterBufferSize() { 1106 if (max_number_of_frames_ >= kMaxNumberOfFrames) 1107 return false; 1108 VCMFrameBuffer* new_frame = new VCMFrameBuffer(); 1109 frame_buffers_[max_number_of_frames_] = new_frame; 1110 free_frames_.push_back(new_frame); 1111 ++max_number_of_frames_; 1112 TRACE_COUNTER1("webrtc", "JBMaxFrames", max_number_of_frames_); 1113 return true; 1114 } 1115 1116 // Recycle oldest frames up to a key frame, used if jitter buffer is completely 1117 // full. 1118 bool VCMJitterBuffer::RecycleFramesUntilKeyFrame() { 1119 // First release incomplete frames, and only release decodable frames if there 1120 // are no incomplete ones. 1121 FrameList::iterator key_frame_it; 1122 bool key_frame_found = false; 1123 int dropped_frames = 0; 1124 dropped_frames += incomplete_frames_.RecycleFramesUntilKeyFrame( 1125 &key_frame_it, &free_frames_); 1126 key_frame_found = key_frame_it != incomplete_frames_.end(); 1127 if (dropped_frames == 0) { 1128 dropped_frames += decodable_frames_.RecycleFramesUntilKeyFrame( 1129 &key_frame_it, &free_frames_); 1130 key_frame_found = key_frame_it != decodable_frames_.end(); 1131 } 1132 drop_count_ += dropped_frames; 1133 TRACE_EVENT_INSTANT0("webrtc", "JB::RecycleFramesUntilKeyFrame"); 1134 if (key_frame_found) { 1135 LOG(LS_INFO) << "Found key frame while dropping frames."; 1136 // Reset last decoded state to make sure the next frame decoded is a key 1137 // frame, and start NACKing from here. 1138 last_decoded_state_.Reset(); 1139 DropPacketsFromNackList(EstimatedLowSequenceNumber(*key_frame_it->second)); 1140 } else if (decodable_frames_.empty()) { 1141 // All frames dropped. Reset the decoding state and clear missing sequence 1142 // numbers as we're starting fresh. 1143 last_decoded_state_.Reset(); 1144 missing_sequence_numbers_.clear(); 1145 } 1146 return key_frame_found; 1147 } 1148 1149 // Must be called under the critical section |crit_sect_|. 1150 void VCMJitterBuffer::CountFrame(const VCMFrameBuffer& frame) { 1151 if (!frame.GetCountedFrame()) { 1152 // Ignore ACK frames. 1153 incoming_frame_count_++; 1154 } 1155 1156 if (frame.FrameType() == kVideoFrameKey) { 1157 TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", 1158 frame.TimeStamp(), "KeyComplete"); 1159 } else { 1160 TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", 1161 frame.TimeStamp(), "DeltaComplete"); 1162 } 1163 1164 // Update receive statistics. We count all layers, thus when you use layers 1165 // adding all key and delta frames might differ from frame count. 1166 if (frame.IsSessionComplete()) { 1167 ++receive_statistics_[frame.FrameType()]; 1168 } 1169 } 1170 1171 void VCMJitterBuffer::UpdateAveragePacketsPerFrame(int current_number_packets) { 1172 if (frame_counter_ > kFastConvergeThreshold) { 1173 average_packets_per_frame_ = average_packets_per_frame_ 1174 * (1 - kNormalConvergeMultiplier) 1175 + current_number_packets * kNormalConvergeMultiplier; 1176 } else if (frame_counter_ > 0) { 1177 average_packets_per_frame_ = average_packets_per_frame_ 1178 * (1 - kFastConvergeMultiplier) 1179 + current_number_packets * kFastConvergeMultiplier; 1180 frame_counter_++; 1181 } else { 1182 average_packets_per_frame_ = current_number_packets; 1183 frame_counter_++; 1184 } 1185 } 1186 1187 // Must be called under the critical section |crit_sect_|. 1188 void VCMJitterBuffer::CleanUpOldOrEmptyFrames() { 1189 drop_count_ += 1190 decodable_frames_.CleanUpOldOrEmptyFrames(&last_decoded_state_, 1191 &free_frames_); 1192 drop_count_ += 1193 incomplete_frames_.CleanUpOldOrEmptyFrames(&last_decoded_state_, 1194 &free_frames_); 1195 if (!last_decoded_state_.in_initial_state()) { 1196 DropPacketsFromNackList(last_decoded_state_.sequence_num()); 1197 } 1198 } 1199 1200 // Must be called from within |crit_sect_|. 1201 bool VCMJitterBuffer::IsPacketRetransmitted(const VCMPacket& packet) const { 1202 return missing_sequence_numbers_.find(packet.seqNum) != 1203 missing_sequence_numbers_.end(); 1204 } 1205 1206 // Must be called under the critical section |crit_sect_|. Should never be 1207 // called with retransmitted frames, they must be filtered out before this 1208 // function is called. 1209 void VCMJitterBuffer::UpdateJitterEstimate(const VCMJitterSample& sample, 1210 bool incomplete_frame) { 1211 if (sample.latest_packet_time == -1) { 1212 return; 1213 } 1214 UpdateJitterEstimate(sample.latest_packet_time, sample.timestamp, 1215 sample.frame_size, incomplete_frame); 1216 } 1217 1218 // Must be called under the critical section crit_sect_. Should never be 1219 // called with retransmitted frames, they must be filtered out before this 1220 // function is called. 1221 void VCMJitterBuffer::UpdateJitterEstimate(const VCMFrameBuffer& frame, 1222 bool incomplete_frame) { 1223 if (frame.LatestPacketTimeMs() == -1) { 1224 return; 1225 } 1226 // No retransmitted frames should be a part of the jitter 1227 // estimate. 1228 UpdateJitterEstimate(frame.LatestPacketTimeMs(), frame.TimeStamp(), 1229 frame.Length(), incomplete_frame); 1230 } 1231 1232 // Must be called under the critical section |crit_sect_|. Should never be 1233 // called with retransmitted frames, they must be filtered out before this 1234 // function is called. 1235 void VCMJitterBuffer::UpdateJitterEstimate( 1236 int64_t latest_packet_time_ms, 1237 uint32_t timestamp, 1238 unsigned int frame_size, 1239 bool incomplete_frame) { 1240 if (latest_packet_time_ms == -1) { 1241 return; 1242 } 1243 int64_t frame_delay; 1244 bool not_reordered = inter_frame_delay_.CalculateDelay(timestamp, 1245 &frame_delay, 1246 latest_packet_time_ms); 1247 // Filter out frames which have been reordered in time by the network 1248 if (not_reordered) { 1249 // Update the jitter estimate with the new samples 1250 jitter_estimate_.UpdateEstimate(frame_delay, frame_size, incomplete_frame); 1251 } 1252 } 1253 1254 bool VCMJitterBuffer::WaitForRetransmissions() { 1255 if (nack_mode_ == kNoNack) { 1256 // NACK disabled -> don't wait for retransmissions. 1257 return false; 1258 } 1259 // Evaluate if the RTT is higher than |high_rtt_nack_threshold_ms_|, and in 1260 // that case we don't wait for retransmissions. 1261 if (high_rtt_nack_threshold_ms_ >= 0 && 1262 rtt_ms_ >= static_cast<unsigned int>(high_rtt_nack_threshold_ms_)) { 1263 return false; 1264 } 1265 return true; 1266 } 1267 } // namespace webrtc 1268