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 8 extern "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. 18 float softvol_scalers[101]; 19 } 20 21 #define BUFFER_SIZE 8192 22 23 static const float RAMP_UNMUTE_DURATION_SECS = 0.5; 24 static const float RAMP_NEW_STREAM_DURATION_SECS = 0.01; 25 static const float RAMP_MUTE_DURATION_SECS = 0.1; 26 27 static int cras_iodev_list_disable_dev_called; 28 static int select_node_called; 29 static enum CRAS_STREAM_DIRECTION select_node_direction; 30 static cras_node_id_t select_node_id; 31 static struct cras_ionode *node_selected; 32 static size_t notify_nodes_changed_called; 33 static size_t notify_active_node_changed_called; 34 static size_t notify_node_volume_called; 35 static size_t notify_node_capture_gain_called; 36 static int dsp_context_new_sample_rate; 37 static const char *dsp_context_new_purpose; 38 static int dsp_context_free_called; 39 static int update_channel_layout_called; 40 static int update_channel_layout_return_val; 41 static int set_swap_mode_for_node_called; 42 static int set_swap_mode_for_node_enable; 43 static int notify_node_left_right_swapped_called; 44 static int cras_audio_format_set_channel_layout_called; 45 static unsigned int cras_system_get_volume_return; 46 static int cras_dsp_get_pipeline_called; 47 static int cras_dsp_get_pipeline_ret; 48 static int cras_dsp_put_pipeline_called; 49 static int cras_dsp_pipeline_get_source_buffer_called; 50 static int cras_dsp_pipeline_get_sink_buffer_called; 51 static float cras_dsp_pipeline_source_buffer[2][DSP_BUFFER_SIZE]; 52 static float cras_dsp_pipeline_sink_buffer[2][DSP_BUFFER_SIZE]; 53 static int cras_dsp_pipeline_get_delay_called; 54 static int cras_dsp_pipeline_apply_called; 55 static int cras_dsp_pipeline_apply_sample_count; 56 static unsigned int cras_mix_mute_count; 57 static unsigned int cras_dsp_num_input_channels_return; 58 static unsigned int cras_dsp_num_output_channels_return; 59 struct cras_dsp_context *cras_dsp_context_new_return; 60 static unsigned int rate_estimator_add_frames_num_frames; 61 static unsigned int rate_estimator_add_frames_called; 62 static int cras_system_get_mute_return; 63 static snd_pcm_format_t cras_scale_buffer_fmt; 64 static float cras_scale_buffer_scaler; 65 static int cras_scale_buffer_called; 66 static unsigned int pre_dsp_hook_called; 67 static const uint8_t *pre_dsp_hook_frames; 68 69 static void *pre_dsp_hook_cb_data; 70 static unsigned int post_dsp_hook_called; 71 static const uint8_t *post_dsp_hook_frames; 72 static void *post_dsp_hook_cb_data; 73 static int iodev_buffer_size; 74 static long cras_system_get_capture_gain_ret_value; 75 static uint8_t audio_buffer[BUFFER_SIZE]; 76 static struct cras_audio_area *audio_area; 77 static unsigned int put_buffer_nframes; 78 static int output_should_wake_ret; 79 static int no_stream_called; 80 static int no_stream_enable; 81 // This will be used extensively in cras_iodev. 82 struct audio_thread_event_log *atlog; 83 static unsigned int simple_no_stream_called; 84 static int simple_no_stream_enable; 85 static int dev_stream_playback_frames_ret; 86 static int get_num_underruns_ret; 87 static int device_monitor_reset_device_called; 88 static int output_underrun_called; 89 static int set_mute_called; 90 static int cras_ramp_start_is_up; 91 static int cras_ramp_start_duration_frames; 92 static int cras_ramp_start_is_called; 93 static int cras_ramp_reset_is_called; 94 static struct cras_ramp_action cras_ramp_get_current_action_ret; 95 static int cras_ramp_update_ramped_frames_num_frames; 96 static cras_ramp_cb cras_ramp_start_cb; 97 static void* cras_ramp_start_cb_data; 98 static int cras_device_monitor_set_device_mute_state_called; 99 static struct cras_iodev* cras_device_monitor_set_device_mute_state_dev; 100 static snd_pcm_format_t cras_scale_buffer_increment_fmt; 101 static uint8_t *cras_scale_buffer_increment_buff; 102 static unsigned int cras_scale_buffer_increment_frame; 103 static float cras_scale_buffer_increment_scaler; 104 static float cras_scale_buffer_increment_increment; 105 static int cras_scale_buffer_increment_channel; 106 107 // Iodev callback 108 int 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 114 int 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 122 void 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 199 namespace { 200 201 // Test fill_time_from_frames 202 TEST(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 211 TEST(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 220 TEST(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 228 class 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 267 TEST_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 285 TEST_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 303 TEST_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 321 TEST_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 335 TEST_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 353 TEST_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 371 TEST_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 385 TEST_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 399 TEST_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 421 TEST_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 443 TEST_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 461 TEST_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 488 TEST_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 517 static 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 535 static 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 545 static 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 553 static int output_should_wake(const struct cras_iodev *odev) 554 { 555 return output_should_wake_ret; 556 } 557 558 static 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 567 static 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 576 TEST(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 599 TEST(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 632 TEST(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 661 TEST(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 704 TEST(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 } 751 TEST(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 780 TEST(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 813 TEST(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 841 TEST(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 911 TEST(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 967 TEST(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 996 static unsigned fr_queued = 0; 997 998 static 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 1005 TEST(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 1024 TEST(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 1050 static void update_active_node(struct cras_iodev *iodev, 1051 unsigned node_idx, 1052 unsigned dev_enabled) 1053 { 1054 } 1055 1056 static void dev_set_volume(struct cras_iodev *iodev) 1057 { 1058 } 1059 1060 static void dev_set_capture_gain(struct cras_iodev *iodev) 1061 { 1062 } 1063 1064 static void dev_set_mute(struct cras_iodev *iodev) 1065 { 1066 set_mute_called++; 1067 } 1068 1069 TEST(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 1096 TEST(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 1110 TEST(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 1122 TEST(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 1139 TEST(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 1160 TEST(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. 1180 TEST(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. 1211 TEST(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. 1242 static 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. 1253 TEST(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 1275 static int open_dev(struct cras_iodev *iodev) { 1276 iodev->buffer_size = iodev_buffer_size; 1277 return 0; 1278 } 1279 1280 TEST(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 1299 int fake_start(const struct cras_iodev *iodev) { 1300 return 0; 1301 } 1302 1303 TEST(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 1323 TEST(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 1342 TEST(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 1362 static 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 1369 TEST(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 1409 TEST(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 1441 TEST(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 1497 TEST(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 1676 TEST(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 1739 TEST(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 1791 TEST(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 1826 TEST(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 1874 static unsigned int get_num_underruns(const struct cras_iodev *iodev) { 1875 return get_num_underruns_ret; 1876 } 1877 1878 TEST(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 1889 TEST(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 1920 static int output_underrun(struct cras_iodev *iodev) { 1921 output_underrun_called++; 1922 return 0; 1923 } 1924 1925 1926 TEST(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 1960 extern "C" { 1961 1962 // From libpthread. 1963 int pthread_create(pthread_t *thread, const pthread_attr_t *attr, 1964 void *(*start_routine)(void*), void *arg) { 1965 return 0; 1966 } 1967 1968 int pthread_join(pthread_t thread, void **value_ptr) { 1969 return 0; 1970 } 1971 1972 // From audio_thread 1973 struct cras_fmt_conv *audio_thread_get_global_remix_converter() 1974 { 1975 return NULL; 1976 } 1977 1978 // Fromt fmt_conv 1979 void 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 1986 struct buffer_share *buffer_share_create(unsigned int buf_sz) { 1987 return NULL; 1988 } 1989 1990 void buffer_share_destroy(struct buffer_share *mix) 1991 { 1992 } 1993 1994 int buffer_share_offset_update(struct buffer_share *mix, unsigned int id, 1995 unsigned int frames) { 1996 return 0; 1997 } 1998 1999 unsigned int buffer_share_get_new_write_point(struct buffer_share *mix) { 2000 return 0; 2001 } 2002 2003 int buffer_share_add_id(struct buffer_share *mix, unsigned int id) { 2004 return 0; 2005 } 2006 2007 int buffer_share_rm_id(struct buffer_share *mix, unsigned int id) { 2008 return 0; 2009 } 2010 2011 unsigned 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. 2018 void cras_system_state_stream_added(enum CRAS_STREAM_DIRECTION direction) { 2019 } 2020 2021 void cras_system_state_stream_removed(enum CRAS_STREAM_DIRECTION direction) { 2022 } 2023 2024 // From cras_dsp 2025 struct 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 2033 void cras_dsp_context_free(struct cras_dsp_context *ctx) 2034 { 2035 dsp_context_free_called++; 2036 } 2037 2038 void cras_dsp_load_pipeline(struct cras_dsp_context *ctx) 2039 { 2040 } 2041 2042 void cras_dsp_set_variable_string(struct cras_dsp_context *ctx, const char *key, 2043 const char *value) 2044 { 2045 } 2046 2047 void cras_dsp_set_variable_boolean(struct cras_dsp_context *ctx, 2048 const char *key, 2049 char value) 2050 { 2051 } 2052 2053 struct 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 2059 void cras_dsp_put_pipeline(struct cras_dsp_context *ctx) 2060 { 2061 cras_dsp_put_pipeline_called++; 2062 } 2063 2064 float *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 2071 float *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 2077 int cras_dsp_pipeline_get_delay(struct pipeline *pipeline) 2078 { 2079 cras_dsp_pipeline_get_delay_called++; 2080 return 0; 2081 } 2082 2083 void 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 2090 void cras_dsp_pipeline_add_statistic(struct pipeline *pipeline, 2091 const struct timespec *time_delta, 2092 int samples) 2093 { 2094 } 2095 2096 unsigned int cras_dsp_num_output_channels(const struct cras_dsp_context *ctx) 2097 { 2098 return cras_dsp_num_output_channels_return; 2099 } 2100 2101 unsigned 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 2107 int audio_thread_post_message(struct audio_thread *thread, 2108 struct audio_thread_msg *msg) { 2109 return 0; 2110 } 2111 2112 void 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 2120 int cras_iodev_list_node_selected(struct cras_ionode *node) 2121 { 2122 return node == node_selected; 2123 } 2124 2125 void cras_iodev_list_disable_dev(struct cras_iodev *dev) 2126 { 2127 cras_iodev_list_disable_dev_called++; 2128 } 2129 2130 void cras_iodev_list_notify_nodes_changed() 2131 { 2132 notify_nodes_changed_called++; 2133 } 2134 2135 void cras_iodev_list_notify_active_node_changed( 2136 enum CRAS_STREAM_DIRECTION direction) 2137 { 2138 notify_active_node_changed_called++; 2139 } 2140 2141 void cras_iodev_list_notify_node_volume(struct cras_ionode *node) 2142 { 2143 notify_node_volume_called++; 2144 } 2145 2146 void cras_iodev_list_notify_node_capture_gain(struct cras_ionode *node) 2147 { 2148 notify_node_capture_gain_called++; 2149 } 2150 2151 void cras_iodev_list_notify_node_left_right_swapped(struct cras_ionode *node) 2152 { 2153 notify_node_left_right_swapped_called++; 2154 } 2155 2156 struct cras_audio_area *cras_audio_area_create(int num_channels) { 2157 return NULL; 2158 } 2159 2160 void cras_audio_area_destroy(struct cras_audio_area *area) { 2161 } 2162 2163 void cras_audio_area_config_channels(struct cras_audio_area *area, 2164 const struct cras_audio_format *fmt) { 2165 } 2166 2167 int 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 2177 float softvol_get_scaler(unsigned int volume_index) 2178 { 2179 return softvol_scalers[volume_index]; 2180 } 2181 2182 size_t cras_system_get_volume() { 2183 return cras_system_get_volume_return; 2184 } 2185 2186 long cras_system_get_capture_gain() { 2187 return cras_system_get_capture_gain_ret_value; 2188 } 2189 2190 int cras_system_get_mute() { 2191 return cras_system_get_mute_return; 2192 } 2193 2194 int cras_system_get_capture_mute() { 2195 return 0; 2196 } 2197 2198 void 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 2205 void 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 2217 size_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 2224 struct rate_estimator *rate_estimator_create(unsigned int rate, 2225 const struct timespec *window_size, 2226 double smooth_factor) { 2227 return NULL; 2228 } 2229 2230 void rate_estimator_destroy(struct rate_estimator *re) { 2231 } 2232 2233 void 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 2238 int rate_estimator_check(struct rate_estimator *re, int level, 2239 struct timespec *now) { 2240 return 0; 2241 } 2242 2243 void rate_estimator_reset_rate(struct rate_estimator *re, unsigned int rate) { 2244 } 2245 2246 double rate_estimator_get_rate(struct rate_estimator *re) { 2247 return 0.0; 2248 } 2249 2250 unsigned 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 2256 int dev_stream_attached_devs(const struct dev_stream *dev_stream) { 2257 return 1; 2258 } 2259 2260 void dev_stream_update_frames(const struct dev_stream *dev_stream) { 2261 } 2262 2263 int dev_stream_playback_frames(const struct dev_stream *dev_stream) { 2264 return dev_stream_playback_frames_ret; 2265 } 2266 2267 int cras_device_monitor_reset_device(struct cras_iodev *iodev) { 2268 device_monitor_reset_device_called++; 2269 return 0; 2270 } 2271 2272 void cras_ramp_destroy(struct cras_ramp* ramp) { 2273 return; 2274 } 2275 2276 int 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 2287 int cras_ramp_reset(struct cras_ramp *ramp) { 2288 cras_ramp_reset_is_called++; 2289 return 0; 2290 } 2291 2292 struct cras_ramp_action cras_ramp_get_current_action( 2293 const struct cras_ramp *ramp) { 2294 return cras_ramp_get_current_action_ret; 2295 } 2296 2297 int 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 2303 int 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 2313 int 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
