[Hotword] Adding audio parameters to handle audio coming from the DSP.

media/audio/cras/cras_input.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/cras/cras_input.h"
 
 #include <math.h>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 165 matching lines @@
     callback_->OnError(this);
     callback_ = NULL;
     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);
 
+  // For a hotword hardware stream, only wait for a single callback.
+  // Replace the existing callback with the HotwordSampleReady one that should
+  // only run once.
+  if (params_.effects() &
+    AudioParameters::PlatformEffectsMask::HARDWARE_INPUT) {
+    if (cras_client_add_hotword_callback(client_, audio_format,
+                                         CrasInputStream::HotwordSampleReady)) {
+      DLOG(WARNING) << "Failed to add the hotword callback.";
+      callback_->OnError(this);
+      callback_ = NULL;
+    }
+  }
+

[dgreid, 2014/09/17 21:16:23]

This can go above the creation of stream_params, and either return early or
otherwise avoid adding an input stream.

[rpetterson, 2014/09/17 21:32:00]

I've moved it and wrapped it in an else sinc ei assume we still need to deal
with adding the stream (or does this take care of that? should that be in the
else as well?) and destroy the stream params when done.

[dgreid, 2014/09/17 21:36:33]

Yes put that in the else as well, there is no need to add the stream.  The call
to add_hotword_callback replaces the call to add_stream.

[rpetterson, 2014/09/17 21:40:20]

Done.

   // Adding the stream will start the audio callbacks.
   if (cras_client_add_stream(client_, &stream_id_, stream_params)) {
     DLOG(WARNING) << "Failed to add the stream.";
     callback_->OnError(this);
     callback_ = NULL;
   }
 
   // Done with config params.
   cras_audio_format_destroy(audio_format);
   cras_client_stream_params_destroy(stream_params);
@@ skipping 21 matching lines @@
                                   cras_stream_id_t stream_id,
                                   uint8* samples,
                                   size_t frames,
                                   const timespec* sample_ts,
                                   void* arg) {
   CrasInputStream* me = static_cast<CrasInputStream*>(arg);
   me->ReadAudio(frames, samples, sample_ts);
   return frames;
 }
 
+// Static callback asking for a single sample. Run on high priority thread.
+int CrasInputStream::HotwordSampleReady(cras_client* client,
+                                        cras_audio_format* fmt,
+                                        uint8* hotword_phrase,
+                                        size_t frames,
+                                        const timespec* sample_ts,
+                                        void* arg) {
+  CrasInputStream* me = static_cast<CrasInputStream*>(arg);
+  me->ReadAudio(frames, single_sample, sample_ts);

[dgreid, 2014/09/17 21:16:23]

this can be as much as two seconds of audio.  Does it need to be broken in to
smaller chunks to fit though the audio bus?

[rpetterson, 2014/09/17 21:32:00]

Question for Dale.

[DaleCurtis, 2014/09/17 22:29:22]

Yes, this needs to be converted to match the parameters given during
construction.

[rpetterson, 2014/09/22 22:24:40]

During construction of the stream? Which parameters? Is this something which
needs to happen in ReadAudio then?

[DaleCurtis, 2014/09/22 23:49:44]

As mentioned, the parameters passed in during construction of CrasInputStream.
Regarding ReadAudio, that's up to you and Dylan.  If ReadAudio() returns the
entire DSP buffer at parameters other than those mentioned, you'll need to
instantiate an AudioConverter and deliver them in a delayed fashion as if it was
real-time playout. See xians@ email about not overloading the shared memory.

The API as written seems to indicate that you'll need to do the above.

[dgreid, 2014/12/10 00:23:34]

It might be better to do it here, call ReadAudio repeatedly with
audio_bus_->frames() worth of samples until all the samples have been sent.

This is awkward, but we are using a streaming interface to send a big chunk of
data.  I'm not sure we can avoid it.

[rpetterson, 2014/12/10 00:37:43]

I'm unclear here. What do I need to change?

[dgreid, 2014/12/10 00:54:49]

ignore that comment.  it must have been a draft from an older patch set that got
sent when I sent the other message.

+  return frames;
+}
+
 // Static callback for stream errors.
 int CrasInputStream::StreamError(cras_client* client,
                                  cras_stream_id_t stream_id,
                                  int err,
                                  void* arg) {
   CrasInputStream* me = static_cast<CrasInputStream*>(arg);
   me->NotifyStreamError(err);
   return 0;
 }
 
@@ skipping 66 matching lines @@
 
 double CrasInputStream::GetVolumeRatioFromDecibels(double dB) const {
   return pow(10, dB / 20.0);
 }
 
 double CrasInputStream::GetDecibelsFromVolumeRatio(double volume_ratio) const {
   return 20 * log10(volume_ratio);
 }
 
 }  // namespace media