Remove Mac input audio restart mechanism and reduce time until startup success check.

media/audio/mac/audio_low_latency_input_mac.cc

 // Copyright (c) 2012 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/audio/mac/audio_low_latency_input_mac.h"
 
 #include <CoreServices/CoreServices.h>
 #include <mach/mach.h>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 11 matching lines @@
 
 namespace media {
 
 // Number of blocks of buffers used in the |fifo_|.
 const int kNumberOfBlocksBufferInFifo = 2;
 
 // Max length of sequence of TooManyFramesToProcessError errors.
 // The stream will be stopped as soon as this time limit is passed.
 const int kMaxErrorTimeoutInSeconds = 1;
 
-// A repeating timer is created and started in Start() and it triggers calls
-// to CheckIfInputStreamIsAlive() where we do periodic checks to see if the
-// input data callback sequence is active or not. If the stream seems dead,
-// up to |kMaxNumberOfRestartAttempts| restart attempts tries to bring the
-// stream back to life.
-const int kCheckInputIsAliveTimeInSeconds = 5;
-
-// Number of restart indications required to actually trigger a restart
-// attempt.
-const int kNumberOfIndicationsToTriggerRestart = 1;
-
-// Max number of times we try to restart a stream when it has been categorized
-// as dead. Note that we can do many restarts during an audio session and this
-// limitation is per detected problem. Once a restart has succeeded, a new
-// sequence of |kMaxNumberOfRestartAttempts| number of restart attempts can be
-// done.
-const int kMaxNumberOfRestartAttempts = 1;
-
 // A one-shot timer is created and started in Start() and it triggers
 // CheckInputStartupSuccess() after this amount of time. UMA stats marked
 // Media.Audio.InputStartupSuccessMac is then updated where true is added
-// if input callbacks have started, and false otherwise. Note that the value
-// is larger than |kCheckInputIsAliveTimeInSeconds| to ensure that at least one
-// restart attempt can be done before storing the result.
-const int kInputCallbackStartTimeoutInSeconds =
-    kCheckInputIsAliveTimeInSeconds + 3;
+// if input callbacks have started, and false otherwise.
+const int kInputCallbackStartTimeoutInSeconds = 5;
 
 // Returns true if the format flags in |format_flags| has the "non-interleaved"
 // flag (kAudioFormatFlagIsNonInterleaved) cleared (set to 0).
 static bool FormatIsInterleaved(UInt32 format_flags) {
   return !(format_flags & kAudioFormatFlagIsNonInterleaved);
 }
 
 // Converts the 32-bit non-terminated 4 byte string into an std::string.
 // Example: code=1735354734 <=> 'goin' <=> kAudioDevicePropertyDeviceIsRunning.
 static std::string FourCharFormatCodeToString(UInt32 code) {
@@ skipping 180 matching lines @@
       number_of_frames_provided_(0),
       io_buffer_frame_size_(0),
       sink_(nullptr),
       audio_unit_(0),
       input_device_id_(audio_device_id),
       hardware_latency_frames_(0),
       number_of_channels_in_frame_(0),
       fifo_(input_params.channels(),
             number_of_frames_,
             kNumberOfBlocksBufferInFifo),
+      got_input_callback_(false),
       input_callback_is_active_(false),
       start_was_deferred_(false),
       buffer_size_was_changed_(false),
       audio_unit_render_has_worked_(false),
       device_listener_is_active_(false),
       last_sample_time_(0.0),
       last_number_of_frames_(0),
       total_lost_frames_(0),
       largest_glitch_frames_(0),
       glitches_detected_(0),
-      number_of_restart_indications_(0),
-      number_of_restart_attempts_(0),
-      total_number_of_restart_attempts_(0),
       log_callback_(log_callback),
       weak_factory_(this) {
   DCHECK(manager_);
   CHECK(!log_callback_.Equals(AudioManager::LogCallback()));
 
   // Set up the desired (output) format specified by the client.
   format_.mSampleRate = input_params.sample_rate();
   format_.mFormatID = kAudioFormatLinearPCM;
   format_.mFormatFlags =
       kLinearPCMFormatFlagIsPacked | kLinearPCMFormatFlagIsSignedInteger;
@@ skipping 255 matching lines @@
                                         base::Unretained(this), callback));
     manager_->GetTaskRunner()->PostDelayedTask(
         FROM_HERE, deferred_start_cb_.callback(),
         base::TimeDelta::FromSeconds(
             AudioManagerMac::kStartDelayInSecsForPowerEvents));
     return;
   }
 
   sink_ = callback;
   last_success_time_ = base::TimeTicks::Now();
-  last_callback_time_ = base::TimeTicks::Now();
   audio_unit_render_has_worked_ = false;
   StartAgc();
   OSStatus result = AudioOutputUnitStart(audio_unit_);
   OSSTATUS_DLOG_IF(ERROR, result != noErr, result)
       << "Failed to start acquiring data";
   if (result != noErr) {
     Stop();
     return;
   }
   DCHECK(IsRunning()) << "Audio unit started OK but is not yet running";
 
   // For UMA stat purposes, start a one-shot timer which detects when input
   // callbacks starts indicating if input audio recording starts as intended.
   // CheckInputStartupSuccess() will check if |input_callback_is_active_| is
   // true when the timer expires.
   input_callback_timer_.reset(new base::OneShotTimer());
   input_callback_timer_->Start(
       FROM_HERE,
       base::TimeDelta::FromSeconds(kInputCallbackStartTimeoutInSeconds), this,
       &AUAudioInputStream::CheckInputStartupSuccess);
   DCHECK(input_callback_timer_->IsRunning());
-
-  // Also create and start a timer that provides periodic callbacks used to
-  // monitor if the input stream is alive or not.
-  check_alive_timer_.reset(new base::RepeatingTimer());
-  check_alive_timer_->Start(
-      FROM_HERE, base::TimeDelta::FromSeconds(kCheckInputIsAliveTimeInSeconds),
-      this, &AUAudioInputStream::CheckIfInputStreamIsAlive);
-  DCHECK(check_alive_timer_->IsRunning());
 }
 
 void AUAudioInputStream::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
   deferred_start_cb_.Cancel();
   DVLOG(1) << "Stop";
   StopAgc();
-  if (check_alive_timer_ != nullptr) {
-    check_alive_timer_->Stop();
-    check_alive_timer_.reset();
-  }
   if (input_callback_timer_ != nullptr) {
     input_callback_timer_->Stop();
     input_callback_timer_.reset();
   }
 
   if (audio_unit_ != nullptr) {
     // Stop the I/O audio unit.
     OSStatus result = AudioOutputUnitStop(audio_unit_);
     DCHECK_EQ(result, noErr);
     // Add a DCHECK here just in case. AFAIK, the call to AudioOutputUnitStop()
     // seems to set this state synchronously, hence it should always report
     // false after a successful call.
     DCHECK(!IsRunning()) << "Audio unit is stopped but still running";
 
     // Reset the audio unit’s render state. This function clears memory.
     // It does not allocate or free memory resources.
     result = AudioUnitReset(audio_unit_, kAudioUnitScope_Global, 0);
     DCHECK_EQ(result, noErr);
     OSSTATUS_DLOG_IF(ERROR, result != noErr, result)
         << "Failed to stop acquiring data";
   }
 
   SetInputCallbackIsActive(false);
   ReportAndResetStats();
   sink_ = nullptr;
   fifo_.Clear();
   io_buffer_frame_size_ = 0;
+  got_input_callback_ = false;
 }
 
 void AUAudioInputStream::Close() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "Close";
+
   // It is valid to call Close() before calling open or Start().
   // It is also valid to call Close() after Start() has been called.
   Stop();
+
   // Uninitialize and dispose the audio unit.
   CloseAudioUnit();
+
   // Disable the listener for device property changes.
   DeRegisterDeviceChangeListener();
+
   // Add more UMA stats but only if AGC was activated, i.e. for e.g. WebRTC
   // audio input streams.
   if (GetAutomaticGainControl()) {
     // Check if any device property changes are added by filtering out a
     // selected set of the |device_property_changes_map_| map. Add UMA stats
     // if valuable data is found.
     AddDevicePropertyChangesToUMA(false);
     // Log whether call to Start() was deferred or not. To be compared with
     // Media.Audio.InputStartWasDeferredMac which logs the same value but only
     // when input audio fails to start.
     UMA_HISTOGRAM_BOOLEAN("Media.Audio.InputStartWasDeferredAudioWorkedMac",
                           start_was_deferred_);
     // Log if a change of I/O buffer size was required. To be compared with
     // Media.Audio.InputBufferSizeWasChangedMac which logs the same value but
     // only when input audio fails to start.
     UMA_HISTOGRAM_BOOLEAN("Media.Audio.InputBufferSizeWasChangedAudioWorkedMac",
                           buffer_size_was_changed_);
-    // Logs the total number of times RestartAudio() has been called.
-    DVLOG(1) << "Total number of restart attempts: "
-             << total_number_of_restart_attempts_;
-    UMA_HISTOGRAM_COUNTS_1000("Media.Audio.InputRestartAttemptsMac",
-                              total_number_of_restart_attempts_);
-    // TODO(henrika): possibly add more values here...
   }
+
   // Inform the audio manager that we have been closed. This will cause our
   // destruction.
   manager_->ReleaseInputStream(this);
 }
 
 double AUAudioInputStream::GetMaxVolume() {
   // Verify that we have a valid device.
   if (input_device_id_ == kAudioObjectUnknown) {
     NOTREACHED() << "Device ID is unknown";
     return 0.0;
@@ skipping 151 matching lines @@
   return self->OnDataIsAvailable(flags, time_stamp, bus_number,
                                  number_of_frames);
 }
 
 OSStatus AUAudioInputStream::OnDataIsAvailable(
     AudioUnitRenderActionFlags* flags,
     const AudioTimeStamp* time_stamp,
     UInt32 bus_number,
     UInt32 number_of_frames) {
   TRACE_EVENT0("audio", "AUAudioInputStream::OnDataIsAvailable");
-  // Update |last_callback_time_| on the main browser thread. Its value is used
-  // by CheckIfInputStreamIsAlive() to detect if the stream is dead or alive.
-  manager_->GetTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&AUAudioInputStream::UpdateDataCallbackTimeOnMainThread,
-                 weak_factory_.GetWeakPtr(), base::TimeTicks::Now()));
 
-  // Indicate that input callbacks have started on the internal AUHAL IO
-  // thread. The |input_callback_is_active_| member is read from the creating
-  // thread when a timer fires once and set to false in Stop() on the same
-  // thread. It means that this thread is the only writer of
-  // |input_callback_is_active_| once the tread starts and it should therefore
-  // be safe to modify.
-  SetInputCallbackIsActive(true);
+  // Indicate that input callbacks have started.
+  if (!got_input_callback_) {
+    got_input_callback_ = true;
+    SetInputCallbackIsActive(true);
+  }
 
   // Update the |mDataByteSize| value in the audio_buffer_list() since
   // |number_of_frames| can be changed on the fly.
   // |mDataByteSize| needs to be exactly mapping to |number_of_frames|,
   // otherwise it will put CoreAudio into bad state and results in
   // AudioUnitRender() returning -50 for the new created stream.
   // We have also seen kAudioUnitErr_TooManyFramesToProcess (-10874) and
   // kAudioUnitErr_CannotDoInCurrentContext (-10863) as error codes.
   // See crbug/428706 for details.
   UInt32 new_size = number_of_frames * format_.mBytesPerFrame;
@@ skipping 375 matching lines @@
                           input_callback_is_active);
     DVLOG(1) << "input_callback_is_active: " << input_callback_is_active;
     if (!input_callback_is_active) {
       // Now when we know that startup has failed for some reason, add extra
       // UMA stats in an attempt to figure out the exact reason.
       AddHistogramsForFailedStartup();
     }
   }
 }
 
-void AUAudioInputStream::UpdateDataCallbackTimeOnMainThread(
-    base::TimeTicks now_tick) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  last_callback_time_ = now_tick;
-}
-
-void AUAudioInputStream::CheckIfInputStreamIsAlive() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  // Avoid checking stream state if we are suspended.
-  if (manager_->IsSuspending())
-    return;
-  // Restrict usage of the restart mechanism to "AGC streams" only.
-  // TODO(henrika): if the restart scheme works well, we might include it
-  // for all types of input streams.
-  if (!GetAutomaticGainControl())
-    return;
-
-  // Clear this counter here when audio is active instead of in Start(),
-  // otherwise it would be cleared at each restart attempt and that would break
-  // the current design where only a certain number of restart attempts is
-  // allowed.
-  if (GetInputCallbackIsActive())
-    number_of_restart_attempts_ = 0;
-
-  // Measure time since last callback. |last_callback_time_| is set the first
-  // time in Start() and then updated in each data callback, hence if
-  // |time_since_last_callback| is large (>1) and growing for each check, the
-  // callback sequence has stopped. A typical value under normal/working
-  // conditions is a few milliseconds.
-  base::TimeDelta time_since_last_callback =
-      base::TimeTicks::Now() - last_callback_time_;
-  DVLOG(2) << "time since last callback: "
-           << time_since_last_callback.InSecondsF();
-
-  // Increase a counter if it has been too long since the last data callback.
-  // A non-zero value of this counter is a strong indication of a "dead" input
-  // stream. Reset the same counter if the stream is alive.
-  if (time_since_last_callback.InSecondsF() >
-      0.5 * kCheckInputIsAliveTimeInSeconds) {
-    ++number_of_restart_indications_;
-  } else {
-    number_of_restart_indications_ = 0;
-  }
-
-  // Restart the audio stream if two conditions are met. First, the number of
-  // restart indicators must be larger than a threshold, and secondly, only a
-  // fixed number of restart attempts is allowed.
-  // Note that, the threshold is different depending on if the stream is seen
-  // as dead directly at the first call to Start() (i.e. it has never started)
-  // or if the stream has started OK at least once but then stopped for some
-  // reason (e.g by placing the device in sleep mode). One restart indication
-  // is sufficient for the first case (threshold is zero), while a larger value
-  // (threshold > 0) is required for the second case to avoid false alarms when
-  // e.g. resuming from a suspended state.
-  const size_t restart_threshold =
-      GetInputCallbackIsActive() ? kNumberOfIndicationsToTriggerRestart : 0;
-  if (number_of_restart_indications_ > restart_threshold &&
-      number_of_restart_attempts_ < kMaxNumberOfRestartAttempts) {
-    SetInputCallbackIsActive(false);
-    ++total_number_of_restart_attempts_;
-    ++number_of_restart_attempts_;
-    number_of_restart_indications_ = 0;
-    RestartAudio();
-  }
-}
-
 void AUAudioInputStream::CloseAudioUnit() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "CloseAudioUnit";
   if (!audio_unit_)
     return;
   OSStatus result = AudioUnitUninitialize(audio_unit_);
   OSSTATUS_DLOG_IF(ERROR, result != noErr, result)
       << "AudioUnitUninitialize() failed.";
   result = AudioComponentInstanceDispose(audio_unit_);
   OSSTATUS_DLOG_IF(ERROR, result != noErr, result)
       << "AudioComponentInstanceDispose() failed.";
   audio_unit_ = 0;
 }
 
-void AUAudioInputStream::RestartAudio() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DVLOG(1) << "RestartAudio";
-  LOG_IF(ERROR, IsRunning())
-      << "Stream is reported dead but actually seems alive";
-  if (!audio_unit_)
-    return;
-
-  // Store the existing  callback instance for upcoming call to Start().
-  AudioInputCallback* sink = sink_;
-  // Do a best-effort attempt to restart the presumably dead input audio stream.
-  // TODO(henrika): initial tests shows that the scheme below works well but
-  // there might be corner cases that I have missed.
-  Stop();
-  CloseAudioUnit();
-  DeRegisterDeviceChangeListener();
-  Open();
-  Start(sink);
-}
-
 void AUAudioInputStream::AddHistogramsForFailedStartup() {
   DCHECK(thread_checker_.CalledOnValidThread());
   UMA_HISTOGRAM_BOOLEAN("Media.Audio.InputStartWasDeferredMac",
                         start_was_deferred_);
   UMA_HISTOGRAM_BOOLEAN("Media.Audio.InputBufferSizeWasChangedMac",
                         buffer_size_was_changed_);
   UMA_HISTOGRAM_COUNTS_1000("Media.Audio.NumberOfOutputStreamsMac",
                             manager_->output_streams());
   UMA_HISTOGRAM_COUNTS_1000("Media.Audio.NumberOfLowLatencyInputStreamsMac",
                             manager_->low_latency_input_streams());
@@ skipping 328 matching lines @@
 
   number_of_frames_provided_ = 0;
   glitches_detected_ = 0;
   last_sample_time_ = 0;
   last_number_of_frames_ = 0;
   total_lost_frames_ = 0;
   largest_glitch_frames_ = 0;
 }
 
 }  // namespace media