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"
@@ skipping 143 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)
 
+static std::string system_default_input_device;
+static std::string system_default_output_device;
+
+void SystemDefaultDeviceCallback(pa_context* context,

[Henrik Grunell, 2016/02/23 11:13:24]

Put these functions in the anonymous namespace above since they're only used in
this file.

[Henrik Grunell, 2016/02/23 11:13:24]

Add comments with brief description for these two functions.

[rchtara, 2016/02/23 14:58:51]

Done.

[rchtara, 2016/02/23 14:58:51]

I changed the cl architecture to use stream objects for storing device names.
I cannot move now the new functions I introduced to an anonymous name space
because the new functions need to be friends with the PulseAudioInputStream so
we can access the private attributes of PulseAudioInputStream from the new
functions.

+                                 const pa_server_info* info,
+                                 void* mainloop) {
+
+  system_default_input_device = info->default_source_name;

[Henrik Grunell, 2016/02/23 11:13:24]

Store the system default device names in the stream objects instead. See e.g.
https://code.google.com/p/chromium/codesearch#chromium/src/media/audio/pulse/...

Seems like that callback doesn't signal, but others do. Can you look into why
and if needed here?

[rchtara, 2016/02/23 14:58:51]

Done
In the callback,  pa_threaded_mainloop_signal is called. so the callback is
signaling.

+  system_default_output_device = info->default_sink_name;
+  pa_threaded_mainloop* pa_mainloop =
+      static_cast<pa_threaded_mainloop*>(mainloop);
+  pa_threaded_mainloop_signal(pa_mainloop, 0);
+}
+
+void GetSystemDefaultDevice(pa_threaded_mainloop* mainloop,
+                            pa_context* context) {
+  DCHECK(mainloop);
+  DCHECK(context);
+
+  pa_operation* operation = pa_context_get_server_info(
+      context, SystemDefaultDeviceCallback, mainloop);
+
+  WaitForOperationCompletion(mainloop, operation);
+}
+
 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;
+
+  GetSystemDefaultDevice(mainloop, context);
+
   RETURN_ON_FAILURE(
       pa_stream_connect_record(
           *stream,
           device_id == AudioManagerBase::kDefaultDeviceId ?
-              NULL : device_id.c_str(),
+              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)
@@ skipping 92 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);
 
+  GetSystemDefaultDevice(*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(),
+              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,
       "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