Don't run WSOLA over always muted channels.

media/renderers/audio_renderer_impl.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/renderers/audio_renderer_impl.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/default_tick_clock.h"
 #include "build/build_config.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_buffer_converter.h"
 #include "media/base/audio_latency.h"
 #include "media/base/bind_to_current_loop.h"
+#include "media/base/channel_mixing_matrix.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/renderer_client.h"
 #include "media/base/timestamp_constants.h"
 #include "media/filters/audio_clock.h"
 #include "media/filters/decrypting_demuxer_stream.h"
 
 namespace media {
 
@@ skipping 384 matching lines @@
     //   down-mixing and use the data from all stream channels.
     ChannelLayout renderer_channel_layout =
         hw_channel_count > stream_channel_count
             ? hw_channel_layout
             : stream->audio_decoder_config().channel_layout();
 
     audio_parameters_.Reset(hw_params.format(), renderer_channel_layout,
                             sample_rate, hw_params.bits_per_sample(),
                             media::AudioLatency::GetHighLatencyBufferSize(
                                 sample_rate, preferred_buffer_size));
+
+    // Figure out if there are muted channels that we should ignore when
+    // playback rate adapatation is requested (it's expensive).
+    if (stream_channel_count < audio_parameters_.channels()) {
+      std::vector<std::vector<float>> matrix;
+      ChannelMixingMatrix(
+          stream->audio_decoder_config().channel_layout(), stream_channel_count,
+          audio_parameters_.channel_layout(), audio_parameters_.channels())
+          .CreateTransformationMatrix(&matrix);
+
+      // All channels with a zero mix are muted and can be ignored.
+      channel_mask_ = std::vector<bool>(audio_parameters_.channels(), false);
+      for (size_t ch = 0; ch < matrix.size(); ++ch) {
+        channel_mask_[ch] =
+            std::find_if(matrix[ch].begin(), matrix[ch].end(),
+                         [](float mix) { return !!mix; }) != matrix[ch].end();

[sandersd (OOO until July 31), 2016/11/22 00:59:24]

Nit: Would be more clear using std::any_of().

[DaleCurtis, 2016/11/22 01:07:49]

Ah, didn't know about that one. Done.

+      }
+    }
   }
 
   audio_clock_.reset(
       new AudioClock(base::TimeDelta(), audio_parameters_.sample_rate()));
 
   audio_buffer_stream_->Initialize(
       stream, base::Bind(&AudioRendererImpl::OnAudioBufferStreamInitialized,
                          weak_factory_.GetWeakPtr()),
       cdm_context, base::Bind(&AudioRendererImpl::OnStatisticsUpdate,
                               weak_factory_.GetWeakPtr()),
@@ skipping 20 matching lines @@
     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
     return;
   }
 
   if (expecting_config_changes_)
     buffer_converter_.reset(new AudioBufferConverter(audio_parameters_));
 
   // We're all good! Continue initializing the rest of the audio renderer
   // based on the decoder format.
   algorithm_.reset(new AudioRendererAlgorithm());
-  algorithm_->Initialize(audio_parameters_);
+  algorithm_->Initialize(audio_parameters_, channel_mask_);
 
   ChangeState_Locked(kFlushed);
 
   {
     base::AutoUnlock auto_unlock(lock_);
     sink_->Initialize(audio_parameters_, this);
     sink_->Start();
 
     // Some sinks play on start...
     sink_->Pause();
@@ skipping 452 matching lines @@
   DCHECK_NE(buffering_state_, buffering_state);
   lock_.AssertAcquired();
   buffering_state_ = buffering_state;
 
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&AudioRendererImpl::OnBufferingStateChange,
                             weak_factory_.GetWeakPtr(), buffering_state_));
 }
 
 }  // namespace media