cras_audio_handler add SetOutputMono method

chromeos/audio/cras_audio_handler.cc

 // Copyright (c) 2013 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 "chromeos/audio/cras_audio_handler.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 16 matching lines @@
 // Default value for unmuting, as a percent in the range [0, 100].
 // Used when sound is unmuted, but volume was less than kMuteThresholdPercent.
 const int kDefaultUnmuteVolumePercent = 4;
 
 // Volume value which should be considered as muted in range [0, 100].
 const int kMuteThresholdPercent = 1;
 
 // The duration of HDMI output re-discover grace period in milliseconds.
 const int kHDMIRediscoverGracePeriodDurationInMs = 2000;
 
+// Mixer matrix, [0.5, 0.5; 0.5, 0.5]
+const std::vector<double> kStereoToMono = {0.5, 0.5, 0.5, 0.5};
+// Mixer matrix, [1, 0; 0, 1]
+const std::vector<double> kStereoToStereo = {1, 0, 0, 1};
+
 static CrasAudioHandler* g_cras_audio_handler = NULL;
 
 bool IsSameAudioDevice(const AudioDevice& a, const AudioDevice& b) {
   return a.stable_device_id == b.stable_device_id && a.is_input == b.is_input &&
          a.type == b.type && a.device_name == b.device_name;
 }
 
 bool IsInNodeList(uint64_t node_id,
                   const CrasAudioHandler::NodeIdList& id_list) {
   return std::find(id_list.begin(), id_list.end(), node_id) != id_list.end();
@@ skipping 34 matching lines @@
 
 void CrasAudioHandler::AudioObserver::OnAudioNodesChanged() {
 }
 
 void CrasAudioHandler::AudioObserver::OnActiveOutputNodeChanged() {
 }
 
 void CrasAudioHandler::AudioObserver::OnActiveInputNodeChanged() {
 }
 
+void CrasAudioHandler::AudioObserver::OnOuputChannelRemixingChanged(
+    bool /* mono_on */) {
+}
+
 // static
 void CrasAudioHandler::Initialize(
     scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler) {
   CHECK(!g_cras_audio_handler);
   g_cras_audio_handler = new CrasAudioHandler(audio_pref_handler);
 }
 
 // static
 void CrasAudioHandler::InitializeForTesting() {
   CHECK(!g_cras_audio_handler);
@@ skipping 220 matching lines @@
        ++it) {
     const AudioDevice& device = it->second;
     if (!device.is_input && device.type == AUDIO_TYPE_INTERNAL_SPEAKER) {
       chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->SwapLeftRight(
           device.id, swap);
       break;
     }
   }
 }
 
+void CrasAudioHandler::SetOutputMono(bool mono_on) {
+  output_mono_on_ = mono_on;
+  if (mono_on) {
+    chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
+        SetGlobalOutputChannelRemix(output_channels_, kStereoToMono);
+  } else {
+    chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
+        SetGlobalOutputChannelRemix(output_channels_, kStereoToStereo);
+  }
+
+  FOR_EACH_OBSERVER(
+      AudioObserver, observers_,
+      OnOuputChannelRemixingChanged(mono_on));
+}
+
+bool CrasAudioHandler::IsOutputMonoEnabled() const {
+  return output_mono_on_;
+}
+
 bool CrasAudioHandler::has_alternative_input() const {
   return has_alternative_input_;
 }
 
 bool CrasAudioHandler::has_alternative_output() const {
   return has_alternative_output_;
 }
 
 void CrasAudioHandler::SetOutputVolumePercent(int volume_percent) {
   // Set all active devices to the same volume.
@@ skipping 165 matching lines @@
     : audio_pref_handler_(audio_pref_handler),
       output_mute_on_(false),
       input_mute_on_(false),
       output_volume_(0),
       input_gain_(0),
       active_output_node_id_(0),
       active_input_node_id_(0),
       has_alternative_input_(false),
       has_alternative_output_(false),
       output_mute_locked_(false),
+      output_channels_(2),
+      output_mono_on_(false),
       log_errors_(false),
       hdmi_rediscover_grace_period_duration_in_ms_(
           kHDMIRediscoverGracePeriodDurationInMs),
       hdmi_rediscovering_(false),
       weak_ptr_factory_(this) {
   if (!audio_pref_handler.get())
     return;
   // If the DBusThreadManager or the CrasAudioClient aren't available, there
   // isn't much we can do. This should only happen when running tests.
   if (!chromeos::DBusThreadManager::IsInitialized() ||
@@ skipping 752 matching lines @@
                      hdmi_rediscover_grace_period_duration_in_ms_),
       this, &CrasAudioHandler::UpdateAudioAfterHDMIRediscoverGracePeriod);
 }
 
 void CrasAudioHandler::SetHDMIRediscoverGracePeriodForTesting(
     int duration_in_ms) {
   hdmi_rediscover_grace_period_duration_in_ms_ = duration_in_ms;
 }
 
 }  // namespace chromeos