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);

[imcheng, 2014/05/14 20:11:24]

What guarantees this?

[hubbe, 2014/05/14 21:46:16]

Hopefully the cast_receiver does.
I put it in here because some of the logic below assumes it.

+  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();

[imcheng, 2014/05/14 20:11:24]

Do you need to do another pop_front()? Comment above states ack every other
frame.

[imcheng, 2014/05/14 20:11:24]

Can ack_queue_ be empty at this point?

[hubbe, 2014/05/14 21:46:16]

What it means is that in slow-ack mode we ack delay acking like this:

We are asked to ack:
1     2     3     4     5     6     7
What we actually ack:
1           2           3           4

[hubbe, 2014/05/14 21:46:16]

No.
When we go into slow mode, we push one value on the queue.
After that we push one value every call and pull one value every other call. We
will have at least one value.

+  }
 
-    // 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