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

chromecast/media/cma/backend/alsa/stream_mixer_alsa_input_impl.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_input_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 27 matching lines @@
 
 #define POST_TASK_TO_CALLER_THREAD(task, ...) \
   caller_task_runner_->PostTask(FROM_HERE,    \
                                 base::Bind(task, weak_this_, ##__VA_ARGS__));
 
 namespace chromecast {
 namespace media {
 
 namespace {
 
+const int kNumOutputChannels = 2;
 const int64_t kMaxInputQueueUs = 90000;
 const int64_t kFadeMs = 15;
 // Number of samples to report as readable when paused. When paused, the mixer
 // will still pull this many frames each time it tries to write frames, but we
 // fill the frames with silence.
 const int kPausedReadSamples = 512;
 const int kDefaultReadSize = ::media::SincResampler::kDefaultRequestSize;
 
 }  // namespace
 
@@ skipping 46 matching lines @@
 }
 
 void StreamMixerAlsaInputImpl::Initialize(
     const MediaPipelineBackendAlsa::RenderingDelay& mixer_rendering_delay) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   DCHECK(!IsDeleting());
   if (mixer_->output_samples_per_second() != input_samples_per_second_) {
     double resample_ratio = static_cast<double>(input_samples_per_second_) /
                             mixer_->output_samples_per_second();
     resampler_.reset(new ::media::MultiChannelResampler(
-        mixer_->num_output_channels(), resample_ratio, kDefaultReadSize,
+        kNumOutputChannels, resample_ratio, kDefaultReadSize,
         base::Bind(&StreamMixerAlsaInputImpl::ReadCB, base::Unretained(this))));
     resampler_->PrimeWithSilence();
   }
   mixer_rendering_delay_ = mixer_rendering_delay;
   fade_out_frames_total_ = NormalFadeFrames();
   fade_frames_remaining_ = NormalFadeFrames();
 }
 
 void StreamMixerAlsaInputImpl::PreventDelegateCalls() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
@@ skipping 60 matching lines @@
   // Alert the |mixer_| on the mixer thread.
   DidQueueData(data->end_of_stream());
   PostPcmCallback(delay);
 }
 
 // Must only be called when queue_lock_ is locked.
 MediaPipelineBackendAlsa::RenderingDelay StreamMixerAlsaInputImpl::QueueData(
     const scoped_refptr<DecoderBufferBase>& data) {
   queue_lock_.AssertAcquired();
   if (!data->end_of_stream()) {
-    int frames =
-        data->data_size() / (mixer_->num_output_channels() * sizeof(float));
+    int frames = data->data_size() / (kNumOutputChannels * sizeof(float));
     queue_.push_back(data);
     queued_frames_ += frames;
     queued_frames_including_resampler_ += frames;
   }
 
   MediaPipelineBackendAlsa::RenderingDelay delay = mixer_rendering_delay_;
   delay.delay_microseconds += static_cast<int64_t>(
       queued_frames_including_resampler_ * base::Time::kMicrosecondsPerSecond /
       input_samples_per_second_);
   return delay;
@@ skipping 24 matching lines @@
       (resampler_ ? resampler_->BufferedFrames() : 0);
 
   bool queued_more_data = false;
   MediaPipelineBackendAlsa::RenderingDelay total_delay;
   {
     base::AutoLock lock(queue_lock_);
     mixer_rendering_delay_ = mixer_rendering_delay;
     queued_frames_ = 0;
     for (const auto& data : queue_)
       queued_frames_ +=
-          data->data_size() / (mixer_->num_output_channels() * sizeof(float));
+          data->data_size() / (kNumOutputChannels * sizeof(float));
     queued_frames_ -= current_buffer_offset_;
     DCHECK_GE(queued_frames_, 0);
     queued_frames_including_resampler_ =
         queued_frames_ + resampler_queued_frames;
 
     if (pending_data_ && queued_frames_ < max_queued_frames_) {
       scoped_refptr<DecoderBufferBase> data = pending_data_;
       pending_data_ = nullptr;
       total_delay = QueueData(data);
       queued_more_data = true;
@@ skipping 32 matching lines @@
 
   if (state_ == kStateFadingOut)
     return std::min(available_frames, fade_frames_remaining_);
   return std::max(0, available_frames - NormalFadeFrames());
 }
 
 void StreamMixerAlsaInputImpl::GetResampledData(::media::AudioBus* dest,
                                                 int frames) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   DCHECK(dest);
-  DCHECK_EQ(mixer_->num_output_channels(), dest->channels());
+  DCHECK_EQ(kNumOutputChannels, dest->channels());
   DCHECK_GE(dest->frames(), frames);
 
   if (state_ == kStatePaused || state_ == kStateDeleted) {
     dest->ZeroFramesPartial(0, frames);
     return;
   }
 
   if (resampler_) {
     resampler_->Resample(frames, dest);
   } else {
@@ skipping 27 matching lines @@
   while (frames_left) {
     scoped_refptr<DecoderBufferBase> buffer;
     int buffer_frames;
     int frames_to_copy;
     int buffer_offset = current_buffer_offset_;
 
     {
       base::AutoLock lock(queue_lock_);
       if (!queue_.empty()) {
         buffer = queue_.front();
-        buffer_frames = buffer->data_size() /
-                        (mixer_->num_output_channels() * sizeof(float));
+        buffer_frames =
+            buffer->data_size() / (kNumOutputChannels * sizeof(float));
         frames_to_copy =
             std::min(frames_left, buffer_frames - current_buffer_offset_);
         // Note that queued_frames_ is not updated until AfterWriteFrames().
         // This is done so that the rendering delay is always correct from the
         // perspective of the calling thread.
         current_buffer_offset_ += frames_to_copy;
         if (current_buffer_offset_ == buffer_frames) {
           queue_.pop_front();
           current_buffer_offset_ = 0;
         }
       }
     }
 
     if (buffer) {
       const float* buffer_samples =
           reinterpret_cast<const float*>(buffer->data());
-      for (int i = 0; i < mixer_->num_output_channels(); ++i) {
+      for (int i = 0; i < kNumOutputChannels; ++i) {
         const float* buffer_channel = buffer_samples + (buffer_frames * i);
         memcpy(output->channel(i) + frames_filled,
                buffer_channel + buffer_offset, frames_to_copy * sizeof(float));
       }
       frames_left -= frames_to_copy;
       frames_filled += frames_to_copy;
       LOG_IF(WARNING, zeroed_frames_ > 0) << "Filled a total of "
                                           << zeroed_frames_ << " frames with 0";
       zeroed_frames_ = 0;
     } else {
@@ skipping 19 matching lines @@
   return std::max(frames, 0);
 }
 
 void StreamMixerAlsaInputImpl::FadeIn(::media::AudioBus* dest, int frames) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   LOG(INFO) << "Fading in, " << fade_frames_remaining_ << " frames remaining";
   float fade_in_frames = mixer_->output_samples_per_second() * kFadeMs /
                          base::Time::kMillisecondsPerSecond;
   for (int f = 0; f < frames && fade_frames_remaining_; ++f) {
     float fade_multiplier = 1.0 - fade_frames_remaining_ / fade_in_frames;
-    for (int c = 0; c < mixer_->num_output_channels(); ++c)
+    for (int c = 0; c < kNumOutputChannels; ++c)
       dest->channel(c)[f] *= fade_multiplier;
     --fade_frames_remaining_;
   }
 }
 
 void StreamMixerAlsaInputImpl::FadeOut(::media::AudioBus* dest, int frames) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   LOG(INFO) << "Fading out, " << fade_frames_remaining_ << " frames remaining";
   int f = 0;
   for (; f < frames && fade_frames_remaining_; ++f) {
     float fade_multiplier =
         fade_frames_remaining_ / static_cast<float>(fade_out_frames_total_);
-    for (int c = 0; c < mixer_->num_output_channels(); ++c)
+    for (int c = 0; c < kNumOutputChannels; ++c)
       dest->channel(c)[f] *= fade_multiplier;
     --fade_frames_remaining_;
   }
   // Zero remaining frames
   for (; f < frames; ++f) {
-    for (int c = 0; c < mixer_->num_output_channels(); ++c)
+    for (int c = 0; c < kNumOutputChannels; ++c)
       dest->channel(c)[f] = 0.0f;
   }
 
   if (fade_frames_remaining_ == 0) {
     if (state_ == kStateFinalFade) {
       DeleteThis();
     } else {
       state_ = kStatePaused;
     }
   }
@@ skipping 54 matching lines @@
   DCHECK(!IsDeleting());
   if (multiplier > 1.0f)
     multiplier = 1.0f;
   if (multiplier < 0.0f)
     multiplier = 0.0f;
   volume_multiplier_ = multiplier;
 }
 
 }  // namespace media
 }  // namespace chromecast