Enable pinning stream output routing for webapp request on ChromeOS

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 31 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";
 
+// Labels for showing audio devices with internal nodes.
+const char kInternalInputDevice[] = "Headset/Front Mic";
+const char kInternalOutputDevice[] = "HP/Speaker";
+
 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) {
   UMA_HISTOGRAM_ENUMERATION("Media.CrosBeamformingDeviceState", state,
@@ skipping 90 matching lines @@
 
 void AudioManagerCras::GetAudioDeviceNamesImpl(bool is_input,
                                                AudioDeviceNames* device_names) {
   DCHECK(device_names->empty());
   // At least two mic positions indicates we have a beamforming capable mic
   // array. Add the virtual beamforming device to the list. When this device is
   // queried through GetInputStreamParameters, provide the cached mic positions.
   if (is_input && mic_positions_.size() > 1)
     AddBeamformingDevices(device_names);
   else
-    device_names->push_back(media::AudioDeviceName::CreateDefault());
+    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;
+    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)

[dgreid, 2016/11/29 19:38:44]

How does this work on devices without a speaker node?  Chromebit and some boxes
don't have a speaker but do have a headset.

Same applies for internal mic, it might not exist for some form factors.

[Qiang(Joe) Xu, 2016/11/29 21:57:47]

For devices without a speaker node or internal mic node,
internal_output_dev_index or internal_input_dev_index will be zero. In this
case, the headset will be labeled as Headphone or MicJack, instead of HP/Speaker
or Headset/Front Mic. Then it should not cause any problem, right?

[dgreid, 2016/11/29 23:23:18]

Got it.  Yes, I hadn't fully understood the code here, that should be OK.

+        internal_output_dev_index = dev_index_of(device.id);
+    }
+
+    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()) {
-        device_names->emplace_back(device.display_name,
-                                   base::Uint64ToString(device.id));
+        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));
+        }

[dgreid, 2016/11/29 19:38:44]

Can you summarize what this code does?

Is "Replace the internal and external device names with a default string and
skip duplicate nodes on internal devices." correct?

Would this also ignore an HDMI node if it was on the default device?

[Qiang(Joe) Xu, 2016/11/29 21:57:47]

"Replace the internal and external device names with a default string and skip
duplicate nodes on internal devices." --> correct

"Would this also ignore an HDMI node if it was on the default device?" What does
this mean? The default label string works only when there are two nodes pair
existing (one is internal mic or one is internal speaker). For other cases, the
behavior should restore to the version before this change.

Do you mean HDMI node can be one of the nodes pair with internal speaker? Is
that possible?

[dgreid, 2016/11/29 23:23:18]

OK, can you add a comment with a summary?  It was hard to determine what the
code was trying to do.

HDMI can be a node on the main device for some intel platforms, but that is an
exception and if it only affects the device pinning path, then it might be OK.

[Qiang(Joe) Xu, 2016/11/30 01:01:17]

Done.

       }
     }
   }
 }
 
 void AudioManagerCras::GetAudioInputDeviceNames(
     AudioDeviceNames* device_names) {
   mic_positions_ = ParsePointsFromString(MicPositions());
   GetAudioDeviceNamesImpl(true, device_names);
 }
@@ skipping 44 matching lines @@
         RecordBeamformingDeviceState(BEAMFORMING_USER_DISABLED);
     }
   }
   return params;
 }
 
 AudioOutputStream* AudioManagerCras::MakeLinearOutputStream(
     const AudioParameters& params,
     const LogCallback& log_callback) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format());
-  return MakeOutputStream(params);
+  // (warx): pinning stream is not supported for MakeLinearOutputStream.
+  return MakeOutputStream(params, AudioDeviceDescription::kDefaultDeviceId);
 }
 
 AudioOutputStream* AudioManagerCras::MakeLowLatencyOutputStream(
     const AudioParameters& params,
     const std::string& device_id,
     const LogCallback& log_callback) {
-  DLOG_IF(ERROR, !device_id.empty()) << "Not implemented!";
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
   // TODO(dgreid): Open the correct input device for unified IO.
-  return MakeOutputStream(params);
+  return MakeOutputStream(params, device_id);
 }
 
 AudioInputStream* AudioManagerCras::MakeLinearInputStream(
     const AudioParameters& params,
     const std::string& device_id,
     const LogCallback& log_callback) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format());
   return MakeInputStream(params, device_id);
 }
 
 AudioInputStream* AudioManagerCras::MakeLowLatencyInputStream(
     const AudioParameters& params,
     const std::string& device_id,
     const LogCallback& log_callback) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
   return MakeInputStream(params, device_id);
 }
 
 AudioParameters AudioManagerCras::GetPreferredOutputStreamParameters(
     const std::string& output_device_id,
     const AudioParameters& input_params) {
-  // TODO(tommi): Support |output_device_id|.
-  DLOG_IF(ERROR, !output_device_id.empty()) << "Not implemented!";
   ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
   int sample_rate = kDefaultSampleRate;
   int buffer_size = kMinimumOutputBufferSize;
   int bits_per_sample = 16;
   if (input_params.IsValid()) {
     sample_rate = input_params.sample_rate();
     bits_per_sample = input_params.bits_per_sample();
     channel_layout = input_params.channel_layout();
     buffer_size =
         std::min(kMaximumOutputBufferSize,
                  std::max(buffer_size, input_params.frames_per_buffer()));
   }
 
   int user_buffer_size = GetUserBufferSize();
   if (user_buffer_size)
     buffer_size = user_buffer_size;
 
   return AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout,
                          sample_rate, bits_per_sample, buffer_size);
 }
 
 AudioOutputStream* AudioManagerCras::MakeOutputStream(
-    const AudioParameters& params) {
-  return new CrasUnifiedStream(params, this);
+    const AudioParameters& params,
+    const std::string& device_id) {
+  return new CrasUnifiedStream(params, this, device_id);
 }
 
 AudioInputStream* AudioManagerCras::MakeInputStream(
     const AudioParameters& params, const std::string& device_id) {
   return new CrasInputStream(params, this, device_id);
 }
 
 snd_pcm_format_t AudioManagerCras::BitsToFormat(int bits_per_sample) {
   switch (bits_per_sample) {
     case 8:
       return SND_PCM_FORMAT_U8;
     case 16:
       return SND_PCM_FORMAT_S16;
     case 24:
       return SND_PCM_FORMAT_S24;
     case 32:
       return SND_PCM_FORMAT_S32;
     default:
       return SND_PCM_FORMAT_UNKNOWN;
   }
 }
 
+bool AudioManagerCras::IsDefault(const std::string& device_id, bool is_input) {
+  AudioDeviceNames device_names;
+  GetAudioDeviceNamesImpl(is_input, &device_names);
+  DCHECK(!device_names.empty());
+  AudioDeviceName device_name = device_names.front();
+  return device_name.unique_id == device_id;
+}
+
 }  // namespace media