Cast: Only ACK decodable frames

media/cast/framer/cast_message_builder.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cast/framer/cast_message_builder.h"
 
 #include "media/cast/cast_defines.h"
 
 namespace media {
 namespace cast {
 
 CastMessageBuilder::CastMessageBuilder(
     base::TickClock* clock,
     RtpPayloadFeedback* incoming_payload_feedback,
     FrameIdMap* frame_id_map,
     uint32 media_ssrc,
     bool decoder_faster_than_max_frame_rate,
     int max_unacked_frames)
     : clock_(clock),
       cast_feedback_(incoming_payload_feedback),
       frame_id_map_(frame_id_map),
       media_ssrc_(media_ssrc),
       decoder_faster_than_max_frame_rate_(decoder_faster_than_max_frame_rate),
       max_unacked_frames_(max_unacked_frames),
       cast_msg_(media_ssrc),
-      waiting_for_key_frame_(true),
       slowing_down_ack_(false),
       acked_last_frame_(true),
       last_acked_frame_id_(kStartFrameId) {
   cast_msg_.ack_frame_id_ = kStartFrameId;
 }
 
 CastMessageBuilder::~CastMessageBuilder() {}
 
-void CastMessageBuilder::CompleteFrameReceived(uint32 frame_id,
-                                               bool is_key_frame) {
+void CastMessageBuilder::CompleteFrameReceived(uint32 frame_id) {
+  DCHECK_GE(static_cast<int32>(frame_id - last_acked_frame_id_), 0);
+  VLOG(2) << "CompleteFrameReceived: " << frame_id;
   if (last_update_time_.is_null()) {
     // Our first update.
     last_update_time_ = clock_->NowTicks();
   }
-  if (waiting_for_key_frame_) {
-    if (!is_key_frame) {
-      // Ignore that we have received this complete frame since we are
-      // waiting on a key frame.
-      return;
-    }
-    waiting_for_key_frame_ = false;
-    cast_msg_.missing_frames_and_packets_.clear();
-    cast_msg_.ack_frame_id_ = frame_id;
-    last_update_time_ = clock_->NowTicks();
-    // We might have other complete frames waiting after we receive the last
-    // packet in the key-frame.
-    UpdateAckMessage();
-  } else {
-    if (!UpdateAckMessage())
-      return;
 
-    BuildPacketList();
+  if (!UpdateAckMessage(frame_id)) {
+    return;
   }
+  BuildPacketList();
+
   // Send cast message.
   VLOG(2) << "Send cast message Ack:" << static_cast<int>(frame_id);
   cast_feedback_->CastFeedback(cast_msg_);
 }
 
-bool CastMessageBuilder::UpdateAckMessage() {
+bool CastMessageBuilder::UpdateAckMessage(uint32 frame_id) {
   if (!decoder_faster_than_max_frame_rate_) {
     int complete_frame_count = frame_id_map_->NumberOfCompleteFrames();
     if (complete_frame_count > max_unacked_frames_) {
       // We have too many frames pending in our framer; slow down ACK.
-      slowing_down_ack_ = true;
+      if (!slowing_down_ack_) {
+        slowing_down_ack_ = true;
+        ack_queue_.push_back(last_acked_frame_id_);
+      }
     } else if (complete_frame_count <= 1) {
       // We are down to one or less frames in our framer; ACK normally.
       slowing_down_ack_ = false;
+      ack_queue_.clear();
     }
   }
+
   if (slowing_down_ack_) {
     // We are slowing down acknowledgment by acknowledging every other frame.
-    if (acked_last_frame_) {
-      acked_last_frame_ = false;
-    } else {
-      acked_last_frame_ = true;
-      last_acked_frame_id_++;
-      // Note: frame skipping and slowdown ACK is not supported at the same
-      // time; and it's not needed since we can skip frames to catch up.
+    // Note: frame skipping and slowdown ACK is not supported at the same
+    // time; and it's not needed since we can skip frames to catch up.
+    if (!ack_queue_.empty() && ack_queue_.back() == frame_id) {
+      return false;
     }
-  } else {
-    uint32 frame_id = frame_id_map_->LastContinuousFrame();
+    ack_queue_.push_back(frame_id);
+    if (!acked_last_frame_) {
+      ack_queue_.pop_front();
+    }
+    frame_id = ack_queue_.front();
+  }
 
-    // Is it a new frame?
-    if (last_acked_frame_id_ == frame_id)
-      return false;
-
-    last_acked_frame_id_ = frame_id;
-    acked_last_frame_ = true;
+  acked_last_frame_ = false;
+  // Is it a new frame?
+  if (last_acked_frame_id_ == frame_id) {
+    return false;
   }
+  acked_last_frame_ = true;
+  last_acked_frame_id_ = frame_id;
   cast_msg_.ack_frame_id_ = last_acked_frame_id_;
   cast_msg_.missing_frames_and_packets_.clear();
   last_update_time_ = clock_->NowTicks();
   return true;
 }
 
 bool CastMessageBuilder::TimeToSendNextCastMessage(
     base::TimeTicks* time_to_send) {
   // We haven't received any packets.
   if (last_update_time_.is_null() && frame_id_map_->Empty())
     return false;
 
   *time_to_send = last_update_time_ + base::TimeDelta::FromMilliseconds(
                                           kCastMessageUpdateIntervalMs);
   return true;
 }
 
 void CastMessageBuilder::UpdateCastMessage() {
   RtcpCastMessage message(media_ssrc_);
   if (!UpdateCastMessageInternal(&message))
     return;
 
   // Send cast message.
   cast_feedback_->CastFeedback(message);
 }
 
 void CastMessageBuilder::Reset() {
-  waiting_for_key_frame_ = true;
   cast_msg_.ack_frame_id_ = kStartFrameId;
   cast_msg_.missing_frames_and_packets_.clear();
   time_last_nacked_map_.clear();
 }
 
 bool CastMessageBuilder::UpdateCastMessageInternal(RtcpCastMessage* message) {
   if (last_update_time_.is_null()) {
     if (!frame_id_map_->Empty()) {
       // We have received packets.
       last_update_time_ = clock_->NowTicks();
     }
     return false;
   }
   // Is it time to update the cast message?
   base::TimeTicks now = clock_->NowTicks();
   if (now - last_update_time_ <
       base::TimeDelta::FromMilliseconds(kCastMessageUpdateIntervalMs)) {
     return false;
   }
   last_update_time_ = now;
 
-  UpdateAckMessage();  // Needed to cover when a frame is skipped.
+  // Needed to cover when a frame is skipped.
+  UpdateAckMessage(last_acked_frame_id_);
   BuildPacketList();
   message->Copy(cast_msg_);
   return true;
 }
 
 void CastMessageBuilder::BuildPacketList() {
   base::TimeTicks now = clock_->NowTicks();
 
   // Clear message NACK list.
   cast_msg_.missing_frames_and_packets_.clear();
@@ skipping 32 matching lines @@
     } else {
       time_last_nacked_map_[next_expected_frame_id] = now;
       missing.insert(kRtcpCastAllPacketsLost);
       cast_msg_.missing_frames_and_packets_[next_expected_frame_id] = missing;
     }
   }
 }
 
 }  //  namespace cast
 }  //  namespace media