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 <cras_client.h>

#include "base/command_line.h"
#include "base/logging.h"
#include "media/audio/alsa/alsa_util.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()
//          |                                   |  WriteAudio()
//          |                                   |
//          |  buffer_frames written to shm     |
//          |<----------------------------------|
//          |                                   |
//         ...  Repeats for each block.        ...
//          |                                   |
//          |                                   |
//          |  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)
    : 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) {
  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) {
    LOG(WARNING) << "Unsupported audio frequency.";
    return false;
  }

  if (alsa_util::BitsToFormat(params_.bits_per_sample()) ==
      SND_PCM_FORMAT_UNKNOWN) {
    LOG(WARNING) << "Unsupported pcm format";
    return false;
  }

  // Create the client and connect to the CRAS server.
  if (cras_client_create(&client_)) {
    LOG(WARNING) << "Couldn't create CRAS client.\n";
    client_ = NULL;
    return false;
  }

  if (cras_client_connect(client_)) {
    LOG(WARNING) << "Couldn't connect CRAS client.\n";
    cras_client_destroy(client_);
    client_ = NULL;
    return false;
  }

  // Then start running the client.
  if (cras_client_run_thread(client_)) {
    LOG(WARNING) << "Couldn't run CRAS client.\n";
    cras_client_destroy(client_);
    client_ = NULL;
    return false;
  }

  return true;
}

void CrasUnifiedStream::Close() {
  if (client_) {
    cras_client_stop(client_);
    cras_client_destroy(client_);
    client_ = NULL;
  }

  // Signal to the manager that we're closed and can be removed.
  // Should be last call in the method as it deletes "this".
  manager_->ReleaseOutputStream(this);
}

void CrasUnifiedStream::Start(AudioSourceCallback* callback) {
  CHECK(callback);

  // Channel map to CRAS_CHANNEL, values in the same order of
  // corresponding source in Chromium defined Channels.
  static const int kChannelMap[] = {
    CRAS_CH_FL,
    CRAS_CH_FR,
    CRAS_CH_FC,
    CRAS_CH_LFE,
    CRAS_CH_RL,
    CRAS_CH_RR,
    CRAS_CH_FLC,
    CRAS_CH_FRC,
    CRAS_CH_RC,
    CRAS_CH_SL,
    CRAS_CH_SR
  };

  source_callback_ = callback;

  // Only start if we can enter the playing state.
  if (is_playing_)
    return;

  // Prepare |audio_format| and |stream_params| for the stream we
  // will create.
  cras_audio_format* audio_format = cras_audio_format_create(
      alsa_util::BitsToFormat(params_.bits_per_sample()),
      params_.sample_rate(),
      params_.channels());
  if (!audio_format) {
    LOG(WARNING) << "Error setting up audio parameters.";
    callback->OnError(this);
    return;
  }

  // Initialize channel layout to all -1 to indicate that none of
  // the channels is set in the layout.
  int8 layout[CRAS_CH_MAX] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };

  // Converts to CRAS defined channels. ChannelOrder will return -1
  // for channels that does not present in params_.channel_layout().
  for (size_t i = 0; i < arraysize(kChannelMap); ++i)
    layout[kChannelMap[i]] = ChannelOrder(params_.channel_layout(),
                                          static_cast<Channels>(i));

  if (cras_audio_format_set_channel_layout(audio_format, layout)) {
    LOG(WARNING) << "Error setting channel layout.";
    callback->OnError(this);
    return;
  }

  cras_stream_params* stream_params = cras_client_unified_params_create(
      stream_direction_,
      params_.frames_per_buffer(),
      CRAS_STREAM_TYPE_DEFAULT,
      0,
      this,
      CrasUnifiedStream::UnifiedCallback,
      CrasUnifiedStream::StreamError,
      audio_format);
  if (!stream_params) {
    LOG(WARNING) << "Error setting up stream parameters.";
    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";
    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.
  cras_audio_format_destroy(audio_format);
  cras_client_stream_params_destroy(stream_params);

  is_playing_ = true;
}

void CrasUnifiedStream::Stop() {
  if (!client_)
    return;

  // Removing the stream from the client stops audio.
  cras_client_rm_stream(client_, stream_id_);

  is_playing_ = false;
}

void CrasUnifiedStream::SetVolume(double volume) {
  if (!client_)
    return;
  volume_ = static_cast<float>(volume);
  cras_client_set_stream_volume(client_, stream_id_, volume_);
}

void CrasUnifiedStream::GetVolume(double* volume) {
  *volume = volume_;
}

uint32 CrasUnifiedStream::GetBytesLatency(
    const struct timespec& latency_ts) {
  uint32 latency_usec;

  // Treat negative latency (if we are too slow to render) as 0.
  if (latency_ts.tv_sec < 0 || latency_ts.tv_nsec < 0) {
    latency_usec = 0;
  } else {
    latency_usec = (latency_ts.tv_sec * base::Time::kMicrosecondsPerSecond) +
        latency_ts.tv_nsec / base::Time::kNanosecondsPerMicrosecond;
  }

  double frames_latency =
      latency_usec * params_.sample_rate() / base::Time::kMicrosecondsPerSecond;

  return static_cast<unsigned int>(frames_latency * bytes_per_frame_);
}

// Static callback asking for samples.
int CrasUnifiedStream::UnifiedCallback(cras_client* client,
                                       cras_stream_id_t stream_id,
                                       uint8* input_samples,
                                       uint8* output_samples,
                                       unsigned int frames,
                                       const timespec* input_ts,
                                       const timespec* output_ts,
                                       void* arg) {
  CrasUnifiedStream* me = static_cast<CrasUnifiedStream*>(arg);
  return me->DispatchCallback(frames,
                              input_samples,
                              output_samples,
                              input_ts,
                              output_ts);
}

// Static callback for stream errors.
int CrasUnifiedStream::StreamError(cras_client* client,
                                   cras_stream_id_t stream_id,
                                   int err,
                                   void* arg) {
  CrasUnifiedStream* me = static_cast<CrasUnifiedStream*>(arg);
  me->NotifyStreamError(err);
  return 0;
}

// Calls the appropriate rendering function for this type of stream.
uint32 CrasUnifiedStream::DispatchCallback(size_t frames,
                                           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_->OnMoreIOData(
      input_bus_.get(),
      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