[Cast] Track audio queued in encoder; account for it in ShouldDropNextFrame().

media/cast/sender/frame_sender.cc

 // Copyright 2014 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/sender/frame_sender.h"
 
 namespace media {
 namespace cast {
 namespace {
 const int kMinSchedulingDelayMs = 1;
 }  // namespace
 
 FrameSender::FrameSender(scoped_refptr<CastEnvironment> cast_environment,
                          CastTransportSender* const transport_sender,
                          base::TimeDelta rtcp_interval,
                          int rtp_timebase,
                          uint32 ssrc,
                          double max_frame_rate,
                          base::TimeDelta playout_delay)
     : cast_environment_(cast_environment),
       transport_sender_(transport_sender),
       ssrc_(ssrc),
       rtt_available_(false),
       rtcp_interval_(rtcp_interval),
       max_frame_rate_(max_frame_rate),
+      frames_in_encoder_(0),
       num_aggressive_rtcp_reports_sent_(0),
       last_sent_frame_id_(0),
       latest_acked_frame_id_(0),
       duplicate_ack_counter_(0),
       rtp_timebase_(rtp_timebase),
       weak_factory_(this) {
   DCHECK_GT(rtp_timebase_, 0);
   SetTargetPlayoutDelay(playout_delay);
   send_target_playout_delay_ = false;
   memset(frame_rtp_timestamps_, 0, sizeof(frame_rtp_timestamps_));
@@ skipping 115 matching lines @@
 }
 
 base::TimeTicks FrameSender::GetRecordedReferenceTime(uint32 frame_id) const {
   return frame_reference_times_[frame_id % arraysize(frame_reference_times_)];
 }
 
 RtpTimestamp FrameSender::GetRecordedRtpTimestamp(uint32 frame_id) const {
   return frame_rtp_timestamps_[frame_id % arraysize(frame_rtp_timestamps_)];
 }
 
+bool FrameSender::ShouldDropNextFrame(base::TimeTicks capture_time) const {
+  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
+  int frames_in_flight = 0;
+  base::TimeDelta duration_in_flight;
+  if (!last_send_time_.is_null()) {
+    frames_in_flight =
+        static_cast<int32>(last_sent_frame_id_ - latest_acked_frame_id_);
+    if (frames_in_flight > 0) {
+      const uint32 oldest_unacked_frame_id = latest_acked_frame_id_ + 1;
+      duration_in_flight =
+          capture_time - GetRecordedReferenceTime(oldest_unacked_frame_id);
+    }
+  }
+  frames_in_flight += frames_in_encoder_;
+  VLOG(2) << frames_in_flight
+          << " frames in flight; last sent: " << last_sent_frame_id_
+          << "; latest acked: " << latest_acked_frame_id_
+          << "; frames in encoder: " << frames_in_encoder_
+          << "; duration in flight: "
+          << duration_in_flight.InMicroseconds() << " usec ("
+          << (target_playout_delay_ > base::TimeDelta() ?
+                  100 * duration_in_flight / target_playout_delay_ :
+                  kint64max) << "%)";
+  return frames_in_flight >= max_unacked_frames_ ||
+      duration_in_flight >= target_playout_delay_;

[Alpha Left Google, 2014/09/05 20:02:07]

What's the reason of choosing "duration_in_flight >= target_playout_delay_" over
"duration_in_flight + frame_duration >= target_playout_delay_"?

[miu, 2014/09/05 20:40:27]

You can ignore this:

1. hubbe@ has already moved this method in his change, so I will undo these LOC
and merge after his change commits.

2. There's no code change here.  This code method was moved from VideoSender
unchanged.

3. In a later change, I've rewritten this method with better logic.  We should
spend our time discussing that logic, and not this old logic.  ;-)

+}
+
 }  // namespace cast
 }  // namespace media