1// Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include <stdio.h>
6#include <gtest/gtest.h>
7
8extern "C" {
9#include "cras_iodev.h"
10#include "cras_ramp.h"
11#include "cras_rstream.h"
12#include "dev_stream.h"
13#include "utlist.h"
14#include "cras_audio_area.h"
15#include "audio_thread_log.h"
16
17// Mock software volume scalers.
18float softvol_scalers[101];
19}
20
21#define BUFFER_SIZE 8192
22
23static const float RAMP_UNMUTE_DURATION_SECS = 0.5;
24static const float RAMP_NEW_STREAM_DURATION_SECS = 0.01;
25static const float RAMP_MUTE_DURATION_SECS = 0.1;
26
27static int cras_iodev_list_disable_dev_called;
28static int select_node_called;
29static enum CRAS_STREAM_DIRECTION select_node_direction;
30static cras_node_id_t select_node_id;
31static struct cras_ionode *node_selected;
32static size_t notify_nodes_changed_called;
33static size_t notify_active_node_changed_called;
34static size_t notify_node_volume_called;
35static size_t notify_node_capture_gain_called;
36static int dsp_context_new_sample_rate;
37static const char *dsp_context_new_purpose;
38static int dsp_context_free_called;
39static int update_channel_layout_called;
40static int update_channel_layout_return_val;
41static int  set_swap_mode_for_node_called;
42static int  set_swap_mode_for_node_enable;
43static int notify_node_left_right_swapped_called;
44static int cras_audio_format_set_channel_layout_called;
45static unsigned int cras_system_get_volume_return;
46static int cras_dsp_get_pipeline_called;
47static int cras_dsp_get_pipeline_ret;
48static int cras_dsp_put_pipeline_called;
49static int cras_dsp_pipeline_get_source_buffer_called;
50static int cras_dsp_pipeline_get_sink_buffer_called;
51static float cras_dsp_pipeline_source_buffer[2][DSP_BUFFER_SIZE];
52static float cras_dsp_pipeline_sink_buffer[2][DSP_BUFFER_SIZE];
53static int cras_dsp_pipeline_get_delay_called;
54static int cras_dsp_pipeline_apply_called;
55static int cras_dsp_pipeline_apply_sample_count;
56static unsigned int cras_mix_mute_count;
57static unsigned int cras_dsp_num_input_channels_return;
58static unsigned int cras_dsp_num_output_channels_return;
59struct cras_dsp_context *cras_dsp_context_new_return;
60static unsigned int rate_estimator_add_frames_num_frames;
61static unsigned int rate_estimator_add_frames_called;
62static int cras_system_get_mute_return;
63static snd_pcm_format_t cras_scale_buffer_fmt;
64static float cras_scale_buffer_scaler;
65static int cras_scale_buffer_called;
66static unsigned int pre_dsp_hook_called;
67static const uint8_t *pre_dsp_hook_frames;
68
69static void *pre_dsp_hook_cb_data;
70static unsigned int post_dsp_hook_called;
71static const uint8_t *post_dsp_hook_frames;
72static void *post_dsp_hook_cb_data;
73static int iodev_buffer_size;
74static long cras_system_get_capture_gain_ret_value;
75static uint8_t audio_buffer[BUFFER_SIZE];
76static struct cras_audio_area *audio_area;
77static unsigned int put_buffer_nframes;
78static int output_should_wake_ret;
79static int no_stream_called;
80static int no_stream_enable;
81// This will be used extensively in cras_iodev.
82struct audio_thread_event_log *atlog;
83static unsigned int simple_no_stream_called;
84static int simple_no_stream_enable;
85static int dev_stream_playback_frames_ret;
86static int get_num_underruns_ret;
87static int device_monitor_reset_device_called;
88static int output_underrun_called;
89static int set_mute_called;
90static int cras_ramp_start_is_up;
91static int cras_ramp_start_duration_frames;
92static int cras_ramp_start_is_called;
93static int cras_ramp_reset_is_called;
94static struct cras_ramp_action cras_ramp_get_current_action_ret;
95static int cras_ramp_update_ramped_frames_num_frames;
96static cras_ramp_cb cras_ramp_start_cb;
97static void* cras_ramp_start_cb_data;
98static int cras_device_monitor_set_device_mute_state_called;
99static struct cras_iodev* cras_device_monitor_set_device_mute_state_dev;
100static snd_pcm_format_t cras_scale_buffer_increment_fmt;
101static uint8_t *cras_scale_buffer_increment_buff;
102static unsigned int cras_scale_buffer_increment_frame;
103static float cras_scale_buffer_increment_scaler;
104static float cras_scale_buffer_increment_increment;
105static int cras_scale_buffer_increment_channel;
106
107// Iodev callback
108int update_channel_layout(struct cras_iodev *iodev) {
109  update_channel_layout_called = 1;
110  return update_channel_layout_return_val;
111}
112
113// Iodev callback
114int set_swap_mode_for_node(struct cras_iodev *iodev, struct cras_ionode *node,
115                           int enable)
116{
117  set_swap_mode_for_node_called++;
118  set_swap_mode_for_node_enable = enable;
119  return 0;
120}
121
122void ResetStubData() {
123  cras_iodev_list_disable_dev_called = 0;
124  select_node_called = 0;
125  notify_nodes_changed_called = 0;
126  notify_active_node_changed_called = 0;
127  notify_node_volume_called = 0;
128  notify_node_capture_gain_called = 0;
129  dsp_context_new_sample_rate = 0;
130  dsp_context_new_purpose = NULL;
131  dsp_context_free_called = 0;
132  set_swap_mode_for_node_called = 0;
133  set_swap_mode_for_node_enable = 0;
134  notify_node_left_right_swapped_called = 0;
135  cras_audio_format_set_channel_layout_called = 0;
136  cras_dsp_get_pipeline_called = 0;
137  cras_dsp_get_pipeline_ret = 0;
138  cras_dsp_put_pipeline_called = 0;
139  cras_dsp_pipeline_get_source_buffer_called = 0;
140  cras_dsp_pipeline_get_sink_buffer_called = 0;
141  memset(&cras_dsp_pipeline_source_buffer, 0,
142         sizeof(cras_dsp_pipeline_source_buffer));
143  memset(&cras_dsp_pipeline_sink_buffer, 0,
144         sizeof(cras_dsp_pipeline_sink_buffer));
145  cras_dsp_pipeline_get_delay_called = 0;
146  cras_dsp_pipeline_apply_called = 0;
147  cras_dsp_pipeline_apply_sample_count = 0;
148  cras_dsp_num_input_channels_return = 2;
149  cras_dsp_num_output_channels_return = 2;
150  cras_dsp_context_new_return = NULL;
151  rate_estimator_add_frames_num_frames = 0;
152  rate_estimator_add_frames_called = 0;
153  cras_system_get_mute_return = 0;
154  cras_system_get_volume_return = 100;
155  cras_mix_mute_count = 0;
156  pre_dsp_hook_called = 0;
157  pre_dsp_hook_frames = NULL;
158  post_dsp_hook_called = 0;
159  post_dsp_hook_frames = NULL; iodev_buffer_size = 0;
160  cras_system_get_capture_gain_ret_value = 0;
161  // Assume there is some data in audio buffer.
162  memset(audio_buffer, 0xff, sizeof(audio_buffer));
163  if (audio_area) {
164    free(audio_area);
165    audio_area = NULL;
166  }
167  put_buffer_nframes = 0;
168  output_should_wake_ret= 0;
169  no_stream_called = 0;
170  no_stream_enable = 0;
171  simple_no_stream_called = 0;
172  simple_no_stream_enable = 0;
173  dev_stream_playback_frames_ret = 0;
174  if (!atlog)
175    atlog = audio_thread_event_log_init();
176  get_num_underruns_ret = 0;
177  device_monitor_reset_device_called = 0;
178  output_underrun_called = 0;
179  set_mute_called = 0;
180  cras_ramp_start_is_up = 0;
181  cras_ramp_start_duration_frames = 0;
182  cras_ramp_start_cb = NULL;
183  cras_ramp_start_cb_data = NULL;
184  cras_ramp_start_is_called = 0;
185  cras_ramp_reset_is_called = 0;
186  cras_ramp_get_current_action_ret.type = CRAS_RAMP_ACTION_NONE;
187  cras_ramp_update_ramped_frames_num_frames = 0;
188  cras_device_monitor_set_device_mute_state_called = 0;
189  cras_device_monitor_set_device_mute_state_dev = NULL;
190  cras_scale_buffer_called = 0;
191  cras_scale_buffer_increment_fmt = SND_PCM_FORMAT_UNKNOWN;
192  cras_scale_buffer_increment_buff = NULL;
193  cras_scale_buffer_increment_frame = 0;
194  cras_scale_buffer_increment_scaler = 0;
195  cras_scale_buffer_increment_increment = 0;
196  cras_scale_buffer_increment_channel = 0;
197}
198
199namespace {
200
201//  Test fill_time_from_frames
202TEST(IoDevTestSuite, FillTimeFromFramesNormal) {
203  struct timespec ts;
204
205  cras_iodev_fill_time_from_frames(12000, 48000, &ts);
206  EXPECT_EQ(0, ts.tv_sec);
207  EXPECT_GE(ts.tv_nsec, 249900000);
208  EXPECT_LE(ts.tv_nsec, 250100000);
209}
210
211TEST(IoDevTestSuite, FillTimeFromFramesLong) {
212  struct timespec ts;
213
214  cras_iodev_fill_time_from_frames(120000 - 12000, 48000, &ts);
215  EXPECT_EQ(2, ts.tv_sec);
216  EXPECT_GE(ts.tv_nsec, 249900000);
217  EXPECT_LE(ts.tv_nsec, 250100000);
218}
219
220TEST(IoDevTestSuite, FillTimeFromFramesShort) {
221  struct timespec ts;
222
223  cras_iodev_fill_time_from_frames(12000 - 12000, 48000, &ts);
224  EXPECT_EQ(0, ts.tv_sec);
225  EXPECT_EQ(0, ts.tv_nsec);
226}
227
228class IoDevSetFormatTestSuite : public testing::Test {
229  protected:
230    virtual void SetUp() {
231      ResetStubData();
232      sample_rates_[0] = 44100;
233      sample_rates_[1] = 48000;
234      sample_rates_[2] = 0;
235
236      channel_counts_[0] = 2;
237      channel_counts_[1] = 0;
238      channel_counts_[2] = 0;
239
240      pcm_formats_[0] = SND_PCM_FORMAT_S16_LE;
241      pcm_formats_[1] = SND_PCM_FORMAT_S32_LE;
242      pcm_formats_[2] = static_cast<snd_pcm_format_t>(0);
243
244      update_channel_layout_called = 0;
245      update_channel_layout_return_val = 0;
246
247      memset(&iodev_, 0, sizeof(iodev_));
248      iodev_.update_channel_layout = update_channel_layout;
249      iodev_.supported_rates = sample_rates_;
250      iodev_.supported_channel_counts = channel_counts_;
251      iodev_.supported_formats = pcm_formats_;
252      iodev_.dsp_context = NULL;
253
254      cras_audio_format_set_channel_layout_called  = 0;
255    }
256
257    virtual void TearDown() {
258      cras_iodev_free_format(&iodev_);
259    }
260
261    struct cras_iodev iodev_;
262    size_t sample_rates_[3];
263    size_t channel_counts_[3];
264    snd_pcm_format_t pcm_formats_[3];
265};
266
267TEST_F(IoDevSetFormatTestSuite, SupportedFormatSecondary) {
268  struct cras_audio_format fmt;
269  int rc;
270
271  fmt.format = SND_PCM_FORMAT_S16_LE;
272  fmt.frame_rate = 48000;
273  fmt.num_channels = 2;
274  iodev_.direction = CRAS_STREAM_OUTPUT;
275  ResetStubData();
276  rc = cras_iodev_set_format(&iodev_, &fmt);
277  EXPECT_EQ(0, rc);
278  EXPECT_EQ(SND_PCM_FORMAT_S16_LE, iodev_.ext_format->format);
279  EXPECT_EQ(48000, iodev_.ext_format->frame_rate);
280  EXPECT_EQ(2, iodev_.ext_format->num_channels);
281  EXPECT_EQ(dsp_context_new_sample_rate, 48000);
282  EXPECT_STREQ(dsp_context_new_purpose, "playback");
283}
284
285TEST_F(IoDevSetFormatTestSuite, SupportedFormat32bit) {
286  struct cras_audio_format fmt;
287  int rc;
288
289  fmt.format = SND_PCM_FORMAT_S32_LE;
290  fmt.frame_rate = 48000;
291  fmt.num_channels = 2;
292  iodev_.direction = CRAS_STREAM_OUTPUT;
293  ResetStubData();
294  rc = cras_iodev_set_format(&iodev_, &fmt);
295  EXPECT_EQ(0, rc);
296  EXPECT_EQ(SND_PCM_FORMAT_S32_LE, iodev_.ext_format->format);
297  EXPECT_EQ(48000, iodev_.ext_format->frame_rate);
298  EXPECT_EQ(2, iodev_.ext_format->num_channels);
299  EXPECT_EQ(dsp_context_new_sample_rate, 48000);
300  EXPECT_STREQ(dsp_context_new_purpose, "playback");
301}
302
303TEST_F(IoDevSetFormatTestSuite, SupportedFormatPrimary) {
304  struct cras_audio_format fmt;
305  int rc;
306
307  fmt.format = SND_PCM_FORMAT_S16_LE;
308  fmt.frame_rate = 44100;
309  fmt.num_channels = 2;
310  iodev_.direction = CRAS_STREAM_INPUT;
311  ResetStubData();
312  rc = cras_iodev_set_format(&iodev_, &fmt);
313  EXPECT_EQ(0, rc);
314  EXPECT_EQ(SND_PCM_FORMAT_S16_LE, iodev_.ext_format->format);
315  EXPECT_EQ(44100, iodev_.ext_format->frame_rate);
316  EXPECT_EQ(2, iodev_.ext_format->num_channels);
317  EXPECT_EQ(dsp_context_new_sample_rate, 44100);
318  EXPECT_STREQ(dsp_context_new_purpose, "capture");
319}
320
321TEST_F(IoDevSetFormatTestSuite, SupportedFormatDivisor) {
322  struct cras_audio_format fmt;
323  int rc;
324
325  fmt.format = SND_PCM_FORMAT_S16_LE;
326  fmt.frame_rate = 96000;
327  fmt.num_channels = 2;
328  rc = cras_iodev_set_format(&iodev_, &fmt);
329  EXPECT_EQ(0, rc);
330  EXPECT_EQ(SND_PCM_FORMAT_S16_LE, iodev_.ext_format->format);
331  EXPECT_EQ(48000, iodev_.ext_format->frame_rate);
332  EXPECT_EQ(2, iodev_.ext_format->num_channels);
333}
334
335TEST_F(IoDevSetFormatTestSuite, Supported96k) {
336  struct cras_audio_format fmt;
337  int rc;
338
339  sample_rates_[0] = 48000;
340  sample_rates_[1] = 96000;
341  sample_rates_[2] = 0;
342
343  fmt.format = SND_PCM_FORMAT_S16_LE;
344  fmt.frame_rate = 96000;
345  fmt.num_channels = 2;
346  rc = cras_iodev_set_format(&iodev_, &fmt);
347  EXPECT_EQ(0, rc);
348  EXPECT_EQ(SND_PCM_FORMAT_S16_LE, iodev_.ext_format->format);
349  EXPECT_EQ(96000, iodev_.ext_format->frame_rate);
350  EXPECT_EQ(2, iodev_.ext_format->num_channels);
351}
352
353TEST_F(IoDevSetFormatTestSuite, LimitLowRate) {
354  struct cras_audio_format fmt;
355  int rc;
356
357  sample_rates_[0] = 48000;
358  sample_rates_[1] = 8000;
359  sample_rates_[2] = 0;
360
361  fmt.format = SND_PCM_FORMAT_S16_LE;
362  fmt.frame_rate = 8000;
363  fmt.num_channels = 2;
364  rc = cras_iodev_set_format(&iodev_, &fmt);
365  EXPECT_EQ(0, rc);
366  EXPECT_EQ(SND_PCM_FORMAT_S16_LE, iodev_.ext_format->format);
367  EXPECT_EQ(48000, iodev_.ext_format->frame_rate);
368  EXPECT_EQ(2, iodev_.ext_format->num_channels);
369}
370
371TEST_F(IoDevSetFormatTestSuite, UnsupportedChannelCount) {
372  struct cras_audio_format fmt;
373  int rc;
374
375  fmt.format = SND_PCM_FORMAT_S16_LE;
376  fmt.frame_rate = 96000;
377  fmt.num_channels = 1;
378  rc = cras_iodev_set_format(&iodev_, &fmt);
379  EXPECT_EQ(0, rc);
380  EXPECT_EQ(SND_PCM_FORMAT_S16_LE, iodev_.ext_format->format);
381  EXPECT_EQ(48000, iodev_.ext_format->frame_rate);
382  EXPECT_EQ(2, iodev_.ext_format->num_channels);
383}
384
385TEST_F(IoDevSetFormatTestSuite, SupportedFormatFallbackDefault) {
386  struct cras_audio_format fmt;
387  int rc;
388
389  fmt.format = SND_PCM_FORMAT_S16_LE;
390  fmt.frame_rate = 96008;
391  fmt.num_channels = 2;
392  rc = cras_iodev_set_format(&iodev_, &fmt);
393  EXPECT_EQ(0, rc);
394  EXPECT_EQ(SND_PCM_FORMAT_S16_LE, iodev_.ext_format->format);
395  EXPECT_EQ(44100, iodev_.ext_format->frame_rate);
396  EXPECT_EQ(2, iodev_.ext_format->num_channels);
397}
398
399TEST_F(IoDevSetFormatTestSuite, OutputDSPChannleReduction) {
400  struct cras_audio_format fmt;
401  int rc;
402
403  fmt.format = SND_PCM_FORMAT_S16_LE;
404  fmt.frame_rate = 48000;
405  fmt.num_channels = 2;
406
407  iodev_.direction = CRAS_STREAM_OUTPUT;
408  iodev_.supported_channel_counts[0] = 1;
409  iodev_.supported_channel_counts[1] = 0;
410  cras_dsp_context_new_return = reinterpret_cast<cras_dsp_context *>(0xf00);
411  cras_dsp_get_pipeline_ret =  0xf01;
412  cras_dsp_num_input_channels_return = 2;
413  cras_dsp_num_output_channels_return = 1;
414  rc = cras_iodev_set_format(&iodev_, &fmt);
415  EXPECT_EQ(0, rc);
416  EXPECT_EQ(SND_PCM_FORMAT_S16_LE, iodev_.ext_format->format);
417  EXPECT_EQ(48000, iodev_.ext_format->frame_rate);
418  EXPECT_EQ(2, iodev_.ext_format->num_channels);
419}
420
421TEST_F(IoDevSetFormatTestSuite, InputDSPChannleReduction) {
422  struct cras_audio_format fmt;
423  int rc;
424
425  fmt.format = SND_PCM_FORMAT_S16_LE;
426  fmt.frame_rate = 48000;
427  fmt.num_channels = 2;
428
429  iodev_.direction = CRAS_STREAM_INPUT;
430  iodev_.supported_channel_counts[0] = 10;
431  iodev_.supported_channel_counts[1] = 0;
432  cras_dsp_context_new_return = reinterpret_cast<cras_dsp_context *>(0xf00);
433  cras_dsp_get_pipeline_ret =  0xf01;
434  cras_dsp_num_input_channels_return = 10;
435  cras_dsp_num_output_channels_return = 2;
436  rc = cras_iodev_set_format(&iodev_, &fmt);
437  EXPECT_EQ(0, rc);
438  EXPECT_EQ(SND_PCM_FORMAT_S16_LE, iodev_.ext_format->format);
439  EXPECT_EQ(48000, iodev_.ext_format->frame_rate);
440  EXPECT_EQ(2, iodev_.ext_format->num_channels);
441}
442
443TEST_F(IoDevSetFormatTestSuite, UpdateChannelLayoutSuccess) {
444  struct cras_audio_format fmt;
445  int rc;
446
447  fmt.format = SND_PCM_FORMAT_S16_LE;
448  fmt.frame_rate = 48000;
449  fmt.num_channels = 6;
450
451  iodev_.supported_channel_counts[0] = 6;
452  iodev_.supported_channel_counts[1] = 2;
453
454  rc = cras_iodev_set_format(&iodev_, &fmt);
455  EXPECT_EQ(0, rc);
456  EXPECT_EQ(SND_PCM_FORMAT_S16_LE, iodev_.ext_format->format);
457  EXPECT_EQ(48000, iodev_.ext_format->frame_rate);
458  EXPECT_EQ(6, iodev_.ext_format->num_channels);
459}
460
461TEST_F(IoDevSetFormatTestSuite, UpdateChannelLayoutFail) {
462  static const int8_t stereo_layout[] =
463      {0, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
464  struct cras_audio_format fmt;
465  int rc, i;
466
467  fmt.format = SND_PCM_FORMAT_S16_LE;
468  fmt.frame_rate = 48000;
469  fmt.num_channels = 2;
470
471  cras_dsp_context_new_return = reinterpret_cast<cras_dsp_context *>(0xf0f);
472
473  update_channel_layout_return_val = -1;
474  iodev_.supported_channel_counts[0] = 6;
475  iodev_.supported_channel_counts[1] = 2;
476
477  rc = cras_iodev_set_format(&iodev_, &fmt);
478  EXPECT_EQ(0, rc);
479  EXPECT_EQ(SND_PCM_FORMAT_S16_LE, iodev_.ext_format->format);
480  EXPECT_EQ(48000, iodev_.ext_format->frame_rate);
481  EXPECT_EQ(2, iodev_.ext_format->num_channels);
482  EXPECT_EQ(2, cras_audio_format_set_channel_layout_called);
483  EXPECT_EQ(0, dsp_context_free_called);
484  for (i = 0; i < CRAS_CH_MAX; i++)
485    EXPECT_EQ(iodev_.format->channel_layout[i], stereo_layout[i]);
486}
487
488TEST_F(IoDevSetFormatTestSuite, UpdateChannelLayoutFail6ch) {
489  static const int8_t default_6ch_layout[] =
490      {0, 1, 2, 3, 4, 5, -1, -1, -1, -1, -1};
491  struct cras_audio_format fmt;
492  int rc, i;
493
494  fmt.format = SND_PCM_FORMAT_S16_LE;
495  fmt.frame_rate = 48000;
496  fmt.num_channels = 6;
497
498  cras_dsp_context_new_return = reinterpret_cast<cras_dsp_context *>(0xf0f);
499
500  update_channel_layout_return_val = -1;
501  iodev_.supported_channel_counts[0] = 6;
502  iodev_.supported_channel_counts[1] = 2;
503
504  rc = cras_iodev_set_format(&iodev_, &fmt);
505  EXPECT_EQ(0, rc);
506  EXPECT_EQ(SND_PCM_FORMAT_S16_LE, iodev_.ext_format->format);
507  EXPECT_EQ(48000, iodev_.ext_format->frame_rate);
508  EXPECT_EQ(6, iodev_.ext_format->num_channels);
509  EXPECT_EQ(2, cras_audio_format_set_channel_layout_called);
510  EXPECT_EQ(0, dsp_context_free_called);
511  for (i = 0; i < CRAS_CH_MAX; i++)
512    EXPECT_EQ(iodev_.format->channel_layout[i], default_6ch_layout[i]);
513}
514
515// Put buffer tests
516
517static int get_buffer(cras_iodev* iodev, struct cras_audio_area** area,
518               unsigned int* num) {
519  size_t sz = sizeof(*audio_area) + sizeof(struct cras_channel_area) * 2;
520
521  audio_area = (cras_audio_area*)calloc(1, sz);
522  audio_area->frames = *num;
523  audio_area->num_channels = 2;
524  audio_area->channels[0].buf = audio_buffer;
525  channel_area_set_channel(&audio_area->channels[0], CRAS_CH_FL);
526  audio_area->channels[0].step_bytes = 4;
527  audio_area->channels[1].buf = audio_buffer + 2;
528  channel_area_set_channel(&audio_area->channels[1], CRAS_CH_FR);
529  audio_area->channels[1].step_bytes = 4;
530
531  *area = audio_area;
532  return 0;
533}
534
535static int put_buffer(struct cras_iodev *iodev, unsigned int nframes)
536{
537  put_buffer_nframes = nframes;
538  if (audio_area) {
539    free(audio_area);
540    audio_area = NULL;
541  }
542  return 0;
543}
544
545static int no_stream(struct cras_iodev *odev, int enable)
546{
547  no_stream_called++;
548  no_stream_enable = enable;
549  // Use default no stream playback to test default behavior.
550  return cras_iodev_default_no_stream_playback(odev, enable);
551}
552
553static int output_should_wake(const struct cras_iodev *odev)
554{
555  return output_should_wake_ret;
556}
557
558static int pre_dsp_hook(const uint8_t *frames, unsigned int nframes,
559			const struct cras_audio_format *fmt, void *cb_data)
560{
561  pre_dsp_hook_called++;
562  pre_dsp_hook_frames = frames;
563  pre_dsp_hook_cb_data = cb_data;
564  return 0;
565}
566
567static int post_dsp_hook(const uint8_t *frames, unsigned int nframes,
568			 const struct cras_audio_format *fmt, void *cb_data)
569{
570  post_dsp_hook_called++;
571  post_dsp_hook_frames = frames;
572  post_dsp_hook_cb_data = cb_data;
573  return 0;
574}
575
576TEST(IoDevPutOutputBuffer, SystemMuted) {
577  struct cras_audio_format fmt;
578  struct cras_iodev iodev;
579  uint8_t *frames = reinterpret_cast<uint8_t*>(0x44);
580  int rc;
581
582  ResetStubData();
583  memset(&iodev, 0, sizeof(iodev));
584  cras_system_get_mute_return = 1;
585
586  fmt.format = SND_PCM_FORMAT_S16_LE;
587  fmt.frame_rate = 48000;
588  fmt.num_channels = 2;
589  iodev.format = &fmt;
590  iodev.put_buffer = put_buffer;
591
592  rc = cras_iodev_put_output_buffer(&iodev, frames, 20);
593  EXPECT_EQ(0, rc);
594  EXPECT_EQ(20, cras_mix_mute_count);
595  EXPECT_EQ(20, put_buffer_nframes);
596  EXPECT_EQ(20, rate_estimator_add_frames_num_frames);
597}
598
599TEST(IoDevPutOutputBuffer, MuteForVolume) {
600  struct cras_iodev iodev;
601  struct cras_ionode ionode;
602
603  ResetStubData();
604  memset(&iodev, 0, sizeof(iodev));
605  memset(&ionode, 0, sizeof(ionode));
606
607  iodev.nodes = &ionode;
608  iodev.active_node = &ionode;
609  iodev.active_node->dev = &iodev;
610
611  // Case: System volume 100; Node volume 0. => Mute
612  cras_system_get_volume_return = 100;
613  iodev.active_node->volume = 0;
614  EXPECT_EQ(1, cras_iodev_is_zero_volume(&iodev));
615
616  // Case: System volume 100; Node volume 50. => Not mute
617  cras_system_get_volume_return = 100;
618  iodev.active_node->volume = 50;
619  EXPECT_EQ(0, cras_iodev_is_zero_volume(&iodev));
620
621  // Case: System volume 0; Node volume 50. => Mute
622  cras_system_get_volume_return = 0;
623  iodev.active_node->volume = 50;
624  EXPECT_EQ(1, cras_iodev_is_zero_volume(&iodev));
625
626  // Case: System volume 50; Node volume 50. => Mute
627  cras_system_get_volume_return = 50;
628  iodev.active_node->volume = 50;
629  EXPECT_EQ(1, cras_iodev_is_zero_volume(&iodev));
630}
631
632TEST(IoDevPutOutputBuffer, NodeVolumeZeroShouldMute) {
633  struct cras_audio_format fmt;
634  struct cras_iodev iodev;
635  struct cras_ionode ionode;
636  uint8_t *frames = reinterpret_cast<uint8_t*>(0x44);
637  int rc;
638
639  ResetStubData();
640  memset(&iodev, 0, sizeof(iodev));
641  memset(&ionode, 0, sizeof(ionode));
642
643  iodev.nodes = &ionode;
644  iodev.active_node = &ionode;
645  iodev.active_node->dev = &iodev;
646  iodev.active_node->volume = 0;
647
648  fmt.format = SND_PCM_FORMAT_S16_LE;
649  fmt.frame_rate = 48000;
650  fmt.num_channels = 2;
651  iodev.format = &fmt;
652  iodev.put_buffer = put_buffer;
653
654  rc = cras_iodev_put_output_buffer(&iodev, frames, 20);
655  EXPECT_EQ(0, rc);
656  EXPECT_EQ(20, cras_mix_mute_count);
657  EXPECT_EQ(20, put_buffer_nframes);
658  EXPECT_EQ(20, rate_estimator_add_frames_num_frames);
659}
660
661TEST(IoDevPutOutputBuffer, SystemMutedWithRamp) {
662  struct cras_audio_format fmt;
663  struct cras_iodev iodev;
664  uint8_t *frames = reinterpret_cast<uint8_t*>(0x44);
665  int rc;
666
667  ResetStubData();
668  memset(&iodev, 0, sizeof(iodev));
669  cras_system_get_mute_return = 1;
670
671  fmt.format = SND_PCM_FORMAT_S16_LE;
672  fmt.frame_rate = 48000;
673  fmt.num_channels = 2;
674  iodev.format = &fmt;
675  iodev.put_buffer = put_buffer;
676
677  // Assume device has ramp member.
678  iodev.ramp = reinterpret_cast<struct cras_ramp*>(0x1);
679
680  // Assume ramping is done.
681  cras_ramp_get_current_action_ret.type = CRAS_RAMP_ACTION_NONE;
682
683  rc = cras_iodev_put_output_buffer(&iodev, frames, 20);
684  // Output should be muted.
685  EXPECT_EQ(0, rc);
686  EXPECT_EQ(20, cras_mix_mute_count);
687  EXPECT_EQ(20, put_buffer_nframes);
688  EXPECT_EQ(20, rate_estimator_add_frames_num_frames);
689
690  // Test for the case where ramping is not done yet.
691  ResetStubData();
692  cras_ramp_get_current_action_ret.type = CRAS_RAMP_ACTION_PARTIAL;
693  rc = cras_iodev_put_output_buffer(&iodev, frames, 20);
694
695  // Output should not be muted.
696  EXPECT_EQ(0, rc);
697  EXPECT_EQ(0, cras_mix_mute_count);
698  // Ramped frames should be increased by 20.
699  EXPECT_EQ(20, cras_ramp_update_ramped_frames_num_frames);
700  EXPECT_EQ(20, put_buffer_nframes);
701  EXPECT_EQ(20, rate_estimator_add_frames_num_frames);
702}
703
704TEST(IoDevPutOutputBuffer, NodeVolumeZeroShouldMuteWithRamp) {
705  struct cras_audio_format fmt;
706  struct cras_iodev iodev;
707  struct cras_ionode ionode;
708  uint8_t *frames = reinterpret_cast<uint8_t*>(0x44);
709  int rc;
710
711  ResetStubData();
712  memset(&iodev, 0, sizeof(iodev));
713  memset(&ionode, 0, sizeof(ionode));
714
715  iodev.nodes = &ionode;
716  iodev.active_node = &ionode;
717  iodev.active_node->dev = &iodev;
718  iodev.active_node->volume = 0;
719
720  fmt.format = SND_PCM_FORMAT_S16_LE;
721  fmt.frame_rate = 48000;
722  fmt.num_channels = 2;
723  iodev.format = &fmt;
724  iodev.put_buffer = put_buffer;
725
726  // Assume device has ramp member.
727  iodev.ramp = reinterpret_cast<struct cras_ramp*>(0x1);
728
729  // Assume ramping is done.
730  cras_ramp_get_current_action_ret.type = CRAS_RAMP_ACTION_NONE;
731
732  rc = cras_iodev_put_output_buffer(&iodev, frames, 20);
733  EXPECT_EQ(0, rc);
734  EXPECT_EQ(20, cras_mix_mute_count);
735  EXPECT_EQ(20, put_buffer_nframes);
736  EXPECT_EQ(20, rate_estimator_add_frames_num_frames);
737
738  // Test for the case where ramping is not done yet.
739  ResetStubData();
740  cras_ramp_get_current_action_ret.type = CRAS_RAMP_ACTION_PARTIAL;
741  rc = cras_iodev_put_output_buffer(&iodev, frames, 20);
742
743  // Output should not be muted.
744  EXPECT_EQ(0, rc);
745  EXPECT_EQ(0, cras_mix_mute_count);
746  // Ramped frames should be increased by 20.
747  EXPECT_EQ(20, cras_ramp_update_ramped_frames_num_frames);
748  EXPECT_EQ(20, put_buffer_nframes);
749  EXPECT_EQ(20, rate_estimator_add_frames_num_frames);
750}
751TEST(IoDevPutOutputBuffer, NoDSP) {
752  struct cras_audio_format fmt;
753  struct cras_iodev iodev;
754  struct cras_ionode ionode;
755  uint8_t *frames = reinterpret_cast<uint8_t*>(0x44);
756  int rc;
757
758  ResetStubData();
759  memset(&iodev, 0, sizeof(iodev));
760  memset(&ionode, 0, sizeof(ionode));
761
762  iodev.nodes = &ionode;
763  iodev.active_node = &ionode;
764  iodev.active_node->dev = &iodev;
765  iodev.active_node->volume = 100;
766
767  fmt.format = SND_PCM_FORMAT_S16_LE;
768  fmt.frame_rate = 48000;
769  fmt.num_channels = 2;
770  iodev.format = &fmt;
771  iodev.put_buffer = put_buffer;
772
773  rc = cras_iodev_put_output_buffer(&iodev, frames, 22);
774  EXPECT_EQ(0, rc);
775  EXPECT_EQ(0, cras_mix_mute_count);
776  EXPECT_EQ(22, put_buffer_nframes);
777  EXPECT_EQ(22, rate_estimator_add_frames_num_frames);
778}
779
780TEST(IoDevPutOutputBuffer, DSP) {
781  struct cras_audio_format fmt;
782  struct cras_iodev iodev;
783  uint8_t *frames = reinterpret_cast<uint8_t*>(0x44);
784  int rc;
785
786  ResetStubData();
787  memset(&iodev, 0, sizeof(iodev));
788  iodev.dsp_context = reinterpret_cast<cras_dsp_context*>(0x15);
789  cras_dsp_get_pipeline_ret = 0x25;
790
791  fmt.format = SND_PCM_FORMAT_S16_LE;
792  fmt.frame_rate = 48000;
793  fmt.num_channels = 2;
794  iodev.format = &fmt;
795  iodev.put_buffer = put_buffer;
796  cras_iodev_register_pre_dsp_hook(&iodev, pre_dsp_hook, (void *)0x1234);
797  cras_iodev_register_post_dsp_hook(&iodev, post_dsp_hook, (void *)0x5678);
798
799  rc = cras_iodev_put_output_buffer(&iodev, frames, 32);
800  EXPECT_EQ(0, rc);
801  EXPECT_EQ(0, cras_mix_mute_count);
802  EXPECT_EQ(1, pre_dsp_hook_called);
803  EXPECT_EQ(frames, pre_dsp_hook_frames);
804  EXPECT_EQ((void *)0x1234, pre_dsp_hook_cb_data);
805  EXPECT_EQ(1, post_dsp_hook_called);
806  EXPECT_EQ((void *)0x5678, post_dsp_hook_cb_data);
807  EXPECT_EQ(32, put_buffer_nframes);
808  EXPECT_EQ(32, rate_estimator_add_frames_num_frames);
809  EXPECT_EQ(32, cras_dsp_pipeline_apply_sample_count);
810  EXPECT_EQ(cras_dsp_get_pipeline_called, cras_dsp_put_pipeline_called);
811}
812
813TEST(IoDevPutOutputBuffer, SoftVol) {
814  struct cras_audio_format fmt;
815  struct cras_iodev iodev;
816  uint8_t *frames = reinterpret_cast<uint8_t*>(0x44);
817  int rc;
818
819  ResetStubData();
820  memset(&iodev, 0, sizeof(iodev));
821  iodev.software_volume_needed = 1;
822
823  fmt.format = SND_PCM_FORMAT_S16_LE;
824  fmt.frame_rate = 48000;
825  fmt.num_channels = 2;
826  iodev.format = &fmt;
827  iodev.put_buffer = put_buffer;
828
829  cras_system_get_volume_return = 13;
830  softvol_scalers[13] = 0.435;
831
832  rc = cras_iodev_put_output_buffer(&iodev, frames, 53);
833  EXPECT_EQ(0, rc);
834  EXPECT_EQ(0, cras_mix_mute_count);
835  EXPECT_EQ(53, put_buffer_nframes);
836  EXPECT_EQ(53, rate_estimator_add_frames_num_frames);
837  EXPECT_EQ(softvol_scalers[13], cras_scale_buffer_scaler);
838  EXPECT_EQ(SND_PCM_FORMAT_S16_LE, cras_scale_buffer_fmt);
839}
840
841TEST(IoDevPutOutputBuffer, SoftVolWithRamp) {
842  struct cras_audio_format fmt;
843  struct cras_iodev iodev;
844  uint8_t *frames = reinterpret_cast<uint8_t*>(0x44);
845  int rc;
846  int n_frames = 53;
847  float ramp_scaler = 0.2;
848  float increment = 0.001;
849  int volume = 13;
850  float volume_scaler = 0.435;
851
852  ResetStubData();
853  memset(&iodev, 0, sizeof(iodev));
854  iodev.software_volume_needed = 1;
855
856  fmt.format = SND_PCM_FORMAT_S16_LE;
857  fmt.frame_rate = 48000;
858  fmt.num_channels = 2;
859  iodev.format = &fmt;
860  iodev.put_buffer = put_buffer;
861  // Assume device has ramp member.
862  iodev.ramp = reinterpret_cast<struct cras_ramp*>(0x1);
863
864  // Assume ramping is done.
865  cras_ramp_get_current_action_ret.type = CRAS_RAMP_ACTION_NONE;
866
867  cras_system_get_volume_return = volume;
868  softvol_scalers[volume] = volume_scaler;
869
870  rc = cras_iodev_put_output_buffer(&iodev, frames, n_frames);
871  EXPECT_EQ(0, rc);
872  EXPECT_EQ(0, cras_mix_mute_count);
873  EXPECT_EQ(n_frames, put_buffer_nframes);
874  EXPECT_EQ(n_frames, rate_estimator_add_frames_num_frames);
875  EXPECT_EQ(softvol_scalers[volume], cras_scale_buffer_scaler);
876  EXPECT_EQ(SND_PCM_FORMAT_S16_LE, cras_scale_buffer_fmt);
877
878  ResetStubData();
879  // Assume ramping is not done.
880  cras_ramp_get_current_action_ret.type = CRAS_RAMP_ACTION_PARTIAL;
881  cras_ramp_get_current_action_ret.scaler = ramp_scaler;
882  cras_ramp_get_current_action_ret.increment = increment;
883
884  cras_system_get_volume_return = volume;
885  softvol_scalers[volume] = volume_scaler;
886
887  rc = cras_iodev_put_output_buffer(&iodev, frames, n_frames);
888  EXPECT_EQ(0, rc);
889  EXPECT_EQ(0, cras_mix_mute_count);
890  // cras_scale_buffer is not called.
891  EXPECT_EQ(0, cras_scale_buffer_called);
892
893  // Verify the arguments passed to cras_scale_buffer_increment.
894  EXPECT_EQ(fmt.format, cras_scale_buffer_increment_fmt);
895  EXPECT_EQ(frames, cras_scale_buffer_increment_buff);
896  EXPECT_EQ(n_frames, cras_scale_buffer_increment_frame);
897  // Initial scaler will be product of software volume scaler and
898  // ramp scaler.
899  EXPECT_FLOAT_EQ(softvol_scalers[volume] * ramp_scaler,
900                  cras_scale_buffer_increment_scaler);
901  // Increment scaler will be product of software volume scaler and
902  // ramp increment.
903  EXPECT_FLOAT_EQ(softvol_scalers[volume] * increment,
904                  cras_scale_buffer_increment_increment);
905  EXPECT_EQ(fmt.num_channels, cras_scale_buffer_increment_channel);
906
907  EXPECT_EQ(n_frames, put_buffer_nframes);
908  EXPECT_EQ(n_frames, rate_estimator_add_frames_num_frames);
909}
910
911TEST(IoDevPutOutputBuffer, NoSoftVolWithRamp) {
912  struct cras_audio_format fmt;
913  struct cras_iodev iodev;
914  uint8_t *frames = reinterpret_cast<uint8_t*>(0x44);
915  int rc;
916  int n_frames = 53;
917  float ramp_scaler = 0.2;
918  float increment = 0.001;
919
920  ResetStubData();
921  memset(&iodev, 0, sizeof(iodev));
922  iodev.software_volume_needed = 0;
923
924  fmt.format = SND_PCM_FORMAT_S16_LE;
925  fmt.frame_rate = 48000;
926  fmt.num_channels = 2;
927  iodev.format = &fmt;
928  iodev.put_buffer = put_buffer;
929  // Assume device has ramp member.
930  iodev.ramp = reinterpret_cast<struct cras_ramp*>(0x1);
931
932  // Assume ramping is done.
933  cras_ramp_get_current_action_ret.type = CRAS_RAMP_ACTION_NONE;
934
935  rc = cras_iodev_put_output_buffer(&iodev, frames, n_frames);
936  EXPECT_EQ(0, rc);
937  EXPECT_EQ(0, cras_mix_mute_count);
938  // cras_scale_buffer is not called.
939  EXPECT_EQ(0, cras_scale_buffer_called);
940  EXPECT_EQ(n_frames, put_buffer_nframes);
941  EXPECT_EQ(n_frames, rate_estimator_add_frames_num_frames);
942
943  ResetStubData();
944  // Assume ramping is not done.
945  cras_ramp_get_current_action_ret.type = CRAS_RAMP_ACTION_PARTIAL;
946  cras_ramp_get_current_action_ret.scaler = ramp_scaler;
947  cras_ramp_get_current_action_ret.increment = increment;
948
949  rc = cras_iodev_put_output_buffer(&iodev, frames, n_frames);
950  EXPECT_EQ(0, rc);
951  EXPECT_EQ(0, cras_mix_mute_count);
952  // cras_scale_buffer is not called.
953  EXPECT_EQ(0, cras_scale_buffer_called);
954
955  // Verify the arguments passed to cras_scale_buffer_increment.
956  EXPECT_EQ(fmt.format, cras_scale_buffer_increment_fmt);
957  EXPECT_EQ(frames, cras_scale_buffer_increment_buff);
958  EXPECT_EQ(n_frames, cras_scale_buffer_increment_frame);
959  EXPECT_FLOAT_EQ(ramp_scaler, cras_scale_buffer_increment_scaler);
960  EXPECT_FLOAT_EQ(increment, cras_scale_buffer_increment_increment);
961  EXPECT_EQ(fmt.num_channels, cras_scale_buffer_increment_channel);
962
963  EXPECT_EQ(n_frames, put_buffer_nframes);
964  EXPECT_EQ(n_frames, rate_estimator_add_frames_num_frames);
965}
966
967TEST(IoDevPutOutputBuffer, Scale32Bit) {
968  struct cras_audio_format fmt;
969  struct cras_iodev iodev;
970  uint8_t *frames = reinterpret_cast<uint8_t*>(0x44);
971  int rc;
972
973  ResetStubData();
974  memset(&iodev, 0, sizeof(iodev));
975  iodev.software_volume_needed = 1;
976
977  cras_system_get_volume_return = 13;
978  softvol_scalers[13] = 0.435;
979
980  fmt.format = SND_PCM_FORMAT_S32_LE;
981  fmt.frame_rate = 48000;
982  fmt.num_channels = 2;
983  iodev.format = &fmt;
984  iodev.put_buffer = put_buffer;
985
986  rc = cras_iodev_put_output_buffer(&iodev, frames, 53);
987  EXPECT_EQ(0, rc);
988  EXPECT_EQ(0, cras_mix_mute_count);
989  EXPECT_EQ(53, put_buffer_nframes);
990  EXPECT_EQ(53, rate_estimator_add_frames_num_frames);
991  EXPECT_EQ(SND_PCM_FORMAT_S32_LE, cras_scale_buffer_fmt);
992}
993
994// frames queued/avail tests
995
996static unsigned fr_queued = 0;
997
998static int frames_queued(const struct cras_iodev *iodev,
999                         struct timespec *tstamp)
1000{
1001  clock_gettime(CLOCK_MONOTONIC_RAW, tstamp);
1002  return fr_queued;
1003}
1004
1005TEST(IoDevQueuedBuffer, ZeroMinBufferLevel) {
1006  struct cras_iodev iodev;
1007  struct timespec tstamp;
1008  int rc;
1009
1010  ResetStubData();
1011  memset(&iodev, 0, sizeof(iodev));
1012  iodev.direction = CRAS_STREAM_OUTPUT;
1013  iodev.frames_queued = frames_queued;
1014  iodev.min_buffer_level = 0;
1015  iodev.buffer_size = 200;
1016  fr_queued = 50;
1017
1018  rc = cras_iodev_frames_queued(&iodev, &tstamp);
1019  EXPECT_EQ(50, rc);
1020  rc = cras_iodev_buffer_avail(&iodev, rc);
1021  EXPECT_EQ(150, rc);
1022}
1023
1024TEST(IoDevQueuedBuffer, NonZeroMinBufferLevel) {
1025  struct cras_iodev iodev;
1026  struct timespec hw_tstamp;
1027  int rc;
1028
1029  ResetStubData();
1030  memset(&iodev, 0, sizeof(iodev));
1031  iodev.direction = CRAS_STREAM_OUTPUT;
1032  iodev.frames_queued = frames_queued;
1033  iodev.min_buffer_level = 100;
1034  iodev.buffer_size = 200;
1035  fr_queued = 180;
1036
1037  rc = cras_iodev_frames_queued(&iodev, &hw_tstamp);
1038  EXPECT_EQ(80, rc);
1039  rc = cras_iodev_buffer_avail(&iodev, rc);
1040  EXPECT_EQ(20, rc);
1041
1042  /* When fr_queued < min_buffer_level*/
1043  fr_queued = 80;
1044  rc = cras_iodev_frames_queued(&iodev, &hw_tstamp);
1045  EXPECT_EQ(0, rc);
1046  rc = cras_iodev_buffer_avail(&iodev, rc);
1047  EXPECT_EQ(100, rc);
1048}
1049
1050static void update_active_node(struct cras_iodev *iodev,
1051                               unsigned node_idx,
1052                               unsigned dev_enabled)
1053{
1054}
1055
1056static void dev_set_volume(struct cras_iodev *iodev)
1057{
1058}
1059
1060static void dev_set_capture_gain(struct cras_iodev *iodev)
1061{
1062}
1063
1064static void dev_set_mute(struct cras_iodev *iodev)
1065{
1066  set_mute_called++;
1067}
1068
1069TEST(IoNodePlug, PlugUnplugNode) {
1070  struct cras_iodev iodev;
1071  struct cras_ionode ionode, ionode2;
1072
1073  memset(&iodev, 0, sizeof(iodev));
1074  memset(&ionode, 0, sizeof(ionode));
1075  memset(&ionode2, 0, sizeof(ionode2));
1076  iodev.direction = CRAS_STREAM_INPUT;
1077  iodev.update_active_node = update_active_node;
1078  ionode.dev = &iodev;
1079  cras_iodev_add_node(&iodev, &ionode);
1080  ionode2.dev = &iodev;
1081  cras_iodev_add_node(&iodev, &ionode2);
1082  cras_iodev_set_active_node(&iodev, &ionode);
1083  ResetStubData();
1084  cras_iodev_set_node_attr(&ionode, IONODE_ATTR_PLUGGED, 1);
1085  EXPECT_EQ(0, cras_iodev_list_disable_dev_called);
1086  cras_iodev_set_node_attr(&ionode, IONODE_ATTR_PLUGGED, 0);
1087  EXPECT_EQ(1, cras_iodev_list_disable_dev_called);
1088
1089  /* Unplug non-active node shouldn't disable iodev. */
1090  cras_iodev_set_node_attr(&ionode2, IONODE_ATTR_PLUGGED, 1);
1091  EXPECT_EQ(1, cras_iodev_list_disable_dev_called);
1092  cras_iodev_set_node_attr(&ionode2, IONODE_ATTR_PLUGGED, 0);
1093  EXPECT_EQ(1, cras_iodev_list_disable_dev_called);
1094}
1095
1096TEST(IoDev, AddRemoveNode) {
1097  struct cras_iodev iodev;
1098  struct cras_ionode ionode;
1099
1100  memset(&iodev, 0, sizeof(iodev));
1101  memset(&ionode, 0, sizeof(ionode));
1102  ResetStubData();
1103  EXPECT_EQ(0, notify_nodes_changed_called);
1104  cras_iodev_add_node(&iodev, &ionode);
1105  EXPECT_EQ(1, notify_nodes_changed_called);
1106  cras_iodev_rm_node(&iodev, &ionode);
1107  EXPECT_EQ(2, notify_nodes_changed_called);
1108}
1109
1110TEST(IoDev, SetActiveNode) {
1111  struct cras_iodev iodev;
1112  struct cras_ionode ionode;
1113
1114  memset(&iodev, 0, sizeof(iodev));
1115  memset(&ionode, 0, sizeof(ionode));
1116  ResetStubData();
1117  EXPECT_EQ(0, notify_active_node_changed_called);
1118  cras_iodev_set_active_node(&iodev, &ionode);
1119  EXPECT_EQ(1, notify_active_node_changed_called);
1120}
1121
1122TEST(IoDev, SetNodeVolume) {
1123  struct cras_iodev iodev;
1124  struct cras_ionode ionode;
1125
1126  memset(&iodev, 0, sizeof(iodev));
1127  memset(&ionode, 0, sizeof(ionode));
1128  iodev.set_volume = dev_set_volume;
1129  iodev.set_capture_gain = dev_set_capture_gain;
1130  ionode.dev = &iodev;
1131  ResetStubData();
1132  cras_iodev_set_node_attr(&ionode, IONODE_ATTR_VOLUME, 10);
1133  EXPECT_EQ(1, notify_node_volume_called);
1134  iodev.direction = CRAS_STREAM_INPUT;
1135  cras_iodev_set_node_attr(&ionode, IONODE_ATTR_CAPTURE_GAIN, 10);
1136  EXPECT_EQ(1, notify_node_capture_gain_called);
1137}
1138
1139TEST(IoDev, SetNodeSwapLeftRight) {
1140  struct cras_iodev iodev;
1141  struct cras_ionode ionode;
1142
1143  memset(&iodev, 0, sizeof(iodev));
1144  memset(&ionode, 0, sizeof(ionode));
1145  iodev.set_swap_mode_for_node = set_swap_mode_for_node;
1146  ionode.dev = &iodev;
1147  ResetStubData();
1148  cras_iodev_set_node_attr(&ionode, IONODE_ATTR_SWAP_LEFT_RIGHT, 1);
1149  EXPECT_EQ(1, set_swap_mode_for_node_called);
1150  EXPECT_EQ(1, set_swap_mode_for_node_enable);
1151  EXPECT_EQ(1, ionode.left_right_swapped);
1152  EXPECT_EQ(1, notify_node_left_right_swapped_called);
1153  cras_iodev_set_node_attr(&ionode, IONODE_ATTR_SWAP_LEFT_RIGHT, 0);
1154  EXPECT_EQ(2, set_swap_mode_for_node_called);
1155  EXPECT_EQ(0, set_swap_mode_for_node_enable);
1156  EXPECT_EQ(0, ionode.left_right_swapped);
1157  EXPECT_EQ(2, notify_node_left_right_swapped_called);
1158}
1159
1160TEST(IoDev, SetMute) {
1161  struct cras_iodev iodev;
1162  int rc;
1163
1164  memset(&iodev, 0, sizeof(iodev));
1165  iodev.set_mute = dev_set_mute;
1166  iodev.state = CRAS_IODEV_STATE_CLOSE;
1167
1168  ResetStubData();
1169  rc = cras_iodev_set_mute(&iodev);
1170  EXPECT_EQ(0, rc);
1171  EXPECT_EQ(0, set_mute_called);
1172
1173  iodev.state = CRAS_IODEV_STATE_OPEN;
1174  rc = cras_iodev_set_mute(&iodev);
1175  EXPECT_EQ(0, rc);
1176  EXPECT_EQ(1, set_mute_called);
1177}
1178
1179// Test software volume changes for default output.
1180TEST(IoDev, SoftwareVolume) {
1181  struct cras_iodev iodev;
1182  struct cras_ionode ionode;
1183
1184  memset(&iodev, 0, sizeof(iodev));
1185  memset(&ionode, 0, sizeof(ionode));
1186  ResetStubData();
1187
1188  iodev.nodes = &ionode;
1189  iodev.active_node = &ionode;
1190  iodev.active_node->dev = &iodev;
1191
1192  iodev.active_node->volume = 100;
1193  iodev.software_volume_needed = 0;
1194
1195
1196  softvol_scalers[80] = 0.5;
1197  softvol_scalers[70] = 0.3;
1198
1199  // Check that system volume changes software volume if needed.
1200  cras_system_get_volume_return = 80;
1201  // system_volume - 100 + node_volume = 80 - 100 + 100 = 80
1202  EXPECT_FLOAT_EQ(0.5, cras_iodev_get_software_volume_scaler(&iodev));
1203
1204  // Check that node volume changes software volume if needed.
1205  iodev.active_node->volume = 90;
1206  // system_volume - 100 + node_volume = 80 - 100 + 90 = 70
1207  EXPECT_FLOAT_EQ(0.3, cras_iodev_get_software_volume_scaler(&iodev));
1208}
1209
1210// Test software gain scaler.
1211TEST(IoDev, SoftwareGain) {
1212  struct cras_iodev iodev;
1213  struct cras_ionode ionode;
1214
1215  memset(&iodev, 0, sizeof(iodev));
1216  memset(&ionode, 0, sizeof(ionode));
1217  ResetStubData();
1218
1219  iodev.nodes = &ionode;
1220  iodev.active_node = &ionode;
1221  iodev.active_node->dev = &iodev;
1222
1223  ionode.capture_gain= 400;
1224  ionode.software_volume_needed = 1;
1225  ionode.max_software_gain = 3000;
1226
1227  // Check that system volume changes software volume if needed.
1228  cras_system_get_capture_gain_ret_value = 2000;
1229  // system_gain + node_gain = 2000 + 400  = 2400
1230  // 2400 dBm is 15.848931
1231  EXPECT_FLOAT_EQ(15.848931, cras_iodev_get_software_gain_scaler(&iodev));
1232  EXPECT_FLOAT_EQ(3000, cras_iodev_maximum_software_gain(&iodev));
1233
1234  // Software gain scaler should be 1.0 if software gain is not needed.
1235  ionode.software_volume_needed = 0;
1236  EXPECT_FLOAT_EQ(1.0, cras_iodev_get_software_gain_scaler(&iodev));
1237  EXPECT_FLOAT_EQ(0, cras_iodev_maximum_software_gain(&iodev));
1238}
1239
1240// This get_buffer implementation set returned frames larger than requested
1241// frames.
1242static int bad_get_buffer(struct cras_iodev *iodev,
1243                          struct cras_audio_area **area,
1244                          unsigned *frames)
1245{
1246  *frames = *frames + 1;
1247  return 0;
1248}
1249
1250// Check that if get_buffer implementation returns invalid frames,
1251// cras_iodev_get_output_buffer and cras_iodev_get_input_buffer can return
1252// error.
1253TEST(IoDev, GetBufferInvalidFrames) {
1254  struct cras_iodev iodev;
1255  struct cras_audio_area **area = NULL;
1256  unsigned int frames = 512;
1257  struct cras_audio_format fmt;
1258
1259  // Format is used in cras_iodev_get_input_buffer;
1260  fmt.format = SND_PCM_FORMAT_S16_LE;
1261  fmt.frame_rate = 48000;
1262  fmt.num_channels = 2;
1263
1264  memset(&iodev, 0, sizeof(iodev));
1265
1266  ResetStubData();
1267
1268  iodev.format = &fmt;
1269  iodev.get_buffer = bad_get_buffer;
1270
1271  EXPECT_EQ(-EINVAL, cras_iodev_get_output_buffer(&iodev, area, &frames));
1272  EXPECT_EQ(-EINVAL, cras_iodev_get_input_buffer(&iodev, area, &frames));
1273}
1274
1275static int open_dev(struct cras_iodev *iodev) {
1276  iodev->buffer_size = iodev_buffer_size;
1277  return 0;
1278}
1279
1280TEST(IoDev, OpenOutputDeviceNoStart) {
1281  struct cras_iodev iodev;
1282
1283  memset(&iodev, 0, sizeof(iodev));
1284  iodev.open_dev = open_dev;
1285  iodev.direction = CRAS_STREAM_OUTPUT;
1286  ResetStubData();
1287
1288  iodev.state = CRAS_IODEV_STATE_CLOSE;
1289
1290  iodev_buffer_size = 1024;
1291  cras_iodev_open(&iodev, 240);
1292  EXPECT_EQ(0, iodev.max_cb_level);
1293  EXPECT_EQ(240, iodev.min_cb_level);
1294
1295  // Test that state is no stream run when there is no start ops.
1296  EXPECT_EQ(CRAS_IODEV_STATE_NO_STREAM_RUN, iodev.state);
1297}
1298
1299int fake_start(const struct cras_iodev *iodev) {
1300  return 0;
1301}
1302
1303TEST(IoDev, OpenOutputDeviceWithStart) {
1304  struct cras_iodev iodev;
1305
1306  memset(&iodev, 0, sizeof(iodev));
1307  iodev.open_dev = open_dev;
1308  iodev.direction = CRAS_STREAM_OUTPUT;
1309  ResetStubData();
1310
1311  iodev.state = CRAS_IODEV_STATE_CLOSE;
1312  iodev.start = fake_start;
1313
1314  iodev_buffer_size = 1024;
1315  cras_iodev_open(&iodev, 240);
1316  EXPECT_EQ(0, iodev.max_cb_level);
1317  EXPECT_EQ(240, iodev.min_cb_level);
1318
1319  // Test that state is no stream run when there is start ops.
1320  EXPECT_EQ(CRAS_IODEV_STATE_OPEN, iodev.state);
1321}
1322
1323TEST(IoDev, OpenInputDeviceNoStart) {
1324  struct cras_iodev iodev;
1325
1326  memset(&iodev, 0, sizeof(iodev));
1327  iodev.open_dev = open_dev;
1328  iodev.direction = CRAS_STREAM_INPUT;
1329  ResetStubData();
1330
1331  iodev.state = CRAS_IODEV_STATE_CLOSE;
1332
1333  iodev_buffer_size = 1024;
1334  cras_iodev_open(&iodev, 240);
1335  EXPECT_EQ(0, iodev.max_cb_level);
1336  EXPECT_EQ(240, iodev.min_cb_level);
1337
1338  // Test that state is normal run when there is start ops.
1339  EXPECT_EQ(CRAS_IODEV_STATE_NORMAL_RUN, iodev.state);
1340}
1341
1342TEST(IoDev, OpenInputDeviceWithStart) {
1343  struct cras_iodev iodev;
1344
1345  memset(&iodev, 0, sizeof(iodev));
1346  iodev.open_dev = open_dev;
1347  iodev.direction = CRAS_STREAM_INPUT;
1348  ResetStubData();
1349
1350  iodev.state = CRAS_IODEV_STATE_CLOSE;
1351  iodev.start = fake_start;
1352
1353  iodev_buffer_size = 1024;
1354  cras_iodev_open(&iodev, 240);
1355  EXPECT_EQ(0, iodev.max_cb_level);
1356  EXPECT_EQ(240, iodev.min_cb_level);
1357
1358  // Test that state is normal run even if there is start ops.
1359  EXPECT_EQ(CRAS_IODEV_STATE_NORMAL_RUN, iodev.state);
1360}
1361
1362static int simple_no_stream(struct cras_iodev *dev, int enable)
1363{
1364  simple_no_stream_enable = enable;
1365  simple_no_stream_called++;
1366  return 0;
1367}
1368
1369TEST(IoDev, AddRmStream) {
1370  struct cras_iodev iodev;
1371  struct cras_rstream rstream1, rstream2;
1372  struct dev_stream stream1, stream2;
1373
1374  memset(&iodev, 0, sizeof(iodev));
1375  iodev.open_dev = open_dev;
1376  iodev.no_stream = simple_no_stream;
1377  iodev.state = CRAS_IODEV_STATE_NORMAL_RUN;
1378  rstream1.cb_threshold = 800;
1379  stream1.stream = &rstream1;
1380  rstream2.cb_threshold = 400;
1381  stream2.stream = &rstream2;
1382  ResetStubData();
1383
1384  iodev_buffer_size = 1024;
1385  cras_iodev_open(&iodev, rstream1.cb_threshold);
1386  EXPECT_EQ(0, iodev.max_cb_level);
1387  EXPECT_EQ(512, iodev.min_cb_level);
1388
1389  /* min_cb_level should not exceed half the buffer size. */
1390  cras_iodev_add_stream(&iodev, &stream1);
1391  EXPECT_EQ(800, iodev.max_cb_level);
1392  EXPECT_EQ(512, iodev.min_cb_level);
1393
1394  cras_iodev_add_stream(&iodev, &stream2);
1395  EXPECT_EQ(800, iodev.max_cb_level);
1396  EXPECT_EQ(400, iodev.min_cb_level);
1397
1398  cras_iodev_rm_stream(&iodev, &rstream1);
1399  EXPECT_EQ(400, iodev.max_cb_level);
1400  EXPECT_EQ(400, iodev.min_cb_level);
1401  EXPECT_EQ(0, simple_no_stream_called);
1402
1403  /* When all streams are removed, keep the last min_cb_level for draining. */
1404  cras_iodev_rm_stream(&iodev, &rstream2);
1405  EXPECT_EQ(0, iodev.max_cb_level);
1406  EXPECT_EQ(400, iodev.min_cb_level);
1407}
1408
1409TEST(IoDev, FillZeros) {
1410  struct cras_iodev iodev;
1411  struct cras_audio_format fmt;
1412  unsigned int frames = 50;
1413  int16_t *zeros;
1414  int rc;
1415
1416  ResetStubData();
1417
1418  memset(&iodev, 0, sizeof(iodev));
1419  fmt.format = SND_PCM_FORMAT_S16_LE;
1420  fmt.frame_rate = 48000;
1421  fmt.num_channels = 2;
1422  iodev.ext_format = &fmt;
1423  iodev.get_buffer = get_buffer;
1424  iodev.put_buffer = put_buffer;
1425
1426  iodev.direction = CRAS_STREAM_INPUT;
1427  rc = cras_iodev_fill_odev_zeros(&iodev, frames);
1428  EXPECT_EQ(-EINVAL, rc);
1429
1430  iodev.direction = CRAS_STREAM_OUTPUT;
1431  rc = cras_iodev_fill_odev_zeros(&iodev, frames);
1432
1433  EXPECT_EQ(0, rc);
1434  EXPECT_EQ(frames, put_buffer_nframes);
1435  zeros = (int16_t *)calloc(frames * 2, sizeof(*zeros));
1436  rc = memcmp(audio_buffer, zeros, frames * 2 * 2);
1437  free(zeros);
1438  EXPECT_EQ(0, rc);
1439}
1440
1441TEST(IoDev, DefaultNoStreamPlaybackRunning) {
1442  struct cras_iodev iodev;
1443  struct cras_audio_format fmt;
1444  unsigned int hw_level = 50;
1445  unsigned int min_cb_level = 240;
1446  unsigned int zeros_to_fill;
1447  int16_t *zeros;
1448  int rc;
1449
1450  memset(&iodev, 0, sizeof(iodev));
1451
1452  fmt.format = SND_PCM_FORMAT_S16_LE;
1453  fmt.frame_rate = 48000;
1454  fmt.num_channels = 2;
1455  iodev.ext_format = &fmt;
1456  iodev.min_cb_level = min_cb_level;
1457  iodev.get_buffer = get_buffer;
1458  iodev.put_buffer = put_buffer;
1459  iodev.frames_queued = frames_queued;
1460  iodev.min_buffer_level = 0;
1461  iodev.direction = CRAS_STREAM_OUTPUT;
1462  iodev.buffer_size = BUFFER_SIZE;
1463  iodev.no_stream = no_stream;
1464
1465  ResetStubData();
1466
1467  // Device is running. hw_level is less than target.
1468  // Need to fill to callback level * 2;
1469  iodev.state = CRAS_IODEV_STATE_NO_STREAM_RUN;
1470  fr_queued = hw_level;
1471  zeros_to_fill = min_cb_level * 2 - hw_level;
1472
1473  rc = cras_iodev_default_no_stream_playback(&iodev, 1);
1474
1475  EXPECT_EQ(0, rc);
1476  EXPECT_EQ(CRAS_IODEV_STATE_NO_STREAM_RUN, iodev.state);
1477  EXPECT_EQ(zeros_to_fill, put_buffer_nframes);
1478  zeros = (int16_t *)calloc(zeros_to_fill * 2, sizeof(*zeros));
1479  EXPECT_EQ(0, memcmp(audio_buffer, zeros, zeros_to_fill * 2 * 2));
1480  free(zeros);
1481
1482  ResetStubData();
1483
1484  // Device is running. hw_level is not less than target.
1485  // No need to fill zeros.
1486  iodev.state = CRAS_IODEV_STATE_NO_STREAM_RUN;
1487  hw_level = min_cb_level * 2;
1488  fr_queued = hw_level;
1489  zeros_to_fill = 0;
1490
1491  rc = cras_iodev_default_no_stream_playback(&iodev, 1);
1492  EXPECT_EQ(0, rc);
1493  EXPECT_EQ(CRAS_IODEV_STATE_NO_STREAM_RUN, iodev.state);
1494  EXPECT_EQ(zeros_to_fill, put_buffer_nframes);
1495}
1496
1497TEST(IoDev, PrepareOutputBeforeWriteSamples) {
1498  struct cras_iodev iodev;
1499  struct cras_audio_format fmt;
1500  unsigned int min_cb_level = 240;
1501  int rc;
1502  struct cras_rstream rstream1;
1503  struct dev_stream stream1;
1504  struct cras_iodev_info info;
1505
1506  ResetStubData();
1507
1508  rstream1.cb_threshold = min_cb_level;
1509  stream1.stream = &rstream1;
1510
1511  memset(&iodev, 0, sizeof(iodev));
1512
1513  fmt.format = SND_PCM_FORMAT_S16_LE;
1514  fmt.frame_rate = 48000;
1515  fmt.num_channels = 2;
1516  iodev.ext_format = &fmt;
1517  iodev.format = &fmt;
1518  iodev.min_cb_level = min_cb_level;
1519  iodev.get_buffer = get_buffer;
1520  iodev.put_buffer = put_buffer;
1521  iodev.frames_queued = frames_queued;
1522  iodev.min_buffer_level = 0;
1523  iodev.direction = CRAS_STREAM_OUTPUT;
1524  iodev.buffer_size = BUFFER_SIZE;
1525  iodev.no_stream = no_stream;
1526  iodev.open_dev = open_dev;
1527  iodev.start = fake_start;
1528  iodev.info = info;
1529  iodev_buffer_size = BUFFER_SIZE;
1530
1531  // Open device.
1532  cras_iodev_open(&iodev, rstream1.cb_threshold);
1533
1534  // Add one stream to device.
1535  cras_iodev_add_stream(&iodev, &stream1);
1536
1537  // Case 1: Assume device is not started yet.
1538  iodev.state = CRAS_IODEV_STATE_OPEN;
1539  // Assume sample is not ready yet.
1540  dev_stream_playback_frames_ret = 0;
1541
1542  rc = cras_iodev_prepare_output_before_write_samples(&iodev);
1543
1544  EXPECT_EQ(0, rc);
1545  // Device should remain in open state.
1546  EXPECT_EQ(CRAS_IODEV_STATE_OPEN, iodev.state);
1547  EXPECT_EQ(0, no_stream_called);
1548
1549  // Assume now sample is ready.
1550  dev_stream_playback_frames_ret = 100;
1551
1552  rc = cras_iodev_prepare_output_before_write_samples(&iodev);
1553
1554  EXPECT_EQ(0, rc);
1555  // Device should enter normal run state.
1556  EXPECT_EQ(CRAS_IODEV_STATE_NORMAL_RUN, iodev.state);
1557  EXPECT_EQ(0, no_stream_called);
1558  // Need to fill 1 callback level of zeros;
1559  EXPECT_EQ(min_cb_level, put_buffer_nframes);
1560
1561  ResetStubData();
1562
1563  // Case 2: Assume device is started and is in no stream state.
1564  iodev.state = CRAS_IODEV_STATE_NO_STREAM_RUN;
1565  // Sample is not ready yet.
1566  dev_stream_playback_frames_ret = 0;
1567
1568  rc = cras_iodev_prepare_output_before_write_samples(&iodev);
1569
1570  EXPECT_EQ(0, rc);
1571  // Device should remain in no_stream state.
1572  EXPECT_EQ(CRAS_IODEV_STATE_NO_STREAM_RUN, iodev.state);
1573  // Device in no_stream state should call no_stream ops once.
1574  EXPECT_EQ(1, no_stream_called);
1575  EXPECT_EQ(1, no_stream_enable);
1576
1577  // Assume now sample is ready.
1578  dev_stream_playback_frames_ret = 100;
1579
1580  rc = cras_iodev_prepare_output_before_write_samples(&iodev);
1581
1582  EXPECT_EQ(0, rc);
1583  // Device should enter normal run state.
1584  EXPECT_EQ(CRAS_IODEV_STATE_NORMAL_RUN, iodev.state);
1585  // Device should call no_stream ops with enable=0 to leave no stream state.
1586  EXPECT_EQ(2, no_stream_called);
1587  EXPECT_EQ(0, no_stream_enable);
1588
1589  ResetStubData();
1590
1591  // Case 3: Assume device is started and is in normal run state.
1592  iodev.state = CRAS_IODEV_STATE_NORMAL_RUN;
1593
1594  rc = cras_iodev_prepare_output_before_write_samples(&iodev);
1595
1596  EXPECT_EQ(0, rc);
1597  // Device should remain in normal run state.
1598  EXPECT_EQ(CRAS_IODEV_STATE_NORMAL_RUN, iodev.state);
1599  // Device in no_stream state should call no_stream ops once.
1600  EXPECT_EQ(0, no_stream_called);
1601
1602  ResetStubData();
1603
1604  // Test for device with ramp. Device should start ramping
1605  // when sample is ready.
1606
1607  // Assume device has ramp member.
1608  iodev.ramp = reinterpret_cast<struct cras_ramp*>(0x1);
1609
1610  // Case 4.1: Assume device with ramp is started and is in no stream state.
1611  iodev.state = CRAS_IODEV_STATE_NO_STREAM_RUN;
1612  // Assume sample is ready.
1613  dev_stream_playback_frames_ret = 100;
1614
1615  rc = cras_iodev_prepare_output_before_write_samples(&iodev);
1616
1617  // Device should start ramping up without setting mute callback.
1618  EXPECT_EQ(0, rc);
1619  EXPECT_EQ(1, cras_ramp_start_is_called);
1620  EXPECT_EQ(1, cras_ramp_start_is_up);
1621  EXPECT_EQ(fmt.frame_rate * RAMP_NEW_STREAM_DURATION_SECS,
1622            cras_ramp_start_duration_frames);
1623  EXPECT_EQ(NULL, cras_ramp_start_cb);
1624  EXPECT_EQ(NULL, cras_ramp_start_cb_data);
1625
1626  ResetStubData();
1627
1628  // Case 4.2: Assume device with ramp is started and is in no stream state.
1629  //           But system is muted.
1630  iodev.state = CRAS_IODEV_STATE_NO_STREAM_RUN;
1631  // Assume system is muted.
1632  cras_system_get_mute_return = 1;
1633  // Assume sample is ready.
1634  dev_stream_playback_frames_ret = 100;
1635
1636  rc = cras_iodev_prepare_output_before_write_samples(&iodev);
1637
1638  // Device should not start ramping up because system is muted.
1639  EXPECT_EQ(0, rc);
1640  EXPECT_EQ(0, cras_ramp_start_is_called);
1641
1642  ResetStubData();
1643
1644  // Case 5.1: Assume device with ramp is in open state.
1645  iodev.state = CRAS_IODEV_STATE_OPEN;
1646  // Assume sample is ready.
1647  dev_stream_playback_frames_ret = 100;
1648
1649  rc = cras_iodev_prepare_output_before_write_samples(&iodev);
1650
1651  // Device should start ramping up without setting mute callback.
1652  EXPECT_EQ(0, rc);
1653  EXPECT_EQ(1, cras_ramp_start_is_called);
1654  EXPECT_EQ(1, cras_ramp_start_is_up);
1655  EXPECT_EQ(fmt.frame_rate * RAMP_NEW_STREAM_DURATION_SECS,
1656            cras_ramp_start_duration_frames);
1657  EXPECT_EQ(NULL, cras_ramp_start_cb);
1658  EXPECT_EQ(NULL, cras_ramp_start_cb_data);
1659
1660  ResetStubData();
1661
1662  // Case 5.2: Assume device with ramp is in open state. But system is muted.
1663  iodev.state = CRAS_IODEV_STATE_OPEN;
1664  // Assume system is muted.
1665  cras_system_get_mute_return = 1;
1666  // Assume sample is ready.
1667  dev_stream_playback_frames_ret = 100;
1668
1669  rc = cras_iodev_prepare_output_before_write_samples(&iodev);
1670
1671  // Device should not start ramping up because system is muted.
1672  EXPECT_EQ(0, rc);
1673  EXPECT_EQ(0, cras_ramp_start_is_called);
1674}
1675
1676TEST(IoDev, StartRampUp) {
1677  struct cras_iodev iodev;
1678  int rc;
1679  struct cras_audio_format fmt;
1680  enum CRAS_IODEV_RAMP_REQUEST req;
1681  memset(&iodev, 0, sizeof(iodev));
1682
1683  // Format will be used in cras_iodev_start_ramp to determine ramp duration.
1684  fmt.format = SND_PCM_FORMAT_S16_LE;
1685  fmt.frame_rate = 48000;
1686  fmt.num_channels = 2;
1687  iodev.format = &fmt;
1688
1689  // Assume device has ramp member.
1690  iodev.ramp = reinterpret_cast<struct cras_ramp*>(0x1);
1691
1692  // Case 1: Device is not opened yet.
1693  ResetStubData();
1694  iodev.state = CRAS_IODEV_STATE_CLOSE;
1695  req = CRAS_IODEV_RAMP_REQUEST_UP_UNMUTE;
1696
1697  rc = cras_iodev_start_ramp(&iodev, req);
1698
1699  // Ramp request is ignored.
1700  EXPECT_EQ(0, rc);
1701  EXPECT_EQ(0, cras_ramp_start_is_called);
1702
1703  // Case 2: Ramp up without mute.
1704  ResetStubData();
1705  iodev.state = CRAS_IODEV_STATE_OPEN;
1706  req = CRAS_IODEV_RAMP_REQUEST_UP_START_PLAYBACK;
1707
1708  rc = cras_iodev_start_ramp(&iodev, req);
1709
1710  // Device should start ramping up without setting mute callback.
1711  EXPECT_EQ(0, rc);
1712  EXPECT_EQ(1, cras_ramp_start_is_called);
1713  EXPECT_EQ(1, cras_ramp_start_is_up);
1714  EXPECT_EQ(fmt.frame_rate * RAMP_NEW_STREAM_DURATION_SECS,
1715            cras_ramp_start_duration_frames);
1716  EXPECT_EQ(NULL, cras_ramp_start_cb);
1717  EXPECT_EQ(NULL, cras_ramp_start_cb_data);
1718
1719  // Case 3: Ramp up for unmute.
1720  ResetStubData();
1721  iodev.state = CRAS_IODEV_STATE_OPEN;
1722  req = CRAS_IODEV_RAMP_REQUEST_UP_UNMUTE;
1723
1724  rc = cras_iodev_start_ramp(&iodev, req);
1725
1726  // Device should start ramping up.
1727  EXPECT_EQ(0, rc);
1728  EXPECT_EQ(1, cras_ramp_start_is_called);
1729  EXPECT_EQ(1, cras_ramp_start_is_up);
1730  EXPECT_EQ(fmt.frame_rate * RAMP_UNMUTE_DURATION_SECS,
1731            cras_ramp_start_duration_frames);
1732  // Callback for unmute is not used.
1733  EXPECT_EQ(NULL, cras_ramp_start_cb);
1734  // Device mute state is set after ramping starts.
1735  EXPECT_EQ(1, cras_device_monitor_set_device_mute_state_called);
1736  EXPECT_EQ(&iodev, cras_device_monitor_set_device_mute_state_dev);
1737}
1738
1739TEST(IoDev, StartRampDown) {
1740  struct cras_iodev iodev;
1741  int rc;
1742  struct cras_audio_format fmt;
1743  enum CRAS_IODEV_RAMP_REQUEST req;
1744  memset(&iodev, 0, sizeof(iodev));
1745
1746  // Format will be used in cras_iodev_start_ramp to determine ramp duration.
1747  fmt.format = SND_PCM_FORMAT_S16_LE;
1748  fmt.frame_rate = 48000;
1749  fmt.num_channels = 2;
1750  iodev.format = &fmt;
1751
1752  // Assume device has ramp member.
1753  iodev.ramp = reinterpret_cast<struct cras_ramp*>(0x1);
1754
1755  // Case 1: Device is not opened yet.
1756  ResetStubData();
1757  iodev.state = CRAS_IODEV_STATE_CLOSE;
1758  req = CRAS_IODEV_RAMP_REQUEST_DOWN_MUTE;
1759
1760  rc = cras_iodev_start_ramp(&iodev, req);
1761
1762  // Ramp request is ignored.
1763  EXPECT_EQ(0, rc);
1764  EXPECT_EQ(0, cras_ramp_start_is_called);
1765
1766  // Case 2: Ramp down for mute.
1767  ResetStubData();
1768  iodev.state = CRAS_IODEV_STATE_OPEN;
1769  req = CRAS_IODEV_RAMP_REQUEST_DOWN_MUTE;
1770
1771  rc = cras_iodev_start_ramp(&iodev, req);
1772
1773  // Device should start ramping down with mute callback.
1774  EXPECT_EQ(0, rc);
1775  EXPECT_EQ(1, cras_ramp_start_is_called);
1776  EXPECT_EQ(0, cras_ramp_start_is_up);
1777  EXPECT_EQ(fmt.frame_rate * RAMP_MUTE_DURATION_SECS,
1778            cras_ramp_start_duration_frames);
1779
1780  // Device mute state is not set yet. It should wait for ramp to finish.
1781  EXPECT_EQ(0, cras_device_monitor_set_device_mute_state_called);
1782  EXPECT_EQ(NULL, cras_device_monitor_set_device_mute_state_dev);
1783
1784  // Assume the callback is set, and it is later called after ramp is done.
1785  // It should trigger cras_device_monitor_set_device_mute_state.
1786  cras_ramp_start_cb(cras_ramp_start_cb_data);
1787  EXPECT_EQ(1, cras_device_monitor_set_device_mute_state_called);
1788  EXPECT_EQ(&iodev, cras_device_monitor_set_device_mute_state_dev);
1789}
1790
1791TEST(IoDev, OutputDeviceShouldWake) {
1792  struct cras_iodev iodev;
1793  int rc;
1794
1795  memset(&iodev, 0, sizeof(iodev));
1796
1797  ResetStubData();
1798
1799  // Device is not running. No need to wake for this device.
1800  iodev.state = CRAS_IODEV_STATE_OPEN;
1801  rc = cras_iodev_odev_should_wake(&iodev);
1802  EXPECT_EQ(0, rc);
1803
1804  // Device is running. Need to wake for this device.
1805  iodev.state = CRAS_IODEV_STATE_NORMAL_RUN;
1806  rc = cras_iodev_odev_should_wake(&iodev);
1807  EXPECT_EQ(1, rc);
1808
1809  // Device is running. Device has output_should_wake ops.
1810  iodev.output_should_wake = output_should_wake;
1811  output_should_wake_ret = 0;
1812  rc = cras_iodev_odev_should_wake(&iodev);
1813  EXPECT_EQ(0, rc);
1814
1815  // Device is running. Device has output_should_wake ops.
1816  output_should_wake_ret = 1;
1817  rc = cras_iodev_odev_should_wake(&iodev);
1818  EXPECT_EQ(1, rc);
1819
1820  // Ignore input device.
1821  iodev.direction = CRAS_STREAM_INPUT;
1822  rc = cras_iodev_odev_should_wake(&iodev);
1823  EXPECT_EQ(0, rc);
1824}
1825
1826TEST(IoDev, FramesToPlayInSleep) {
1827  struct cras_iodev iodev;
1828  unsigned int min_cb_level = 240, hw_level;
1829  unsigned int got_hw_level, got_frames;
1830  struct timespec hw_tstamp;
1831
1832  memset(&iodev, 0, sizeof(iodev));
1833  iodev.frames_queued = frames_queued;
1834  iodev.min_buffer_level = 0;
1835  iodev.direction = CRAS_STREAM_OUTPUT;
1836  iodev.buffer_size = BUFFER_SIZE;
1837  iodev.min_cb_level = min_cb_level;
1838
1839  ResetStubData();
1840
1841  // Device is running. There is at least one stream for this device.
1842  // hw_level is greater than min_cb_level.
1843  iodev.state = CRAS_IODEV_STATE_NORMAL_RUN;
1844  hw_level = min_cb_level + 50;
1845  fr_queued = hw_level;
1846  iodev.streams = reinterpret_cast<struct dev_stream *>(0x1);
1847
1848  got_frames = cras_iodev_frames_to_play_in_sleep(
1849                   &iodev, &got_hw_level, &hw_tstamp);
1850  EXPECT_EQ(hw_level, got_hw_level);
1851  EXPECT_EQ(hw_level, got_frames);
1852
1853  // Device is running. There is no stream for this device.
1854  // hw_level is greater than min_cb_level.
1855  iodev.streams = NULL;
1856
1857  got_frames = cras_iodev_frames_to_play_in_sleep(
1858                   &iodev, &got_hw_level, &hw_tstamp);
1859  EXPECT_EQ(hw_level, got_hw_level);
1860  EXPECT_EQ(hw_level - min_cb_level, got_frames);
1861
1862  // Device is running. There is no stream for this device.
1863  // hw_level is less than min_cb_level.
1864  iodev.streams = NULL;
1865  hw_level = min_cb_level - 50;
1866  fr_queued = hw_level;
1867
1868  got_frames = cras_iodev_frames_to_play_in_sleep(
1869                   &iodev, &got_hw_level, &hw_tstamp);
1870  EXPECT_EQ(hw_level, got_hw_level);
1871  EXPECT_EQ(0, got_frames);
1872}
1873
1874static unsigned int get_num_underruns(const struct cras_iodev *iodev) {
1875  return get_num_underruns_ret;
1876}
1877
1878TEST(IoDev, GetNumUnderruns) {
1879  struct cras_iodev iodev;
1880  memset(&iodev, 0, sizeof(iodev));
1881
1882  EXPECT_EQ(0, cras_iodev_get_num_underruns(&iodev));
1883
1884  iodev.get_num_underruns = get_num_underruns;
1885  get_num_underruns_ret = 10;
1886  EXPECT_EQ(10, cras_iodev_get_num_underruns(&iodev));
1887}
1888
1889TEST(IoDev, RequestReset) {
1890  struct cras_iodev iodev;
1891  memset(&iodev, 0, sizeof(iodev));
1892
1893  ResetStubData();
1894
1895  iodev.open_dev = open_dev;
1896  iodev.direction = CRAS_STREAM_OUTPUT;
1897
1898  iodev.state = CRAS_IODEV_STATE_CLOSE;
1899  iodev_buffer_size = 1024;
1900
1901  // Open device.
1902  cras_iodev_open(&iodev, 240);
1903
1904  // The first reset request works.
1905  EXPECT_EQ(0, cras_iodev_reset_request(&iodev));
1906  EXPECT_EQ(1, device_monitor_reset_device_called);
1907
1908  // The second reset request will do nothing.
1909  EXPECT_EQ(0, cras_iodev_reset_request(&iodev));
1910  EXPECT_EQ(1, device_monitor_reset_device_called);
1911
1912  // Assume device is opened again.
1913  cras_iodev_open(&iodev, 240);
1914
1915  // The reset request works.
1916  EXPECT_EQ(0, cras_iodev_reset_request(&iodev));
1917  EXPECT_EQ(2, device_monitor_reset_device_called);
1918}
1919
1920static int output_underrun(struct cras_iodev *iodev) {
1921  output_underrun_called++;
1922  return 0;
1923}
1924
1925
1926TEST(IoDev, HandleOutputUnderrun) {
1927  struct cras_iodev iodev;
1928  struct cras_audio_format fmt;
1929  unsigned int frames = 240;
1930  int16_t *zeros;
1931  int rc;
1932
1933  ResetStubData();
1934
1935  memset(&iodev, 0, sizeof(iodev));
1936  fmt.format = SND_PCM_FORMAT_S16_LE;
1937  fmt.frame_rate = 48000;
1938  fmt.num_channels = 2;
1939  iodev.ext_format = &fmt;
1940  iodev.get_buffer = get_buffer;
1941  iodev.put_buffer = put_buffer;
1942  iodev.direction = CRAS_STREAM_OUTPUT;
1943  iodev.min_cb_level = frames;
1944
1945  // Default case, fill one block of zeros.
1946  EXPECT_EQ(0, cras_iodev_output_underrun(&iodev));
1947
1948  EXPECT_EQ(frames, put_buffer_nframes);
1949  zeros = (int16_t *)calloc(frames * 2, sizeof(*zeros));
1950  rc = memcmp(audio_buffer, zeros, frames * 2 * 2);
1951  free(zeros);
1952  EXPECT_EQ(0, rc);
1953
1954  // Test iodev has output_underrun ops.
1955  iodev.output_underrun = output_underrun;
1956  EXPECT_EQ(0, cras_iodev_output_underrun(&iodev));
1957  EXPECT_EQ(1, output_underrun_called);
1958}
1959
1960extern "C" {
1961
1962//  From libpthread.
1963int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
1964                   void *(*start_routine)(void*), void *arg) {
1965  return 0;
1966}
1967
1968int pthread_join(pthread_t thread, void **value_ptr) {
1969  return 0;
1970}
1971
1972// From audio_thread
1973struct cras_fmt_conv *audio_thread_get_global_remix_converter()
1974{
1975  return NULL;
1976}
1977
1978// Fromt fmt_conv
1979void cras_channel_remix_convert(struct cras_fmt_conv *conv,
1980    uint8_t *in_buf,
1981    size_t frames)
1982{
1983}
1984
1985// From buffer_share
1986struct buffer_share *buffer_share_create(unsigned int buf_sz) {
1987  return NULL;
1988}
1989
1990void buffer_share_destroy(struct buffer_share *mix)
1991{
1992}
1993
1994int buffer_share_offset_update(struct buffer_share *mix, unsigned int id,
1995                               unsigned int frames) {
1996  return 0;
1997}
1998
1999unsigned int buffer_share_get_new_write_point(struct buffer_share *mix) {
2000  return 0;
2001}
2002
2003int buffer_share_add_id(struct buffer_share *mix, unsigned int id) {
2004  return 0;
2005}
2006
2007int buffer_share_rm_id(struct buffer_share *mix, unsigned int id) {
2008  return 0;
2009}
2010
2011unsigned int buffer_share_id_offset(const struct buffer_share *mix,
2012                                    unsigned int id)
2013{
2014  return 0;
2015}
2016
2017// From cras_system_state.
2018void cras_system_state_stream_added(enum CRAS_STREAM_DIRECTION direction) {
2019}
2020
2021void cras_system_state_stream_removed(enum CRAS_STREAM_DIRECTION direction) {
2022}
2023
2024// From cras_dsp
2025struct cras_dsp_context *cras_dsp_context_new(int sample_rate,
2026                                              const char *purpose)
2027{
2028  dsp_context_new_sample_rate = sample_rate;
2029  dsp_context_new_purpose = purpose;
2030  return cras_dsp_context_new_return;
2031}
2032
2033void cras_dsp_context_free(struct cras_dsp_context *ctx)
2034{
2035  dsp_context_free_called++;
2036}
2037
2038void cras_dsp_load_pipeline(struct cras_dsp_context *ctx)
2039{
2040}
2041
2042void cras_dsp_set_variable_string(struct cras_dsp_context *ctx, const char *key,
2043                                  const char *value)
2044{
2045}
2046
2047void cras_dsp_set_variable_boolean(struct cras_dsp_context *ctx,
2048                                   const char *key,
2049                                   char value)
2050{
2051}
2052
2053struct pipeline *cras_dsp_get_pipeline(struct cras_dsp_context *ctx)
2054{
2055  cras_dsp_get_pipeline_called++;
2056  return reinterpret_cast<struct pipeline *>(cras_dsp_get_pipeline_ret);
2057}
2058
2059void cras_dsp_put_pipeline(struct cras_dsp_context *ctx)
2060{
2061  cras_dsp_put_pipeline_called++;
2062}
2063
2064float *cras_dsp_pipeline_get_source_buffer(struct pipeline *pipeline,
2065					   int index)
2066{
2067  cras_dsp_pipeline_get_source_buffer_called++;
2068  return cras_dsp_pipeline_source_buffer[index];
2069}
2070
2071float *cras_dsp_pipeline_get_sink_buffer(struct pipeline *pipeline, int index)
2072{
2073  cras_dsp_pipeline_get_sink_buffer_called++;
2074  return cras_dsp_pipeline_sink_buffer[index];
2075}
2076
2077int cras_dsp_pipeline_get_delay(struct pipeline *pipeline)
2078{
2079  cras_dsp_pipeline_get_delay_called++;
2080  return 0;
2081}
2082
2083void cras_dsp_pipeline_apply(struct pipeline *pipeline,
2084			     uint8_t *buf, unsigned int frames)
2085{
2086  cras_dsp_pipeline_apply_called++;
2087  cras_dsp_pipeline_apply_sample_count = frames;
2088}
2089
2090void cras_dsp_pipeline_add_statistic(struct pipeline *pipeline,
2091                                     const struct timespec *time_delta,
2092                                     int samples)
2093{
2094}
2095
2096unsigned int cras_dsp_num_output_channels(const struct cras_dsp_context *ctx)
2097{
2098	return cras_dsp_num_output_channels_return;
2099}
2100
2101unsigned int cras_dsp_num_input_channels(const struct cras_dsp_context *ctx)
2102{
2103	return cras_dsp_num_input_channels_return;
2104}
2105
2106// From audio thread
2107int audio_thread_post_message(struct audio_thread *thread,
2108                              struct audio_thread_msg *msg) {
2109  return 0;
2110}
2111
2112void cras_iodev_list_select_node(enum CRAS_STREAM_DIRECTION direction,
2113                                 cras_node_id_t node_id)
2114{
2115  select_node_called++;
2116  select_node_direction = direction;
2117  select_node_id = node_id;
2118}
2119
2120int cras_iodev_list_node_selected(struct cras_ionode *node)
2121{
2122  return node == node_selected;
2123}
2124
2125void cras_iodev_list_disable_dev(struct cras_iodev *dev)
2126{
2127  cras_iodev_list_disable_dev_called++;
2128}
2129
2130void cras_iodev_list_notify_nodes_changed()
2131{
2132  notify_nodes_changed_called++;
2133}
2134
2135void cras_iodev_list_notify_active_node_changed(
2136				enum CRAS_STREAM_DIRECTION direction)
2137{
2138  notify_active_node_changed_called++;
2139}
2140
2141void cras_iodev_list_notify_node_volume(struct cras_ionode *node)
2142{
2143	notify_node_volume_called++;
2144}
2145
2146void cras_iodev_list_notify_node_capture_gain(struct cras_ionode *node)
2147{
2148	notify_node_capture_gain_called++;
2149}
2150
2151void cras_iodev_list_notify_node_left_right_swapped(struct cras_ionode *node)
2152{
2153  notify_node_left_right_swapped_called++;
2154}
2155
2156struct cras_audio_area *cras_audio_area_create(int num_channels) {
2157	return NULL;
2158}
2159
2160void cras_audio_area_destroy(struct cras_audio_area *area) {
2161}
2162
2163void cras_audio_area_config_channels(struct cras_audio_area *area,
2164                                     const struct cras_audio_format *fmt) {
2165}
2166
2167int cras_audio_format_set_channel_layout(struct cras_audio_format *format,
2168					 const int8_t layout[CRAS_CH_MAX])
2169{
2170  int i;
2171  cras_audio_format_set_channel_layout_called++;
2172  for (i = 0; i < CRAS_CH_MAX; i++)
2173    format->channel_layout[i] = layout[i];
2174  return 0;
2175}
2176
2177float softvol_get_scaler(unsigned int volume_index)
2178{
2179	return softvol_scalers[volume_index];
2180}
2181
2182size_t cras_system_get_volume() {
2183  return cras_system_get_volume_return;
2184}
2185
2186long cras_system_get_capture_gain() {
2187  return cras_system_get_capture_gain_ret_value;
2188}
2189
2190int cras_system_get_mute() {
2191  return cras_system_get_mute_return;
2192}
2193
2194int cras_system_get_capture_mute() {
2195  return 0;
2196}
2197
2198void cras_scale_buffer(snd_pcm_format_t fmt, uint8_t *buffer,
2199                       unsigned int count, float scaler) {
2200  cras_scale_buffer_called++;
2201  cras_scale_buffer_fmt = fmt;
2202  cras_scale_buffer_scaler = scaler;
2203}
2204
2205void cras_scale_buffer_increment(snd_pcm_format_t fmt, uint8_t *buff,
2206                                 unsigned int frame, float scaler,
2207                                 float increment, int channel)
2208{
2209  cras_scale_buffer_increment_fmt = fmt;
2210  cras_scale_buffer_increment_buff = buff;
2211  cras_scale_buffer_increment_frame = frame;
2212  cras_scale_buffer_increment_scaler = scaler;
2213  cras_scale_buffer_increment_increment = increment;
2214  cras_scale_buffer_increment_channel = channel;
2215}
2216
2217size_t cras_mix_mute_buffer(uint8_t *dst,
2218                            size_t frame_bytes,
2219                            size_t count) {
2220  cras_mix_mute_count = count;
2221  return count;
2222}
2223
2224struct rate_estimator *rate_estimator_create(unsigned int rate,
2225                                             const struct timespec *window_size,
2226                                             double smooth_factor) {
2227  return NULL;
2228}
2229
2230void rate_estimator_destroy(struct rate_estimator *re) {
2231}
2232
2233void rate_estimator_add_frames(struct rate_estimator *re, int fr) {
2234  rate_estimator_add_frames_called++;
2235  rate_estimator_add_frames_num_frames = fr;
2236}
2237
2238int rate_estimator_check(struct rate_estimator *re, int level,
2239                         struct timespec *now) {
2240  return 0;
2241}
2242
2243void rate_estimator_reset_rate(struct rate_estimator *re, unsigned int rate) {
2244}
2245
2246double rate_estimator_get_rate(struct rate_estimator *re) {
2247  return 0.0;
2248}
2249
2250unsigned int dev_stream_cb_threshold(const struct dev_stream *dev_stream) {
2251  if (dev_stream->stream)
2252    return dev_stream->stream->cb_threshold;
2253  return 0;
2254}
2255
2256int dev_stream_attached_devs(const struct dev_stream *dev_stream) {
2257  return 1;
2258}
2259
2260void dev_stream_update_frames(const struct dev_stream *dev_stream) {
2261}
2262
2263int dev_stream_playback_frames(const struct dev_stream *dev_stream) {
2264  return dev_stream_playback_frames_ret;
2265}
2266
2267int cras_device_monitor_reset_device(struct cras_iodev *iodev) {
2268  device_monitor_reset_device_called++;
2269  return 0;
2270}
2271
2272void cras_ramp_destroy(struct cras_ramp* ramp) {
2273  return;
2274}
2275
2276int cras_ramp_start(struct cras_ramp *ramp, int is_up, int duration_frames,
2277                    cras_ramp_cb cb, void *cb_data)
2278{
2279  cras_ramp_start_is_called++;
2280  cras_ramp_start_is_up = is_up;
2281  cras_ramp_start_duration_frames = duration_frames;
2282  cras_ramp_start_cb = cb;
2283  cras_ramp_start_cb_data = cb_data;
2284  return 0;
2285}
2286
2287int cras_ramp_reset(struct cras_ramp *ramp) {
2288  cras_ramp_reset_is_called++;
2289  return 0;
2290}
2291
2292struct cras_ramp_action cras_ramp_get_current_action(
2293    const struct cras_ramp *ramp) {
2294  return cras_ramp_get_current_action_ret;
2295}
2296
2297int cras_ramp_update_ramped_frames(
2298    struct cras_ramp *ramp, int num_frames) {
2299  cras_ramp_update_ramped_frames_num_frames = num_frames;
2300  return 0;
2301}
2302
2303int cras_device_monitor_set_device_mute_state(struct cras_iodev *iodev)
2304{
2305  cras_device_monitor_set_device_mute_state_called++;
2306  cras_device_monitor_set_device_mute_state_dev = iodev;
2307  return 0;
2308}
2309
2310}  // extern "C"
2311}  //  namespace
2312
2313int main(int argc, char **argv) {
2314  ::testing::InitGoogleTest(&argc, argv);
2315  int rc = RUN_ALL_TESTS();
2316
2317  audio_thread_event_log_deinit(atlog);
2318  return rc;
2319}
2320