// Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
extern "C" {
#include "audio_thread.c"
}
#include <stdio.h>
#include <sys/select.h>
#include <gtest/gtest.h>
extern "C" {
struct dev_stream_capture_call {
struct dev_stream *dev_stream;
const struct cras_audio_area *area;
unsigned int dev_index;
unsigned int num_called;
};
struct cap_sleep_frames_call {
struct dev_stream *dev_stream;
unsigned int written;
unsigned int num_called;
};
static int dev_stream_mix_dont_fill_next;
static unsigned int dev_stream_mix_count;
static unsigned int cras_mix_mute_count;
static unsigned int dev_stream_request_playback_samples_called;
static unsigned int cras_rstream_destroy_called;
static unsigned int cras_metrics_log_histogram_called;
static const char *cras_metrics_log_histogram_name;
static unsigned int cras_metrics_log_histogram_sample;
static unsigned int cras_metrics_log_event_called;
static void (*cras_system_add_select_fd_callback)(void *data);
static void *cras_system_add_select_fd_callback_data;
static int select_return_value;
static struct timeval select_timeval;
static int select_max_fd;
static fd_set select_in_fds;
static fd_set select_out_fds;
static uint32_t *select_write_ptr;
static uint32_t select_write_value;
static unsigned int cras_iodev_set_format_called;
static unsigned int dev_stream_set_delay_called;
static unsigned int cras_system_get_volume_return;
static unsigned int dev_stream_mix_called;
static struct timespec time_now;
static int cras_fmt_conversion_needed_return_val;
static struct cras_audio_area *dummy_audio_area1;
static struct cras_audio_area *dummy_audio_area2;
static struct cras_audio_format cras_iodev_set_format_val;
static struct dev_stream_capture_call dev_stream_capture_call;
static struct cap_sleep_frames_call cap_sleep_frames_call;
}
// Number of frames past target that will be added to sleep times to insure that
// all frames are ready.
static const int CAP_EXTRA_SLEEP_FRAMES = 16;
// Test the audio capture path.
class ReadStreamSuite : public testing::Test {
protected:
virtual void SetUp() {
memset(&cras_iodev_set_format_val, 0, sizeof(cras_iodev_set_format_val));
cras_iodev_set_format_val.frame_rate = 44100;
cras_iodev_set_format_val.num_channels = 2;
cras_iodev_set_format_val.format = SND_PCM_FORMAT_S16_LE;
memset(&iodev_, 0, sizeof(iodev_));
iodev_.buffer_size = 16384;
cb_threshold_ = 480;
iodev_.direction = CRAS_STREAM_INPUT;
iodev_.frames_queued = frames_queued;
iodev_.delay_frames = delay_frames;
iodev_.get_buffer = get_buffer;
iodev_.put_buffer = put_buffer;
iodev_.is_open = is_open;
iodev_.open_dev = open_dev;
iodev_.close_dev = close_dev;
iodev_.dev_running = dev_running;
memcpy(&output_dev_, &iodev_, sizeof(output_dev_));
output_dev_.direction = CRAS_STREAM_OUTPUT;
SetupRstream(&rstream_, 1);
shm_ = cras_rstream_input_shm(rstream_);
SetupRstream(&rstream2_, 2);
shm2_ = cras_rstream_input_shm(rstream2_);
dummy_audio_area1 = (cras_audio_area*)calloc(1,
sizeof(cras_audio_area) + 2 * sizeof(cras_channel_area));
dummy_audio_area1->num_channels = 2;
channel_area_set_channel(&dummy_audio_area1->channels[0], CRAS_CH_FL);
channel_area_set_channel(&dummy_audio_area1->channels[1], CRAS_CH_FR);
rstream_->input_audio_area = dummy_audio_area1;
dummy_audio_area2 = (cras_audio_area*)calloc(1,
sizeof(cras_audio_area) + 2 * sizeof(cras_channel_area));
dummy_audio_area2->num_channels = 2;
channel_area_set_channel(&dummy_audio_area2->channels[0], CRAS_CH_FL);
channel_area_set_channel(&dummy_audio_area2->channels[1], CRAS_CH_FR);
rstream2_->input_audio_area = dummy_audio_area2;
dev_stream_mix_dont_fill_next = 0;
dev_stream_mix_count = 0;
dev_running_called_ = 0;
is_open_ = 0;
close_dev_called_ = 0;
cras_iodev_set_format_called = 0;
dev_stream_set_delay_called = 0;
}
virtual void TearDown() {
free(shm_->area);
free(rstream_);
free(shm2_->area);
free(rstream2_);
free(dummy_audio_area1);
free(dummy_audio_area2);
}
void SetupRstream(struct cras_rstream **rstream, int fd) {
struct cras_audio_shm *shm;
*rstream = (struct cras_rstream *)calloc(1, sizeof(**rstream));
memcpy(&(*rstream)->format, &cras_iodev_set_format_val,
sizeof(cras_iodev_set_format_val));
(*rstream)->direction = CRAS_STREAM_INPUT;
(*rstream)->cb_threshold = cb_threshold_;
(*rstream)->client = (struct cras_rclient *)this;
shm = cras_rstream_input_shm(*rstream);
shm->area = (struct cras_audio_shm_area *)calloc(1,
sizeof(*shm->area) + cb_threshold_ * 8);
cras_shm_set_frame_bytes(shm, 4);
cras_shm_set_used_size(
shm, cb_threshold_ * cras_shm_frame_bytes(shm));
}
unsigned int GetCaptureSleepFrames() {
// Account for padding the sleep interval to ensure the wake up happens
// after the last desired frame is received.
return cb_threshold_ + 16;
}
// Stub functions for the iodev structure.
static int frames_queued(const cras_iodev* iodev) {
return frames_queued_;
}
static int delay_frames(const cras_iodev* iodev) {
return delay_frames_;
}
static int get_buffer(cras_iodev* iodev,
struct cras_audio_area** area,
unsigned int* num) {
size_t sz = sizeof(*area_) + sizeof(struct cras_channel_area) * 2;
if (audio_buffer_size_ < *num)
*num = audio_buffer_size_;
area_ = (cras_audio_area*)calloc(1, sz);
area_->frames = *num;
area_->num_channels = 2;
area_->channels[0].buf = audio_buffer_;
channel_area_set_channel(&area_->channels[0], CRAS_CH_FL);
area_->channels[0].step_bytes = 4;
area_->channels[1].buf = audio_buffer_ + 2;
channel_area_set_channel(&area_->channels[1], CRAS_CH_FR);
area_->channels[1].step_bytes = 4;
*area = area_;
return 0;
}
static int put_buffer(cras_iodev* iodev,
unsigned int num) {
free(area_);
return 0;
}
static int is_open(const cras_iodev* iodev) {
return is_open_;
}
static int open_dev(cras_iodev* iodev) {
return 0;
}
static int close_dev(cras_iodev* iodev) {
close_dev_called_++;
return 0;
}
static int dev_running(const cras_iodev* iodev) {
dev_running_called_++;
return 1;
}
struct cras_iodev iodev_;
struct cras_iodev output_dev_;
static int is_open_;
static int frames_queued_;
static int delay_frames_;
static unsigned int cb_threshold_;
static uint8_t audio_buffer_[8192];
static struct cras_audio_area *area_;
static unsigned int audio_buffer_size_;
static unsigned int dev_running_called_;
static unsigned int close_dev_called_;
struct cras_rstream *rstream_;
struct cras_rstream *rstream2_;
struct cras_audio_shm *shm_;
struct cras_audio_shm *shm2_;
};
int ReadStreamSuite::is_open_ = 0;
int ReadStreamSuite::frames_queued_ = 0;
int ReadStreamSuite::delay_frames_ = 0;
unsigned int ReadStreamSuite::close_dev_called_ = 0;
uint8_t ReadStreamSuite::audio_buffer_[8192];
unsigned int ReadStreamSuite::audio_buffer_size_ = 0;
unsigned int ReadStreamSuite::dev_running_called_ = 0;
unsigned int ReadStreamSuite::cb_threshold_ = 0;
struct cras_audio_area *ReadStreamSuite::area_;
TEST_F(ReadStreamSuite, PossiblyReadGetAvailError) {
struct timespec ts;
int rc;
struct audio_thread *thread;
thread = audio_thread_create();
ASSERT_TRUE(thread);
thread_set_active_dev(thread, &iodev_);
thread_add_stream(thread, rstream_);
EXPECT_EQ(1, cras_iodev_set_format_called);
frames_queued_ = -4;
is_open_ = 1;
rc = unified_io(thread, &ts);
EXPECT_EQ(-4, rc);
EXPECT_EQ(0, ts.tv_sec);
EXPECT_EQ(0, ts.tv_nsec);
EXPECT_EQ(0, dev_stream_set_delay_called);
EXPECT_EQ(1, close_dev_called_);
audio_thread_destroy(thread);
}
TEST_F(ReadStreamSuite, PossiblyReadEmpty) {
struct timespec ts;
int rc;
uint64_t nsec_expected;
struct audio_thread *thread;
thread = audio_thread_create();
ASSERT_TRUE(thread);
thread_set_active_dev(thread, &iodev_);
thread_add_stream(thread, rstream_);
EXPECT_EQ(1, cras_iodev_set_format_called);
// If no samples are present, it should sleep for cb_threshold frames.
frames_queued_ = 0;
is_open_ = 1;
nsec_expected = (GetCaptureSleepFrames()) * 1000000000ULL /
(uint64_t)cras_iodev_set_format_val.frame_rate;
rc = unified_io(thread, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(0, ts.tv_sec);
EXPECT_EQ(0, shm_->area->write_offset[0]);
EXPECT_GE(ts.tv_nsec, nsec_expected - 1000);
EXPECT_LE(ts.tv_nsec, nsec_expected + 1000);
EXPECT_EQ(1, dev_running_called_);
EXPECT_EQ(1, dev_stream_set_delay_called);
audio_thread_destroy(thread);
}
TEST_F(ReadStreamSuite, PossiblyReadTooLittleData) {
struct timespec ts;
int rc;
uint64_t nsec_expected;
static const uint64_t num_frames_short = 40;
struct audio_thread *thread;
thread = audio_thread_create();
ASSERT_TRUE(thread);
thread_set_active_dev(thread, &iodev_);
thread_add_stream(thread, rstream_);
frames_queued_ = cb_threshold_ - num_frames_short;
is_open_ = 1;
audio_buffer_size_ = frames_queued_;
nsec_expected = ((uint64_t)num_frames_short + CAP_EXTRA_SLEEP_FRAMES) *
1000000000ULL /
(uint64_t)cras_iodev_set_format_val.frame_rate;
rc = unified_io(thread, &ts);
EXPECT_EQ(0, rc);
/* As much data as can be, should be read. */
EXPECT_EQ(&audio_buffer_[0], dev_stream_capture_call.area->channels[0].buf);
EXPECT_EQ(rstream_, dev_stream_capture_call.dev_stream->stream);
EXPECT_EQ(cb_threshold_ - num_frames_short, cap_sleep_frames_call.written);
EXPECT_EQ(0, ts.tv_sec);
EXPECT_GE(ts.tv_nsec, nsec_expected - 1000);
EXPECT_LE(ts.tv_nsec, nsec_expected + 1000);
audio_thread_destroy(thread);
}
TEST_F(ReadStreamSuite, PossiblyReadHasDataWriteStream) {
struct timespec ts;
int rc;
uint64_t nsec_expected;
struct audio_thread *thread;
thread = audio_thread_create();
ASSERT_TRUE(thread);
thread_set_active_dev(thread, &iodev_);
thread_add_stream(thread, rstream_);
// A full block plus 4 frames.
frames_queued_ = cb_threshold_ + 4;
audio_buffer_size_ = frames_queued_;
for (unsigned int i = 0; i < sizeof(audio_buffer_); i++)
audio_buffer_[i] = i;
uint64_t sleep_frames = GetCaptureSleepFrames() - 4;
nsec_expected = (uint64_t)sleep_frames * 1000000000ULL /
(uint64_t)cras_iodev_set_format_val.frame_rate;
is_open_ = 1;
// Give it some samples to copy.
rc = unified_io(thread, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(0, ts.tv_sec);
EXPECT_GE(ts.tv_nsec, nsec_expected - 1000);
EXPECT_LE(ts.tv_nsec, nsec_expected + 1000);
EXPECT_EQ(1, dev_stream_set_delay_called);
EXPECT_EQ(&audio_buffer_[0], dev_stream_capture_call.area->channels[0].buf);
EXPECT_EQ(rstream_, dev_stream_capture_call.dev_stream->stream);
EXPECT_EQ(cb_threshold_, cap_sleep_frames_call.written);
EXPECT_EQ(rstream_, cap_sleep_frames_call.dev_stream->stream);
audio_thread_destroy(thread);
}
TEST_F(ReadStreamSuite, PossiblyReadHasDataWriteTwoStreams) {
struct timespec ts;
int rc;
uint64_t nsec_expected;
struct audio_thread *thread;
dev_stream_capture_call.num_called = 0;
cap_sleep_frames_call.num_called = 0;
thread = audio_thread_create();
ASSERT_TRUE(thread);
thread_set_active_dev(thread, &iodev_);
rc = thread_add_stream(thread, rstream_);
EXPECT_EQ(0, rc);
rc = thread_add_stream(thread, rstream2_);
EXPECT_EQ(0, rc);
// A full block plus 4 frames.
frames_queued_ = cb_threshold_ + 4;
audio_buffer_size_ = frames_queued_;
for (unsigned int i = 0; i < sizeof(audio_buffer_); i++)
audio_buffer_[i] = i;
uint64_t sleep_frames = GetCaptureSleepFrames() - 4;
nsec_expected = (uint64_t)sleep_frames * 1000000000ULL /
(uint64_t)cras_iodev_set_format_val.frame_rate;
is_open_ = 1;
// Give it some samples to copy.
rc = unified_io(thread, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(0, ts.tv_sec);
EXPECT_GE(ts.tv_nsec, nsec_expected - 1000);
EXPECT_LE(ts.tv_nsec, nsec_expected + 1000);
EXPECT_EQ(2, dev_stream_capture_call.num_called);
EXPECT_EQ(2, cap_sleep_frames_call.num_called);
audio_thread_destroy(thread);
}
TEST_F(ReadStreamSuite, PossiblyReadHasDataWriteTwoDifferentStreams) {
struct timespec ts;
int rc;
uint64_t nsec_expected;
struct audio_thread *thread;
thread = audio_thread_create();
ASSERT_TRUE(thread);
thread_set_active_dev(thread, &iodev_);
cb_threshold_ /= 2;
rstream_->cb_threshold = cb_threshold_;
rc = thread_add_stream(thread, rstream_);
EXPECT_EQ(0, rc);
rc = thread_add_stream(thread, rstream2_);
EXPECT_EQ(0, rc);
// A full block plus 4 frames.
frames_queued_ = cb_threshold_ + 4;
audio_buffer_size_ = frames_queued_;
uint64_t sleep_frames = GetCaptureSleepFrames() - 4;
nsec_expected = (uint64_t)sleep_frames * 1000000000ULL /
(uint64_t)cras_iodev_set_format_val.frame_rate;
is_open_ = 1;
// Give it some samples to copy.
rc = unified_io(thread, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(0, ts.tv_sec);
EXPECT_GE(ts.tv_nsec, nsec_expected - 1000);
EXPECT_LE(ts.tv_nsec, nsec_expected + 1000);
frames_queued_ = cb_threshold_ + 5;
sleep_frames = GetCaptureSleepFrames() - 5;
nsec_expected = (uint64_t)sleep_frames * 1000000000ULL /
(uint64_t)cras_iodev_set_format_val.frame_rate;
audio_buffer_size_ = frames_queued_;
is_open_ = 1;
// Give it some samples to copy.
rc = unified_io(thread, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(0, ts.tv_sec);
EXPECT_GE(ts.tv_nsec, nsec_expected - 1000);
EXPECT_LE(ts.tv_nsec, nsec_expected + 1000);
audio_thread_destroy(thread);
}
TEST_F(ReadStreamSuite, PossiblyReadWriteThreeBuffers) {
struct timespec ts;
int rc;
struct audio_thread *thread;
thread = audio_thread_create();
ASSERT_TRUE(thread);
thread_set_active_dev(thread, &iodev_);
thread_add_stream(thread, rstream_);
// A full block plus 4 frames.
frames_queued_ = cb_threshold_ + 4;
audio_buffer_size_ = frames_queued_;
is_open_ = 1;
// Give it some samples to copy.
rc = unified_io(thread, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(0, cras_shm_num_overruns(shm_));
EXPECT_EQ(&audio_buffer_[0], dev_stream_capture_call.area->channels[0].buf);
EXPECT_EQ(rstream_, dev_stream_capture_call.dev_stream->stream);
EXPECT_EQ(cb_threshold_, cap_sleep_frames_call.written);
EXPECT_EQ(rstream_, cap_sleep_frames_call.dev_stream->stream);
is_open_ = 1;
rc = unified_io(thread, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(0, cras_shm_num_overruns(shm_));
EXPECT_EQ(&audio_buffer_[0], dev_stream_capture_call.area->channels[0].buf);
EXPECT_EQ(rstream_, dev_stream_capture_call.dev_stream->stream);
EXPECT_EQ(cb_threshold_, cap_sleep_frames_call.written);
EXPECT_EQ(rstream_, cap_sleep_frames_call.dev_stream->stream);
is_open_ = 1;
rc = unified_io(thread, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(&audio_buffer_[0], dev_stream_capture_call.area->channels[0].buf);
EXPECT_EQ(rstream_, dev_stream_capture_call.dev_stream->stream);
EXPECT_EQ(cb_threshold_, cap_sleep_frames_call.written);
EXPECT_EQ(rstream_, cap_sleep_frames_call.dev_stream->stream);
audio_thread_destroy(thread);
}
// Test the audio playback path.
class WriteStreamSuite : public testing::Test {
protected:
virtual void SetUp() {
memset(&fmt_, 0, sizeof(fmt_));
fmt_.frame_rate = 44100;
fmt_.num_channels = 2;
fmt_.format = SND_PCM_FORMAT_S16_LE;
memset(&iodev_, 0, sizeof(iodev_));
iodev_.format = &fmt_;
iodev_.buffer_size = 16384;
iodev_.direction = CRAS_STREAM_OUTPUT;
iodev_.frames_queued = frames_queued;
iodev_.delay_frames = delay_frames;
iodev_.get_buffer = get_buffer;
iodev_.put_buffer = put_buffer;
iodev_.dev_running = dev_running;
iodev_.is_open = is_open;
iodev_.open_dev = open_dev;
iodev_.close_dev = close_dev;
iodev_.buffer_size = 480;
buffer_frames_ = iodev_.buffer_size;
cb_threshold_ = 96;
SetupRstream(&rstream_, 1);
shm_ = cras_rstream_output_shm(rstream_);
SetupRstream(&rstream2_, 2);
shm2_ = cras_rstream_output_shm(rstream2_);
thread_ = audio_thread_create();
ASSERT_TRUE(thread_);
thread_set_active_dev(thread_, &iodev_);
dev_stream_mix_dont_fill_next = 0;
dev_stream_mix_count = 0;
select_max_fd = -1;
select_write_ptr = NULL;
cras_metrics_log_event_called = 0;
dev_stream_request_playback_samples_called = 0;
cras_rstream_destroy_called = 0;
dev_stream_mix_called = 0;
is_open_ = 0;
close_dev_called_ = 0;
dev_running_called_ = 0;
audio_buffer_size_ = 8196;
thread_add_stream(thread_, rstream_);
frames_written_ = 0;
}
virtual void TearDown() {
free(shm_->area);
free(rstream_);
free(shm2_->area);
free(rstream2_);
audio_thread_destroy(thread_);
}
void SetupRstream(struct cras_rstream **rstream, int fd) {
struct cras_audio_shm *shm;
*rstream = (struct cras_rstream *)calloc(1, sizeof(**rstream));
memcpy(&(*rstream)->format, &fmt_, sizeof(fmt_));
(*rstream)->fd = fd;
(*rstream)->buffer_frames = buffer_frames_;
(*rstream)->cb_threshold = cb_threshold_;
(*rstream)->client = (struct cras_rclient *)this;
shm = cras_rstream_output_shm(*rstream);
shm->area = (struct cras_audio_shm_area *)calloc(1,
sizeof(*shm->area) + cb_threshold_ * 8);
cras_shm_set_frame_bytes(shm, 4);
cras_shm_set_used_size(
shm, buffer_frames_ * cras_shm_frame_bytes(shm));
}
uint64_t GetCaptureSleepFrames() {
// Account for padding the sleep interval to ensure the wake up happens
// after the last desired frame is received.
return cb_threshold_ + CAP_EXTRA_SLEEP_FRAMES;
}
// Stub functions for the iodev structure.
static int frames_queued(const cras_iodev* iodev) {
return frames_queued_ + frames_written_;
}
static int delay_frames(const cras_iodev* iodev) {
return delay_frames_;
}
static int get_buffer(cras_iodev* iodev,
struct cras_audio_area** area,
unsigned int* num) {
size_t sz = sizeof(*area_) + sizeof(struct cras_channel_area) * 2;
if (audio_buffer_size_ < *num)
*num = audio_buffer_size_;
area_ = (cras_audio_area*)calloc(1, sz);
area_->frames = *num;
area_->num_channels = 2;
area_->channels[0].buf = audio_buffer_;
channel_area_set_channel(&area_->channels[0], CRAS_CH_FL);
area_->channels[0].step_bytes = 4;
area_->channels[1].buf = audio_buffer_ + 2;
channel_area_set_channel(&area_->channels[1], CRAS_CH_FR);
area_->channels[1].step_bytes = 4;
*area = area_;
return 0;
}
static int put_buffer(cras_iodev* iodev,
unsigned int num) {
free(area_);
frames_written_ += num;
return 0;
}
static int dev_running(const cras_iodev* iodev) {
dev_running_called_++;
return dev_running_;
}
static int is_open(const cras_iodev* iodev) {
return is_open_;
}
static int open_dev(cras_iodev* iodev) {
is_open_ = 1;
open_dev_called_++;
return 0;
}
static int close_dev(cras_iodev* iodev) {
close_dev_called_++;
is_open_ = 0;
return 0;
}
struct cras_iodev iodev_;
static int is_open_;
static int frames_queued_;
static int frames_written_;
static int delay_frames_;
static unsigned int cb_threshold_;
static unsigned int buffer_frames_;
static uint8_t audio_buffer_[8192];
static unsigned int audio_buffer_size_;
static int dev_running_;
static unsigned int dev_running_called_;
static unsigned int close_dev_called_;
static unsigned int open_dev_called_;
static struct cras_audio_area *area_;
struct cras_audio_format fmt_;
struct cras_rstream* rstream_;
struct cras_rstream* rstream2_;
struct cras_audio_shm* shm_;
struct cras_audio_shm* shm2_;
struct audio_thread *thread_;
};
int WriteStreamSuite::is_open_ = 0;
int WriteStreamSuite::frames_queued_ = 0;
int WriteStreamSuite::frames_written_ = 0;
int WriteStreamSuite::delay_frames_ = 0;
unsigned int WriteStreamSuite::cb_threshold_ = 0;
unsigned int WriteStreamSuite::buffer_frames_ = 0;
uint8_t WriteStreamSuite::audio_buffer_[8192];
unsigned int WriteStreamSuite::audio_buffer_size_ = 0;
int WriteStreamSuite::dev_running_ = 1;
unsigned int WriteStreamSuite::dev_running_called_ = 0;
unsigned int WriteStreamSuite::close_dev_called_ = 0;
unsigned int WriteStreamSuite::open_dev_called_ = 0;
struct cras_audio_area *WriteStreamSuite::area_;
TEST_F(WriteStreamSuite, PossiblyFillGetAvailError) {
struct timespec ts;
int rc;
frames_queued_ = -4;
is_open_ = 1;
rc = unified_io(thread_, &ts);
EXPECT_EQ(-4, rc);
EXPECT_EQ(0, ts.tv_sec);
EXPECT_EQ(0, ts.tv_nsec);
EXPECT_EQ(1, close_dev_called_);
}
TEST_F(WriteStreamSuite, PossiblyFillEarlyWake) {
struct timespec ts;
int rc;
// If woken and still have tons of data to play, go back to sleep.
frames_queued_ = cb_threshold_ * 2;
audio_buffer_size_ = buffer_frames_ - frames_queued_;
iodev_.direction = CRAS_STREAM_OUTPUT;
is_open_ = 1;
rc = unified_io(thread_, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(0, ts.tv_sec);
}
TEST_F(WriteStreamSuite, PossiblyFillGetFromStreamFull) {
struct timespec ts;
int rc;
uint64_t nsec_expected;
// Have cb_threshold samples left.
frames_queued_ = cb_threshold_;
audio_buffer_size_ = buffer_frames_ - frames_queued_;
nsec_expected = (uint64_t)cb_threshold_ *
1000000000ULL / (uint64_t)fmt_.frame_rate;
// shm has plenty of data in it.
shm_->area->write_offset[0] = cb_threshold_ * 4;
FD_ZERO(&select_out_fds);
FD_SET(rstream_->fd, &select_out_fds);
select_return_value = 1;
is_open_ = 1;
rc = unified_io(thread_, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(0, ts.tv_sec);
EXPECT_GE(ts.tv_nsec, nsec_expected - 1000);
EXPECT_LE(ts.tv_nsec, nsec_expected + 1000);
EXPECT_EQ(cb_threshold_, dev_stream_mix_count);
EXPECT_EQ(0, dev_stream_request_playback_samples_called);
EXPECT_EQ(-1, select_max_fd);
}
TEST_F(WriteStreamSuite, PossiblyFillGetFromStreamMinSet) {
struct timespec ts;
int rc;
uint64_t nsec_expected;
// Have cb_threshold samples left.
frames_queued_ = cb_threshold_ * 2;
audio_buffer_size_ = buffer_frames_ - frames_queued_;
// Setting the min_buffer_level should shorten the sleep time.
iodev_.min_buffer_level = cb_threshold_;
// shm has is empty.
shm_->area->write_offset[0] = 0;
FD_ZERO(&select_out_fds);
FD_SET(rstream_->fd, &select_out_fds);
select_return_value = 1;
is_open_ = 1;
// Set write offset after call to select.
select_write_ptr = &shm_->area->write_offset[0];
select_write_value = cb_threshold_ * 4;
// After the callback there will be cb_thresh of data in the buffer and
// cb_thresh x 2 data in the hardware (frames_queued_) = 3 cb_thresh total.
// It should sleep until there is a total of cb_threshold + min_buffer_level
// left, or 3 - 2 = 1 cb_thresh worth of delay.
nsec_expected = (uint64_t)cb_threshold_ *
1000000000ULL / (uint64_t)fmt_.frame_rate;
rc = unified_io(thread_, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(0, ts.tv_sec);
EXPECT_GE(ts.tv_nsec, nsec_expected - 1000);
EXPECT_LE(ts.tv_nsec, nsec_expected + 1000);
EXPECT_EQ(cb_threshold_, dev_stream_mix_count);
EXPECT_EQ(1, dev_stream_request_playback_samples_called);
}
TEST_F(WriteStreamSuite, PossiblyFillFramesQueued) {
struct timespec ts;
int rc;
// Have cb_threshold samples left.
frames_queued_ = cb_threshold_;
audio_buffer_size_ = buffer_frames_ - frames_queued_;
// shm has plenty of data in it.
shm_->area->write_offset[0] = cras_shm_used_size(shm_);
is_open_ = 1;
rc = unified_io(thread_, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(1, dev_running_called_);
}
TEST_F(WriteStreamSuite, PossiblyFillGetFromStreamOneEmpty) {
struct timespec ts;
int rc;
// Have cb_threshold samples left.
frames_queued_ = cb_threshold_;
audio_buffer_size_ = buffer_frames_ - frames_queued_;
// shm has plenty of data in it.
shm_->area->write_offset[0] = cras_shm_used_size(shm_);
// Test that nothing breaks if there is an empty stream.
dev_stream_mix_dont_fill_next = 1;
FD_ZERO(&select_out_fds);
FD_SET(rstream_->fd, &select_out_fds);
select_return_value = 1;
is_open_ = 1;
rc = unified_io(thread_, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(0, dev_stream_request_playback_samples_called);
EXPECT_EQ(-1, select_max_fd);
EXPECT_EQ(0, shm_->area->read_offset[0]);
EXPECT_EQ(0, shm_->area->read_offset[1]);
EXPECT_EQ(cras_shm_used_size(shm_), shm_->area->write_offset[0]);
EXPECT_EQ(0, shm_->area->write_offset[1]);
}
TEST_F(WriteStreamSuite, PossiblyFillGetFromStreamNeedFill) {
struct timespec ts;
uint64_t nsec_expected;
int rc;
// Have cb_threshold samples left.
frames_queued_ = cb_threshold_;
audio_buffer_size_ = buffer_frames_ - frames_queued_;
// shm is out of data.
shm_->area->write_offset[0] = 0;
FD_ZERO(&select_out_fds);
FD_SET(rstream_->fd, &select_out_fds);
select_return_value = 1;
// Set write offset after call to select.
select_write_ptr = &shm_->area->write_offset[0];
select_write_value = (buffer_frames_ - cb_threshold_) * 4;
nsec_expected = (buffer_frames_ - cb_threshold_) *
1000000000ULL / (uint64_t)fmt_.frame_rate;
is_open_ = 1;
rc = unified_io(thread_, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(0, ts.tv_sec);
EXPECT_GE(ts.tv_nsec, nsec_expected - 1000);
EXPECT_LE(ts.tv_nsec, nsec_expected + 1000);
EXPECT_EQ(buffer_frames_ - cb_threshold_, dev_stream_mix_count);
EXPECT_EQ(1, dev_stream_request_playback_samples_called);
EXPECT_NE(-1, select_max_fd);
EXPECT_EQ(0, memcmp(&select_out_fds, &select_in_fds, sizeof(select_in_fds)));
EXPECT_EQ(0, shm_->area->read_offset[0]);
}
TEST_F(WriteStreamSuite, PossiblyFillGetFromTwoStreamsFull) {
struct timespec ts;
int rc;
uint64_t nsec_expected;
// Have cb_threshold samples left.
frames_queued_ = cras_rstream_get_cb_threshold(rstream_);
audio_buffer_size_ = buffer_frames_ - frames_queued_;
nsec_expected = (uint64_t)cras_rstream_get_cb_threshold(rstream_) *
1000000000ULL / (uint64_t)fmt_.frame_rate;
// shm has plenty of data in it.
shm_->area->write_offset[0] = cras_rstream_get_cb_threshold(rstream_) * 4;
shm2_->area->write_offset[0] = cras_rstream_get_cb_threshold(rstream2_) * 4;
thread_add_stream(thread_, rstream2_);
is_open_ = 1;
rc = unified_io(thread_, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(2, dev_stream_mix_called);
EXPECT_EQ(0, ts.tv_sec);
EXPECT_GE(ts.tv_nsec, nsec_expected - 1000);
EXPECT_LE(ts.tv_nsec, nsec_expected + 1000);
EXPECT_EQ(cras_rstream_get_cb_threshold(rstream_),
dev_stream_mix_count);
EXPECT_EQ(0, dev_stream_request_playback_samples_called);
EXPECT_EQ(-1, select_max_fd);
}
TEST_F(WriteStreamSuite, PossiblyFillGetFromTwoOneEmptySmallerCbThreshold) {
struct timespec ts;
int rc;
uint64_t nsec_expected;
// Have cb_threshold samples left.
frames_queued_ = cb_threshold_;
audio_buffer_size_ = buffer_frames_ - frames_queued_;
// First stream is empty and with a smaller cb_threshold. This is to test
// the case that when buffer level reaches the cb_threshold of one stream
// but not yet the other stream of smaller cb_threshold.
rstream_->cb_threshold -= 20;
nsec_expected = 20 * 1000000000ULL / (uint64_t)fmt_.frame_rate;
shm_->area->write_offset[0] = 0;
shm2_->area->write_offset[0] = cras_shm_used_size(shm2_);
thread_add_stream(thread_, rstream2_);
is_open_ = 1;
rc = unified_io(thread_, &ts);
// In this case, assert (1) we didn't request the empty stream since buffer
// level is larger then its cb_threshold, (2) still mix both streams so
// dev_stream_mix_count is zero, and (3) the resulting sleep frames
// equals the cb_threshold difference.
EXPECT_EQ(0, rc);
EXPECT_EQ(2, dev_stream_mix_called);
EXPECT_GE(ts.tv_nsec, nsec_expected - 1000);
EXPECT_LE(ts.tv_nsec, nsec_expected + 1000);
EXPECT_EQ(0, dev_stream_mix_count);
EXPECT_EQ(0, dev_stream_request_playback_samples_called);
}
TEST_F(WriteStreamSuite, PossiblyFillGetFromTwoOneEmptyAfterFetch) {
struct timespec ts;
int rc;
// Have cb_threshold samples left.
frames_queued_ = cb_threshold_;
audio_buffer_size_ = buffer_frames_ - frames_queued_;
// First stream empty while the second stream full.
shm_->area->write_offset[0] = 0;
shm2_->area->write_offset[0] = cras_shm_used_size(shm2_);
thread_add_stream(thread_, rstream2_);
FD_ZERO(&select_out_fds);
FD_SET(rstream_->fd, &select_out_fds);
select_return_value = 1;
is_open_ = 1;
rc = unified_io(thread_, &ts);
// Assert that the empty stream is skipped, only one stream mixed.
EXPECT_EQ(0, rc);
EXPECT_EQ(1, dev_stream_mix_called);
EXPECT_EQ(buffer_frames_ - cb_threshold_, dev_stream_mix_count);
EXPECT_EQ(1, dev_stream_request_playback_samples_called);
EXPECT_NE(-1, select_max_fd);
EXPECT_EQ(0, memcmp(&select_out_fds, &select_in_fds, sizeof(select_in_fds)));
}
TEST_F(WriteStreamSuite, PossiblyFillGetFromTwoStreamsFullOneMixes) {
struct timespec ts;
int rc;
size_t written_expected;
// Have cb_threshold samples left.
frames_queued_ = cb_threshold_;
audio_buffer_size_ = buffer_frames_ - frames_queued_;
written_expected = buffer_frames_ - cb_threshold_;
// shm has plenty of data in it.
shm_->area->write_offset[0] = cras_shm_used_size(shm_);
shm2_->area->write_offset[0] = cras_shm_used_size(shm2_);
thread_add_stream(thread_, rstream2_);
// Test that nothing breaks if one stream doesn't fill.
dev_stream_mix_dont_fill_next = 1;
is_open_ = 1;
rc = unified_io(thread_, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(0, dev_stream_request_playback_samples_called);
EXPECT_EQ(0, shm_->area->read_offset[0]); // No write from first stream.
EXPECT_EQ(written_expected * 4, shm2_->area->read_offset[0]);
}
TEST_F(WriteStreamSuite, PossiblyFillGetFromTwoStreamsOneLimited) {
struct timespec ts;
int rc;
uint64_t nsec_expected;
static const unsigned int smaller_frames = 10;
// Have cb_threshold samples left.
frames_queued_ = cb_threshold_;
audio_buffer_size_ = buffer_frames_ - frames_queued_;
nsec_expected = (uint64_t)smaller_frames *
(1000000000ULL / (uint64_t)fmt_.frame_rate);
// One has too little the other is full.
shm_->area->write_offset[0] = smaller_frames * 4;
shm_->area->write_buf_idx = 1;
shm2_->area->write_offset[0] = cras_shm_used_size(shm2_);
shm2_->area->write_buf_idx = 1;
thread_add_stream(thread_, rstream2_);
FD_ZERO(&select_out_fds);
FD_SET(rstream_->fd, &select_out_fds);
select_return_value = 1;
is_open_ = 1;
rc = unified_io(thread_, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(0, ts.tv_sec);
EXPECT_GE(ts.tv_nsec, nsec_expected - 1000);
EXPECT_LE(ts.tv_nsec, nsec_expected + 1000);
EXPECT_EQ(smaller_frames, dev_stream_mix_count);
EXPECT_EQ(1, dev_stream_request_playback_samples_called);
EXPECT_NE(-1, select_max_fd);
}
TEST_F(WriteStreamSuite, DrainOutputBufferCompelete) {
frames_queued_ = 3 * cb_threshold_;
close_dev_called_ = 0;
// All the audio in hw buffer are extra silent frames.
iodev_.extra_silent_frames = frames_queued_ + 1;
drain_output_buffer(thread_, &iodev_);
EXPECT_EQ(1, close_dev_called_);
}
TEST_F(WriteStreamSuite, DrainOutputBufferWaitForPlayback) {
// Hardware buffer is full.
frames_queued_ = buffer_frames_;
iodev_.extra_silent_frames = 0;
close_dev_called_ = 0;
drain_output_buffer(thread_, &iodev_);
EXPECT_EQ(0, close_dev_called_);
}
TEST_F(WriteStreamSuite, DrainOutputBufferWaitForAudio) {
// Hardware buffer is almost empty
frames_queued_ = 30;
iodev_.extra_silent_frames = 0;
close_dev_called_ = 0;
drain_output_buffer(thread_, &iodev_);
EXPECT_LT(cb_threshold_ - frames_queued_, frames_written_);
EXPECT_EQ(0, close_dev_called_);
}
TEST_F(WriteStreamSuite, DrainOutputStream) {
struct timespec ts;
int rc;
// Have 3 * cb_threshold samples in the hw buffer.
// Have 4 * cb_threshold samples in the first stream's shm
// Note: used_size = 5 * cb_threshold.
frames_queued_ = 3 * cb_threshold_;
audio_buffer_size_ = buffer_frames_ - frames_queued_;
shm_->area->write_offset[0] = 4 * cb_threshold_ * 4;
is_open_ = 1;
close_dev_called_ = 0;
open_dev_called_ = 0;
thread_disconnect_stream(thread_, rstream_);
// We should be draining the audio.
EXPECT_EQ(0, close_dev_called_);
EXPECT_EQ(0, open_dev_called_);
rc = unified_io(thread_, &ts);
EXPECT_EQ(0, rc);
EXPECT_EQ(2 * cb_threshold_, frames_written_);
EXPECT_EQ(0, open_dev_called_);
EXPECT_EQ(0, close_dev_called_);
// Clear the hardware buffer
frames_queued_ = 0;
frames_written_ = 0;
audio_buffer_size_ = buffer_frames_ - frames_queued_;
rc = unified_io(thread_, &ts);
// Verified that all data in stream1 is written.
// The device is not closed before we have played all the content.
EXPECT_EQ(0, rc);
EXPECT_EQ(2 * cb_threshold_, frames_written_);
EXPECT_EQ(0, close_dev_called_);
// Clear the hardware buffer again.
frames_queued_ = 0;
frames_written_ = 0;
audio_buffer_size_ = buffer_frames_ - frames_queued_;
rc = unified_io(thread_, &ts);
EXPECT_EQ(1, cras_rstream_destroy_called);
EXPECT_EQ(1, iodev_.is_draining);
EXPECT_EQ(0, rc);
EXPECT_EQ(480, thread_->buffer_frames[CRAS_STREAM_OUTPUT]);
EXPECT_EQ(96, thread_->cb_threshold[CRAS_STREAM_OUTPUT]);
// Clear the hardware buffer again.
frames_queued_ = 0;
frames_written_ = 0;
audio_buffer_size_ = buffer_frames_ - frames_queued_;
rc = unified_io(thread_, &ts);
EXPECT_EQ(1, close_dev_called_);
EXPECT_EQ(0, thread_->buffer_frames[CRAS_STREAM_OUTPUT]);
EXPECT_EQ(0, thread_->cb_threshold[CRAS_STREAM_OUTPUT]);
}
// Test adding and removing streams.
class AddStreamSuite : public testing::Test {
protected:
virtual void SetUp() {
memset(&cras_iodev_set_format_val, 0, sizeof(cras_iodev_set_format_val));
cras_iodev_set_format_val.frame_rate = 44100;
cras_iodev_set_format_val.num_channels = 2;
cras_iodev_set_format_val.format = SND_PCM_FORMAT_S16_LE;
memset(&iodev_, 0, sizeof(iodev_));
iodev_.buffer_size = 16384;
used_size_ = 480;
cb_threshold_ = 96;
iodev_.direction = CRAS_STREAM_OUTPUT;
iodev_.is_open = is_open;
iodev_.open_dev = open_dev;
iodev_.close_dev = close_dev;
iodev_.get_buffer = get_buffer;
iodev_.put_buffer = put_buffer;
is_open_ = 0;
is_open_called_ = 0;
open_dev_called_ = 0;
close_dev_called_ = 0;
open_dev_return_val_ = 0;
cras_iodev_set_format_called = 0;
cras_rstream_destroy_called = 0;
cras_metrics_log_histogram_called = 0;
cras_metrics_log_histogram_name = NULL;
cras_metrics_log_histogram_sample = 0;
audio_buffer_size_ = 8196;
}
virtual void TearDown() {
}
unsigned int GetCaptureSleepFrames() {
// Account for padding the sleep interval to ensure the wake up happens
// after the last desired frame is received.
return cb_threshold_ + 16;
}
// Stub functions for the iodev structure.
static int get_buffer(cras_iodev* iodev,
struct cras_audio_area** area,
unsigned int* num) {
size_t sz = sizeof(*area_) + sizeof(struct cras_channel_area) * 2;
if (audio_buffer_size_ < *num)
*num = audio_buffer_size_;
area_ = (cras_audio_area*)calloc(1, sz);
area_->frames = *num;
area_->num_channels = 2;
area_->channels[0].buf = audio_buffer_;
channel_area_set_channel(&area_->channels[0], CRAS_CH_FL);
area_->channels[0].step_bytes = 4;
area_->channels[1].buf = audio_buffer_ + 2;
channel_area_set_channel(&area_->channels[1], CRAS_CH_FR);
area_->channels[1].step_bytes = 4;
*area = area_;
return 0;
}
static int put_buffer(cras_iodev* iodev,
unsigned int num) {
free(area_);
return 0;
}
static int is_open(const cras_iodev* iodev) {
is_open_called_++;
return is_open_;
}
static int open_dev(cras_iodev* iodev) {
open_dev_called_++;
is_open_ = true;
return open_dev_return_val_;
}
static int close_dev(cras_iodev* iodev) {
close_dev_called_++;
is_open_ = false;
return 0;
}
void add_rm_two_streams(CRAS_STREAM_DIRECTION direction) {
int rc;
struct cras_rstream *new_stream, *second_stream;
cras_audio_shm *shm;
struct cras_audio_format *fmt;
struct audio_thread *thread;
thread = audio_thread_create();
fmt = (struct cras_audio_format *)malloc(sizeof(*fmt));
memcpy(fmt, &cras_iodev_set_format_val, sizeof(*fmt));
iodev_.direction = direction;
new_stream = (struct cras_rstream *)calloc(1, sizeof(*new_stream));
new_stream->fd = 55;
new_stream->buffer_frames = 65;
new_stream->cb_threshold = 80;
new_stream->direction = direction;
memcpy(&new_stream->format, fmt, sizeof(*fmt));
shm = cras_rstream_output_shm(new_stream);
shm->area = (struct cras_audio_shm_area *)calloc(1, sizeof(*shm->area));
if (direction == CRAS_STREAM_INPUT)
thread_set_active_dev(thread, &iodev_);
else
thread_set_active_dev(thread, &iodev_);
thread_add_stream(thread, new_stream);
EXPECT_EQ(1, thread->devs_open[direction]);
EXPECT_EQ(1, open_dev_called_);
EXPECT_EQ(65, thread->buffer_frames[direction]);
if (direction == CRAS_STREAM_OUTPUT)
EXPECT_EQ(32, thread->cb_threshold[direction]);
else
EXPECT_EQ(80, thread->cb_threshold[direction]);
is_open_ = 1;
second_stream = (struct cras_rstream *)calloc(1, sizeof(*second_stream));
second_stream->fd = 56;
second_stream->buffer_frames = 25;
second_stream->cb_threshold = 12;
second_stream->direction = direction;
memcpy(&second_stream->format, fmt, sizeof(*fmt));
shm = cras_rstream_output_shm(second_stream);
shm->area = (struct cras_audio_shm_area *)calloc(1, sizeof(*shm->area));
is_open_called_ = 0;
thread_add_stream(thread, second_stream);
EXPECT_EQ(1, thread->devs_open[direction]);
EXPECT_EQ(1, open_dev_called_);
EXPECT_EQ(25, thread->buffer_frames[direction]);
EXPECT_EQ(12, thread->cb_threshold[direction]);
// Remove the streams.
rc = thread_remove_stream(thread, second_stream);
EXPECT_EQ(1, rc);
EXPECT_EQ(0, close_dev_called_);
if (direction == CRAS_STREAM_OUTPUT)
EXPECT_EQ(32, thread->cb_threshold[direction]);
else
EXPECT_EQ(80, thread->cb_threshold[direction]);
rc = thread_remove_stream(thread, new_stream);
EXPECT_EQ(0, rc);
// For output stream, we enter the draining mode;
// for input stream, we close the device directly.
if (direction == CRAS_STREAM_INPUT) {
EXPECT_EQ(0, thread->devs_open[direction]);
EXPECT_EQ(0, thread->buffer_frames[direction]);
EXPECT_EQ(0, thread->cb_threshold[direction]);
} else {
EXPECT_EQ(1, iodev_.is_draining);
}
free(fmt);
shm = cras_rstream_output_shm(new_stream);
audio_thread_destroy(thread);
free(shm->area);
free(new_stream);
shm = cras_rstream_output_shm(second_stream);
free(shm->area);
free(second_stream);
}
struct cras_iodev iodev_;
static int is_open_;
static int is_open_called_;
static int open_dev_called_;
static int open_dev_return_val_;
static int close_dev_called_;
static int used_size_;
static int cb_threshold_;
struct cras_audio_format fmt_;
static struct cras_audio_area *area_;
static uint8_t audio_buffer_[8192];
static unsigned int audio_buffer_size_;
};
int AddStreamSuite::is_open_ = 0;
int AddStreamSuite::is_open_called_ = 0;
int AddStreamSuite::open_dev_called_ = 0;
int AddStreamSuite::open_dev_return_val_ = 0;
int AddStreamSuite::close_dev_called_ = 0;
int AddStreamSuite::used_size_ = 0;
int AddStreamSuite::cb_threshold_ = 0;
struct cras_audio_area *AddStreamSuite::area_;
uint8_t AddStreamSuite::audio_buffer_[8192];
unsigned int AddStreamSuite::audio_buffer_size_ = 0;
TEST_F(AddStreamSuite, SimpleAddOutputStream) {
int rc;
cras_rstream* new_stream;
cras_audio_shm *shm;
struct audio_thread *thread;
thread = audio_thread_create();
new_stream = (struct cras_rstream *)calloc(1, sizeof(*new_stream));
new_stream->client = (struct cras_rclient* )this;
new_stream->fd = 55;
new_stream->buffer_frames = 65;
new_stream->cb_threshold = 80;
memcpy(&new_stream->format, &cras_iodev_set_format_val,
sizeof(cras_iodev_set_format_val));
shm = cras_rstream_output_shm(new_stream);
shm->area = (struct cras_audio_shm_area *)calloc(1, sizeof(*shm->area));
thread_set_active_dev(thread, &iodev_);
rc = thread_add_stream(thread, new_stream);
ASSERT_EQ(0, rc);
EXPECT_EQ(1, thread->devs_open[CRAS_STREAM_OUTPUT]);
EXPECT_EQ(1, open_dev_called_);
EXPECT_EQ(65, thread->buffer_frames[CRAS_STREAM_OUTPUT]);
EXPECT_EQ(32, thread->cb_threshold[CRAS_STREAM_OUTPUT]);
is_open_ = 1;
// remove the stream.
rc = thread_remove_stream(thread, new_stream);
EXPECT_EQ(0, rc);
EXPECT_EQ(1, iodev_.is_draining);
EXPECT_EQ(0, cras_metrics_log_histogram_called);
EXPECT_EQ(0, cras_rstream_destroy_called);
rc = thread_disconnect_stream(thread, new_stream);
EXPECT_EQ(1, cras_rstream_destroy_called);
free(shm->area);
audio_thread_destroy(thread);
free(new_stream);
}
TEST_F(AddStreamSuite, AddStreamOpenFail) {
struct audio_thread *thread;
cras_rstream new_stream;
cras_audio_shm *shm;
thread = audio_thread_create();
ASSERT_TRUE(thread);
thread_set_active_dev(thread, &iodev_);
printf("1\n");
shm = cras_rstream_output_shm(&new_stream);
shm->area = (struct cras_audio_shm_area *)calloc(1, sizeof(*shm->area));
open_dev_return_val_ = -1;
new_stream.direction = CRAS_STREAM_OUTPUT;
EXPECT_EQ(AUDIO_THREAD_OUTPUT_DEV_ERROR,
thread_add_stream(thread, &new_stream));
printf("2\n");
EXPECT_EQ(1, open_dev_called_);
EXPECT_EQ(1, cras_iodev_set_format_called);
audio_thread_destroy(thread);
printf("3\n");
free(shm->area);
}
TEST_F(AddStreamSuite, AddRmTwoOutputStreams) {
add_rm_two_streams(CRAS_STREAM_OUTPUT);
}
TEST_F(AddStreamSuite, AddRmTwoInputStreams) {
add_rm_two_streams(CRAS_STREAM_INPUT);
}
TEST_F(AddStreamSuite, RmStreamLogLongestTimeout) {
int rc;
cras_rstream* new_stream;
cras_audio_shm *shm;
struct audio_thread *thread;
thread = audio_thread_create();
new_stream = (struct cras_rstream *)calloc(1, sizeof(*new_stream));
new_stream->fd = 55;
new_stream->buffer_frames = 65;
new_stream->cb_threshold = 80;
memcpy(&new_stream->format, &cras_iodev_set_format_val,
sizeof(cras_iodev_set_format_val));
shm = cras_rstream_output_shm(new_stream);
shm->area = (struct cras_audio_shm_area *)calloc(1, sizeof(*shm->area));
thread_set_active_dev(thread, &iodev_);
rc = thread_add_stream(thread, new_stream);
ASSERT_EQ(0, rc);
EXPECT_EQ(1, thread->devs_open[CRAS_STREAM_OUTPUT]);
EXPECT_EQ(1, open_dev_called_);
EXPECT_EQ(65, thread->buffer_frames[CRAS_STREAM_OUTPUT]);
EXPECT_EQ(32, thread->cb_threshold[CRAS_STREAM_OUTPUT]);
is_open_ = 1;
cras_shm_set_longest_timeout(shm, 90);
// remove the stream.
rc = thread_remove_stream(thread, new_stream);
EXPECT_EQ(0, rc);
EXPECT_EQ(1, iodev_.is_draining);
cras_system_add_select_fd_callback(cras_system_add_select_fd_callback_data);
EXPECT_EQ(1, cras_metrics_log_histogram_called);
EXPECT_STREQ(kStreamTimeoutMilliSeconds, cras_metrics_log_histogram_name);
EXPECT_EQ(90, cras_metrics_log_histogram_sample);
free(shm->area);
free(new_stream);
audio_thread_destroy(thread);
}
class ActiveDevicesSuite : public testing::Test {
protected:
virtual void SetUp() {
memset(&cras_iodev_set_format_val, 0, sizeof(cras_iodev_set_format_val));
cras_iodev_set_format_val.frame_rate = 44100;
cras_iodev_set_format_val.num_channels = 2;
cras_iodev_set_format_val.format = SND_PCM_FORMAT_S16_LE;
memset(&iodev_, 0, sizeof(iodev_));
memset(&iodev2_, 0, sizeof(iodev2_));
iodev_.close_dev = close_dev;
iodev_.is_open = is_open;
iodev_.open_dev = open_dev;
iodev_.delay_frames = delay_frames;
iodev_.get_buffer = get_buffer;
iodev_.put_buffer = put_buffer;
iodev_.frames_queued = frames_queued;
iodev_.delay_frames = delay_frames;
iodev_.dev_running = dev_running;
iodev_.buffer_size = 2048;
iodev2_.close_dev = close_dev;
iodev2_.is_open = is_open;
iodev2_.open_dev = open_dev;
iodev2_.delay_frames = delay_frames;
iodev2_.get_buffer = get_buffer;
iodev2_.put_buffer = put_buffer;
iodev2_.frames_queued = frames_queued;
iodev2_.delay_frames = delay_frames;
iodev2_.dev_running = dev_running;
iodev2_.buffer_size = 2048;
thread_ = audio_thread_create();
ASSERT_TRUE(thread_);
buffer_frames_ = 500;
cb_threshold_ = 250;
SetupRstream(&rstream_);
SetupRstream(&rstream2_);
rstream2_->buffer_frames -= 50;
rstream2_->cb_threshold -= 50;
dummy_audio_area1 = (cras_audio_area*)calloc(1,
sizeof(cras_audio_area) + 2 * sizeof(cras_channel_area));
dummy_audio_area1->num_channels = 2;
channel_area_set_channel(&dummy_audio_area1->channels[0], CRAS_CH_FL);
channel_area_set_channel(&dummy_audio_area1->channels[1], CRAS_CH_FR);
rstream_->input_audio_area = dummy_audio_area1;
dummy_audio_area2 = (cras_audio_area*)calloc(1,
sizeof(cras_audio_area) + 2 * sizeof(cras_channel_area));
dummy_audio_area2->num_channels = 2;
channel_area_set_channel(&dummy_audio_area2->channels[0], CRAS_CH_FL);
channel_area_set_channel(&dummy_audio_area2->channels[1], CRAS_CH_FR);
rstream2_->input_audio_area = dummy_audio_area2;
cras_iodev_set_format_called = 0;
close_dev_called_ = 0;
is_open_ = 0;
cras_fmt_conversion_needed_return_val = 0;
open_dev_val_idx_ = 0;
delay_frames_val_idx_ = 0;
frames_queued_val_idx_ = 0;
frames_queued_[0] = 250;
frames_queued_[1] = 250;
get_buffer_val_idx_ = 0;
put_buffer_val_idx_ = 0;
for (int i = 0; i < 8; i++) {
open_dev_val_[i] = 0;
delay_frames_[i] = 0;
audio_buffer_size_[i] = 250;
get_buffer_rc_[i] = 0;
put_buffer_rc_[i] = 0;
}
}
virtual void TearDown() {
struct cras_audio_shm *shm;
audio_thread_destroy(thread_);
shm = cras_rstream_output_shm(rstream_);
free(shm->area);
free(rstream_);
free(dummy_audio_area1);
free(dummy_audio_area2);
}
void SetupRstream(struct cras_rstream **rstream) {
struct cras_audio_shm *shm;
*rstream = (struct cras_rstream *)calloc(1, sizeof(**rstream));
memcpy(&(*rstream)->format, &cras_iodev_set_format_val,
sizeof(cras_iodev_set_format_val));
(*rstream)->direction = CRAS_STREAM_OUTPUT;
(*rstream)->buffer_frames = buffer_frames_;
(*rstream)->cb_threshold = cb_threshold_;
shm = cras_rstream_output_shm(*rstream);
shm->area = (struct cras_audio_shm_area *)calloc(1,
sizeof(*shm->area) + cb_threshold_ * 8);
cras_shm_set_frame_bytes(shm, 4);
cras_shm_set_used_size(
shm, buffer_frames_ * cras_shm_frame_bytes(shm));
shm = cras_rstream_input_shm(*rstream);
shm->area = (struct cras_audio_shm_area *)calloc(1,
sizeof(*shm->area) + buffer_frames_ * 8);
cras_shm_set_frame_bytes(shm, 4);
cras_shm_set_used_size(
shm, cb_threshold_* cras_shm_frame_bytes(shm));
}
static int close_dev(struct cras_iodev *iodev) {
close_dev_called_++;
return 0;
}
static int is_open(const cras_iodev *iodev) {
return is_open_;
}
static int open_dev(struct cras_iodev *iodev) {
open_dev_val_idx_ %= 8;
is_open_ = 1;
return open_dev_val_[open_dev_val_idx_++];
}
static int delay_frames(const cras_iodev* iodev) {
delay_frames_val_idx_ %= 8;
return delay_frames_[delay_frames_val_idx_++];
}
static int dev_running(const cras_iodev* iodev) {
return 1;
}
static int frames_queued(const cras_iodev* iodev) {
frames_queued_val_idx_ %= 2;
return frames_queued_[frames_queued_val_idx_++];
}
static int get_buffer(cras_iodev* iodev,
struct cras_audio_area** area,
unsigned int* num) {
size_t sz = sizeof(*area_) + sizeof(struct cras_channel_area) * 2;
get_buffer_val_idx_ %= 8;
if (audio_buffer_size_[get_buffer_val_idx_] < *num)
*num = audio_buffer_size_[get_buffer_val_idx_];
area_ = (cras_audio_area*)calloc(1, sz);
area_->frames = *num;
area_->num_channels = 2;
area_->channels[0].buf = audio_buffer_[get_buffer_val_idx_];
channel_area_set_channel(&area_->channels[0], CRAS_CH_FL);
area_->channels[0].step_bytes = 4;
area_->channels[1].buf = audio_buffer_[get_buffer_val_idx_] + 2;
channel_area_set_channel(&area_->channels[1], CRAS_CH_FR);
area_->channels[1].step_bytes = 4;
*area = area_;
get_buffer_val_idx_++;
return 0;
}
static int put_buffer(cras_iodev* iodev,
unsigned int num) {
free(area_);
put_buffer_val_idx_ %= 8;
return put_buffer_rc_[put_buffer_val_idx_++];
}
static int is_open_;
static int open_dev_val_[8];
static int open_dev_val_idx_;
static int close_dev_called_;
static int buffer_frames_;
static int cb_threshold_;
static int frames_queued_[2];
static int frames_queued_val_idx_;
static uint8_t audio_buffer_[8][8192];
static unsigned int audio_buffer_size_[8];
static int get_buffer_rc_[8];
static int put_buffer_rc_[8];
static int get_buffer_val_idx_;
static int put_buffer_val_idx_;
struct cras_iodev iodev_;
struct cras_iodev iodev2_;
struct cras_rstream *rstream_;
struct cras_rstream *rstream2_;
struct audio_thread *thread_;
static struct cras_audio_area *area_;
static int delay_frames_val_idx_;
static int delay_frames_[8];
};
int ActiveDevicesSuite::is_open_ = 0;
int ActiveDevicesSuite::buffer_frames_ = 0;
int ActiveDevicesSuite::cb_threshold_ = 0;
int ActiveDevicesSuite::frames_queued_[2];
int ActiveDevicesSuite::frames_queued_val_idx_;
int ActiveDevicesSuite::close_dev_called_ = 0;
int ActiveDevicesSuite::open_dev_val_[8];
int ActiveDevicesSuite::open_dev_val_idx_ = 0;
int ActiveDevicesSuite::delay_frames_val_idx_ = 0;
int ActiveDevicesSuite::delay_frames_[8];
uint8_t ActiveDevicesSuite::audio_buffer_[8][8192];
unsigned int ActiveDevicesSuite::audio_buffer_size_[8];
int ActiveDevicesSuite::get_buffer_val_idx_ = 0;
int ActiveDevicesSuite::put_buffer_val_idx_ = 0;
int ActiveDevicesSuite::get_buffer_rc_[8];
int ActiveDevicesSuite::put_buffer_rc_[8];
struct cras_audio_area *ActiveDevicesSuite::area_;
TEST_F(ActiveDevicesSuite, SetActiveDevRemoveOld) {
struct active_dev *adevs;
struct cras_iodev iodev3_;
iodev_.direction = CRAS_STREAM_INPUT;
iodev2_.direction = CRAS_STREAM_INPUT;
iodev3_.direction = CRAS_STREAM_INPUT;
thread_set_active_dev(thread_, &iodev_);
adevs = thread_->active_devs[CRAS_STREAM_INPUT];
EXPECT_NE((void *)NULL, adevs);
EXPECT_EQ(adevs->dev, &iodev_);
EXPECT_EQ(1, iodev_.is_active);
/* Assert the first active dev is still iodev. */
thread_add_active_dev(thread_, &iodev2_);
adevs = thread_->active_devs[CRAS_STREAM_INPUT];
EXPECT_EQ(adevs->dev, &iodev_);
thread_set_active_dev(thread_, &iodev3_);
adevs = thread_->active_devs[CRAS_STREAM_INPUT];
EXPECT_EQ(adevs->dev, &iodev3_);
EXPECT_EQ(iodev3_.is_active, 1);
EXPECT_EQ(iodev_.is_active, 0);
}
TEST_F(ActiveDevicesSuite, SetActiveDevAlreadyInList) {
struct active_dev *adevs;
iodev_.direction = CRAS_STREAM_INPUT;
iodev2_.direction = CRAS_STREAM_INPUT;
thread_set_active_dev(thread_, &iodev_);
thread_add_active_dev(thread_, &iodev2_);
adevs = thread_->active_devs[CRAS_STREAM_INPUT];
EXPECT_EQ(adevs->dev, &iodev_);
EXPECT_EQ(iodev_.is_active, 1);
thread_set_active_dev(thread_, &iodev2_);
adevs = thread_->active_devs[CRAS_STREAM_INPUT];
EXPECT_EQ(adevs->dev, &iodev2_);
EXPECT_EQ(iodev2_.is_active, 1);
EXPECT_EQ(iodev_.is_active, 0);
}
TEST_F(ActiveDevicesSuite, AddRemoveActiveDevice) {
struct active_dev *adevs;
iodev_.direction = CRAS_STREAM_INPUT;
iodev2_.direction = CRAS_STREAM_INPUT;
thread_set_active_dev(thread_, &iodev_);
adevs = thread_->active_devs[CRAS_STREAM_INPUT];
EXPECT_NE((void *)NULL, adevs);
EXPECT_EQ(adevs->dev, &iodev_);
EXPECT_EQ(1, iodev_.is_active);
thread_add_active_dev(thread_, &iodev2_);
EXPECT_NE((void *)NULL, adevs->next);
EXPECT_EQ(adevs->next->dev, &iodev2_);
EXPECT_EQ(1, iodev2_.is_active);
thread_rm_active_dev(thread_, &iodev_);
adevs = thread_->active_devs[CRAS_STREAM_INPUT];
EXPECT_EQ((void *)NULL, adevs->next);
EXPECT_EQ(adevs->dev, &iodev2_);
EXPECT_EQ(0, iodev_.is_active);
iodev_.direction = CRAS_STREAM_POST_MIX_PRE_DSP;
thread_add_active_dev(thread_, &iodev_);
EXPECT_NE((void *)NULL, thread_->active_devs[CRAS_STREAM_POST_MIX_PRE_DSP]);
EXPECT_EQ(1, iodev_.is_active);
}
TEST_F(ActiveDevicesSuite, ClearActiveDevices) {
iodev_.direction = CRAS_STREAM_OUTPUT;
iodev2_.direction = CRAS_STREAM_OUTPUT;
thread_set_active_dev(thread_, &iodev_);
thread_add_active_dev(thread_, &iodev2_);
EXPECT_NE((void *)NULL, thread_->active_devs[CRAS_STREAM_OUTPUT]);
EXPECT_EQ(1, iodev_.is_active);
EXPECT_EQ(1, iodev2_.is_active);
thread_clear_active_devs(thread_, CRAS_STREAM_OUTPUT);
EXPECT_EQ((void *)NULL, thread_->active_devs[CRAS_STREAM_OUTPUT]);
EXPECT_EQ(0, iodev_.is_active);
EXPECT_EQ(0, iodev2_.is_active);
}
TEST_F(ActiveDevicesSuite, OpenActiveDevices) {
iodev_.direction = CRAS_STREAM_OUTPUT;
iodev2_.direction = CRAS_STREAM_OUTPUT;
thread_set_active_dev(thread_, &iodev_);
thread_add_active_dev(thread_, &iodev2_);
thread_add_stream(thread_, rstream_);
EXPECT_EQ(2, cras_iodev_set_format_called);
EXPECT_EQ(500, thread_->buffer_frames[CRAS_STREAM_OUTPUT]);
EXPECT_EQ(250, thread_->cb_threshold[CRAS_STREAM_OUTPUT]);
}
TEST_F(ActiveDevicesSuite, OpenFirstActiveDeviceFail) {
int rc;
iodev_.direction = CRAS_STREAM_OUTPUT;
iodev2_.direction = CRAS_STREAM_OUTPUT;
thread_set_active_dev(thread_, &iodev_);
thread_add_active_dev(thread_, &iodev2_);
open_dev_val_[0] = -1;
rc = thread_add_stream(thread_, rstream_);
EXPECT_EQ(rc, AUDIO_THREAD_OUTPUT_DEV_ERROR);
EXPECT_EQ(2, cras_iodev_set_format_called);
EXPECT_EQ(0, thread_->buffer_frames[CRAS_STREAM_OUTPUT]);
EXPECT_EQ(0, thread_->cb_threshold[CRAS_STREAM_OUTPUT]);
}
TEST_F(ActiveDevicesSuite, OpenSecondActiveDeviceFail) {
int rc;
iodev_.direction = CRAS_STREAM_OUTPUT;
iodev2_.direction = CRAS_STREAM_OUTPUT;
thread_set_active_dev(thread_, &iodev_);
thread_add_active_dev(thread_, &iodev2_);
open_dev_val_[1] = -1;
rc = thread_add_stream(thread_, rstream_);
EXPECT_EQ(0, rc);
EXPECT_EQ(2, cras_iodev_set_format_called);
EXPECT_EQ(500, thread_->buffer_frames[CRAS_STREAM_OUTPUT]);
EXPECT_EQ(250, thread_->cb_threshold[CRAS_STREAM_OUTPUT]);
EXPECT_EQ(0, close_dev_called_);
EXPECT_EQ((void *)NULL, thread_->active_devs[CRAS_STREAM_OUTPUT]->next);
}
TEST_F(ActiveDevicesSuite, OpenSecondActiveDeviceFormatIncompatible) {
int rc;
iodev_.direction = CRAS_STREAM_OUTPUT;
iodev2_.direction = CRAS_STREAM_OUTPUT;
thread_set_active_dev(thread_, &iodev_);
thread_add_active_dev(thread_, &iodev2_);
cras_fmt_conversion_needed_return_val = 1;
rc = thread_add_stream(thread_, rstream_);
EXPECT_EQ(0, rc);
EXPECT_EQ(2, cras_iodev_set_format_called);
EXPECT_EQ(500, thread_->buffer_frames[CRAS_STREAM_OUTPUT]);
EXPECT_EQ(250, thread_->cb_threshold[CRAS_STREAM_OUTPUT]);
EXPECT_EQ(1, close_dev_called_);
EXPECT_EQ((void *)NULL, thread_->active_devs[CRAS_STREAM_OUTPUT]->next);
}
TEST_F(ActiveDevicesSuite, CloseActiveDevices) {
iodev_.direction = CRAS_STREAM_OUTPUT;
iodev2_.direction = CRAS_STREAM_OUTPUT;
thread_set_active_dev(thread_, &iodev_);
thread_add_active_dev(thread_, &iodev2_);
thread_add_stream(thread_, rstream_);
EXPECT_EQ(1, thread_->devs_open[CRAS_STREAM_OUTPUT]);
EXPECT_EQ(2, cras_iodev_set_format_called);
thread_add_stream(thread_, rstream2_);
EXPECT_EQ(4, cras_iodev_set_format_called);
thread_remove_stream(thread_, rstream2_);
thread_remove_stream(thread_, rstream_);
EXPECT_EQ(1, iodev_.is_draining);
EXPECT_EQ(1, iodev2_.is_draining);
}
TEST_F(ActiveDevicesSuite, InputDelayFrames) {
int fr;
iodev_.direction = CRAS_STREAM_INPUT;
iodev2_.direction = CRAS_STREAM_INPUT;
rstream_->direction = CRAS_STREAM_INPUT;
thread_set_active_dev(thread_, &iodev_);
thread_add_active_dev(thread_, &iodev2_);
thread_add_stream(thread_, rstream_);
delay_frames_[0] = 3;
delay_frames_[1] = 33;
fr = input_delay_frames(thread_->active_devs[CRAS_STREAM_INPUT]);
EXPECT_EQ(33, fr);
delay_frames_val_idx_ = 0;
delay_frames_[1] = -1;
fr = input_delay_frames(thread_->active_devs[CRAS_STREAM_INPUT]);
EXPECT_EQ(-1, fr);
}
TEST_F(ActiveDevicesSuite, InputFramesQueued) {
int fr;
iodev_.direction = CRAS_STREAM_INPUT;
iodev2_.direction = CRAS_STREAM_INPUT;
thread_set_active_dev(thread_, &iodev_);
thread_add_active_dev(thread_, &iodev2_);
frames_queued_val_idx_ = 0;
frames_queued_[0] = 195;
frames_queued_[1] = 190;
fr = input_min_frames_queued(thread_->active_devs[CRAS_STREAM_INPUT]);
EXPECT_EQ(190, fr);
/* Test error path. */
frames_queued_val_idx_ = 0;
frames_queued_[0] = -1;
frames_queued_[1] = 190;
fr = input_min_frames_queued(thread_->active_devs[CRAS_STREAM_INPUT]);
EXPECT_EQ(-1, fr);
}
TEST_F(ActiveDevicesSuite, MixMultipleInputs) {
struct timespec ts;
iodev_.direction = CRAS_STREAM_INPUT;
iodev2_.direction = CRAS_STREAM_INPUT;
rstream_->direction = CRAS_STREAM_INPUT;
rstream2_->direction = CRAS_STREAM_INPUT;
for (unsigned int dev = 0; dev < 8; dev++) {
int16_t *buff = (int16_t*)audio_buffer_[dev];
for (unsigned int i = 0; i < 250; i++)
buff[i] = i;
}
thread_set_active_dev(thread_, &iodev_);
thread_add_active_dev(thread_, &iodev2_);
/* Assert shm from rstream_ is used. */
thread_add_stream(thread_, rstream_);
unified_io(thread_, &ts);
EXPECT_EQ(rstream_, cap_sleep_frames_call.dev_stream->stream);
thread_add_stream(thread_, rstream2_);
unified_io(thread_, &ts);
EXPECT_EQ(rstream2_, cap_sleep_frames_call.dev_stream->stream);
}
extern "C" {
const char kNoCodecsFoundMetric[] = "Cras.NoCodecsFoundAtBoot";
const char kStreamTimeoutMilliSeconds[] = "Cras.StreamTimeoutMilliSeconds";
int cras_iodev_get_thread_poll_fd(const struct cras_iodev *iodev) {
return 0;
}
int cras_iodev_read_thread_command(struct cras_iodev *iodev,
uint8_t *buf,
size_t max_len) {
return 0;
}
int cras_iodev_send_command_response(struct cras_iodev *iodev, int rc) {
return 0;
}
void cras_iodev_fill_time_from_frames(size_t frames,
size_t frame_rate,
struct timespec *ts) {
uint64_t to_play_usec;
ts->tv_sec = 0;
/* adjust sleep time to target our callback threshold */
to_play_usec = (uint64_t)frames * 1000000L / (uint64_t)frame_rate;
while (to_play_usec > 1000000) {
ts->tv_sec++;
to_play_usec -= 1000000;
}
ts->tv_nsec = to_play_usec * 1000;
}
void dev_stream_set_delay(const struct dev_stream *dev_stream,
unsigned int delay_frames) {
dev_stream_set_delay_called++;
}
void cras_set_capture_timestamp(size_t frame_rate,
size_t frames,
struct cras_timespec *ts) {
}
int cras_iodev_set_format(struct cras_iodev *iodev,
struct cras_audio_format *fmt)
{
cras_iodev_set_format_called++;
iodev->format = &cras_iodev_set_format_val;
return 0;
}
// From mixer.
unsigned int dev_stream_mix(struct dev_stream *dev_stream,
size_t num_channels,
uint8_t *dst,
size_t *count,
size_t *index) {
int16_t *src;
int16_t *target = (int16_t *)dst;
size_t fr_written, fr_in_buf;
size_t num_samples;
size_t frames = 0;
struct cras_audio_shm *shm;
if (dev_stream->stream->direction == CRAS_STREAM_OUTPUT) {
shm = &dev_stream->stream->output_shm;
} else {
shm = &dev_stream->stream->input_shm;
}
dev_stream_mix_called++;
if (dev_stream_mix_dont_fill_next) {
dev_stream_mix_dont_fill_next = 0;
return 0;
}
dev_stream_mix_count = *count;
/* We only copy the data from shm to dst, not actually mix them. */
fr_in_buf = cras_shm_get_frames(shm);
if (fr_in_buf == 0)
return 0;
if (fr_in_buf < *count)
*count = fr_in_buf;
fr_written = 0;
while (fr_written < *count) {
src = cras_shm_get_readable_frames(shm,
fr_written, &frames);
if (frames > *count - fr_written)
frames = *count - fr_written;
num_samples = frames * num_channels;
memcpy(target, src, num_samples * 2);
fr_written += frames;
target += num_samples;
}
*index = *index + 1;
cras_shm_buffer_read(shm, fr_written);
return *count;
}
void cras_scale_buffer(int16_t *buffer, unsigned int count, float scaler) {
}
size_t cras_mix_mute_buffer(uint8_t *dst,
size_t frame_bytes,
size_t count) {
cras_mix_mute_count = count;
return count;
}
void cras_mix_add_clip(int16_t *dst, const int16_t *src, size_t count) {
int32_t sum;
unsigned int i;
for (i = 0; i < count; i++) {
sum = dst[i] + src[i];
if (sum > 0x7fff)
sum = 0x7fff;
else if (sum < -0x8000)
sum = -0x8000;
dst[i] = sum;
}
}
// From cras_metrics.c
void cras_metrics_log_event(const char *event)
{
cras_metrics_log_event_called++;
}
void cras_metrics_log_histogram(const char *name, int sample, int min,
int max, int nbuckets)
{
cras_metrics_log_histogram_called++;
cras_metrics_log_histogram_name = name;
cras_metrics_log_histogram_sample = sample;
}
// From util.
int cras_set_rt_scheduling(int rt_lim) {
return 0;
}
int cras_set_thread_priority(int priority) {
return 0;
}
// From rstream.
int cras_rstream_get_audio_request_reply(const struct cras_rstream *stream) {
return 0;
}
void cras_rstream_log_overrun(const struct cras_rstream *stream) {
}
int cras_system_add_select_fd(int fd,
void (*callback)(void *data),
void *callback_data)
{
cras_system_add_select_fd_callback = callback;
cras_system_add_select_fd_callback_data = callback_data;
return 0;
}
void cras_system_rm_select_fd(int fd)
{
}
size_t cras_system_get_volume() {
return cras_system_get_volume_return;
}
int cras_system_get_mute() {
return 0;
}
int cras_system_get_capture_mute() {
return 0;
}
void cras_rstream_destroy(struct cras_rstream *stream) {
cras_rstream_destroy_called++;
}
void loopback_iodev_set_format(struct cras_iodev *loopback_dev,
const struct cras_audio_format *fmt) {
}
int loopback_iodev_add_audio(struct cras_iodev *loopback_dev,
const uint8_t *audio,
unsigned int count) {
return 0;
}
int loopback_iodev_add_zeros(struct cras_iodev *dev,
unsigned int count) {
return 0;
}
int cras_fmt_conversion_needed(const struct cras_audio_format *a,
const struct cras_audio_format *b)
{
return cras_fmt_conversion_needed_return_val;
}
void cras_audio_area_config_buf_pointers(struct cras_audio_area *area,
const struct cras_audio_format *fmt,
uint8_t *base_buffer) {
unsigned int i;
const int sample_size = snd_pcm_format_physical_width(fmt->format) / 8;
/* TODO(dgreid) - assuming interleaved audio here for now. */
for (i = 0 ; i < area->num_channels; i++) {
area->channels[i].step_bytes = cras_get_format_bytes(fmt);
area->channels[i].buf = base_buffer + i * sample_size;
}
}
void cras_audio_area_copy(const struct cras_audio_area *dst,
unsigned int dst_offset, unsigned int dst_format_bytes,
const struct cras_audio_area *src, unsigned int src_index)
{
unsigned count, i;
int16_t *dchan, *schan;
if (src_index == 0)
memset(dst->channels[0].buf, 0, src->frames * dst_format_bytes);
dchan = (int16_t *)(dst->channels[0].buf +
dst_offset * dst->channels[0].step_bytes);
schan = (int16_t *)src->channels[0].buf;
count = src->frames * src->num_channels;
for (i = 0; i < count; i++) {
int32_t sum;
sum = *dchan + *schan;
if (sum > 0x7fff)
sum = 0x7fff;
else if (sum < -0x8000)
sum = -0x8000;
*dchan = sum;
dchan++;
schan++;
}
}
// Override select so it can be stubbed.
int select(int nfds,
fd_set *readfds,
fd_set *writefds,
fd_set *exceptfds,
struct timeval *timeout) {
select_max_fd = nfds;
select_timeval.tv_sec = timeout->tv_sec;
select_timeval.tv_usec = timeout->tv_usec;
select_in_fds = *readfds;
*readfds = select_out_fds;
if (select_write_ptr)
*select_write_ptr = select_write_value;
return select_return_value;
}
int clock_gettime(clockid_t clk_id, struct timespec *tp) {
*tp = time_now;
return 0;
}
struct dev_stream *dev_stream_create(struct cras_rstream *stream,
const struct cras_audio_format *fmt) {
struct dev_stream *out = static_cast<dev_stream*>(calloc(1, sizeof(*out)));
out->stream = stream;
return out;
}
void dev_stream_destroy(struct dev_stream *dev_stream) {
free(dev_stream);
}
void dev_stream_capture(struct dev_stream *dev_stream,
const struct cras_audio_area *area,
unsigned int dev_index)
{
dev_stream_capture_call.dev_stream = dev_stream;
dev_stream_capture_call.area = area;
dev_stream_capture_call.dev_index = dev_index;
dev_stream_capture_call.num_called++;
}
int dev_stream_playback_frames(const struct dev_stream *dev_stream) {
struct cras_audio_shm *shm;
int frames;
shm = cras_rstream_output_shm(dev_stream->stream);
frames = cras_shm_get_frames(shm);
if (frames < 0)
return frames;
if (!dev_stream->conv)
return frames;
return cras_fmt_conv_in_frames_to_out(dev_stream->conv, frames);
}
unsigned int dev_stream_capture_avail(const struct dev_stream *dev_stream)
{
struct cras_audio_shm *shm;
struct cras_rstream *rstream = dev_stream->stream;
unsigned int cb_threshold = cras_rstream_get_cb_threshold(rstream);
unsigned int frames_avail;
shm = cras_rstream_input_shm(rstream);
cras_shm_get_writeable_frames(shm, cb_threshold, &frames_avail);
return frames_avail;
}
int dev_stream_capture_sleep_frames(struct dev_stream *dev_stream,
unsigned int written) {
cap_sleep_frames_call.dev_stream = dev_stream;
cap_sleep_frames_call.written = written;
cap_sleep_frames_call.num_called++;
return 0;
}
int dev_stream_request_playback_samples(struct dev_stream *dev_stream)
{
struct cras_rstream *rstream = dev_stream->stream;
dev_stream_request_playback_samples_called++;
cras_shm_set_callback_pending(cras_rstream_output_shm(rstream), 1);
return 0;
}
size_t cras_fmt_conv_in_frames_to_out(struct cras_fmt_conv *conv,
size_t in_frames)
{
return in_frames;
}
size_t cras_fmt_conv_out_frames_to_in(struct cras_fmt_conv *conv,
size_t out_frames)
{
return out_frames;
}
} // extern "C"
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}