Query native channel count in preferred parameters.

media/audio/pulse/audio_manager_pulse.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/pulse/audio_manager_pulse.h"
 
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 40 matching lines @@
 AudioManagerPulse::AudioManagerPulse(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
     AudioLogFactory* audio_log_factory)
     : AudioManagerBase(std::move(task_runner),
                        std::move(worker_task_runner),
                        audio_log_factory),
       input_mainloop_(NULL),
       input_context_(NULL),
       devices_(NULL),
-      native_input_sample_rate_(0) {
+      native_input_sample_rate_(0),
+      native_channel_count_(0) {
   SetMaxOutputStreamsAllowed(kMaxOutputStreams);
 }
 
 AudioManagerPulse::~AudioManagerPulse() {
   Shutdown();
   // The Pulse objects are the last things to be destroyed since Shutdown()
   // needs them.
   DestroyPulse();
 }
 
@@ skipping 57 matching lines @@
   GetAudioDeviceNames(false, device_names);
 }
 
 AudioParameters AudioManagerPulse::GetInputStreamParameters(
     const std::string& device_id) {
   int user_buffer_size = GetUserBufferSize();
   int buffer_size = user_buffer_size ?
       user_buffer_size : kDefaultInputBufferSize;
 
   // TODO(xians): add support for querying native channel layout for pulse.
+  UpdateNativeAudioHardwareInfo();
   return AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY,
-                         CHANNEL_LAYOUT_STEREO, GetNativeSampleRate(), 16,
+                         CHANNEL_LAYOUT_STEREO, native_input_sample_rate_, 16,
                          buffer_size);
 }
 
 AudioOutputStream* AudioManagerPulse::MakeLinearOutputStream(
     const AudioParameters& params,
     const LogCallback& log_callback) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format());
   return MakeOutputStream(params, AudioDeviceDescription::kDefaultDeviceId);
 }
 
@@ skipping 22 matching lines @@
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
   return MakeInputStream(params, device_id);
 }
 
 AudioParameters AudioManagerPulse::GetPreferredOutputStreamParameters(
     const std::string& output_device_id,
     const AudioParameters& input_params) {
   // TODO(tommi): Support |output_device_id|.
   VLOG_IF(0, !output_device_id.empty()) << "Not implemented!";
 
-  ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
   int buffer_size = kMinimumOutputBufferSize;
   int bits_per_sample = 16;
-  int sample_rate = GetNativeSampleRate();
+
+  // Query native parameters where applicable; Pulse does not require these to
+  // be respected though, so prefer the input parameters for channel count.
+  UpdateNativeAudioHardwareInfo();
+  int sample_rate = native_input_sample_rate_;
+  ChannelLayout channel_layout = GuessChannelLayout(native_channel_count_);
+
   if (input_params.IsValid()) {
     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* AudioManagerPulse::MakeOutputStream(
     const AudioParameters& params,
     const std::string& device_id) {
   DCHECK(!device_id.empty());
   return new PulseAudioOutputStream(params, device_id, this);
 }
 
 AudioInputStream* AudioManagerPulse::MakeInputStream(
     const AudioParameters& params, const std::string& device_id) {
   return new PulseAudioInputStream(this, device_id, params,
                                    input_mainloop_, input_context_);
 }
 
-int AudioManagerPulse::GetNativeSampleRate() {
+void AudioManagerPulse::UpdateNativeAudioHardwareInfo() {
   DCHECK(input_mainloop_);
   DCHECK(input_context_);
   AutoPulseLock auto_lock(input_mainloop_);
   pa_operation* operation = pa_context_get_server_info(
-      input_context_, SampleRateInfoCallback, this);
+      input_context_, AudioHardwareInfoCallback, this);
   WaitForOperationCompletion(input_mainloop_, operation);
-
-  return native_input_sample_rate_;
 }
 
 bool AudioManagerPulse::InitPulse() {
   DCHECK(!input_mainloop_);
 
 #if defined(DLOPEN_PULSEAUDIO)
   StubPathMap paths;
 
   // Check if the pulse library is avialbale.
   paths[kModulePulse].push_back(kPulseLib);
@@ skipping 94 matching lines @@
   if (error) {
     // Signal the pulse object that it is done.
     pa_threaded_mainloop_signal(manager->input_mainloop_, 0);
     return;
   }
 
   manager->devices_->push_back(AudioDeviceName(info->description,
                                                info->name));
 }
 
-void AudioManagerPulse::SampleRateInfoCallback(pa_context* context,
-                                               const pa_server_info* info,
-                                               void* user_data) {
+void AudioManagerPulse::AudioHardwareInfoCallback(pa_context* context,
+                                                  const pa_server_info* info,
+                                                  void* user_data) {
   AudioManagerPulse* manager = reinterpret_cast<AudioManagerPulse*>(user_data);
 
   manager->native_input_sample_rate_ = info->sample_spec.rate;
+  manager->native_channel_count_ = info->sample_spec.channels;
   pa_threaded_mainloop_signal(manager->input_mainloop_, 0);
 }
 
 }  // namespace media