cros: Create virtual device name only when two audio nodes sharing the same device index

media/audio/cras/audio_manager_cras.cc

 // Copyright 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 "media/audio/cras/audio_manager_cras.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 32 matching lines @@
 // Define bounds for the output buffer size.
 const int kMinimumOutputBufferSize = 512;
 const int kMaximumOutputBufferSize = 8192;
 
 // Default input buffer size.
 const int kDefaultInputBufferSize = 1024;
 
 const char kBeamformingOnDeviceId[] = "default-beamforming-on";
 const char kBeamformingOffDeviceId[] = "default-beamforming-off";
 
-const char kInternalInputDevice[] = "Built-in mic";
-const char kInternalOutputDevice[] = "Built-in speaker";
+const char kInternalInputVirtualDevice[] = "Built-in mic";
+const char kInternalOutputVirtualDevice[] = "Built-in speaker";
+const char kHeadphoneLineOutVirtualDevice[] = "Headphone/Line Out";
 
 enum CrosBeamformingDeviceState {
   BEAMFORMING_DEFAULT_ENABLED = 0,
   BEAMFORMING_USER_ENABLED,
   BEAMFORMING_DEFAULT_DISABLED,
   BEAMFORMING_USER_DISABLED,
   BEAMFORMING_STATE_MAX = BEAMFORMING_USER_DISABLED
 };
 
 void RecordBeamformingDeviceState(CrosBeamformingDeviceState state) {
@@ skipping 15 matching lines @@
   chromeos::CrasAudioHandler::Get()->GetAudioDevices(&devices);
   for (const auto& device : devices) {
     if (device.type == chromeos::AUDIO_TYPE_INTERNAL_MIC) {
       // There should be only one internal mic device.
       return device.mic_positions;
     }
   }
   return "";
 }
 
+// Process |device_list| that two shares the same dev_index by creating a
+// virtual device name for them.
+void ProcessVirtualDeviceName(AudioDeviceNames* device_names,
+                              const chromeos::AudioDeviceList& device_list) {
+  DCHECK_EQ(2, device_list.size());
+  if (device_list[0].type == chromeos::AUDIO_TYPE_LINEOUT ||
+      device_list[1].type == chromeos::AUDIO_TYPE_LINEOUT) {
+    device_names->emplace_back(kHeadphoneLineOutVirtualDevice,
+                               base::Uint64ToString(device_list[0].id));
+  } else if (device_list[0].type == chromeos::AUDIO_TYPE_INTERNAL_SPEAKER ||
+             device_list[1].type == chromeos::AUDIO_TYPE_INTERNAL_SPEAKER) {
+    device_names->emplace_back(kInternalOutputVirtualDevice,
+                               base::Uint64ToString(device_list[0].id));
+  } else {
+    DCHECK(device_list[0].type == chromeos::AUDIO_TYPE_INTERNAL_MIC ||
+           device_list[1].type == chromeos::AUDIO_TYPE_INTERNAL_MIC);
+    device_names->emplace_back(kInternalInputVirtualDevice,
+                               base::Uint64ToString(device_list[0].id));
+  }
+}
+
 }  // namespace
 
 // Adds the beamforming on and off devices to |device_names|.
 void AudioManagerCras::AddBeamformingDevices(AudioDeviceNames* device_names) {
   DCHECK(device_names->empty());
   const std::string beamforming_on_name =
       GetLocalizedStringUTF8(BEAMFORMING_ON_DEFAULT_AUDIO_INPUT_DEVICE_NAME);
   const std::string beamforming_off_name =
       GetLocalizedStringUTF8(BEAMFORMING_OFF_DEFAULT_AUDIO_INPUT_DEVICE_NAME);
 
@@ skipping 62 matching lines @@
   // queried through GetInputStreamParameters, provide the cached mic positions.
   if (is_input && mic_positions_.size() > 1)
     AddBeamformingDevices(device_names);
   else
     device_names->push_back(AudioDeviceName::CreateDefault());
 
   if (base::FeatureList::IsEnabled(features::kEnumerateAudioDevices)) {
     chromeos::AudioDeviceList devices;
     chromeos::CrasAudioHandler::Get()->GetAudioDevices(&devices);
 
-    int internal_input_dev_index = 0;
-    int internal_output_dev_index = 0;
+    // |dev_idx_map| is a map of dev_index and their audio devices.
+    std::map<int, chromeos::AudioDeviceList> dev_idx_map;
     for (const auto& device : devices) {
-      if (device.type == chromeos::AUDIO_TYPE_INTERNAL_MIC)
-        internal_input_dev_index = dev_index_of(device.id);
-      else if (device.type == chromeos::AUDIO_TYPE_INTERNAL_SPEAKER)
-        internal_output_dev_index = dev_index_of(device.id);
+      if (device.is_input != is_input || !device.is_for_simple_usage())
+        continue;
+
+      dev_idx_map[dev_index_of(device.id)].push_back(device);
     }
 
-    bool has_internal_input = false;
-    bool has_internal_output = false;
-    for (const auto& device : devices) {
-      if (device.is_input == is_input && device.is_for_simple_usage()) {
-        int dev_index = dev_index_of(device.id);
-        if (dev_index == internal_input_dev_index) {
-          if (!has_internal_input) {
-            device_names->emplace_back(kInternalInputDevice,
-                                       base::Uint64ToString(device.id));
-            has_internal_input = true;
-          }
-        } else if (dev_index == internal_output_dev_index) {
-          if (!has_internal_output) {
-            device_names->emplace_back(kInternalOutputDevice,
-                                       base::Uint64ToString(device.id));
-            has_internal_output = true;
-          }
-        } else {
-          device_names->emplace_back(device.display_name,
-                                     base::Uint64ToString(device.id));
-        }
+    for (const auto& item : dev_idx_map) {
+      if (1 == item.second.size()) {
+        const chromeos::AudioDevice& device = item.second.front();
+        device_names->emplace_back(device.display_name,
+                                   base::Uint64ToString(device.id));
+      } else {
+        // Create virtual device name for audio nodes that share the same device
+        // index.
+        ProcessVirtualDeviceName(device_names, item.second);
       }
     }
   }
 }
 
 void AudioManagerCras::GetAudioInputDeviceNames(
     AudioDeviceNames* device_names) {
   mic_positions_ = ParsePointsFromString(MicPositions());
   GetAudioDeviceNamesImpl(true, device_names);
 }
@@ skipping 147 matching lines @@
 
 bool AudioManagerCras::IsDefault(const std::string& device_id, bool is_input) {
   AudioDeviceNames device_names;
   GetAudioDeviceNamesImpl(is_input, &device_names);
   DCHECK(!device_names.empty());
   const AudioDeviceName& device_name = device_names.front();
   return device_name.unique_id == device_id;
 }
 
 }  // namespace media