[EXPERIMENTAL] Generic stereo codec with index header sending merged frames

webrtc/modules/video_coding/frame_buffer2.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 44 matching lines @@
 FrameBuffer::~FrameBuffer() {}
 
 FrameBuffer::ReturnReason FrameBuffer::NextFrame(
     int64_t max_wait_time_ms,
     std::unique_ptr<FrameObject>* frame_out) {
   TRACE_EVENT0("webrtc", "FrameBuffer::NextFrame");
   int64_t latest_return_time_ms =
       clock_->TimeInMilliseconds() + max_wait_time_ms;
   int64_t wait_ms = max_wait_time_ms;
   int64_t now_ms = 0;
-
   do {
     now_ms = clock_->TimeInMilliseconds();
     {
       rtc::CritScope lock(&crit_);
       new_continuous_frame_event_.Reset();
-      if (stopped_)
+      if (stopped_) {
         return kStopped;
+      }
 
       wait_ms = max_wait_time_ms;
 
       // Need to hold |crit_| in order to use |frames_|, therefore we
       // set it here in the loop instead of outside the loop in order to not
       // acquire the lock unnecesserily.
       next_frame_it_ = frames_.end();
 
       // |frame_it| points to the first frame after the
       // |last_decoded_frame_it_|.
@@ skipping 72 matching lines @@
       // Sanity check for RTP timestamp monotonicity.
       if (last_decoded_frame_it_ != frames_.end()) {
         const FrameKey& last_decoded_frame_key = last_decoded_frame_it_->first;
         const FrameKey& frame_key = next_frame_it_->first;
 
         const bool frame_is_higher_spatial_layer_of_last_decoded_frame =
             last_decoded_frame_timestamp_ == frame->timestamp &&
             last_decoded_frame_key.picture_id == frame_key.picture_id &&
             last_decoded_frame_key.spatial_layer < frame_key.spatial_layer;
 
-        if (AheadOrAt(last_decoded_frame_timestamp_, frame->timestamp) &&
+        if (AheadOf(last_decoded_frame_timestamp_, frame->timestamp) &&
             !frame_is_higher_spatial_layer_of_last_decoded_frame) {
           // TODO(brandtr): Consider clearing the entire buffer when we hit
           // these conditions.
           LOG(LS_WARNING) << "Frame with (timestamp:picture_id:spatial_id) ("
                           << frame->timestamp << ":" << frame->picture_id << ":"
                           << static_cast<int>(frame->spatial_layer) << ")"
                           << " sent to decoder after frame with"
                           << " (timestamp:picture_id:spatial_id) ("
                           << last_decoded_frame_timestamp_ << ":"
                           << last_decoded_frame_key.picture_id << ":"
@@ skipping 146 matching lines @@
   // Test if inserting this frame would cause the order of the frames to become
   // ambiguous (covering more than half the interval of 2^16). This can happen
   // when the picture id make large jumps mid stream.
   if (!frames_.empty() &&
       key < frames_.begin()->first &&
       frames_.rbegin()->first < key) {
     LOG(LS_WARNING) << "A jump in picture id was detected, clearing buffer.";
     ClearFramesAndHistory();
     last_continuous_picture_id = -1;
   }
-
   auto info = frames_.insert(std::make_pair(key, FrameInfo())).first;
 
   if (info->second.frame) {
     LOG(LS_WARNING) << "Frame with (picture_id:spatial_id) (" << key.picture_id
                     << ":" << static_cast<int>(key.spatial_layer)
                     << ") already inserted, dropping frame.";
     return last_continuous_picture_id;
   }
 
   if (!UpdateFrameInfoWithIncomingFrame(*frame, info))
@@ skipping 52 matching lines @@
 }
 
 void FrameBuffer::PropagateDecodability(const FrameInfo& info) {
   TRACE_EVENT0("webrtc", "FrameBuffer::PropagateDecodability");
   RTC_CHECK(info.num_dependent_frames < FrameInfo::kMaxNumDependentFrames);
   for (size_t d = 0; d < info.num_dependent_frames; ++d) {
     auto ref_info = frames_.find(info.dependent_frames[d]);
     RTC_DCHECK(ref_info != frames_.end());
     // TODO(philipel): Look into why we've seen this happen.
     if (ref_info != frames_.end()) {
-      RTC_DCHECK_GT(ref_info->second.num_missing_decodable, 0U);
+      // RTC_DCHECK_GT(ref_info->second.num_missing_decodable, 0U);
       --ref_info->second.num_missing_decodable;
     }
   }
 }
 
 void FrameBuffer::AdvanceLastDecodedFrame(FrameMap::iterator decoded) {
   TRACE_EVENT0("webrtc", "FrameBuffer::AdvanceLastDecodedFrame");
   if (last_decoded_frame_it_ == frames_.end()) {
     last_decoded_frame_it_ = frames_.begin();
   } else {
@@ skipping 131 matching lines @@
   frames_.clear();
   last_decoded_frame_it_ = frames_.end();
   last_continuous_frame_it_ = frames_.end();
   next_frame_it_ = frames_.end();
   num_frames_history_ = 0;
   num_frames_buffered_ = 0;
 }
 
 }  // namespace video_coding
 }  // namespace webrtc