[Chromecast] Resample all audio below 32000 Hz.

chromecast/media/cma/backend/alsa/stream_mixer_alsa.cc

 // Copyright 2015 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 "chromecast/media/cma/backend/alsa/stream_mixer_alsa.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <utility>
@@ skipping 65 matching lines @@
 // A list of supported sample rates.
 // TODO(jyw): move this up into chromecast/public for 1) documentation and
 // 2) to help when implementing IsSampleRateSupported()
 // clang-format off
 const int kSupportedSampleRates[] =
     { 8000, 11025, 12000,
      16000, 22050, 24000,
      32000, 44100, 48000,
      64000, 88200, 96000};
 // clang-format on
+const int kInvalidSampleRate = 0;
 
 // Arbitrary sample rate in Hz to mix all audio to when a new primary input has
 // a sample rate that is not directly supported, and a better fallback sample
 // rate cannot be determined. 48000 is the highest supported non-hi-res sample
 // rate. 96000 is the highest supported hi-res sample rate.
 const unsigned int kFallbackSampleRate = 48000;
 const unsigned int kFallbackSampleRateHiRes = 96000;
 
+// Resample all audio below this frequency.
+const unsigned int kLowSampleRateCutoff = 32000;
+
 // The snd_pcm_(hw|sw)_params_set_*_near families of functions will report what
 // direction they adjusted the requested parameter in, but since we read the
 // output param and then log the information, this module doesn't need to get
 // the direction explicitly.
 static int* kAlsaDirDontCare = nullptr;
 
 // These sample formats will be tried in order. 32 bit samples is ideal, but
 // some devices do not support 32 bit samples.
 const snd_pcm_format_t kPreferredSampleFormats[] = {SND_PCM_FORMAT_S32,
                                                     SND_PCM_FORMAT_S16};
@@ skipping 58 matching lines @@
 
 // static
 void StreamMixerAlsa::MakeSingleThreadedForTest() {
   single_threaded_for_test_ = true;
   StreamMixerAlsa::Get()->ResetTaskRunnerForTest();
 }
 
 StreamMixerAlsa::StreamMixerAlsa()
     : mixer_thread_(new base::Thread("ALSA CMA mixer thread")),
       mixer_task_runner_(nullptr),
-      requested_output_samples_per_second_(0),
-      output_samples_per_second_(0),
+      requested_output_samples_per_second_(kInvalidSampleRate),
+      output_samples_per_second_(kInvalidSampleRate),
       pcm_(nullptr),
       pcm_hw_params_(nullptr),
       pcm_status_(nullptr),
       pcm_format_(SND_PCM_FORMAT_UNKNOWN),
       alsa_buffer_size_(0),
       alsa_period_explicitly_set(false),
       alsa_period_size_(0),
       alsa_start_threshold_(0),
       alsa_avail_min_(0),
       state_(kStateUninitialized),
@@ skipping 115 matching lines @@
   // doesn't always choose a rate that's actually near the given input sample
   // rate when the input sample rate is not supported.
   const int* kSupportedSampleRatesEnd =
       kSupportedSampleRates + arraysize(kSupportedSampleRates);
   auto nearest_sample_rate =
       std::min_element(kSupportedSampleRates, kSupportedSampleRatesEnd,
                        [this](int r1, int r2) -> bool {
                          return abs(requested_output_samples_per_second_ - r1) <
                                 abs(requested_output_samples_per_second_ - r2);
                        });
+  // Resample audio with sample rates deemed to be too low (i.e.  below 32kHz)
+  // because some common AV receivers don't support optical out at these
+  // frequencies. See b/26385501
+  unsigned int first_choice_sample_rate = requested_rate;
+  if (requested_rate < kLowSampleRateCutoff) {
+    first_choice_sample_rate = output_samples_per_second_ != kInvalidSampleRate
+                                   ? output_samples_per_second_
+                                   : kFallbackSampleRate;
+  }
   const unsigned int preferred_sample_rates[] = {
-      requested_rate,
+      first_choice_sample_rate,
       static_cast<unsigned int>(*nearest_sample_rate),
       kFallbackSampleRateHiRes,
       kFallbackSampleRate};
   for (const auto& sample_rate : preferred_sample_rates) {
     err = alsa_->PcmHwParamsTestRate(pcm_, pcm_hw_params_, sample_rate,
                                      0 /* try exact rate */);
     if (err == 0) {
       unsigned_output_samples_per_second = sample_rate;
       break;
     }
@@ skipping 136 matching lines @@
 
   state_ = kStateNormalPlayback;
 }
 
 void StreamMixerAlsa::Stop() {
   alsa_->PcmStatusFree(pcm_status_);
   pcm_status_ = nullptr;
   alsa_->PcmHwParamsFree(pcm_hw_params_);
   pcm_hw_params_ = nullptr;
   state_ = kStateUninitialized;
+  output_samples_per_second_ = kInvalidSampleRate;
 
   if (!pcm_)
     return;
 
   // If |pcm_| is RUNNING, drain all pending data.
   if (alsa_->PcmState(pcm_) == SND_PCM_STATE_RUNNING) {
     int err = alsa_->PcmDrain(pcm_);
     if (err < 0)
       LOG(ERROR) << "snd_pcm_drain error: " << alsa_->StrError(err);
   } else {
@@ skipping 64 matching lines @@
     input_ptr->Initialize(rendering_delay_);
   } else {
     input_ptr->SignalError();
   }
 }
 
 void StreamMixerAlsa::CheckChangeOutputRate(int input_samples_per_second) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   if (!pcm_ ||
       input_samples_per_second == requested_output_samples_per_second_ ||
-      input_samples_per_second == output_samples_per_second_)
+      input_samples_per_second == output_samples_per_second_ ||
+      input_samples_per_second < static_cast<int>(kLowSampleRateCutoff))
     return;
   for (InputQueue* input : inputs_) {
     if (input->primary() && !input->IsDeleting())
       return;
   }
 
   // Move all current inputs to the ignored list
   for (InputQueue* input : inputs_) {
     LOG(INFO) << "Mixer input " << input
               << " now being ignored due to output sample rate change from "
@@ skipping 181 matching lines @@
   rendering_delay_.timestamp_microseconds =
       TimespecToMicroseconds(status_timestamp);
   snd_pcm_sframes_t delay_frames = alsa_->PcmStatusGetDelay(pcm_status_);
   rendering_delay_.delay_microseconds = static_cast<int64_t>(delay_frames) *
                                         base::Time::kMicrosecondsPerSecond /
                                         output_samples_per_second_;
 }
 
 }  // namespace media
 }  // namespace chromecast