Enable pinning stream output routing for webapp request on ChromeOS

media/audio/cras/cras_unified.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/cras_unified.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/strings/string_number_conversions.h"
 #include "media/audio/cras/audio_manager_cras.h"
 
 namespace media {
 
 // Overview of operation:
 // 1) An object of CrasUnifiedStream is created by the AudioManager
 // factory: audio_man->MakeAudioStream().
 // 2) Next some thread will call Open(), at that point a client is created and
 // configured for the correct format and sample rate.
 // 3) Then Start(source) is called and a stream is added to the CRAS client
@@ skipping 24 matching lines @@
 //          |  Remove stream                    |
 //          |<----------------------------------|
 //          |                                   |
 //
 // For Unified streams the Chrome client is notified whenever buffer_frames have
 // been captured.  For Output streams the client is notified a few milliseconds
 // before the hardware buffer underruns and fills the buffer with another block
 // of audio.
 
 CrasUnifiedStream::CrasUnifiedStream(const AudioParameters& params,
-                                     AudioManagerCras* manager)
+                                     AudioManagerCras* manager,
+                                     const std::string& device_id)
     : client_(NULL),
       stream_id_(0),
       params_(params),
       bytes_per_frame_(0),
       is_playing_(false),
       volume_(1.0),
       manager_(manager),
       source_callback_(NULL),
-      stream_direction_(CRAS_STREAM_OUTPUT) {
+      stream_direction_(CRAS_STREAM_OUTPUT),
+      pin_device_(NO_DEVICE) {
   DCHECK(manager_);
   DCHECK_GT(params_.channels(), 0);
 
   output_bus_ = AudioBus::Create(params);
+  if (!manager_->IsDefault(device_id, false)) {
+    uint64_t cras_node_id;
+    base::StringToUint64(device_id, &cras_node_id);
+    pin_device_ = dev_index_of(cras_node_id);
+  }
 }
 
 CrasUnifiedStream::~CrasUnifiedStream() {
   DCHECK(!is_playing_);
 }
 
 bool CrasUnifiedStream::Open() {
   // Sanity check input values.
   if (params_.sample_rate() <= 0) {
     LOG(WARNING) << "Unsupported audio frequency.";
@@ skipping 110 matching lines @@
     callback->OnError(this);
     cras_audio_format_destroy(audio_format);
     return;
   }
 
   // Before starting the stream, save the number of bytes in a frame for use in
   // the callback.
   bytes_per_frame_ = cras_client_format_bytes_per_frame(audio_format);
 
   // Adding the stream will start the audio callbacks requesting data.
-  if (cras_client_add_stream(client_, &stream_id_, stream_params) < 0) {
-    LOG(WARNING) << "Failed to add the stream";
+  if (cras_client_add_pinned_stream(client_, pin_device_, &stream_id_,
+                                    stream_params)) {
+    LOG(WARNING) << "Failed to add the stream.";

[dgreid, 2016/11/30 01:45:08]

How does this work when the Chrome OS UI switches the device?  What about when a
device is unplugged?

I was expecting this to set a pinned device when needed, but add a default
stream otherwise.

[Qiang(Joe) Xu, 2016/11/30 02:08:44]

The expectation can be satisfied. When GetUserMedia is called, audio manager
(AudioManagerCras here) MakeOutputStream, depending on the device_id (Default
choice or device that wants to be pinned to), pin_device_ will be initialized in
line 72-76. If 'Default' label is chosen, pin_device_ == NO_DEVICE, which will
be the default stream, otherwise pin_device_ is a dev_idx.

cras_client_add_pinned_stream(client_, NO_DEVICE, &stream_id_, stream_params) is
equal to cras_client_add_stream(client_, &stream_id_, stream_params)

When ChromeOS UI switches the device, it matters when the choice is 'Default',
but it doesn't matter for other choices.

When a device is unplugged, all I can think of is if this device is doing
pinning stream, it can no longer fill or read audio datas anymore... my cl
doesn't handle this. It will possibly notify stream error, and stop or destroy
the stream? If this device is not doing pinning stream, I think it is fine. The
next mediaDevices.enumerateDevices call will not show the unplugged device.

     callback->OnError(this);
     cras_audio_format_destroy(audio_format);
     cras_client_stream_params_destroy(stream_params);
     return;
   }
 
   // Set initial volume.
   cras_client_set_stream_volume(client_, stream_id_, volume_);
 
   // Done with config params.
@@ skipping 94 matching lines @@
   return frames_filled;
 }
 
 void CrasUnifiedStream::NotifyStreamError(int err) {
   // This will remove the stream from the client.
   if (source_callback_)
     source_callback_->OnError(this);
 }
 
 }  // namespace media