src/third_party/webrtc/modules/video_coding/main/source/jitter_buffer.cc

   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   if (!running_) {
 486     return NULL;
 487   }
 488   // Extract the frame with the desired timestamp.
 489   VCMFrameBuffer* frame = decodable_frames_.PopFrame(timestamp);
 490   bool continuous = true;
 491   if (!frame) {
 492     frame = incomplete_frames_.PopFrame(timestamp);
 493     if (frame)
 494       continuous = last_decoded_state_.ContinuousFrame(frame);
 495     else
 496       return NULL;
 497   }
 498   TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", timestamp, "Extract");
 499   // Frame pulled out from jitter buffer, update the jitter estimate.
 500   const bool retransmitted = (frame->GetNackCount() > 0);
 501   if (retransmitted) {
 502     jitter_estimate_.FrameNacked();
 503   } else if (frame->Length() > 0) {
 504     // Ignore retransmitted and empty frames.
 505     if (waiting_for_completion_.latest_packet_time >= 0) {
 506       UpdateJitterEstimate(waiting_for_completion_, true);
 507     }
 508     if (frame->GetState() == kStateComplete) {
 509       UpdateJitterEstimate(*frame, false);
 510     } else {
 511       // Wait for this one to get complete.
 512       waiting_for_completion_.frame_size = frame->Length();
 513       waiting_for_completion_.latest_packet_time =
 514           frame->LatestPacketTimeMs();
 515       waiting_for_completion_.timestamp = frame->TimeStamp();
 516     }
 517   }
 518
 519   // The state must be changed to decoding before cleaning up zero sized
 520   // frames to avoid empty frames being cleaned up and then given to the
 521   // decoder. Propagates the missing_frame bit.
 522   frame->PrepareForDecode(continuous);
 523
 524   // We have a frame - update the last decoded state and nack list.
 525   last_decoded_state_.SetState(frame);
 526   DropPacketsFromNackList(last_decoded_state_.sequence_num());
 527
 528   if ((*frame).IsSessionComplete())
 529     UpdateAveragePacketsPerFrame(frame->NumPackets());
 530
 531   return frame;
 532 }
 533
 534 // Release frame when done with decoding. Should never be used to release
 535 // frames from within the jitter buffer.
 536 void VCMJitterBuffer::ReleaseFrame(VCMEncodedFrame* frame) {
 537   CriticalSectionScoped cs(crit_sect_);
 538   VCMFrameBuffer* frame_buffer = static_cast<VCMFrameBuffer*>(frame);
 539   if (frame_buffer) {
 540     free_frames_.push_back(frame_buffer);
 541   }
 542 }
 543
 544 // Gets frame to use for this timestamp. If no match, get empty frame.
 545 VCMFrameBufferEnum VCMJitterBuffer::GetFrame(const VCMPacket& packet,
 546                                              VCMFrameBuffer** frame) {
 547   // Does this packet belong to an old frame?
 548   if (last_decoded_state_.IsOldPacket(&packet)) {
 549     // Account only for media packets.
 550     if (packet.sizeBytes > 0) {
 551       num_discarded_packets_++;
 552       num_consecutive_old_packets_++;
 553     }
 554     // Update last decoded sequence number if the packet arrived late and
 555     // belongs to a frame with a timestamp equal to the last decoded
 556     // timestamp.
 557     last_decoded_state_.UpdateOldPacket(&packet);
 558     DropPacketsFromNackList(last_decoded_state_.sequence_num());
 559
 560     if (num_consecutive_old_packets_ > kMaxConsecutiveOldPackets) {
 561       LOG(LS_WARNING) << num_consecutive_old_packets_ << " consecutive old "
 562                          "packets received. Flushing the jitter buffer.";
 563       Flush();
 564       return kFlushIndicator;
 565     }
 566     return kOldPacket;
 567   }
 568   num_consecutive_old_packets_ = 0;
 569
 570   *frame = incomplete_frames_.FindFrame(packet.timestamp);
 571   if (*frame)
 572     return kNoError;
 573   *frame = decodable_frames_.FindFrame(packet.timestamp);
 574   if (*frame)
 575     return kNoError;
 576
 577   // No match, return empty frame.
 578   *frame = GetEmptyFrame();
 579   VCMFrameBufferEnum ret = kNoError;
 580   if (!*frame) {
 581     // No free frame! Try to reclaim some...
 582     LOG(LS_WARNING) << "Unable to get empty frame; Recycling.";
 583     bool found_key_frame = RecycleFramesUntilKeyFrame();
 584     *frame = GetEmptyFrame();
 585     assert(*frame);
 586     if (!found_key_frame) {
 587       ret = kFlushIndicator;
 588     }
 589   }
 590   (*frame)->Reset();
 591   return ret;
 592 }
 593
 594 int64_t VCMJitterBuffer::LastPacketTime(const VCMEncodedFrame* frame,
 595                                         bool* retransmitted) const {
 596   assert(retransmitted);
 597   CriticalSectionScoped cs(crit_sect_);
 598   const VCMFrameBuffer* frame_buffer =
 599       static_cast<const VCMFrameBuffer*>(frame);
 600   *retransmitted = (frame_buffer->GetNackCount() > 0);
 601   return frame_buffer->LatestPacketTimeMs();
 602 }
 603
 604 VCMFrameBufferEnum VCMJitterBuffer::InsertPacket(const VCMPacket& packet,
 605                                                  bool* retransmitted) {
 606   CriticalSectionScoped cs(crit_sect_);
 607
 608   VCMFrameBuffer* frame = NULL;
 609   const VCMFrameBufferEnum error = GetFrame(packet, &frame);
 610   if (error != kNoError && frame == NULL) {
 611     return error;
 612   }
 613   int64_t now_ms = clock_->TimeInMilliseconds();
 614   // We are keeping track of the first and latest seq numbers, and
 615   // the number of wraps to be able to calculate how many packets we expect.
 616   if (first_packet_since_reset_) {
 617     // Now it's time to start estimating jitter
 618     // reset the delay estimate.
 619     inter_frame_delay_.Reset(now_ms);
 620   }
 621   if (last_decoded_state_.IsOldPacket(&packet)) {
 622     // This packet belongs to an old, already decoded frame, we want to update
 623     // the last decoded sequence number.
 624     last_decoded_state_.UpdateOldPacket(&packet);
 625     drop_count_++;
 626     // Flush if this happens consistently.
 627     num_consecutive_old_frames_++;
 628     if (num_consecutive_old_frames_ > kMaxConsecutiveOldFrames) {
 629       LOG(LS_WARNING) << num_consecutive_old_packets_ << " consecutive old "
 630                          "frames received. Flushing the jitter buffer.";
 631       Flush();
 632       return kFlushIndicator;
 633     }
 634     return kNoError;
 635   }
 636
 637   num_consecutive_old_frames_ = 0;
 638
 639   // Empty packets may bias the jitter estimate (lacking size component),
 640   // therefore don't let empty packet trigger the following updates:
 641   if (packet.frameType != kFrameEmpty) {
 642     if (waiting_for_completion_.timestamp == packet.timestamp) {
 643       // This can get bad if we have a lot of duplicate packets,
 644       // we will then count some packet multiple times.
 645       waiting_for_completion_.frame_size += packet.sizeBytes;
 646       waiting_for_completion_.latest_packet_time = now_ms;
 647     } else if (waiting_for_completion_.latest_packet_time >= 0 &&
 648                waiting_for_completion_.latest_packet_time + 2000 <= now_ms) {
 649       // A packet should never be more than two seconds late
 650       UpdateJitterEstimate(waiting_for_completion_, true);
 651       waiting_for_completion_.latest_packet_time = -1;
 652       waiting_for_completion_.frame_size = 0;
 653       waiting_for_completion_.timestamp = 0;
 654     }
 655   }
 656
 657   VCMFrameBufferStateEnum previous_state = frame->GetState();
 658   // Insert packet.
 659   // Check for first packet. High sequence number will be -1 if neither an empty
 660   // packet nor a media packet has been inserted.
 661   bool first = (frame->GetHighSeqNum() == -1);
 662   FrameData frame_data;
 663   frame_data.rtt_ms = rtt_ms_;
 664   frame_data.rolling_average_packets_per_frame = average_packets_per_frame_;
 665   VCMFrameBufferEnum buffer_return = frame->InsertPacket(packet,
 666                                                          now_ms,
 667                                                          decode_error_mode_,
 668                                                          frame_data);
 669   if (!frame->GetCountedFrame()) {
 670     TRACE_EVENT_ASYNC_BEGIN1("webrtc", "Video", frame->TimeStamp(),
 671                              "timestamp", frame->TimeStamp());
 672   }
 673
 674   if (buffer_return > 0) {
 675     incoming_bit_count_ += packet.sizeBytes << 3;
 676     if (first_packet_since_reset_) {
 677       latest_received_sequence_number_ = packet.seqNum;
 678       first_packet_since_reset_ = false;
 679     } else {
 680       if (IsPacketRetransmitted(packet)) {
 681         frame->IncrementNackCount();
 682       }
 683       if (!UpdateNackList(packet.seqNum) &&
 684           packet.frameType != kVideoFrameKey) {
 685         buffer_return = kFlushIndicator;
 686       }
 687       latest_received_sequence_number_ = LatestSequenceNumber(
 688           latest_received_sequence_number_, packet.seqNum);
 689     }
 690   }
 691
 692   // Is the frame already in the decodable list?
 693   bool update_decodable_list = (previous_state != kStateDecodable &&
 694       previous_state != kStateComplete);
 695   bool continuous = IsContinuous(*frame);
 696   switch (buffer_return) {
 697     case kGeneralError:
 698     case kTimeStampError:
 699     case kSizeError: {
 700       // This frame will be cleaned up later from the frame list.
 701       frame->Reset();
 702       break;
 703     }
 704     case kCompleteSession: {
 705       if (update_decodable_list) {
 706         CountFrame(*frame);
 707         frame->SetCountedFrame(true);
 708         if (continuous) {
 709           // Signal that we have a complete session.
 710           frame_event_->Set();
 711         }
 712       }
 713     }
 714     // Note: There is no break here - continuing to kDecodableSession.
 715     case kDecodableSession: {
 716       *retransmitted = (frame->GetNackCount() > 0);
 717       // Signal that we have a received packet.
 718       packet_event_->Set();
 719       if (!update_decodable_list) {
 720         break;
 721       }
 722       if (continuous) {
 723         if (!first) {
 724           incomplete_frames_.PopFrame(packet.timestamp);
 725         }
 726         decodable_frames_.InsertFrame(frame);
 727         FindAndInsertContinuousFrames(*frame);
 728       } else if (first) {
 729         incomplete_frames_.InsertFrame(frame);
 730       }
 731       break;
 732     }
 733     case kIncomplete: {
 734       // No point in storing empty continuous frames.
 735       if (frame->GetState() == kStateEmpty &&
 736           last_decoded_state_.UpdateEmptyFrame(frame)) {
 737         free_frames_.push_back(frame);
 738         frame->Reset();
 739         frame = NULL;
 740         return kNoError;
 741       } else if (first) {
 742         incomplete_frames_.InsertFrame(frame);
 743       }
 744       // Signal that we have received a packet.
 745       packet_event_->Set();
 746       break;
 747     }
 748     case kNoError:
 749     case kOutOfBoundsPacket:
 750     case kDuplicatePacket: {
 751       break;
 752     }
 753     case kFlushIndicator:
 754       return kFlushIndicator;
 755     default: {
 756       assert(false && "JitterBuffer::InsertPacket: Undefined value");
 757     }
 758   }
 759   return buffer_return;
 760 }
 761
 762 bool VCMJitterBuffer::IsContinuousInState(const VCMFrameBuffer& frame,
 763     const VCMDecodingState& decoding_state) const {
 764   if (decode_error_mode_ == kWithErrors)
 765     return true;
 766   // Is this frame (complete or decodable) and continuous?
 767   // kStateDecodable will never be set when decode_error_mode_ is false
 768   // as SessionInfo determines this state based on the error mode (and frame
 769   // completeness).
 770   if ((frame.GetState() == kStateComplete ||
 771        frame.GetState() == kStateDecodable) &&
 772        decoding_state.ContinuousFrame(&frame)) {
 773     return true;
 774   } else {
 775     return false;
 776   }
 777 }
 778
 779 bool VCMJitterBuffer::IsContinuous(const VCMFrameBuffer& frame) const {
 780   if (IsContinuousInState(frame, last_decoded_state_)) {
 781     return true;
 782   }
 783   VCMDecodingState decoding_state;
 784   decoding_state.CopyFrom(last_decoded_state_);
 785   for (FrameList::const_iterator it = decodable_frames_.begin();
 786        it != decodable_frames_.end(); ++it)  {
 787     VCMFrameBuffer* decodable_frame = it->second;
 788     if (IsNewerTimestamp(decodable_frame->TimeStamp(), frame.TimeStamp())) {
 789       break;
 790     }
 791     decoding_state.SetState(decodable_frame);
 792     if (IsContinuousInState(frame, decoding_state)) {
 793       return true;
 794     }
 795   }
 796   return false;
 797 }
 798
 799 void VCMJitterBuffer::FindAndInsertContinuousFrames(
 800     const VCMFrameBuffer& new_frame) {
 801   VCMDecodingState decoding_state;
 802   decoding_state.CopyFrom(last_decoded_state_);
 803   decoding_state.SetState(&new_frame);
 804   // When temporal layers are available, we search for a complete or decodable
 805   // frame until we hit one of the following:
 806   // 1. Continuous base or sync layer.
 807   // 2. The end of the list was reached.
 808   for (FrameList::iterator it = incomplete_frames_.begin();
 809        it != incomplete_frames_.end();)  {
 810     VCMFrameBuffer* frame = it->second;
 811     if (IsNewerTimestamp(new_frame.TimeStamp(), frame->TimeStamp())) {
 812       ++it;
 813       continue;
 814     }
 815     if (IsContinuousInState(*frame, decoding_state)) {
 816       decodable_frames_.InsertFrame(frame);
 817       incomplete_frames_.erase(it++);
 818       decoding_state.SetState(frame);
 819     } else if (frame->TemporalId() <= 0) {
 820       break;
 821     } else {
 822       ++it;
 823     }
 824   }
 825 }
 826
 827 uint32_t VCMJitterBuffer::EstimatedJitterMs() {
 828   CriticalSectionScoped cs(crit_sect_);
 829   // Compute RTT multiplier for estimation.
 830   // low_rtt_nackThresholdMs_ == -1 means no FEC.
 831   double rtt_mult = 1.0f;
 832   if (low_rtt_nack_threshold_ms_ >= 0 &&
 833       static_cast<int>(rtt_ms_) >= low_rtt_nack_threshold_ms_) {
 834     // For RTTs above low_rtt_nack_threshold_ms_ we don't apply extra delay
 835     // when waiting for retransmissions.
 836     rtt_mult = 0.0f;
 837   }
 838   return jitter_estimate_.GetJitterEstimate(rtt_mult);
 839 }
 840
 841 void VCMJitterBuffer::UpdateRtt(uint32_t rtt_ms) {
 842   CriticalSectionScoped cs(crit_sect_);
 843   rtt_ms_ = rtt_ms;
 844   jitter_estimate_.UpdateRtt(rtt_ms);
 845 }
 846
 847 void VCMJitterBuffer::SetNackMode(VCMNackMode mode,
 848                                   int low_rtt_nack_threshold_ms,
 849                                   int high_rtt_nack_threshold_ms) {
 850   CriticalSectionScoped cs(crit_sect_);
 851   nack_mode_ = mode;
 852   if (mode == kNoNack) {
 853     missing_sequence_numbers_.clear();
 854   }
 855   assert(low_rtt_nack_threshold_ms >= -1 && high_rtt_nack_threshold_ms >= -1);
 856   assert(high_rtt_nack_threshold_ms == -1 ||
 857          low_rtt_nack_threshold_ms <= high_rtt_nack_threshold_ms);
 858   assert(low_rtt_nack_threshold_ms > -1 || high_rtt_nack_threshold_ms == -1);
 859   low_rtt_nack_threshold_ms_ = low_rtt_nack_threshold_ms;
 860   high_rtt_nack_threshold_ms_ = high_rtt_nack_threshold_ms;
 861   // Don't set a high start rtt if high_rtt_nack_threshold_ms_ is used, to not
 862   // disable NACK in hybrid mode.
 863   if (rtt_ms_ == kDefaultRtt && high_rtt_nack_threshold_ms_ != -1) {
 864     rtt_ms_ = 0;
 865   }
 866   if (!WaitForRetransmissions()) {
 867     jitter_estimate_.ResetNackCount();
 868   }
 869 }
 870
 871 void VCMJitterBuffer::SetNackSettings(size_t max_nack_list_size,
 872                                       int max_packet_age_to_nack,
 873                                       int max_incomplete_time_ms) {
 874   CriticalSectionScoped cs(crit_sect_);
 875   assert(max_packet_age_to_nack >= 0);
 876   assert(max_incomplete_time_ms_ >= 0);
 877   max_nack_list_size_ = max_nack_list_size;
 878   max_packet_age_to_nack_ = max_packet_age_to_nack;
 879   max_incomplete_time_ms_ = max_incomplete_time_ms;
 880   nack_seq_nums_.resize(max_nack_list_size_);
 881 }
 882
 883 VCMNackMode VCMJitterBuffer::nack_mode() const {
 884   CriticalSectionScoped cs(crit_sect_);
 885   return nack_mode_;
 886 }
 887
 888 int VCMJitterBuffer::NonContinuousOrIncompleteDuration() {
 889   if (incomplete_frames_.empty()) {
 890     return 0;
 891   }
 892   uint32_t start_timestamp = incomplete_frames_.Front()->TimeStamp();
 893   if (!decodable_frames_.empty()) {
 894     start_timestamp = decodable_frames_.Back()->TimeStamp();
 895   }
 896   return incomplete_frames_.Back()->TimeStamp() - start_timestamp;
 897 }
 898
 899 uint16_t VCMJitterBuffer::EstimatedLowSequenceNumber(
 900     const VCMFrameBuffer& frame) const {
 901   assert(frame.GetLowSeqNum() >= 0);
 902   if (frame.HaveFirstPacket())
 903     return frame.GetLowSeqNum();
 904
 905   // This estimate is not accurate if more than one packet with lower sequence
 906   // number is lost.
 907   return frame.GetLowSeqNum() - 1;
 908 }
 909
 910 uint16_t* VCMJitterBuffer::GetNackList(uint16_t* nack_list_size,
 911                                        bool* request_key_frame) {
 912   CriticalSectionScoped cs(crit_sect_);
 913   *request_key_frame = false;
 914   if (nack_mode_ == kNoNack) {
 915     *nack_list_size = 0;
 916     return NULL;
 917   }
 918   if (last_decoded_state_.in_initial_state()) {
 919     VCMFrameBuffer* next_frame =  NextFrame();
 920     const bool first_frame_is_key = next_frame &&
 921         next_frame->FrameType() == kVideoFrameKey &&
 922         next_frame->HaveFirstPacket();
 923     if (!first_frame_is_key) {
 924       bool have_non_empty_frame = decodable_frames_.end() != find_if(
 925           decodable_frames_.begin(), decodable_frames_.end(),
 926           HasNonEmptyState);
 927       if (!have_non_empty_frame) {
 928         have_non_empty_frame = incomplete_frames_.end() != find_if(
 929             incomplete_frames_.begin(), incomplete_frames_.end(),
 930             HasNonEmptyState);
 931       }
 932       bool found_key_frame = RecycleFramesUntilKeyFrame();
 933       if (!found_key_frame) {
 934         *request_key_frame = have_non_empty_frame;
 935         *nack_list_size = 0;
 936         return NULL;
 937       }
 938     }
 939   }
 940   if (TooLargeNackList()) {
 941     *request_key_frame = !HandleTooLargeNackList();
 942   }
 943   if (max_incomplete_time_ms_ > 0) {
 944     int non_continuous_incomplete_duration =
 945         NonContinuousOrIncompleteDuration();
 946     if (non_continuous_incomplete_duration > 90 * max_incomplete_time_ms_) {
 947       LOG_F(LS_WARNING) << "Too long non-decodable duration: "
 948                         << non_continuous_incomplete_duration << " > "
 949                         << 90 * max_incomplete_time_ms_;
 950       FrameList::reverse_iterator rit = find_if(incomplete_frames_.rbegin(),
 951           incomplete_frames_.rend(), IsKeyFrame);
 952       if (rit == incomplete_frames_.rend()) {
 953         // Request a key frame if we don't have one already.
 954         *request_key_frame = true;
 955         *nack_list_size = 0;
 956         return NULL;
 957       } else {
 958         // Skip to the last key frame. If it's incomplete we will start
 959         // NACKing it.
 960         // Note that the estimated low sequence number is correct for VP8
 961         // streams because only the first packet of a key frame is marked.
 962         last_decoded_state_.Reset();
 963         DropPacketsFromNackList(EstimatedLowSequenceNumber(*rit->second));
 964       }
 965     }
 966   }
 967   unsigned int i = 0;
 968   SequenceNumberSet::iterator it = missing_sequence_numbers_.begin();
 969   for (; it != missing_sequence_numbers_.end(); ++it, ++i) {
 970     nack_seq_nums_[i] = *it;
 971   }
 972   *nack_list_size = i;
 973   return &nack_seq_nums_[0];
 974 }
 975
 976 void VCMJitterBuffer::SetDecodeErrorMode(VCMDecodeErrorMode error_mode) {
 977   CriticalSectionScoped cs(crit_sect_);
 978   decode_error_mode_ = error_mode;
 979 }
 980
 981 VCMFrameBuffer* VCMJitterBuffer::NextFrame() const {
 982   if (!decodable_frames_.empty())
 983     return decodable_frames_.Front();
 984   if (!incomplete_frames_.empty())
 985     return incomplete_frames_.Front();
 986   return NULL;
 987 }
 988
 989 bool VCMJitterBuffer::UpdateNackList(uint16_t sequence_number) {
 990   if (nack_mode_ == kNoNack) {
 991     return true;
 992   }
 993   // Make sure we don't add packets which are already too old to be decoded.
 994   if (!last_decoded_state_.in_initial_state()) {
 995     latest_received_sequence_number_ = LatestSequenceNumber(
 996         latest_received_sequence_number_,
 997         last_decoded_state_.sequence_num());
 998   }
 999   if (IsNewerSequenceNumber(sequence_number,
1000                             latest_received_sequence_number_)) {
1001     // Push any missing sequence numbers to the NACK list.
1002     for (uint16_t i = latest_received_sequence_number_ + 1;
1003          IsNewerSequenceNumber(sequence_number, i); ++i) {
1004       missing_sequence_numbers_.insert(missing_sequence_numbers_.end(), i);
1005       TRACE_EVENT_INSTANT1("webrtc", "AddNack", "seqnum", i);
1006     }
1007     if (TooLargeNackList() && !HandleTooLargeNackList()) {
1008       LOG(LS_WARNING) << "Requesting key frame due to too large NACK list.";
1009       return false;
1010     }
1011     if (MissingTooOldPacket(sequence_number) &&
1012         !HandleTooOldPackets(sequence_number)) {
1013       LOG(LS_WARNING) << "Requesting key frame due to missing too old packets";
1014       return false;
1015     }
1016   } else {
1017     missing_sequence_numbers_.erase(sequence_number);
1018     TRACE_EVENT_INSTANT1("webrtc", "RemoveNack", "seqnum", sequence_number);
1019   }
1020   return true;
1021 }
1022
1023 bool VCMJitterBuffer::TooLargeNackList() const {
1024   return missing_sequence_numbers_.size() > max_nack_list_size_;
1025 }
1026
1027 bool VCMJitterBuffer::HandleTooLargeNackList() {
1028   // Recycle frames until the NACK list is small enough. It is likely cheaper to
1029   // request a key frame than to retransmit this many missing packets.
1030   LOG_F(LS_WARNING) << "NACK list has grown too large: "
1031                     << missing_sequence_numbers_.size() << " > "
1032                     << max_nack_list_size_;
1033   bool key_frame_found = false;
1034   while (TooLargeNackList()) {
1035     key_frame_found = RecycleFramesUntilKeyFrame();
1036   }
1037   return key_frame_found;
1038 }
1039
1040 bool VCMJitterBuffer::MissingTooOldPacket(
1041     uint16_t latest_sequence_number) const {
1042   if (missing_sequence_numbers_.empty()) {
1043     return false;
1044   }
1045   const uint16_t age_of_oldest_missing_packet = latest_sequence_number -
1046       *missing_sequence_numbers_.begin();
1047   // Recycle frames if the NACK list contains too old sequence numbers as
1048   // the packets may have already been dropped by the sender.
1049   return age_of_oldest_missing_packet > max_packet_age_to_nack_;
1050 }
1051
1052 bool VCMJitterBuffer::HandleTooOldPackets(uint16_t latest_sequence_number) {
1053   bool key_frame_found = false;
1054   const uint16_t age_of_oldest_missing_packet = latest_sequence_number -
1055       *missing_sequence_numbers_.begin();
1056   LOG_F(LS_WARNING) << "NACK list contains too old sequence numbers: "
1057                     << age_of_oldest_missing_packet << " > "
1058                     << max_packet_age_to_nack_;
1059   while (MissingTooOldPacket(latest_sequence_number)) {
1060     key_frame_found = RecycleFramesUntilKeyFrame();
1061   }
1062   return key_frame_found;
1063 }
1064
1065 void VCMJitterBuffer::DropPacketsFromNackList(
1066     uint16_t last_decoded_sequence_number) {
1067   // Erase all sequence numbers from the NACK list which we won't need any
1068   // longer.
1069   missing_sequence_numbers_.erase(missing_sequence_numbers_.begin(),
1070                                   missing_sequence_numbers_.upper_bound(
1071                                       last_decoded_sequence_number));
1072 }
1073
1074 int64_t VCMJitterBuffer::LastDecodedTimestamp() const {
1075   CriticalSectionScoped cs(crit_sect_);
1076   return last_decoded_state_.time_stamp();
1077 }
1078
1079 void VCMJitterBuffer::RenderBufferSize(uint32_t* timestamp_start,
1080                                        uint32_t* timestamp_end) {
1081   CriticalSectionScoped cs(crit_sect_);
1082   CleanUpOldOrEmptyFrames();
1083   *timestamp_start = 0;
1084   *timestamp_end = 0;
1085   if (decodable_frames_.empty()) {
1086     return;
1087   }
1088   *timestamp_start = decodable_frames_.Front()->TimeStamp();
1089   *timestamp_end = decodable_frames_.Back()->TimeStamp();
1090 }
1091
1092 VCMFrameBuffer* VCMJitterBuffer::GetEmptyFrame() {
1093   if (free_frames_.empty()) {
1094     if (!TryToIncreaseJitterBufferSize()) {
1095       return NULL;
1096     }
1097   }
1098   VCMFrameBuffer* frame = free_frames_.front();
1099   free_frames_.pop_front();
1100   return frame;
1101 }
1102
1103 bool VCMJitterBuffer::TryToIncreaseJitterBufferSize() {
1104   if (max_number_of_frames_ >= kMaxNumberOfFrames)
1105     return false;
1106   VCMFrameBuffer* new_frame = new VCMFrameBuffer();
1107   frame_buffers_[max_number_of_frames_] = new_frame;
1108   free_frames_.push_back(new_frame);
1109   ++max_number_of_frames_;
1110   TRACE_COUNTER1("webrtc", "JBMaxFrames", max_number_of_frames_);
1111   return true;
1112 }
1113
1114 // Recycle oldest frames up to a key frame, used if jitter buffer is completely
1115 // full.
1116 bool VCMJitterBuffer::RecycleFramesUntilKeyFrame() {
1117   // First release incomplete frames, and only release decodable frames if there
1118   // are no incomplete ones.
1119   FrameList::iterator key_frame_it;
1120   bool key_frame_found = false;
1121   int dropped_frames = 0;
1122   dropped_frames += incomplete_frames_.RecycleFramesUntilKeyFrame(
1123       &key_frame_it, &free_frames_);
1124   key_frame_found = key_frame_it != incomplete_frames_.end();
1125   if (dropped_frames == 0) {
1126     dropped_frames += decodable_frames_.RecycleFramesUntilKeyFrame(
1127         &key_frame_it, &free_frames_);
1128     key_frame_found = key_frame_it != decodable_frames_.end();
1129   }
1130   drop_count_ += dropped_frames;
1131   TRACE_EVENT_INSTANT0("webrtc", "JB::RecycleFramesUntilKeyFrame");
1132   if (key_frame_found) {
1133     LOG(LS_INFO) << "Found key frame while dropping frames.";
1134     // Reset last decoded state to make sure the next frame decoded is a key
1135     // frame, and start NACKing from here.
1136     last_decoded_state_.Reset();
1137     DropPacketsFromNackList(EstimatedLowSequenceNumber(*key_frame_it->second));
1138   } else if (decodable_frames_.empty()) {
1139     // All frames dropped. Reset the decoding state and clear missing sequence
1140     // numbers as we're starting fresh.
1141     last_decoded_state_.Reset();
1142     missing_sequence_numbers_.clear();
1143   }
1144   return key_frame_found;
1145 }
1146
1147 // Must be called under the critical section |crit_sect_|.
1148 void VCMJitterBuffer::CountFrame(const VCMFrameBuffer& frame) {
1149   if (!frame.GetCountedFrame()) {
1150     // Ignore ACK frames.
1151     incoming_frame_count_++;
1152   }
1153
1154   if (frame.FrameType() == kVideoFrameKey) {
1155     TRACE_EVENT_ASYNC_STEP0("webrtc", "Video",
1156                             frame.TimeStamp(), "KeyComplete");
1157   } else {
1158     TRACE_EVENT_ASYNC_STEP0("webrtc", "Video",
1159                             frame.TimeStamp(), "DeltaComplete");
1160   }
1161
1162   // Update receive statistics. We count all layers, thus when you use layers
1163   // adding all key and delta frames might differ from frame count.
1164   if (frame.IsSessionComplete()) {
1165     ++receive_statistics_[frame.FrameType()];
1166   }
1167 }
1168
1169 void VCMJitterBuffer::UpdateAveragePacketsPerFrame(int current_number_packets) {
1170   if (frame_counter_ > kFastConvergeThreshold) {
1171     average_packets_per_frame_ = average_packets_per_frame_
1172               * (1 - kNormalConvergeMultiplier)
1173             + current_number_packets * kNormalConvergeMultiplier;
1174   } else if (frame_counter_ > 0) {
1175     average_packets_per_frame_ = average_packets_per_frame_
1176               * (1 - kFastConvergeMultiplier)
1177             + current_number_packets * kFastConvergeMultiplier;
1178     frame_counter_++;
1179   } else {
1180     average_packets_per_frame_ = current_number_packets;
1181     frame_counter_++;
1182   }
1183 }
1184
1185 // Must be called under the critical section |crit_sect_|.
1186 void VCMJitterBuffer::CleanUpOldOrEmptyFrames() {
1187   drop_count_ +=
1188       decodable_frames_.CleanUpOldOrEmptyFrames(&last_decoded_state_,
1189           &free_frames_);
1190   drop_count_ +=
1191       incomplete_frames_.CleanUpOldOrEmptyFrames(&last_decoded_state_,
1192           &free_frames_);
1193   if (!last_decoded_state_.in_initial_state()) {
1194     DropPacketsFromNackList(last_decoded_state_.sequence_num());
1195   }
1196 }
1197
1198 // Must be called from within |crit_sect_|.
1199 bool VCMJitterBuffer::IsPacketRetransmitted(const VCMPacket& packet) const {
1200   return missing_sequence_numbers_.find(packet.seqNum) !=
1201       missing_sequence_numbers_.end();
1202 }
1203
1204 // Must be called under the critical section |crit_sect_|. Should never be
1205 // called with retransmitted frames, they must be filtered out before this
1206 // function is called.
1207 void VCMJitterBuffer::UpdateJitterEstimate(const VCMJitterSample& sample,
1208                                            bool incomplete_frame) {
1209   if (sample.latest_packet_time == -1) {
1210     return;
1211   }
1212   UpdateJitterEstimate(sample.latest_packet_time, sample.timestamp,
1213                        sample.frame_size, incomplete_frame);
1214 }
1215
1216 // Must be called under the critical section crit_sect_. Should never be
1217 // called with retransmitted frames, they must be filtered out before this
1218 // function is called.
1219 void VCMJitterBuffer::UpdateJitterEstimate(const VCMFrameBuffer& frame,
1220                                            bool incomplete_frame) {
1221   if (frame.LatestPacketTimeMs() == -1) {
1222     return;
1223   }
1224   // No retransmitted frames should be a part of the jitter
1225   // estimate.
1226   UpdateJitterEstimate(frame.LatestPacketTimeMs(), frame.TimeStamp(),
1227                        frame.Length(), incomplete_frame);
1228 }
1229
1230 // Must be called under the critical section |crit_sect_|. Should never be
1231 // called with retransmitted frames, they must be filtered out before this
1232 // function is called.
1233 void VCMJitterBuffer::UpdateJitterEstimate(
1234     int64_t latest_packet_time_ms,
1235     uint32_t timestamp,
1236     unsigned int frame_size,
1237     bool incomplete_frame) {
1238   if (latest_packet_time_ms == -1) {
1239     return;
1240   }
1241   int64_t frame_delay;
1242   bool not_reordered = inter_frame_delay_.CalculateDelay(timestamp,
1243                                                       &frame_delay,
1244                                                       latest_packet_time_ms);
1245   // Filter out frames which have been reordered in time by the network
1246   if (not_reordered) {
1247     // Update the jitter estimate with the new samples
1248     jitter_estimate_.UpdateEstimate(frame_delay, frame_size, incomplete_frame);
1249   }
1250 }
1251
1252 bool VCMJitterBuffer::WaitForRetransmissions() {
1253   if (nack_mode_ == kNoNack) {
1254     // NACK disabled -> don't wait for retransmissions.
1255     return false;
1256   }
1257   // Evaluate if the RTT is higher than |high_rtt_nack_threshold_ms_|, and in
1258   // that case we don't wait for retransmissions.
1259   if (high_rtt_nack_threshold_ms_ >= 0 &&
1260       rtt_ms_ >= static_cast<unsigned int>(high_rtt_nack_threshold_ms_)) {
1261     return false;
1262   }
1263   return true;
1264 }
1265 }  // namespace webrtc