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";
 
+const char kInternal[] = "Internal";
+
 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)
+        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(kInternal,
+                                       base::Uint64ToString(device.id));
+            has_internal_input = true;
+          }
+        } else if (dev_index == internal_output_dev_index) {
+          if (!has_internal_output) {
+            device_names->emplace_back(kInternal,
+                                       base::Uint64ToString(device.id));
+            has_internal_output = true;
+          }
+        } else {
+          device_names->emplace_back(device.display_name,
+                                     base::Uint64ToString(device.id));
+        }
       }
     }
   }
 }
 
 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.

[Qiang(Joe) Xu, 2016/11/19 00:41:44]

shall we open a new bug to track this? I don't have much context with
this...@tommi for more thoughts.

+  return MakeOutputStream(params, AudioDeviceName::CreateDefault().unique_id);
 }
 
 AudioOutputStream* AudioManagerCras::MakeLowLatencyOutputStream(
     const AudioParameters& params,
     const std::string& device_id,
     const LogCallback& log_callback) {
-  DLOG_IF(ERROR, !device_id.empty()) << "Not implemented!";

[Qiang(Joe) Xu, 2016/11/19 00:41:44]

it is now supported

   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!";

[Qiang(Joe) Xu, 2016/11/19 00:41:44]

it is now supported

   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