Let default device in PulseAudio be the system default device

media/audio/pulse/pulse_util.cc

 // Copyright (c) 2012 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/pulse_util.h"
 
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/audio_parameters.h"
+#include "media/audio/pulse/pulse_input.h"
+#include "media/base/limits.h"
 
 namespace media {
 
 namespace pulse {
 
 namespace {
 
 #if defined(GOOGLE_CHROME_BUILD)
 static const char kBrowserDisplayName[] = "google-chrome";
 #else
@@ skipping 130 matching lines @@
 
 // Helper macro for CreateInput/OutputStream() to avoid code spam and
 // string bloat.
 #define RETURN_ON_FAILURE(expression, message) do { \
   if (!(expression)) { \
     DLOG(ERROR) << message; \
     return false; \
   } \
 } while (0)
 
+void SystemDefaultInputDeviceCallback(pa_context* context,
+                                      const pa_server_info* info,
+                                      void* user_data) {
+  PulseAudioInputStream* stream =
+      reinterpret_cast<PulseAudioInputStream*>(user_data);
+  stream->device_name_ = info->default_source_name;

[Henrik Grunell, 2016/02/24 15:54:53]

This will overwrite the device name provided in the stream ctor, which will
break how things should work. If the default device should be used,
|stream->device_name_| will be "default". When overwritten that device will be
used going forward, even if the default changes.

Looking closer at this, instead move getting the system default device name into
PulseAudioInputStream::Open(). There first check if |device_name_| ==
AudioManagerBase::kDefaultDeviceId. If yes get the system default device name
and use that when calling CreateInputStream(). If no, use |device_name_|. These
two functions go there as ordinary functions in the cc file.

Same for output.

[rchtara, 2016/02/25 17:17:26]

Done.

+  pa_threaded_mainloop* pa_mainloop =
+      static_cast<pa_threaded_mainloop*>(stream->pa_mainloop_);
+  pa_threaded_mainloop_signal(pa_mainloop, 0);
+}
+
+std::string GetSystemDefaultInputDevice(pa_threaded_mainloop* mainloop,
+                                        pa_context* context) {
+  DCHECK(mainloop);
+  DCHECK(context);
+  AudioParameters params(AudioParameters::Format::AUDIO_PCM_LINEAR,
+                         ChannelLayout::CHANNEL_LAYOUT_MONO,
+                         limits::kMinSampleRate, limits::kMaxBitsPerSample,
+                         limits::kMaxSamplesPerPacket);
+
+  PulseAudioInputStream stream(NULL, "", params, mainloop, context);
+
+  pa_operation* operation = pa_context_get_server_info(
+      context, SystemDefaultInputDeviceCallback, &stream);
+  WaitForOperationCompletion(mainloop, operation);
+  return stream.device_name_;
+}
+
 bool CreateInputStream(pa_threaded_mainloop* mainloop,
                        pa_context* context,
                        pa_stream** stream,
                        const AudioParameters& params,
                        const std::string& device_id,
                        pa_stream_notify_cb_t stream_callback,
                        void* user_data) {
   DCHECK(mainloop);
   DCHECK(context);
 
@@ skipping 25 matching lines @@
   // Set server-side capture buffer metrics. Detailed documentation on what
   // values should be chosen can be found at
   // freedesktop.org/software/pulseaudio/doxygen/structpa__buffer__attr.html.
   pa_buffer_attr buffer_attributes;
   const unsigned int buffer_size = params.GetBytesPerBuffer();
   buffer_attributes.maxlength = static_cast<uint32_t>(-1);
   buffer_attributes.tlength = buffer_size;
   buffer_attributes.minreq = buffer_size;
   buffer_attributes.prebuf = static_cast<uint32_t>(-1);
   buffer_attributes.fragsize = buffer_size;
+
   int flags = PA_STREAM_AUTO_TIMING_UPDATE |
               PA_STREAM_INTERPOLATE_TIMING |
               PA_STREAM_ADJUST_LATENCY |
               PA_STREAM_START_CORKED;
+
+  std::string system_default_input_device =
+      GetSystemDefaultInputDevice(mainloop, context);
+
   RETURN_ON_FAILURE(
       pa_stream_connect_record(
-          *stream,
-          device_id == AudioManagerBase::kDefaultDeviceId ?
-              NULL : device_id.c_str(),
-          &buffer_attributes,
-          static_cast<pa_stream_flags_t>(flags)) == 0,
+          *stream, device_id == AudioManagerBase::kDefaultDeviceId

[Henrik Grunell, 2016/02/24 15:54:52]

Then here, always use |device_id|.

And below for input too.

[rchtara, 2016/02/25 17:17:26]

Done.

[rchtara, 2016/02/25 17:17:26]

Done.

+                       ? system_default_input_device.c_str()
+                       : device_id.c_str(),
+          &buffer_attributes, static_cast<pa_stream_flags_t>(flags)) == 0,
       "pa_stream_connect_record FAILED ");
 
   // Wait for the stream to be ready.
   while (true) {
     pa_stream_state_t stream_state = pa_stream_get_state(*stream);
     RETURN_ON_FAILURE(
         PA_STREAM_IS_GOOD(stream_state), "Invalid PulseAudio stream state");
     if (stream_state == PA_STREAM_READY)
         break;
     pa_threaded_mainloop_wait(mainloop);
   }
 
   return true;
 }
 
+void SystemDefaultOutputDeviceCallback(pa_context* context,
+                                       const pa_server_info* info,
+                                       void* user_data) {
+  PulseAudioInputStream* stream =
+      reinterpret_cast<PulseAudioInputStream*>(user_data);
+  stream->device_name_ = info->default_sink_name;
+  pa_threaded_mainloop* pa_mainloop =
+      static_cast<pa_threaded_mainloop*>(stream->pa_mainloop_);
+  pa_threaded_mainloop_signal(pa_mainloop, 0);
+}
+
+std::string GetSystemDefaultOutputDevice(pa_threaded_mainloop* mainloop,
+                                         pa_context* context) {
+  DCHECK(mainloop);
+  DCHECK(context);
+  AudioParameters params(AudioParameters::Format::AUDIO_PCM_LINEAR,
+                         ChannelLayout::CHANNEL_LAYOUT_MONO,
+                         limits::kMinSampleRate, limits::kMaxBitsPerSample,
+                         limits::kMaxSamplesPerPacket);
+
+  PulseAudioInputStream stream(NULL, "", params, mainloop, context);
+
+  pa_operation* operation = pa_context_get_server_info(
+      context, SystemDefaultOutputDeviceCallback, &stream);
+  WaitForOperationCompletion(mainloop, operation);
+  DLOG(WARNING) << "Operation is NU" << stream.device_name_;
+  return stream.device_name_;
+}
+
 bool CreateOutputStream(pa_threaded_mainloop** mainloop,
                         pa_context** context,
                         pa_stream** stream,
                         const AudioParameters& params,
                         const std::string& device_id,
                         const std::string& app_name,
                         pa_stream_notify_cb_t stream_callback,
                         pa_stream_request_cb_t write_callback,
                         void* user_data) {
   DCHECK(!*mainloop);
@@ skipping 75 matching lines @@
   // Setting |minreq| to the exact buffer size leads to more callbacks than
   // necessary, so we've clipped it to half the buffer size.  Regardless of the
   // requested amount, we'll always fill |params.GetBytesPerBuffer()| though.
   pa_buffer_attr pa_buffer_attributes;
   pa_buffer_attributes.maxlength = static_cast<uint32_t>(-1);
   pa_buffer_attributes.minreq = params.GetBytesPerBuffer() / 2;
   pa_buffer_attributes.prebuf = static_cast<uint32_t>(-1);
   pa_buffer_attributes.tlength = params.GetBytesPerBuffer() * 3;
   pa_buffer_attributes.fragsize = static_cast<uint32_t>(-1);
 
+  std::string system_default_output_device =
+      GetSystemDefaultOutputDevice(*mainloop, *context);
+
   // Connect playback stream.  Like pa_buffer_attr, the pa_stream_flags have a
   // huge impact on the performance of the stream and were chosen through trial
   // and error.
   RETURN_ON_FAILURE(
       pa_stream_connect_playback(
-          *stream,
-          device_id == AudioManagerBase::kDefaultDeviceId ?
-              NULL : device_id.c_str(),
+          *stream, device_id == AudioManagerBase::kDefaultDeviceId
+                       ? system_default_output_device.c_str()
+                       : device_id.c_str(),
           &pa_buffer_attributes,
           static_cast<pa_stream_flags_t>(
               PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_ADJUST_LATENCY |
               PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_NOT_MONOTONIC |
               PA_STREAM_START_CORKED),
-          NULL,
-          NULL) == 0,
+          NULL, NULL) == 0,
       "pa_stream_connect_playback FAILED ");
 
   // Wait for the stream to be ready.
   while (true) {
     pa_stream_state_t stream_state = pa_stream_get_state(*stream);
     RETURN_ON_FAILURE(
         PA_STREAM_IS_GOOD(stream_state), "Invalid PulseAudio stream state");
     if (stream_state == PA_STREAM_READY)
       break;
     pa_threaded_mainloop_wait(*mainloop);
   }
 
   return true;
 }
 
 #undef RETURN_ON_FAILURE
 
 }  // namespace pulse
 
 }  // namespace media