Revert of Remove the last piece of deprecated synchronous IO code.

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 "base/logging.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
 // which will create its own thread that periodically calls the source for more
 // data as buffers are being consumed.
 // 4) When finished Stop() is called, which is handled by stopping the stream.
 // 5) Finally Close() is called. It cleans up and notifies the audio manager,
 // which likely will destroy this object.
 //
+// For output-only streams, a unified stream is created with 0 input channels.
+//
+// Simplified data flow for unified streams:
+//
+//   +-------------+                  +------------------+
+//   | CRAS Server |                  | Chrome Client    |
+//   +------+------+    Add Stream    +---------+--------+
+//          |<----------------------------------|
+//          |                                   |
+//          |  buffer_frames captured to shm    |
+//          |---------------------------------->|
+//          |                                   |  UnifiedCallback()
+//          |                                   |  ReadWriteAudio()
+//          |                                   |
+//          |  buffer_frames written to shm     |
+//          |<----------------------------------|
+//          |                                   |
+//         ...  Repeats for each block.        ...
+//          |                                   |
+//          |                                   |
+//          |  Remove stream                    |
+//          |<----------------------------------|
+//          |                                   |
+//
 // Simplified data flow for output only streams:
 //
 //   +-------------+                  +------------------+
 //   | CRAS Server |                  | Chrome Client    |
 //   +------+------+    Add Stream    +---------+--------+
 //          |<----------------------------------|
 //          |                                   |
 //          | Near out of samples, request more |
 //          |---------------------------------->|
 //          |                                   |  UnifiedCallback()
@@ skipping 21 matching lines @@
       params_(params),
       bytes_per_frame_(0),
       is_playing_(false),
       volume_(1.0),
       manager_(manager),
       source_callback_(NULL),
       stream_direction_(CRAS_STREAM_OUTPUT) {
   DCHECK(manager_);
   DCHECK(params_.channels()  > 0);
 
+  // Must have at least one input or output.  If there are both they must be the
+  // same.
+  int input_channels = params_.input_channels();
+
+  if (input_channels) {
+    // A unified stream for input and output.
+    DCHECK(params_.channels() == input_channels);
+    stream_direction_ = CRAS_STREAM_UNIFIED;
+    input_bus_ = AudioBus::Create(input_channels,
+                                  params_.frames_per_buffer());
+  }
+
   output_bus_ = AudioBus::Create(params);
 }
 
 CrasUnifiedStream::~CrasUnifiedStream() {
   DCHECK(!is_playing_);
 }
 
 bool CrasUnifiedStream::Open() {
   // Sanity check input values.
   if (params_.sample_rate() <= 0) {
@@ skipping 207 matching lines @@
                                            uint8* input_samples,
                                            uint8* output_samples,
                                            const timespec* input_ts,
                                            const timespec* output_ts) {
   switch (stream_direction_) {
     case CRAS_STREAM_OUTPUT:
       return WriteAudio(frames, output_samples, output_ts);
     case CRAS_STREAM_INPUT:
       NOTREACHED() << "CrasUnifiedStream doesn't support input streams.";
       return 0;
+    case CRAS_STREAM_UNIFIED:
+      return ReadWriteAudio(frames, input_samples, output_samples,
+                            input_ts, output_ts);
     default:
       break;
   }
 
   return 0;
 }
 
+// Note these are run from a real time thread, so don't waste cycles here.
+uint32 CrasUnifiedStream::ReadWriteAudio(size_t frames,
+                                         uint8* input_samples,
+                                         uint8* output_samples,
+                                         const timespec* input_ts,
+                                         const timespec* output_ts) {
+  DCHECK_EQ(frames, static_cast<size_t>(output_bus_->frames()));
+  DCHECK(source_callback_);
+
+  uint32 bytes_per_sample = bytes_per_frame_ / params_.channels();
+  input_bus_->FromInterleaved(input_samples, frames, bytes_per_sample);
+
+  // Determine latency and pass that on to the source.  We have the capture time
+  // of the first input sample and the playback time of the next audio sample
+  // passed from the audio server, add them together for total latency.
+  uint32 total_delay_bytes;
+  timespec latency_ts  = {0, 0};
+  cras_client_calc_capture_latency(input_ts, &latency_ts);
+  total_delay_bytes = GetBytesLatency(latency_ts);
+  cras_client_calc_playback_latency(output_ts, &latency_ts);
+  total_delay_bytes += GetBytesLatency(latency_ts);
+
+  int frames_filled = source_callback_->OnMoreData(
+      output_bus_.get(),
+      AudioBuffersState(0, total_delay_bytes));
+
+  output_bus_->ToInterleaved(frames_filled, bytes_per_sample, output_samples);
+
+  return frames_filled;
+}
+
 uint32 CrasUnifiedStream::WriteAudio(size_t frames,
                                      uint8* buffer,
                                      const timespec* sample_ts) {
   DCHECK_EQ(frames, static_cast<size_t>(output_bus_->frames()));
 
   // Determine latency and pass that on to the source.
   timespec latency_ts  = {0, 0};
   cras_client_calc_playback_latency(sample_ts, &latency_ts);
 
   int frames_filled = source_callback_->OnMoreData(
       output_bus_.get(), AudioBuffersState(0, GetBytesLatency(latency_ts)));
 
   // Note: If this ever changes to output raw float the data must be clipped and
   // sanitized since it may come from an untrusted source such as NaCl.
   output_bus_->ToInterleaved(
       frames_filled, bytes_per_frame_ / params_.channels(), buffer);
 
   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