[Chromecast] Remove command-line switch to change the number of mixer output channels

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 46 matching lines @@
 #define POST_TASK_TO_MIXER_THREAD(task, ...) \
   mixer_task_runner_->PostTask(              \
       FROM_HERE, base::Bind(task, base::Unretained(this), ##__VA_ARGS__));
 
 namespace chromecast {
 namespace media {
 
 namespace {
 
 const char kOutputDeviceDefaultName[] = "default";
-const int kDefaultNumOutputChannels = 2;
+const int kNumOutputChannels = 2;
 
 const int kDefaultOutputBufferSizeFrames = 4096;
 const bool kPcmRecoverIsSilent = false;
 // The number of frames of silence to write (to prevent underrun) when no inputs
 // are present.
 const int kPreventUnderrunChunkSize = 512;
 const int kDefaultCheckCloseTimeoutMs = 2000;
 
 // A list of supported sample rates.
 // TODO(jyw): move this up into chromecast/public for 1) documentation and
@@ skipping 120 matching lines @@
 
   alsa_device_name_ = kOutputDeviceDefaultName;
   if (base::CommandLine::InitializedForCurrentProcess() &&
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAlsaOutputDevice)) {
     alsa_device_name_ =
         base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
             switches::kAlsaOutputDevice);
   }
 
-  GetSwitchValueAsNonNegativeInt(switches::kAlsaNumOutputChannels,
-                                 kDefaultNumOutputChannels,
-                                 &num_output_channels_);
-
   int fixed_samples_per_second;
   GetSwitchValueAsNonNegativeInt(switches::kAlsaFixedOutputSampleRate,
                                  kInvalidSampleRate, &fixed_samples_per_second);
   if (fixed_samples_per_second != kInvalidSampleRate)
     LOG(INFO) << "Setting fixed sample rate to " << fixed_samples_per_second;
-
   fixed_output_samples_per_second_ = fixed_samples_per_second;
 
   DefineAlsaParameters();
 }
 
 void StreamMixerAlsa::ResetTaskRunnerForTest() {
   mixer_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 }
 
 void StreamMixerAlsa::DefineAlsaParameters() {
@@ skipping 480 matching lines @@
   }
 
   if (active_inputs.empty()) {
     // No inputs have any data to provide.
     if (!inputs_.empty())
       return false;  // If there are some inputs, don't fill with silence.
 
     // If we have no inputs, fill with silence to avoid underrun.
     chunk_size = kPreventUnderrunChunkSize;
     if (!mixed_ || mixed_->frames() < chunk_size)
-      mixed_ = ::media::AudioBus::Create(num_output_channels_, chunk_size);
+      mixed_ = ::media::AudioBus::Create(kNumOutputChannels, chunk_size);
     mixed_->Zero();
     WriteMixedPcm(*mixed_, chunk_size);
     return true;
   }
 
   // If |mixed_| has not been allocated, or it is too small, allocate a buffer.
   if (!mixed_ || mixed_->frames() < chunk_size)
-    mixed_ = ::media::AudioBus::Create(num_output_channels_, chunk_size);
+    mixed_ = ::media::AudioBus::Create(kNumOutputChannels, chunk_size);
   // If |temp_| has not been allocated, or is too small, allocate a buffer.
   if (!temp_ || temp_->frames() < chunk_size)
-    temp_ = ::media::AudioBus::Create(num_output_channels_, chunk_size);
+    temp_ = ::media::AudioBus::Create(kNumOutputChannels, chunk_size);
 
   mixed_->ZeroFramesPartial(0, chunk_size);
 
   // Loop through active inputs, polling them for data, and mixing them.
   for (InputQueue* input : active_inputs) {
     input->GetResampledData(temp_.get(), chunk_size);
-    for (int c = 0; c < num_output_channels_; ++c) {
+    for (int c = 0; c < kNumOutputChannels; ++c) {
       float volume_scalar = input->volume_multiplier();
       DCHECK(volume_scalar >= 0.0 && volume_scalar <= 1.0) << volume_scalar;
       ::media::vector_math::FMAC(temp_->channel(c), volume_scalar, chunk_size,
                                  mixed_->channel(c));
     }
   }
 
   WriteMixedPcm(*mixed_, chunk_size);
   return true;
 }
 
 ssize_t StreamMixerAlsa::BytesPerOutputFormatSample() {
   return alsa_->PcmFormatSize(pcm_format_, 1);
 }
 
 void StreamMixerAlsa::WriteMixedPcm(const ::media::AudioBus& mixed,
                                     int frames) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   CHECK_PCM_INITIALIZED();
 
-  size_t interleaved_size = static_cast<size_t>(frames * num_output_channels_) *
+  size_t interleaved_size = static_cast<size_t>(frames * kNumOutputChannels) *
                             BytesPerOutputFormatSample();
   if (interleaved_.size() < interleaved_size)
     interleaved_.resize(interleaved_size);
 
   int64_t expected_playback_time = rendering_delay_.timestamp_microseconds +
                                    rendering_delay_.delay_microseconds;
   mixed.ToInterleaved(frames, BytesPerOutputFormatSample(),
                       interleaved_.data());
   for (CastMediaShlib::LoopbackAudioObserver* observer : loopback_observers_) {
     observer->OnLoopbackAudio(expected_playback_time, kSampleFormatS32,
                               output_samples_per_second_, num_output_channels_,
                               interleaved_.data(), interleaved_size);
   }
 
   // If the PCM has been drained it will be in SND_PCM_STATE_SETUP and need
   // to be prepared in order for playback to work.
   if (alsa_->PcmState(pcm_) == SND_PCM_STATE_SETUP)
     RETURN_REPORT_ERROR(PcmPrepare, pcm_);
 
   int frames_left = frames;
   uint8_t* data = &interleaved_[0];
   while (frames_left) {
     int frames_or_error;
     while ((frames_or_error = alsa_->PcmWritei(pcm_, data, frames_left)) < 0) {
       RETURN_REPORT_ERROR(PcmRecover, pcm_, frames_or_error,
                           kPcmRecoverIsSilent);
     }
     frames_left -= frames_or_error;
     DCHECK_GE(frames_left, 0);
-    data +=
-        frames_or_error * num_output_channels_ * BytesPerOutputFormatSample();
+    data += frames_or_error * kNumOutputChannels * BytesPerOutputFormatSample();
   }
   UpdateRenderingDelay(frames);
   for (auto&& input : inputs_)
     input->AfterWriteFrames(rendering_delay_);
 }
 
 void StreamMixerAlsa::UpdateRenderingDelay(int newly_pushed_frames) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   CHECK_PCM_INITIALIZED();
 
@@ skipping 30 matching lines @@
   DCHECK(std::find(loopback_observers_.begin(), loopback_observers_.end(),
                    observer) != loopback_observers_.end());
   loopback_observers_.erase(std::remove(loopback_observers_.begin(),
                                         loopback_observers_.end(), observer),
                             loopback_observers_.end());
   observer->OnRemoved();
 }
 
 }  // namespace media
 }  // namespace chromecast