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

media/cast/sender/audio_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/audio_sender.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/cast_defines.h"
@@ skipping 18 matching lines @@
                          CastTransportSender* const transport_sender)
     : FrameSender(
         cast_environment,
         transport_sender,
         base::TimeDelta::FromMilliseconds(audio_config.rtcp_interval),
         audio_config.frequency,
         audio_config.ssrc,
         kAudioFrameRate * 2.0, // We lie to increase max outstanding frames.
         audio_config.target_playout_delay),
       configured_encoder_bitrate_(audio_config.bitrate),
+      samples_in_encoder_(0),
       weak_factory_(this) {
   cast_initialization_status_ = STATUS_AUDIO_UNINITIALIZED;
   VLOG(1) << "max_unacked_frames " << max_unacked_frames_;
   DCHECK_GT(max_unacked_frames_, 0);
 
   if (!audio_config.use_external_encoder) {
     audio_encoder_.reset(
         new AudioEncoder(cast_environment,
                          audio_config.channels,
                          audio_config.frequency,
@@ skipping 28 matching lines @@
 
 void AudioSender::InsertAudio(scoped_ptr<AudioBus> audio_bus,
                               const base::TimeTicks& recorded_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (cast_initialization_status_ != STATUS_AUDIO_INITIALIZED) {
     NOTREACHED();
     return;
   }
   DCHECK(audio_encoder_.get()) << "Invalid internal state";
 
+  // TODO(miu): An |audio_bus| that represents more duration than a single
+  // frame's duration can defeat our logic here, causing too much data to become
+  // enqueued.  This will be addressed in a soon-upcoming change.
   if (ShouldDropNextFrame(recorded_time)) {
     VLOG(1) << "Dropping frame due to too many frames currently in-flight.";
     return;
   }
 
+  UpdateEncoderBacklogStats(+audio_bus->frames());

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

What's with the '+'?

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

Readability thing.  Just a helper to see that this is where the backlog gets
incremented.  The complier treats it as a no-op.

+
   audio_encoder_->InsertAudio(audio_bus.Pass(), recorded_time);
 }
 
+void AudioSender::UpdateEncoderBacklogStats(int samples_added) {
+  samples_in_encoder_ += samples_added;
+  DCHECK_GE(samples_in_encoder_, 0);
+  frames_in_encoder_ =
+      samples_in_encoder_ / audio_encoder_->GetSamplesPerFrame();
+}
+
 void AudioSender::SendEncodedAudioFrame(
-    scoped_ptr<EncodedFrame> encoded_frame) {
+    scoped_ptr<EncodedFrame> encoded_frame,
+    int samples_skipped) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
+  UpdateEncoderBacklogStats(
+      -(audio_encoder_->GetSamplesPerFrame() + samples_skipped));
+
   const uint32 frame_id = encoded_frame->frame_id;
 
   const bool is_first_frame_to_be_sent = last_send_time_.is_null();
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   last_sent_frame_id_ = frame_id;
   // If this is the first frame about to be sent, fake the value of
   // |latest_acked_frame_id_| to indicate the receiver starts out all caught up.
   // Also, schedule the periodic frame re-send checks.
   if (is_first_frame_to_be_sent) {
     latest_acked_frame_id_ = frame_id - 1;
@@ skipping 86 matching lines @@
     std::vector<uint32> cancel_sending_frames;
     while (latest_acked_frame_id_ != cast_feedback.ack_frame_id) {
       latest_acked_frame_id_++;
       cancel_sending_frames.push_back(latest_acked_frame_id_);
     }
     transport_sender_->CancelSendingFrames(ssrc_, cancel_sending_frames);
     latest_acked_frame_id_ = cast_feedback.ack_frame_id;
   }
 }
 
-bool AudioSender::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);
-    }
-  }
-  VLOG(2) << frames_in_flight
-          << " frames in flight; last sent: " << last_sent_frame_id_
-          << "; latest acked: " << latest_acked_frame_id_
-          << "; 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_;
-}
-
 }  // namespace cast
 }  // namespace media