Implement adaptive target delay extension

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"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/sender/audio_encoder.h"
 
 namespace media {
 namespace cast {
 namespace {
 
 const int kNumAggressiveReportsSentAtStart = 100;
 const int kMinSchedulingDelayMs = 1;
 
 // TODO(miu): This should be specified in AudioSenderConfig, but currently it is
 // fixed to 100 FPS (i.e., 10 ms per frame), and AudioEncoder assumes this as
 // well.
 const int kAudioFrameRate = 100;
 
-// Helper function to compute the maximum unacked audio frames that is sent.
-int GetMaxUnackedFrames(base::TimeDelta target_delay) {
-  // As long as it doesn't go over |kMaxUnackedFrames|, it is okay to send more
-  // audio data than the target delay would suggest. Audio packets are tiny and
-  // receiver has the ability to drop any one of the packets.
-  // We send up to three times of the target delay of audio frames.
-  int frames =
-      1 + 2 * target_delay * kAudioFrameRate / base::TimeDelta::FromSeconds(1);
-  return std::min(kMaxUnackedFrames, frames);
-}
 }  // namespace
 
 AudioSender::AudioSender(scoped_refptr<CastEnvironment> cast_environment,
                          const AudioSenderConfig& audio_config,
                          CastTransportSender* const transport_sender)
     : FrameSender(
         cast_environment,
         transport_sender,
         base::TimeDelta::FromMilliseconds(audio_config.rtcp_interval),
         audio_config.frequency,
-        audio_config.ssrc),
-      target_playout_delay_(audio_config.target_playout_delay),
-      max_unacked_frames_(GetMaxUnackedFrames(target_playout_delay_)),
+        audio_config.ssrc,
+        kAudioFrameRate * 2.0, // We lie to increase max outstanding frames.
+        audio_config.target_playout_delay),
       configured_encoder_bitrate_(audio_config.bitrate),
       num_aggressive_rtcp_reports_sent_(0),
       last_sent_frame_id_(0),
       latest_acked_frame_id_(0),
       duplicate_ack_counter_(0),
       cast_initialization_status_(STATUS_AUDIO_UNINITIALIZED),
       weak_factory_(this) {
   VLOG(1) << "max_unacked_frames " << max_unacked_frames_;
   DCHECK_GT(max_unacked_frames_, 0);
 
@@ skipping 86 matching lines @@
   if (num_aggressive_rtcp_reports_sent_ < kNumAggressiveReportsSentAtStart) {
     // SendRtcpReport() will schedule future reports to be made if this is the
     // last "aggressive report."
     ++num_aggressive_rtcp_reports_sent_;
     const bool is_last_aggressive_report =
         (num_aggressive_rtcp_reports_sent_ == kNumAggressiveReportsSentAtStart);
     VLOG_IF(1, is_last_aggressive_report) << "Sending last aggressive report.";
     SendRtcpReport(is_last_aggressive_report);
   }
 
+  if (send_target_playout_delay_) {
+    encoded_frame->new_playout_delay_ms =
+        target_playout_delay_.InMilliseconds();
+  }
   transport_sender_->InsertCodedAudioFrame(*encoded_frame);
 }
 
 void AudioSender::ScheduleNextResendCheck() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(!last_send_time_.is_null());
   base::TimeDelta time_to_next =
       last_send_time_ - cast_environment_->Clock()->NowTicks() +
       target_playout_delay_;
   time_to_next = std::max(
@@ skipping 102 matching lines @@
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(!last_send_time_.is_null());
   VLOG(1) << "Resending last packet of frame " << last_sent_frame_id_
           << " to kick-start.";
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   transport_sender_->ResendFrameForKickstart(ssrc_, last_sent_frame_id_);
 }
 
 }  // namespace cast
 }  // namespace media