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 <gtest/gtest.h> 6 #include <map> 7 #include <stdio.h> 8 #include <syslog.h> 9 #include <vector> 10 11 extern "C" { 12 13 #include "cras_iodev.h" 14 #include "cras_shm.h" 15 #include "cras_system_state.h" 16 #include "cras_types.h" 17 #include "cras_alsa_mixer.h" 18 19 // Include C file to test static functions. 20 #include "cras_alsa_io.c" 21 } 22 23 #define BUFFER_SIZE 8192 24 25 // Data for simulating functions stubbed below. 26 static int cras_alsa_open_called; 27 static int cras_iodev_append_stream_ret; 28 static int cras_alsa_get_avail_frames_ret; 29 static int cras_alsa_get_avail_frames_avail; 30 static int cras_alsa_start_called; 31 static uint8_t *cras_alsa_mmap_begin_buffer; 32 static size_t cras_alsa_mmap_begin_frames; 33 static size_t cras_alsa_fill_properties_called; 34 static size_t alsa_mixer_set_dBFS_called; 35 static int alsa_mixer_set_dBFS_value; 36 static const struct mixer_control *alsa_mixer_set_dBFS_output; 37 static size_t alsa_mixer_set_capture_dBFS_called; 38 static int alsa_mixer_set_capture_dBFS_value; 39 static const struct mixer_control *alsa_mixer_set_capture_dBFS_input; 40 static const struct mixer_control 41 *cras_alsa_mixer_get_minimum_capture_gain_mixer_input; 42 static const struct mixer_control 43 *cras_alsa_mixer_get_maximum_capture_gain_mixer_input; 44 static size_t cras_alsa_mixer_list_outputs_called; 45 static size_t cras_alsa_mixer_list_inputs_called; 46 static size_t cras_alsa_mixer_get_control_for_section_called; 47 static struct mixer_control * 48 cras_alsa_mixer_get_control_for_section_return_value; 49 static size_t sys_get_volume_called; 50 static size_t sys_get_volume_return_value; 51 static size_t sys_get_capture_gain_called; 52 static long sys_get_capture_gain_return_value; 53 static size_t alsa_mixer_set_mute_called; 54 static int alsa_mixer_set_mute_value; 55 static size_t alsa_mixer_get_dB_range_called; 56 static long alsa_mixer_get_dB_range_value; 57 static size_t alsa_mixer_get_output_dB_range_called; 58 static long alsa_mixer_get_output_dB_range_value; 59 static const struct mixer_control *alsa_mixer_set_mute_output; 60 static size_t alsa_mixer_set_capture_mute_called; 61 static int alsa_mixer_set_capture_mute_value; 62 static const struct mixer_control *alsa_mixer_set_capture_mute_input; 63 static size_t sys_get_mute_called; 64 static int sys_get_mute_return_value; 65 static size_t sys_get_capture_mute_called; 66 static int sys_get_capture_mute_return_value; 67 static struct cras_alsa_mixer *fake_mixer = (struct cras_alsa_mixer *)1; 68 static struct cras_card_config *fake_config = (struct cras_card_config *)2; 69 static struct mixer_control **cras_alsa_mixer_list_outputs_outputs; 70 static size_t cras_alsa_mixer_list_outputs_outputs_length; 71 static struct mixer_control **cras_alsa_mixer_list_inputs_outputs; 72 static size_t cras_alsa_mixer_list_inputs_outputs_length; 73 static size_t cras_alsa_mixer_set_output_active_state_called; 74 static std::vector<struct mixer_control *> 75 cras_alsa_mixer_set_output_active_state_outputs; 76 static std::vector<int> cras_alsa_mixer_set_output_active_state_values; 77 static cras_audio_format *fake_format; 78 static size_t sys_set_volume_limits_called; 79 static size_t sys_set_capture_gain_limits_called; 80 static size_t cras_alsa_mixer_get_minimum_capture_gain_called; 81 static size_t cras_alsa_mixer_get_maximum_capture_gain_called; 82 static struct mixer_control *cras_alsa_jack_get_mixer_output_ret; 83 static struct mixer_control *cras_alsa_jack_get_mixer_input_ret; 84 static size_t cras_alsa_mixer_get_output_volume_curve_called; 85 typedef std::map<const struct mixer_control*, std::string> ControlNameMap; 86 static ControlNameMap cras_alsa_mixer_get_control_name_values; 87 static size_t cras_alsa_mixer_get_control_name_called; 88 static size_t cras_alsa_jack_list_create_called; 89 static size_t cras_alsa_jack_list_find_jacks_by_name_matching_called; 90 static size_t cras_alsa_jack_list_add_jack_for_section_called; 91 static struct cras_alsa_jack * 92 cras_alsa_jack_list_add_jack_for_section_result_jack; 93 static size_t cras_alsa_jack_list_destroy_called; 94 static int cras_alsa_jack_list_has_hctl_jacks_return_val; 95 static jack_state_change_callback *cras_alsa_jack_list_create_cb; 96 static void *cras_alsa_jack_list_create_cb_data; 97 static char test_card_name[] = "TestCard"; 98 static char test_dev_name[] = "TestDev"; 99 static char test_dev_id[] = "TestDevId"; 100 static size_t cras_iodev_add_node_called; 101 static struct cras_ionode *cras_iodev_set_node_attr_ionode; 102 static size_t cras_iodev_set_node_attr_called; 103 static enum ionode_attr cras_iodev_set_node_attr_attr; 104 static int cras_iodev_set_node_attr_value; 105 static unsigned cras_alsa_jack_enable_ucm_called; 106 static unsigned ucm_set_enabled_called; 107 static size_t cras_iodev_update_dsp_called; 108 static const char *cras_iodev_update_dsp_name; 109 static size_t ucm_get_dsp_name_default_called; 110 static const char *ucm_get_dsp_name_default_value; 111 static size_t cras_alsa_jack_get_dsp_name_called; 112 static const char *cras_alsa_jack_get_dsp_name_value; 113 static size_t cras_iodev_free_resources_called; 114 static size_t cras_alsa_jack_update_node_type_called; 115 static int ucm_swap_mode_exists_ret_value; 116 static int ucm_enable_swap_mode_ret_value; 117 static size_t ucm_enable_swap_mode_called; 118 static int is_utf8_string_ret_value; 119 static const char *cras_alsa_jack_update_monitor_fake_name = 0; 120 static int cras_alsa_jack_get_name_called; 121 static const char *cras_alsa_jack_get_name_ret_value = 0; 122 static char default_jack_name[] = "Something Jack"; 123 static int auto_unplug_input_node_ret = 0; 124 static int auto_unplug_output_node_ret = 0; 125 static int ucm_get_min_software_gain_called; 126 static int ucm_get_min_software_gain_ret_value; 127 static long ucm_get_min_software_gain_value; 128 static int ucm_get_max_software_gain_called; 129 static int ucm_get_max_software_gain_ret_value; 130 static long ucm_get_max_software_gain_value; 131 static long cras_system_set_capture_gain_limits_set_value[2]; 132 static long cras_alsa_mixer_get_minimum_capture_gain_ret_value; 133 static long cras_alsa_mixer_get_maximum_capture_gain_ret_value; 134 static snd_pcm_state_t snd_pcm_state_ret; 135 static int cras_alsa_attempt_resume_called; 136 static snd_hctl_t *fake_hctl = (snd_hctl_t *)2; 137 static size_t ucm_get_dma_period_for_dev_called; 138 static unsigned int ucm_get_dma_period_for_dev_ret; 139 static int cras_card_config_get_volume_curve_for_control_called; 140 typedef std::map<std::string, struct cras_volume_curve *> VolCurveMap; 141 static VolCurveMap cras_card_config_get_volume_curve_vals; 142 static int cras_alsa_mmap_get_whole_buffer_called; 143 static int cras_iodev_fill_odev_zeros_called; 144 static unsigned int cras_iodev_fill_odev_zeros_frames; 145 static int cras_iodev_frames_queued_ret; 146 static int cras_iodev_buffer_avail_ret; 147 static int cras_alsa_resume_appl_ptr_called; 148 static int cras_alsa_resume_appl_ptr_ahead; 149 static int ucm_get_enable_htimestamp_flag_ret; 150 static const struct cras_volume_curve *fake_get_dBFS_volume_curve_val; 151 static int cras_iodev_dsp_set_swap_mode_for_node_called; 152 static std::map<std::string, long> ucm_get_default_node_gain_values; 153 static thread_callback audio_thread_cb; 154 static void *audio_thread_cb_data; 155 static int hotword_send_triggered_msg_called; 156 157 void ResetStubData() { 158 cras_alsa_open_called = 0; 159 cras_iodev_append_stream_ret = 0; 160 cras_alsa_get_avail_frames_ret = 0; 161 cras_alsa_get_avail_frames_avail = 0; 162 cras_alsa_start_called = 0; 163 cras_alsa_fill_properties_called = 0; 164 sys_get_volume_called = 0; 165 sys_get_capture_gain_called = 0; 166 alsa_mixer_set_dBFS_called = 0; 167 alsa_mixer_set_capture_dBFS_called = 0; 168 sys_get_mute_called = 0; 169 sys_get_capture_mute_called = 0; 170 alsa_mixer_set_mute_called = 0; 171 alsa_mixer_get_dB_range_called = 0; 172 alsa_mixer_get_output_dB_range_called = 0; 173 alsa_mixer_set_capture_mute_called = 0; 174 cras_alsa_mixer_get_control_for_section_called = 0; 175 cras_alsa_mixer_get_control_for_section_return_value = NULL; 176 cras_alsa_mixer_list_outputs_called = 0; 177 cras_alsa_mixer_list_outputs_outputs_length = 0; 178 cras_alsa_mixer_list_inputs_called = 0; 179 cras_alsa_mixer_list_inputs_outputs_length = 0; 180 cras_alsa_mixer_set_output_active_state_called = 0; 181 cras_alsa_mixer_set_output_active_state_outputs.clear(); 182 cras_alsa_mixer_set_output_active_state_values.clear(); 183 sys_set_volume_limits_called = 0; 184 sys_set_capture_gain_limits_called = 0; 185 sys_get_capture_gain_return_value = 0; 186 cras_alsa_mixer_get_minimum_capture_gain_called = 0; 187 cras_alsa_mixer_get_maximum_capture_gain_called = 0; 188 cras_alsa_mixer_get_output_volume_curve_called = 0; 189 cras_alsa_jack_get_mixer_output_ret = NULL; 190 cras_alsa_jack_get_mixer_input_ret = NULL; 191 cras_alsa_mixer_get_control_name_values.clear(); 192 cras_alsa_mixer_get_control_name_called = 0; 193 cras_alsa_jack_list_create_called = 0; 194 cras_alsa_jack_list_find_jacks_by_name_matching_called = 0; 195 cras_alsa_jack_list_add_jack_for_section_called = 0; 196 cras_alsa_jack_list_add_jack_for_section_result_jack = NULL; 197 cras_alsa_jack_list_destroy_called = 0; 198 cras_alsa_jack_list_has_hctl_jacks_return_val = 1; 199 cras_iodev_add_node_called = 0; 200 cras_iodev_set_node_attr_called = 0; 201 cras_alsa_jack_enable_ucm_called = 0; 202 ucm_set_enabled_called = 0; 203 cras_iodev_update_dsp_called = 0; 204 cras_iodev_update_dsp_name = 0; 205 ucm_get_dsp_name_default_called = 0; 206 ucm_get_dsp_name_default_value = NULL; 207 cras_alsa_jack_get_dsp_name_called = 0; 208 cras_alsa_jack_get_dsp_name_value = NULL; 209 cras_iodev_free_resources_called = 0; 210 cras_alsa_jack_update_node_type_called = 0; 211 ucm_swap_mode_exists_ret_value = 0; 212 ucm_enable_swap_mode_ret_value = 0; 213 ucm_enable_swap_mode_called = 0; 214 is_utf8_string_ret_value = 1; 215 cras_alsa_jack_get_name_called = 0; 216 cras_alsa_jack_get_name_ret_value = default_jack_name; 217 cras_alsa_jack_update_monitor_fake_name = 0; 218 ucm_get_min_software_gain_called = 0; 219 ucm_get_min_software_gain_ret_value = -1; 220 ucm_get_min_software_gain_value = 0; 221 ucm_get_max_software_gain_called = 0; 222 ucm_get_max_software_gain_ret_value = -1; 223 ucm_get_max_software_gain_value = 0; 224 cras_card_config_get_volume_curve_for_control_called = 0; 225 cras_card_config_get_volume_curve_vals.clear(); 226 cras_system_set_capture_gain_limits_set_value[0] = -1; 227 cras_system_set_capture_gain_limits_set_value[1] = -1; 228 cras_alsa_mixer_get_minimum_capture_gain_ret_value = 0; 229 cras_alsa_mixer_get_maximum_capture_gain_ret_value = 0; 230 snd_pcm_state_ret = SND_PCM_STATE_RUNNING; 231 cras_alsa_attempt_resume_called = 0; 232 ucm_get_dma_period_for_dev_called = 0; 233 ucm_get_dma_period_for_dev_ret = 0; 234 cras_alsa_mmap_get_whole_buffer_called = 0; 235 cras_iodev_fill_odev_zeros_called = 0; 236 cras_iodev_fill_odev_zeros_frames = 0; 237 cras_iodev_frames_queued_ret = 0; 238 cras_iodev_buffer_avail_ret = 0; 239 cras_alsa_resume_appl_ptr_called = 0; 240 cras_alsa_resume_appl_ptr_ahead = 0; 241 ucm_get_enable_htimestamp_flag_ret = 0; 242 fake_get_dBFS_volume_curve_val = NULL; 243 cras_iodev_dsp_set_swap_mode_for_node_called = 0; 244 ucm_get_default_node_gain_values.clear(); 245 } 246 247 static long fake_get_dBFS(const struct cras_volume_curve *curve, size_t volume) 248 { 249 fake_get_dBFS_volume_curve_val = curve; 250 return (volume - 100) * 100; 251 } 252 static cras_volume_curve default_curve = { 253 .get_dBFS = fake_get_dBFS, 254 }; 255 256 static struct cras_iodev *alsa_iodev_create_with_default_parameters( 257 size_t card_index, 258 const char *dev_id, 259 enum CRAS_ALSA_CARD_TYPE card_type, 260 int is_first, 261 struct cras_alsa_mixer *mixer, 262 struct cras_card_config *config, 263 struct cras_use_case_mgr *ucm, 264 enum CRAS_STREAM_DIRECTION direction) { 265 return alsa_iodev_create(card_index, test_card_name, 0, test_dev_name, 266 dev_id, card_type, is_first, 267 mixer, config, ucm, fake_hctl, 268 direction, 0, 0, (char *)"123"); 269 } 270 271 namespace { 272 273 TEST(AlsaIoInit, InitializeInvalidDirection) { 274 struct alsa_io *aio; 275 276 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 277 0, NULL, ALSA_CARD_TYPE_INTERNAL, 0, fake_mixer, fake_config, NULL, 278 CRAS_NUM_DIRECTIONS); 279 ASSERT_EQ(aio, (void *)NULL); 280 } 281 282 TEST(AlsaIoInit, InitializePlayback) { 283 struct alsa_io *aio; 284 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer*)2; 285 286 ResetStubData(); 287 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 288 0, test_dev_id, ALSA_CARD_TYPE_INTERNAL, 1, fake_mixer, fake_config, NULL, 289 CRAS_STREAM_OUTPUT); 290 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 291 /* Get volume curve twice for iodev, and default node. */ 292 EXPECT_EQ(2, cras_card_config_get_volume_curve_for_control_called); 293 EXPECT_EQ(SND_PCM_STREAM_PLAYBACK, aio->alsa_stream); 294 EXPECT_EQ(0, cras_alsa_fill_properties_called); 295 EXPECT_EQ(1, cras_alsa_mixer_list_outputs_called); 296 EXPECT_EQ(0, strncmp(test_card_name, 297 aio->base.info.name, 298 strlen(test_card_name))); 299 EXPECT_EQ(0, ucm_get_dsp_name_default_called); 300 EXPECT_EQ(NULL, cras_iodev_update_dsp_name); 301 ASSERT_NE(reinterpret_cast<const char *>(NULL), aio->dev_name); 302 EXPECT_EQ(0, strcmp(test_dev_name, aio->dev_name)); 303 ASSERT_NE(reinterpret_cast<const char *>(NULL), aio->dev_id); 304 EXPECT_EQ(0, strcmp(test_dev_id, aio->dev_id)); 305 306 alsa_iodev_destroy((struct cras_iodev *)aio); 307 EXPECT_EQ(1, cras_iodev_free_resources_called); 308 } 309 310 TEST(AlsaIoInit, DefaultNodeInternalCard) { 311 struct alsa_io *aio; 312 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer*)2; 313 314 ResetStubData(); 315 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 316 0, NULL, ALSA_CARD_TYPE_INTERNAL, 0, fake_mixer, fake_config, NULL, 317 CRAS_STREAM_OUTPUT); 318 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 319 EXPECT_EQ(2, cras_card_config_get_volume_curve_for_control_called); 320 ASSERT_STREQ("(default)", aio->base.active_node->name); 321 ASSERT_EQ(1, aio->base.active_node->plugged); 322 ASSERT_EQ((void *)no_stream, (void *)aio->base.no_stream); 323 ASSERT_EQ((void *)output_should_wake, (void *)aio->base.output_should_wake); 324 alsa_iodev_destroy((struct cras_iodev *)aio); 325 326 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 327 0, NULL, ALSA_CARD_TYPE_INTERNAL, 1, fake_mixer, fake_config, NULL, 328 CRAS_STREAM_OUTPUT); 329 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 330 EXPECT_EQ(4, cras_card_config_get_volume_curve_for_control_called); 331 ASSERT_STREQ("Speaker", aio->base.active_node->name); 332 ASSERT_EQ(1, aio->base.active_node->plugged); 333 ASSERT_EQ((void *)no_stream, (void *)aio->base.no_stream); 334 ASSERT_EQ((void *)output_should_wake, (void *)aio->base.output_should_wake); 335 alsa_iodev_destroy((struct cras_iodev *)aio); 336 337 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 338 0, NULL, ALSA_CARD_TYPE_INTERNAL, 0, fake_mixer, fake_config, NULL, 339 CRAS_STREAM_INPUT); 340 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 341 /* No more call to get volume curve for input device. */ 342 EXPECT_EQ(4, cras_card_config_get_volume_curve_for_control_called); 343 ASSERT_STREQ("(default)", aio->base.active_node->name); 344 ASSERT_EQ(1, aio->base.active_node->plugged); 345 ASSERT_EQ((void *)no_stream, (void *)aio->base.no_stream); 346 ASSERT_EQ((void *)output_should_wake, (void *)aio->base.output_should_wake); 347 alsa_iodev_destroy((struct cras_iodev *)aio); 348 349 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 350 0, NULL, ALSA_CARD_TYPE_INTERNAL, 1, fake_mixer, fake_config, NULL, 351 CRAS_STREAM_INPUT); 352 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 353 EXPECT_EQ(4, cras_card_config_get_volume_curve_for_control_called); 354 ASSERT_STREQ("Internal Mic", aio->base.active_node->name); 355 ASSERT_EQ(1, aio->base.active_node->plugged); 356 ASSERT_EQ((void *)no_stream, (void *)aio->base.no_stream); 357 ASSERT_EQ((void *)output_should_wake, (void *)aio->base.output_should_wake); 358 alsa_iodev_destroy((struct cras_iodev *)aio); 359 } 360 361 TEST(AlsaIoInit, DefaultNodeUSBCard) { 362 struct alsa_io *aio; 363 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer*)2; 364 365 ResetStubData(); 366 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 367 0, NULL, ALSA_CARD_TYPE_USB, 1, fake_mixer, fake_config, NULL, 368 CRAS_STREAM_OUTPUT); 369 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 370 EXPECT_EQ(2, cras_card_config_get_volume_curve_for_control_called); 371 ASSERT_STREQ("(default)", aio->base.active_node->name); 372 ASSERT_EQ(1, aio->base.active_node->plugged); 373 EXPECT_EQ(1, cras_iodev_set_node_attr_called); 374 EXPECT_EQ(IONODE_ATTR_PLUGGED, cras_iodev_set_node_attr_attr); 375 EXPECT_EQ(1, cras_iodev_set_node_attr_value); 376 alsa_iodev_destroy((struct cras_iodev *)aio); 377 378 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 379 0, NULL, ALSA_CARD_TYPE_USB, 1, fake_mixer, fake_config, NULL, 380 CRAS_STREAM_INPUT); 381 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 382 EXPECT_EQ(2, cras_card_config_get_volume_curve_for_control_called); 383 ASSERT_STREQ("(default)", aio->base.active_node->name); 384 ASSERT_EQ(1, aio->base.active_node->plugged); 385 EXPECT_EQ(2, cras_iodev_set_node_attr_called); 386 EXPECT_EQ(IONODE_ATTR_PLUGGED, cras_iodev_set_node_attr_attr); 387 EXPECT_EQ(1, cras_iodev_set_node_attr_value); 388 alsa_iodev_destroy((struct cras_iodev *)aio); 389 } 390 391 TEST(AlsaIoInit, OpenPlayback) { 392 struct cras_iodev *iodev; 393 struct cras_audio_format format; 394 struct alsa_io *aio; 395 396 ResetStubData(); 397 iodev = alsa_iodev_create_with_default_parameters(0, NULL, 398 ALSA_CARD_TYPE_INTERNAL, 0, 399 fake_mixer, fake_config, 400 NULL, CRAS_STREAM_OUTPUT); 401 ASSERT_EQ(0, alsa_iodev_legacy_complete_init(iodev)); 402 EXPECT_EQ(2, cras_card_config_get_volume_curve_for_control_called); 403 aio = (struct alsa_io *)iodev; 404 format.frame_rate = 48000; 405 format.num_channels = 1; 406 cras_iodev_set_format(iodev, &format); 407 408 // Test that these flags are cleared after open_dev. 409 aio->is_free_running = 1; 410 aio->filled_zeros_for_draining = 512; 411 iodev->open_dev(iodev); 412 EXPECT_EQ(1, cras_alsa_open_called); 413 iodev->configure_dev(iodev); 414 EXPECT_EQ(1, cras_alsa_open_called); 415 EXPECT_EQ(1, sys_set_volume_limits_called); 416 EXPECT_EQ(1, alsa_mixer_set_dBFS_called); 417 EXPECT_EQ(0, cras_alsa_start_called); 418 EXPECT_EQ(0, cras_iodev_set_node_attr_called); 419 EXPECT_EQ(0, aio->is_free_running); 420 EXPECT_EQ(0, aio->filled_zeros_for_draining); 421 EXPECT_EQ(SEVERE_UNDERRUN_MS * format.frame_rate / 1000, 422 aio->severe_underrun_frames); 423 424 alsa_iodev_destroy(iodev); 425 free(fake_format); 426 } 427 428 TEST(AlsaIoInit, UsbCardAutoPlug) { 429 struct cras_iodev *iodev; 430 431 ResetStubData(); 432 iodev = alsa_iodev_create_with_default_parameters(0, NULL, 433 ALSA_CARD_TYPE_INTERNAL, 1, 434 fake_mixer, fake_config, 435 NULL, CRAS_STREAM_OUTPUT); 436 ASSERT_EQ(0, alsa_iodev_legacy_complete_init(iodev)); 437 EXPECT_EQ(2, cras_card_config_get_volume_curve_for_control_called); 438 EXPECT_EQ(0, cras_iodev_set_node_attr_called); 439 alsa_iodev_destroy(iodev); 440 441 ResetStubData(); 442 iodev = alsa_iodev_create_with_default_parameters(0, NULL, ALSA_CARD_TYPE_USB, 443 0, fake_mixer, fake_config, 444 NULL, CRAS_STREAM_OUTPUT); 445 ASSERT_EQ(0, alsa_iodev_legacy_complete_init(iodev)); 446 EXPECT_EQ(2, cras_card_config_get_volume_curve_for_control_called); 447 EXPECT_EQ(0, cras_iodev_set_node_attr_called); 448 alsa_iodev_destroy(iodev); 449 450 ResetStubData(); 451 iodev = alsa_iodev_create_with_default_parameters(0, NULL, ALSA_CARD_TYPE_USB, 452 1, fake_mixer, fake_config, 453 NULL, CRAS_STREAM_OUTPUT); 454 ASSERT_EQ(0, alsa_iodev_legacy_complete_init(iodev)); 455 EXPECT_EQ(2, cras_card_config_get_volume_curve_for_control_called); 456 // Should assume USB devs are plugged when they appear. 457 EXPECT_EQ(1, cras_iodev_set_node_attr_called); 458 EXPECT_EQ(IONODE_ATTR_PLUGGED, cras_iodev_set_node_attr_attr); 459 EXPECT_EQ(1, cras_iodev_set_node_attr_value); 460 alsa_iodev_destroy(iodev); 461 } 462 463 TEST(AlsaIoInit, UsbCardUseSoftwareVolume) { 464 struct cras_iodev *iodev; 465 466 alsa_mixer_get_dB_range_value = 1000; 467 alsa_mixer_get_output_dB_range_value = 1000; 468 ResetStubData(); 469 iodev = alsa_iodev_create_with_default_parameters(0, NULL, ALSA_CARD_TYPE_USB, 470 1, fake_mixer, fake_config, 471 NULL, CRAS_STREAM_OUTPUT); 472 ASSERT_EQ(0, alsa_iodev_legacy_complete_init(iodev)); 473 EXPECT_EQ(2, cras_card_config_get_volume_curve_for_control_called); 474 EXPECT_EQ(1, alsa_mixer_get_dB_range_called); 475 EXPECT_EQ(1, alsa_mixer_get_output_dB_range_called); 476 EXPECT_EQ(1, iodev->active_node->software_volume_needed); 477 alsa_iodev_destroy(iodev); 478 479 alsa_mixer_get_dB_range_value = 3000; 480 alsa_mixer_get_output_dB_range_value = 2000; 481 ResetStubData(); 482 iodev = alsa_iodev_create_with_default_parameters(0, NULL, ALSA_CARD_TYPE_USB, 483 1, fake_mixer, fake_config, 484 NULL, CRAS_STREAM_OUTPUT); 485 ASSERT_EQ(0, alsa_iodev_legacy_complete_init(iodev)); 486 EXPECT_EQ(2, cras_card_config_get_volume_curve_for_control_called); 487 EXPECT_EQ(1, alsa_mixer_get_dB_range_called); 488 EXPECT_EQ(1, alsa_mixer_get_output_dB_range_called); 489 EXPECT_EQ(0, iodev->active_node->software_volume_needed); 490 alsa_iodev_destroy(iodev); 491 } 492 493 TEST(AlsaIoInit, UseSoftwareGain) { 494 struct cras_iodev *iodev; 495 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr*)3; 496 497 /* MaxSoftwareGain is specified in UCM */ 498 ResetStubData(); 499 ucm_get_min_software_gain_ret_value = 1; 500 ucm_get_min_software_gain_value = 1; 501 ucm_get_max_software_gain_ret_value = 0; 502 ucm_get_max_software_gain_value = 2000; 503 iodev = alsa_iodev_create_with_default_parameters(0, NULL, 504 ALSA_CARD_TYPE_INTERNAL, 1, 505 fake_mixer, fake_config, 506 fake_ucm, 507 CRAS_STREAM_INPUT); 508 ASSERT_EQ(0, alsa_iodev_legacy_complete_init(iodev)); 509 EXPECT_EQ(1, iodev->active_node->software_volume_needed); 510 EXPECT_EQ(DEFAULT_MIN_CAPTURE_GAIN, iodev->active_node->min_software_gain); 511 EXPECT_EQ(2000, iodev->active_node->max_software_gain); 512 ASSERT_EQ(1, sys_set_capture_gain_limits_called); 513 /* The gain range is [DEFAULT_MIN_CAPTURE_GAIN, maximum software gain]. */ 514 ASSERT_EQ(cras_system_set_capture_gain_limits_set_value[0], 515 DEFAULT_MIN_CAPTURE_GAIN); 516 ASSERT_EQ(cras_system_set_capture_gain_limits_set_value[1], 2000); 517 518 alsa_iodev_destroy(iodev); 519 520 /* MaxSoftwareGain and MinSoftwareGain are specified in UCM. */ 521 ResetStubData(); 522 ucm_get_min_software_gain_ret_value = 0; 523 ucm_get_min_software_gain_value = 1000; 524 ucm_get_max_software_gain_ret_value = 0; 525 ucm_get_max_software_gain_value = 2000; 526 iodev = alsa_iodev_create_with_default_parameters(0, NULL, 527 ALSA_CARD_TYPE_INTERNAL, 1, 528 fake_mixer, fake_config, 529 fake_ucm, 530 CRAS_STREAM_INPUT); 531 ASSERT_EQ(0, alsa_iodev_legacy_complete_init(iodev)); 532 EXPECT_EQ(1, iodev->active_node->software_volume_needed); 533 EXPECT_EQ(1000, iodev->active_node->min_software_gain); 534 EXPECT_EQ(2000, iodev->active_node->max_software_gain); 535 ASSERT_EQ(1, sys_set_capture_gain_limits_called); 536 /* The gain range is [minimum software gain, maximum software gain]. */ 537 ASSERT_EQ(cras_system_set_capture_gain_limits_set_value[0], 1000); 538 ASSERT_EQ(cras_system_set_capture_gain_limits_set_value[1], 2000); 539 540 alsa_iodev_destroy(iodev); 541 542 /* MinSoftwareGain is larger than MaxSoftwareGain in UCM. */ 543 ResetStubData(); 544 ucm_get_min_software_gain_ret_value = 0; 545 ucm_get_min_software_gain_value = 3000; 546 ucm_get_max_software_gain_ret_value = 0; 547 ucm_get_max_software_gain_value = 2000; 548 iodev = alsa_iodev_create_with_default_parameters(0, NULL, 549 ALSA_CARD_TYPE_INTERNAL, 1, 550 fake_mixer, fake_config, 551 fake_ucm, 552 CRAS_STREAM_INPUT); 553 ASSERT_EQ(0, alsa_iodev_legacy_complete_init(iodev)); 554 EXPECT_EQ(1, iodev->active_node->software_volume_needed); 555 EXPECT_EQ(DEFAULT_MIN_CAPTURE_GAIN, iodev->active_node->min_software_gain); 556 EXPECT_EQ(2000, iodev->active_node->max_software_gain); 557 ASSERT_EQ(1, sys_set_capture_gain_limits_called); 558 /* The gain range is [DEFAULT_MIN_CAPTURE_GAIN, maximum software gain]. */ 559 ASSERT_EQ(cras_system_set_capture_gain_limits_set_value[0], 560 DEFAULT_MIN_CAPTURE_GAIN); 561 ASSERT_EQ(cras_system_set_capture_gain_limits_set_value[1], 2000); 562 563 alsa_iodev_destroy(iodev); 564 565 /* MaxSoftwareGain is not specified in UCM. */ 566 ResetStubData(); 567 ucm_get_max_software_gain_ret_value = 1; 568 ucm_get_max_software_gain_value = 1; 569 cras_alsa_mixer_get_minimum_capture_gain_ret_value = -500; 570 cras_alsa_mixer_get_maximum_capture_gain_ret_value = 500; 571 iodev = alsa_iodev_create_with_default_parameters(0, NULL, 572 ALSA_CARD_TYPE_INTERNAL, 1, 573 fake_mixer, fake_config, 574 fake_ucm, 575 CRAS_STREAM_INPUT); 576 ASSERT_EQ(0, alsa_iodev_legacy_complete_init(iodev)); 577 EXPECT_EQ(0, iodev->active_node->software_volume_needed); 578 EXPECT_EQ(0, iodev->active_node->max_software_gain); 579 ASSERT_EQ(1, sys_set_capture_gain_limits_called); 580 /* The gain range is reported by controls. */ 581 ASSERT_EQ(cras_system_set_capture_gain_limits_set_value[0], -500); 582 ASSERT_EQ(cras_system_set_capture_gain_limits_set_value[1], 500); 583 584 alsa_iodev_destroy(iodev); 585 } 586 587 TEST(AlsaIoInit, SoftwareGainWithDefaultNodeGain) { 588 struct cras_iodev *iodev; 589 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr*)3; 590 long system_gain = 500; 591 long default_node_gain = -1000; 592 593 ResetStubData(); 594 595 // Use software gain. 596 ucm_get_max_software_gain_ret_value = 0; 597 ucm_get_max_software_gain_value = 2000; 598 599 // Set default node gain to -1000 * 0.01 dB. 600 ucm_get_default_node_gain_values["Internal Mic"] = default_node_gain; 601 602 // Assume this is the first device so it gets internal mic node name. 603 iodev = alsa_iodev_create_with_default_parameters(0, NULL, 604 ALSA_CARD_TYPE_INTERNAL, 1, 605 fake_mixer, fake_config, 606 fake_ucm, 607 CRAS_STREAM_INPUT); 608 ASSERT_EQ(0, alsa_iodev_legacy_complete_init(iodev)); 609 610 // Gain on node is 300 * 0.01 dB. 611 iodev->active_node->capture_gain = default_node_gain; 612 613 // cras_iodev will call cras_iodev_adjust_active_node_gain to get gain for 614 // software gain. 615 ASSERT_EQ(system_gain + default_node_gain, 616 cras_iodev_adjust_active_node_gain(iodev, system_gain)); 617 618 alsa_iodev_destroy(iodev); 619 } 620 621 TEST(AlsaIoInit, RouteBasedOnJackCallback) { 622 struct alsa_io *aio; 623 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer*)2; 624 625 ResetStubData(); 626 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 627 0, NULL, ALSA_CARD_TYPE_INTERNAL, 1, fake_mixer, fake_config, NULL, 628 CRAS_STREAM_OUTPUT); 629 ASSERT_NE(aio, (void *)NULL); 630 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 631 EXPECT_EQ(2, cras_card_config_get_volume_curve_for_control_called); 632 EXPECT_EQ(SND_PCM_STREAM_PLAYBACK, aio->alsa_stream); 633 EXPECT_EQ(0, cras_alsa_fill_properties_called); 634 EXPECT_EQ(1, cras_alsa_mixer_list_outputs_called); 635 EXPECT_EQ(1, cras_alsa_jack_list_create_called); 636 EXPECT_EQ(1, cras_alsa_jack_list_find_jacks_by_name_matching_called); 637 EXPECT_EQ(0, cras_alsa_jack_list_add_jack_for_section_called); 638 639 cras_alsa_jack_list_create_cb(NULL, 1, cras_alsa_jack_list_create_cb_data); 640 EXPECT_EQ(1, cras_iodev_set_node_attr_called); 641 EXPECT_EQ(IONODE_ATTR_PLUGGED, cras_iodev_set_node_attr_attr); 642 EXPECT_EQ(1, cras_iodev_set_node_attr_value); 643 cras_alsa_jack_list_create_cb(NULL, 0, cras_alsa_jack_list_create_cb_data); 644 EXPECT_EQ(2, cras_iodev_set_node_attr_called); 645 EXPECT_EQ(IONODE_ATTR_PLUGGED, cras_iodev_set_node_attr_attr); 646 EXPECT_EQ(0, cras_iodev_set_node_attr_value); 647 648 alsa_iodev_destroy((struct cras_iodev *)aio); 649 EXPECT_EQ(1, cras_alsa_jack_list_destroy_called); 650 } 651 652 TEST(AlsaIoInit, RouteBasedOnInputJackCallback) { 653 struct alsa_io *aio; 654 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer*)2; 655 656 ResetStubData(); 657 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 658 0, NULL, ALSA_CARD_TYPE_INTERNAL, 0, fake_mixer, fake_config, NULL, 659 CRAS_STREAM_INPUT); 660 ASSERT_NE(aio, (void *)NULL); 661 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 662 663 EXPECT_EQ(SND_PCM_STREAM_CAPTURE, aio->alsa_stream); 664 EXPECT_EQ(0, cras_alsa_fill_properties_called); 665 EXPECT_EQ(1, cras_alsa_jack_list_create_called); 666 EXPECT_EQ(1, cras_alsa_jack_list_find_jacks_by_name_matching_called); 667 EXPECT_EQ(0, cras_alsa_jack_list_add_jack_for_section_called); 668 669 cras_alsa_jack_list_create_cb(NULL, 1, cras_alsa_jack_list_create_cb_data); 670 EXPECT_EQ(1, cras_iodev_set_node_attr_called); 671 EXPECT_EQ(IONODE_ATTR_PLUGGED, cras_iodev_set_node_attr_attr); 672 EXPECT_EQ(1, cras_iodev_set_node_attr_value); 673 cras_alsa_jack_list_create_cb(NULL, 0, cras_alsa_jack_list_create_cb_data); 674 EXPECT_EQ(2, cras_iodev_set_node_attr_called); 675 EXPECT_EQ(IONODE_ATTR_PLUGGED, cras_iodev_set_node_attr_attr); 676 EXPECT_EQ(0, cras_iodev_set_node_attr_value); 677 678 alsa_iodev_destroy((struct cras_iodev *)aio); 679 EXPECT_EQ(1, cras_alsa_jack_list_destroy_called); 680 } 681 682 TEST(AlsaIoInit, InitializeCapture) { 683 struct alsa_io *aio; 684 685 ResetStubData(); 686 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 687 0, NULL, ALSA_CARD_TYPE_INTERNAL, 1, fake_mixer, fake_config, NULL, 688 CRAS_STREAM_INPUT); 689 ASSERT_NE(aio, (void *)NULL); 690 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 691 692 EXPECT_EQ(SND_PCM_STREAM_CAPTURE, aio->alsa_stream); 693 EXPECT_EQ(0, cras_alsa_fill_properties_called); 694 EXPECT_EQ(1, cras_alsa_mixer_list_inputs_called); 695 696 alsa_iodev_destroy((struct cras_iodev *)aio); 697 } 698 699 TEST(AlsaIoInit, OpenCapture) { 700 struct cras_iodev *iodev; 701 struct cras_audio_format format; 702 struct alsa_io *aio; 703 704 iodev = alsa_iodev_create_with_default_parameters(0, NULL, 705 ALSA_CARD_TYPE_INTERNAL, 0, 706 fake_mixer, fake_config, 707 NULL, CRAS_STREAM_INPUT); 708 ASSERT_EQ(0, alsa_iodev_legacy_complete_init(iodev)); 709 710 aio = (struct alsa_io *)iodev; 711 format.frame_rate = 48000; 712 format.num_channels = 1; 713 cras_iodev_set_format(iodev, &format); 714 715 ResetStubData(); 716 iodev->open_dev(iodev); 717 EXPECT_EQ(1, cras_alsa_open_called); 718 iodev->configure_dev(iodev); 719 EXPECT_EQ(1, cras_alsa_open_called); 720 EXPECT_EQ(1, cras_alsa_mixer_get_minimum_capture_gain_called); 721 EXPECT_EQ(1, cras_alsa_mixer_get_maximum_capture_gain_called); 722 EXPECT_EQ(1, sys_set_capture_gain_limits_called); 723 EXPECT_EQ(1, sys_get_capture_gain_called); 724 EXPECT_EQ(1, alsa_mixer_set_capture_dBFS_called); 725 EXPECT_EQ(1, sys_get_capture_mute_called); 726 EXPECT_EQ(1, alsa_mixer_set_capture_mute_called); 727 EXPECT_EQ(1, cras_alsa_start_called); 728 EXPECT_EQ(SEVERE_UNDERRUN_MS * format.frame_rate / 1000, 729 aio->severe_underrun_frames); 730 731 alsa_iodev_destroy(iodev); 732 free(fake_format); 733 } 734 735 TEST(AlsaIoInit, OpenCaptureSetCaptureGainWithDefaultNodeGain) { 736 struct cras_iodev *iodev; 737 struct cras_audio_format format; 738 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr*)3; 739 long system_gain = 2000; 740 long default_node_gain = -1000; 741 742 ResetStubData(); 743 // Set default node gain to -1000 * 0.01 dB. 744 ucm_get_default_node_gain_values["Internal Mic"] = default_node_gain; 745 746 // Assume this is the first device so it gets internal mic node name. 747 iodev = alsa_iodev_create_with_default_parameters(0, NULL, 748 ALSA_CARD_TYPE_INTERNAL, 1, 749 fake_mixer, fake_config, 750 fake_ucm, 751 CRAS_STREAM_INPUT); 752 ASSERT_EQ(0, alsa_iodev_legacy_complete_init(iodev)); 753 754 cras_iodev_set_format(iodev, &format); 755 756 // Check the default node gain is the same as what specified in UCM. 757 EXPECT_EQ(default_node_gain, iodev->active_node->capture_gain); 758 // System gain is set to 2000 * 0.01 dB. 759 sys_get_capture_gain_return_value = system_gain; 760 761 iodev->open_dev(iodev); 762 iodev->configure_dev(iodev); 763 iodev->close_dev(iodev); 764 765 // Hardware gain is set to (2000 - 1000) * 0.01 dB. 766 EXPECT_EQ(system_gain + default_node_gain, alsa_mixer_set_capture_dBFS_value); 767 768 alsa_iodev_destroy(iodev); 769 free(fake_format); 770 } 771 772 TEST(AlsaIoInit, OpenCaptureSetCaptureGainWithSoftwareGain) { 773 struct cras_iodev *iodev; 774 struct cras_audio_format format; 775 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr*)3; 776 777 /* Meet the requirements of using software gain. */ 778 ResetStubData(); 779 ucm_get_max_software_gain_ret_value = 0; 780 ucm_get_max_software_gain_value = 2000; 781 782 iodev = alsa_iodev_create_with_default_parameters(0, NULL, 783 ALSA_CARD_TYPE_INTERNAL, 0, 784 fake_mixer, fake_config, 785 fake_ucm, 786 CRAS_STREAM_INPUT); 787 ASSERT_EQ(0, alsa_iodev_legacy_complete_init(iodev)); 788 789 format.frame_rate = 48000; 790 format.num_channels = 1; 791 cras_iodev_set_format(iodev, &format); 792 793 /* System gain is set to 1000 * 0.01 dB */ 794 sys_get_capture_gain_return_value = 1000; 795 796 iodev->open_dev(iodev); 797 iodev->configure_dev(iodev); 798 iodev->close_dev(iodev); 799 800 /* Hardware gain is set to 0dB when software gain is used. */ 801 EXPECT_EQ(0, alsa_mixer_set_capture_dBFS_value); 802 803 /* Test the case where software gain is not needed. */ 804 iodev->active_node->software_volume_needed = 0; 805 iodev->open_dev(iodev); 806 iodev->configure_dev(iodev); 807 iodev->close_dev(iodev); 808 809 /* Hardware gain is set to 1000 * 0.01 dB as got from system capture gain.*/ 810 EXPECT_EQ(1000, alsa_mixer_set_capture_dBFS_value); 811 812 alsa_iodev_destroy(iodev); 813 free(fake_format); 814 } 815 816 TEST(AlsaIoInit, UpdateActiveNode) { 817 struct cras_iodev *iodev; 818 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer*)2; 819 820 ResetStubData(); 821 iodev = alsa_iodev_create_with_default_parameters(0, NULL, 822 ALSA_CARD_TYPE_INTERNAL, 0, 823 fake_mixer, fake_config, 824 NULL, 825 CRAS_STREAM_OUTPUT); 826 ASSERT_EQ(0, alsa_iodev_legacy_complete_init(iodev)); 827 EXPECT_EQ(2, cras_card_config_get_volume_curve_for_control_called); 828 829 iodev->update_active_node(iodev, 0, 1); 830 831 alsa_iodev_destroy(iodev); 832 } 833 834 TEST(AlsaIoInit, StartDevice) { 835 struct cras_iodev *iodev; 836 int rc; 837 838 ResetStubData(); 839 iodev = alsa_iodev_create_with_default_parameters(0, NULL, 840 ALSA_CARD_TYPE_INTERNAL, 0, 841 NULL, fake_config, NULL, 842 CRAS_STREAM_OUTPUT); 843 ASSERT_EQ(0, alsa_iodev_legacy_complete_init(iodev)); 844 EXPECT_EQ(2, cras_card_config_get_volume_curve_for_control_called); 845 846 // Return right away if it is already running. 847 snd_pcm_state_ret = SND_PCM_STATE_RUNNING; 848 rc = iodev->start(iodev); 849 EXPECT_EQ(0, rc); 850 EXPECT_EQ(0, cras_alsa_start_called); 851 852 // Otherwise, start the device. 853 snd_pcm_state_ret = SND_PCM_STATE_SETUP; 854 rc = iodev->start(iodev); 855 EXPECT_EQ(0, rc); 856 EXPECT_EQ(1, cras_alsa_start_called); 857 858 alsa_iodev_destroy(iodev); 859 } 860 861 TEST(AlsaIoInit, ResumeDevice) { 862 struct cras_iodev *iodev; 863 int rc; 864 865 ResetStubData(); 866 iodev = alsa_iodev_create_with_default_parameters(0, NULL, 867 ALSA_CARD_TYPE_INTERNAL, 0, 868 NULL, fake_config, NULL, 869 CRAS_STREAM_OUTPUT); 870 ASSERT_EQ(0, alsa_iodev_legacy_complete_init(iodev)); 871 EXPECT_EQ(2, cras_card_config_get_volume_curve_for_control_called); 872 873 // Attempt to resume if the device is suspended. 874 snd_pcm_state_ret = SND_PCM_STATE_SUSPENDED; 875 rc = iodev->start(iodev); 876 EXPECT_EQ(0, rc); 877 EXPECT_EQ(1, cras_alsa_attempt_resume_called); 878 879 alsa_iodev_destroy(iodev); 880 } 881 882 TEST(AlsaIoInit, DspNameDefault) { 883 struct alsa_io *aio; 884 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer*)2; 885 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr*)3; 886 887 ResetStubData(); 888 ucm_get_dsp_name_default_value = "hello"; 889 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 890 0, NULL, ALSA_CARD_TYPE_INTERNAL, 0, fake_mixer, fake_config, fake_ucm, 891 CRAS_STREAM_OUTPUT); 892 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 893 EXPECT_EQ(2, cras_card_config_get_volume_curve_for_control_called); 894 EXPECT_EQ(SND_PCM_STREAM_PLAYBACK, aio->alsa_stream); 895 EXPECT_EQ(1, ucm_get_dsp_name_default_called); 896 EXPECT_EQ(1, cras_alsa_jack_get_dsp_name_called); 897 EXPECT_STREQ("hello", cras_iodev_update_dsp_name); 898 899 alsa_iodev_destroy((struct cras_iodev *)aio); 900 } 901 902 TEST(AlsaIoInit, DspNameJackOverride) { 903 struct alsa_io *aio; 904 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer*)2; 905 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr*)3; 906 const struct cras_alsa_jack *jack = (struct cras_alsa_jack*)4; 907 908 ResetStubData(); 909 ucm_get_dsp_name_default_value = "default_dsp"; 910 cras_alsa_jack_get_dsp_name_value = "override_dsp"; 911 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 912 0, NULL, ALSA_CARD_TYPE_INTERNAL, 0, fake_mixer, fake_config, fake_ucm, 913 CRAS_STREAM_OUTPUT); 914 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 915 EXPECT_EQ(SND_PCM_STREAM_PLAYBACK, aio->alsa_stream); 916 EXPECT_EQ(1, ucm_get_dsp_name_default_called); 917 EXPECT_EQ(1, cras_alsa_jack_get_dsp_name_called); 918 EXPECT_EQ(1, cras_iodev_update_dsp_called); 919 EXPECT_STREQ("default_dsp", cras_iodev_update_dsp_name); 920 921 // Add the jack node. 922 cras_alsa_jack_list_create_cb(jack, 1, cras_alsa_jack_list_create_cb_data); 923 EXPECT_EQ(1, ucm_get_dsp_name_default_called); 924 925 // Mark the jack node as active. 926 alsa_iodev_set_active_node(&aio->base, aio->base.nodes->next, 1); 927 EXPECT_EQ(2, cras_alsa_jack_get_dsp_name_called); 928 EXPECT_EQ(2, cras_iodev_update_dsp_called); 929 EXPECT_STREQ("override_dsp", cras_iodev_update_dsp_name); 930 931 // Mark the default node as active. 932 alsa_iodev_set_active_node(&aio->base, aio->base.nodes, 1); 933 EXPECT_EQ(1, ucm_get_dsp_name_default_called); 934 EXPECT_EQ(3, cras_alsa_jack_get_dsp_name_called); 935 EXPECT_EQ(3, cras_iodev_update_dsp_called); 936 EXPECT_STREQ("default_dsp", cras_iodev_update_dsp_name); 937 938 alsa_iodev_destroy((struct cras_iodev *)aio); 939 } 940 941 TEST(AlsaIoInit, NodeTypeOverride) { 942 struct alsa_io *aio; 943 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer*)2; 944 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr*)3; 945 const struct cras_alsa_jack *jack = (struct cras_alsa_jack*)4; 946 947 ResetStubData(); 948 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 949 0, NULL, ALSA_CARD_TYPE_INTERNAL, 0, fake_mixer, fake_config, fake_ucm, 950 CRAS_STREAM_OUTPUT); 951 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 952 // Add the jack node. 953 cras_alsa_jack_list_create_cb(jack, 1, cras_alsa_jack_list_create_cb_data); 954 // Verify that cras_alsa_jack_update_node_type is called when an output device 955 // is created. 956 EXPECT_EQ(1, cras_alsa_jack_update_node_type_called); 957 958 alsa_iodev_destroy((struct cras_iodev *)aio); 959 } 960 961 TEST(AlsaIoInit, SwapMode) { 962 struct alsa_io *aio; 963 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer*)2; 964 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr*)3; 965 struct cras_ionode * const fake_node = (cras_ionode *)calloc( 966 1, sizeof(struct cras_ionode)); 967 ResetStubData(); 968 // Stub replies that swap mode does not exist. 969 ucm_swap_mode_exists_ret_value = 0; 970 971 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 972 0, NULL, ALSA_CARD_TYPE_INTERNAL, 0, fake_mixer, fake_config, fake_ucm, 973 CRAS_STREAM_OUTPUT); 974 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 975 976 aio->base.set_swap_mode_for_node((cras_iodev*)aio, fake_node, 1); 977 /* Swap mode is implemented by dsp. */ 978 EXPECT_EQ(1, cras_iodev_dsp_set_swap_mode_for_node_called); 979 980 // Stub replies that swap mode exists. 981 ucm_swap_mode_exists_ret_value = 1; 982 alsa_iodev_destroy((struct cras_iodev *)aio); 983 984 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 985 0, NULL, ALSA_CARD_TYPE_INTERNAL, 0, fake_mixer, fake_config, fake_ucm, 986 CRAS_STREAM_OUTPUT); 987 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 988 // Enable swap mode. 989 aio->base.set_swap_mode_for_node((cras_iodev*)aio, fake_node, 1); 990 991 // Verify that ucm_enable_swap_mode is called when callback to enable 992 // swap mode is called. 993 EXPECT_EQ(1, ucm_enable_swap_mode_called); 994 995 alsa_iodev_destroy((struct cras_iodev *)aio); 996 free(fake_node); 997 } 998 999 // Test that system settins aren't touched if no streams active. 1000 TEST(AlsaOutputNode, SystemSettingsWhenInactive) { 1001 int rc; 1002 struct alsa_io *aio; 1003 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer*)2; 1004 struct mixer_control *outputs[2]; 1005 1006 ResetStubData(); 1007 outputs[0] = reinterpret_cast<struct mixer_control *>(3); 1008 outputs[1] = reinterpret_cast<struct mixer_control *>(4); 1009 cras_alsa_mixer_list_outputs_outputs = outputs; 1010 cras_alsa_mixer_list_outputs_outputs_length = ARRAY_SIZE(outputs); 1011 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 1012 0, NULL, ALSA_CARD_TYPE_INTERNAL, 1, fake_mixer, fake_config, NULL, 1013 CRAS_STREAM_OUTPUT); 1014 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 1015 /* Two mixer controls calls get volume curve. */ 1016 EXPECT_EQ(4, cras_card_config_get_volume_curve_for_control_called); 1017 EXPECT_EQ(SND_PCM_STREAM_PLAYBACK, aio->alsa_stream); 1018 EXPECT_EQ(1, cras_alsa_mixer_list_outputs_called); 1019 1020 ResetStubData(); 1021 rc = alsa_iodev_set_active_node((struct cras_iodev *)aio, 1022 aio->base.nodes->next, 1); 1023 EXPECT_EQ(0, rc); 1024 EXPECT_EQ(0, alsa_mixer_set_mute_called); 1025 EXPECT_EQ(0, alsa_mixer_set_dBFS_called); 1026 ASSERT_EQ(2, cras_alsa_mixer_set_output_active_state_called); 1027 EXPECT_EQ(outputs[0], cras_alsa_mixer_set_output_active_state_outputs[0]); 1028 EXPECT_EQ(0, cras_alsa_mixer_set_output_active_state_values[0]); 1029 EXPECT_EQ(outputs[1], cras_alsa_mixer_set_output_active_state_outputs[1]); 1030 EXPECT_EQ(1, cras_alsa_mixer_set_output_active_state_values[1]); 1031 EXPECT_EQ(1, cras_iodev_update_dsp_called); 1032 // No jack is defined, and UCM is not used. 1033 EXPECT_EQ(0, cras_alsa_jack_enable_ucm_called); 1034 EXPECT_EQ(0, ucm_set_enabled_called); 1035 1036 alsa_iodev_destroy((struct cras_iodev *)aio); 1037 } 1038 1039 // Test handling of different amounts of outputs. 1040 TEST(AlsaOutputNode, TwoOutputs) { 1041 int rc; 1042 struct alsa_io *aio; 1043 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer*)2; 1044 struct mixer_control *outputs[2]; 1045 1046 ResetStubData(); 1047 outputs[0] = reinterpret_cast<struct mixer_control *>(3); 1048 outputs[1] = reinterpret_cast<struct mixer_control *>(4); 1049 cras_alsa_mixer_list_outputs_outputs = outputs; 1050 cras_alsa_mixer_list_outputs_outputs_length = ARRAY_SIZE(outputs); 1051 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 1052 0, NULL, ALSA_CARD_TYPE_INTERNAL, 1, fake_mixer, fake_config, NULL, 1053 CRAS_STREAM_OUTPUT); 1054 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 1055 EXPECT_EQ(4, cras_card_config_get_volume_curve_for_control_called); 1056 EXPECT_EQ(SND_PCM_STREAM_PLAYBACK, aio->alsa_stream); 1057 EXPECT_EQ(1, cras_alsa_mixer_list_outputs_called); 1058 1059 aio->handle = (snd_pcm_t *)0x24; 1060 1061 ResetStubData(); 1062 rc = alsa_iodev_set_active_node((struct cras_iodev *)aio, 1063 aio->base.nodes->next, 1); 1064 EXPECT_EQ(0, rc); 1065 EXPECT_EQ(2, alsa_mixer_set_mute_called); 1066 EXPECT_EQ(outputs[1], alsa_mixer_set_mute_output); 1067 EXPECT_EQ(1, alsa_mixer_set_dBFS_called); 1068 EXPECT_EQ(outputs[1], alsa_mixer_set_dBFS_output); 1069 ASSERT_EQ(2, cras_alsa_mixer_set_output_active_state_called); 1070 EXPECT_EQ(outputs[0], cras_alsa_mixer_set_output_active_state_outputs[0]); 1071 EXPECT_EQ(0, cras_alsa_mixer_set_output_active_state_values[0]); 1072 EXPECT_EQ(outputs[1], cras_alsa_mixer_set_output_active_state_outputs[1]); 1073 EXPECT_EQ(1, cras_alsa_mixer_set_output_active_state_values[1]); 1074 EXPECT_EQ(1, cras_iodev_update_dsp_called); 1075 // No jacks defined, and UCM is not used. 1076 EXPECT_EQ(0, cras_alsa_jack_enable_ucm_called); 1077 EXPECT_EQ(0, ucm_set_enabled_called); 1078 1079 alsa_iodev_destroy((struct cras_iodev *)aio); 1080 } 1081 1082 TEST(AlsaOutputNode, TwoJacksHeadphoneLineout) { 1083 struct alsa_io *aio; 1084 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer *)2; 1085 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr *)3; 1086 struct cras_iodev *iodev; 1087 struct mixer_control *output; 1088 struct ucm_section *section; 1089 1090 ResetStubData(); 1091 output = reinterpret_cast<struct mixer_control *>(3); 1092 cras_alsa_mixer_get_control_name_values[output] = "Headphone"; 1093 1094 // Create the iodev 1095 iodev = alsa_iodev_create_with_default_parameters( 1096 0, NULL, ALSA_CARD_TYPE_INTERNAL, 1, fake_mixer, fake_config, fake_ucm, 1097 CRAS_STREAM_OUTPUT); 1098 ASSERT_NE(iodev, (void *)NULL); 1099 aio = reinterpret_cast<struct alsa_io *>(iodev); 1100 EXPECT_EQ(1, cras_card_config_get_volume_curve_for_control_called); 1101 1102 // First node 'Headphone' 1103 section = ucm_section_create("Headphone", 0, CRAS_STREAM_OUTPUT, 1104 "fake-jack", "gpio"); 1105 ucm_section_set_mixer_name(section, "Headphone"); 1106 cras_alsa_jack_list_add_jack_for_section_result_jack = 1107 reinterpret_cast<struct cras_alsa_jack *>(10); 1108 cras_alsa_mixer_get_control_for_section_return_value = output; 1109 ASSERT_EQ(0, alsa_iodev_ucm_add_nodes_and_jacks(iodev, section)); 1110 EXPECT_EQ(4, cras_card_config_get_volume_curve_for_control_called); 1111 ucm_section_free_list(section); 1112 1113 // Second node 'Line Out' 1114 section = ucm_section_create("Line Out", 0, CRAS_STREAM_OUTPUT, 1115 "fake-jack", "gpio"); 1116 ucm_section_set_mixer_name(section, "Headphone"); 1117 cras_alsa_jack_list_add_jack_for_section_result_jack = 1118 reinterpret_cast<struct cras_alsa_jack *>(20); 1119 cras_alsa_mixer_get_control_for_section_return_value = output; 1120 ASSERT_EQ(0, alsa_iodev_ucm_add_nodes_and_jacks(iodev, section)); 1121 EXPECT_EQ(7, cras_card_config_get_volume_curve_for_control_called); 1122 ucm_section_free_list(section); 1123 1124 // Both nodes are associated with the same mixer output. Different jack plug 1125 // report should trigger different node attribute change. 1126 cras_alsa_jack_get_mixer_output_ret = output; 1127 jack_output_plug_event(reinterpret_cast<struct cras_alsa_jack *>(10), 0, aio); 1128 EXPECT_STREQ(cras_iodev_set_node_attr_ionode->name, "Headphone"); 1129 1130 jack_output_plug_event(reinterpret_cast<struct cras_alsa_jack *>(20), 0, aio); 1131 EXPECT_STREQ(cras_iodev_set_node_attr_ionode->name, "Line Out"); 1132 1133 alsa_iodev_destroy(iodev); 1134 } 1135 1136 TEST(AlsaOutputNode, OutputsFromUCM) { 1137 struct alsa_io *aio; 1138 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer*)2; 1139 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr*)3; 1140 struct cras_iodev *iodev; 1141 static const char *jack_name = "TestCard - Headset Jack"; 1142 struct mixer_control *outputs[2]; 1143 int rc; 1144 struct ucm_section *section; 1145 1146 ResetStubData(); 1147 outputs[0] = reinterpret_cast<struct mixer_control *>(3); 1148 outputs[1] = reinterpret_cast<struct mixer_control *>(4); 1149 cras_alsa_mixer_list_outputs_outputs = outputs; 1150 cras_alsa_mixer_list_outputs_outputs_length = ARRAY_SIZE(outputs); 1151 cras_alsa_mixer_get_control_name_values[outputs[0]] = INTERNAL_SPEAKER; 1152 cras_alsa_mixer_get_control_name_values[outputs[1]] = "Headphone"; 1153 ucm_get_dma_period_for_dev_ret = 1000; 1154 1155 // Create the IO device. 1156 iodev = alsa_iodev_create_with_default_parameters(0, NULL, 1157 ALSA_CARD_TYPE_INTERNAL, 1, 1158 fake_mixer, fake_config, 1159 fake_ucm, 1160 CRAS_STREAM_OUTPUT); 1161 ASSERT_NE(iodev, (void *)NULL); 1162 aio = reinterpret_cast<struct alsa_io *>(iodev); 1163 EXPECT_EQ(1, cras_card_config_get_volume_curve_for_control_called); 1164 1165 // First node. 1166 section = ucm_section_create(INTERNAL_SPEAKER, 0, CRAS_STREAM_OUTPUT, 1167 NULL, NULL); 1168 ucm_section_set_mixer_name(section, INTERNAL_SPEAKER); 1169 cras_alsa_jack_list_add_jack_for_section_result_jack = 1170 reinterpret_cast<struct cras_alsa_jack *>(1); 1171 cras_alsa_mixer_get_control_for_section_return_value = outputs[0]; 1172 ASSERT_EQ(0, alsa_iodev_ucm_add_nodes_and_jacks(iodev, section)); 1173 ucm_section_free_list(section); 1174 EXPECT_EQ(4, cras_card_config_get_volume_curve_for_control_called); 1175 1176 // Add a second node (will use the same iodev). 1177 section = ucm_section_create("Headphone", 0, CRAS_STREAM_OUTPUT, 1178 jack_name, "hctl"); 1179 ucm_section_add_coupled(section, "HP-L", MIXER_NAME_VOLUME); 1180 ucm_section_add_coupled(section, "HP-R", MIXER_NAME_VOLUME); 1181 cras_alsa_jack_list_add_jack_for_section_result_jack = NULL; 1182 cras_alsa_mixer_get_control_for_section_return_value = outputs[1]; 1183 ASSERT_EQ(0, alsa_iodev_ucm_add_nodes_and_jacks(iodev, section)); 1184 ucm_section_free_list(section); 1185 /* New nodes creation calls get volume curve once, NULL jack doesn't make 1186 * more calls. */ 1187 EXPECT_EQ(5, cras_card_config_get_volume_curve_for_control_called); 1188 1189 // Jack plug of an unkonwn device should do nothing. 1190 cras_alsa_jack_get_mixer_output_ret = NULL; 1191 cras_alsa_jack_get_name_ret_value = "Some other jack"; 1192 jack_output_plug_event(reinterpret_cast<struct cras_alsa_jack *>(4), 0, aio); 1193 EXPECT_EQ(0, cras_iodev_set_node_attr_called); 1194 1195 // Complete initialization, and make first node active. 1196 alsa_iodev_ucm_complete_init(iodev); 1197 EXPECT_EQ(SND_PCM_STREAM_PLAYBACK, aio->alsa_stream); 1198 EXPECT_EQ(2, cras_alsa_jack_list_add_jack_for_section_called); 1199 EXPECT_EQ(2, cras_alsa_mixer_get_control_for_section_called); 1200 EXPECT_EQ(1, ucm_get_dma_period_for_dev_called); 1201 EXPECT_EQ(ucm_get_dma_period_for_dev_ret, aio->dma_period_set_microsecs); 1202 1203 aio->handle = (snd_pcm_t *)0x24; 1204 1205 ResetStubData(); 1206 rc = alsa_iodev_set_active_node(iodev, aio->base.nodes->next, 1); 1207 EXPECT_EQ(0, rc); 1208 EXPECT_EQ(2, alsa_mixer_set_mute_called); 1209 EXPECT_EQ(outputs[1], alsa_mixer_set_mute_output); 1210 EXPECT_EQ(1, alsa_mixer_set_dBFS_called); 1211 EXPECT_EQ(outputs[1], alsa_mixer_set_dBFS_output); 1212 ASSERT_EQ(2, cras_alsa_mixer_set_output_active_state_called); 1213 EXPECT_EQ(outputs[0], cras_alsa_mixer_set_output_active_state_outputs[0]); 1214 EXPECT_EQ(0, cras_alsa_mixer_set_output_active_state_values[0]); 1215 EXPECT_EQ(outputs[1], cras_alsa_mixer_set_output_active_state_outputs[1]); 1216 EXPECT_EQ(1, cras_alsa_mixer_set_output_active_state_values[1]); 1217 EXPECT_EQ(1, cras_iodev_update_dsp_called); 1218 EXPECT_EQ(1, cras_alsa_jack_enable_ucm_called); 1219 EXPECT_EQ(1, ucm_set_enabled_called); 1220 1221 // Simulate jack plug event. 1222 cras_alsa_jack_get_mixer_output_ret = outputs[1]; 1223 cras_alsa_jack_get_name_ret_value = jack_name; 1224 jack_output_plug_event(reinterpret_cast<struct cras_alsa_jack *>(4), 0, aio); 1225 EXPECT_EQ(1, cras_iodev_set_node_attr_called); 1226 1227 alsa_iodev_destroy(iodev); 1228 } 1229 1230 TEST(AlsaOutputNode, OutputNoControlsUCM) { 1231 struct alsa_io *aio; 1232 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr*)3; 1233 struct cras_iodev *iodev; 1234 struct ucm_section *section; 1235 1236 ResetStubData(); 1237 1238 // Create the IO device. 1239 iodev = alsa_iodev_create_with_default_parameters(1, NULL, 1240 ALSA_CARD_TYPE_INTERNAL, 1, 1241 fake_mixer, fake_config, 1242 fake_ucm, 1243 CRAS_STREAM_OUTPUT); 1244 ASSERT_NE(iodev, (void *)NULL); 1245 aio = reinterpret_cast<struct alsa_io *>(iodev); 1246 EXPECT_EQ(1, cras_card_config_get_volume_curve_for_control_called); 1247 1248 // Node without controls or jacks. 1249 section = ucm_section_create(INTERNAL_SPEAKER, 1, CRAS_STREAM_OUTPUT, 1250 NULL, NULL); 1251 // Device index doesn't match. 1252 EXPECT_EQ(-22, alsa_iodev_ucm_add_nodes_and_jacks(iodev, section)); 1253 section->dev_idx = 0; 1254 ASSERT_EQ(0, alsa_iodev_ucm_add_nodes_and_jacks(iodev, section)); 1255 EXPECT_EQ(2, cras_card_config_get_volume_curve_for_control_called); 1256 EXPECT_EQ(1, cras_alsa_mixer_get_control_for_section_called); 1257 EXPECT_EQ(1, cras_iodev_add_node_called); 1258 ucm_section_free_list(section); 1259 1260 // Complete initialization, and make first node active. 1261 alsa_iodev_ucm_complete_init(iodev); 1262 EXPECT_EQ(SND_PCM_STREAM_PLAYBACK, aio->alsa_stream); 1263 EXPECT_EQ(0, cras_alsa_mixer_get_control_name_called); 1264 EXPECT_EQ(1, cras_iodev_update_dsp_called); 1265 EXPECT_EQ(0, cras_alsa_jack_enable_ucm_called); 1266 EXPECT_EQ(1, ucm_set_enabled_called); 1267 1268 alsa_iodev_destroy(iodev); 1269 } 1270 1271 TEST(AlsaOutputNode, OutputFromJackUCM) { 1272 struct alsa_io *aio; 1273 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr*)3; 1274 struct cras_iodev *iodev; 1275 static const char *jack_name = "TestCard - Headset Jack"; 1276 struct ucm_section *section; 1277 1278 ResetStubData(); 1279 1280 // Create the IO device. 1281 iodev = alsa_iodev_create_with_default_parameters(1, NULL, 1282 ALSA_CARD_TYPE_INTERNAL, 1, 1283 fake_mixer, fake_config, 1284 fake_ucm, 1285 CRAS_STREAM_OUTPUT); 1286 ASSERT_NE(iodev, (void *)NULL); 1287 aio = reinterpret_cast<struct alsa_io *>(iodev); 1288 EXPECT_EQ(1, cras_card_config_get_volume_curve_for_control_called); 1289 1290 // Node without controls or jacks. 1291 cras_alsa_jack_list_add_jack_for_section_result_jack = 1292 reinterpret_cast<struct cras_alsa_jack *>(1); 1293 section = ucm_section_create("Headphone", 0, CRAS_STREAM_OUTPUT, 1294 jack_name, "hctl"); 1295 ASSERT_EQ(0, alsa_iodev_ucm_add_nodes_and_jacks(iodev, section)); 1296 EXPECT_EQ(4, cras_card_config_get_volume_curve_for_control_called); 1297 EXPECT_EQ(1, cras_alsa_mixer_get_control_for_section_called); 1298 EXPECT_EQ(1, cras_iodev_add_node_called); 1299 EXPECT_EQ(1, cras_alsa_jack_list_add_jack_for_section_called); 1300 ucm_section_free_list(section); 1301 1302 // Complete initialization, and make first node active. 1303 alsa_iodev_ucm_complete_init(iodev); 1304 EXPECT_EQ(SND_PCM_STREAM_PLAYBACK, aio->alsa_stream); 1305 EXPECT_EQ(0, cras_alsa_mixer_get_control_name_called); 1306 EXPECT_EQ(1, cras_iodev_update_dsp_called); 1307 EXPECT_EQ(1, cras_alsa_jack_enable_ucm_called); 1308 EXPECT_EQ(0, ucm_set_enabled_called); 1309 1310 alsa_iodev_destroy(iodev); 1311 } 1312 1313 TEST(AlsaOutputNode, InputsFromUCM) { 1314 struct alsa_io *aio; 1315 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer*)2; 1316 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr*)3; 1317 struct mixer_control *inputs[2]; 1318 struct cras_iodev *iodev; 1319 static const char *jack_name = "TestCard - Headset Jack"; 1320 int rc; 1321 struct ucm_section *section; 1322 1323 ResetStubData(); 1324 inputs[0] = reinterpret_cast<struct mixer_control *>(3); 1325 inputs[1] = reinterpret_cast<struct mixer_control *>(4); 1326 cras_alsa_mixer_list_inputs_outputs = inputs; 1327 cras_alsa_mixer_list_inputs_outputs_length = ARRAY_SIZE(inputs); 1328 cras_alsa_mixer_get_control_name_values[inputs[0]] = "Internal Mic"; 1329 cras_alsa_mixer_get_control_name_values[inputs[1]] = "Mic"; 1330 1331 // Create the IO device. 1332 iodev = alsa_iodev_create_with_default_parameters(0, NULL, 1333 ALSA_CARD_TYPE_INTERNAL, 1, 1334 fake_mixer, fake_config, 1335 fake_ucm, 1336 CRAS_STREAM_INPUT); 1337 ASSERT_NE(iodev, (void *)NULL); 1338 aio = reinterpret_cast<struct alsa_io *>(iodev); 1339 1340 // First node. 1341 cras_alsa_mixer_get_control_for_section_return_value = inputs[0]; 1342 ucm_get_max_software_gain_ret_value = -1; 1343 section = ucm_section_create(INTERNAL_MICROPHONE, 0, CRAS_STREAM_INPUT, 1344 NULL, NULL); 1345 ucm_section_add_coupled(section, "MIC-L", MIXER_NAME_VOLUME); 1346 ucm_section_add_coupled(section, "MIC-R", MIXER_NAME_VOLUME); 1347 ASSERT_EQ(0, alsa_iodev_ucm_add_nodes_and_jacks(iodev, section)); 1348 ucm_section_free_list(section); 1349 1350 // Add a second node (will use the same iodev). 1351 cras_alsa_mixer_get_control_name_called = 0; 1352 ucm_get_max_software_gain_ret_value = 0; 1353 ucm_get_max_software_gain_value = 2000; 1354 cras_alsa_jack_list_add_jack_for_section_result_jack = 1355 reinterpret_cast<struct cras_alsa_jack *>(1); 1356 cras_alsa_mixer_get_control_for_section_return_value = inputs[1]; 1357 section = ucm_section_create("Mic", 0, CRAS_STREAM_INPUT, jack_name, "hctl"); 1358 ucm_section_set_mixer_name(section, "Mic"); 1359 ASSERT_EQ(0, alsa_iodev_ucm_add_nodes_and_jacks(iodev, section)); 1360 ucm_section_free_list(section); 1361 1362 // Jack plug of an unkonwn device should do nothing. 1363 cras_alsa_jack_get_mixer_input_ret = NULL; 1364 cras_alsa_jack_get_name_ret_value = "Some other jack"; 1365 jack_input_plug_event(reinterpret_cast<struct cras_alsa_jack *>(4), 0, aio); 1366 EXPECT_EQ(0, cras_iodev_set_node_attr_called); 1367 1368 // Simulate jack plug event. 1369 cras_alsa_jack_get_mixer_input_ret = inputs[1]; 1370 cras_alsa_jack_get_name_ret_value = jack_name; 1371 jack_input_plug_event(reinterpret_cast<struct cras_alsa_jack *>(4), 0, aio); 1372 EXPECT_EQ(1, cras_iodev_set_node_attr_called); 1373 1374 // Complete initialization, and make first node active. 1375 alsa_iodev_ucm_complete_init(iodev); 1376 EXPECT_EQ(SND_PCM_STREAM_CAPTURE, aio->alsa_stream); 1377 EXPECT_EQ(2, cras_alsa_jack_list_add_jack_for_section_called); 1378 EXPECT_EQ(2, cras_alsa_mixer_get_control_for_section_called); 1379 EXPECT_EQ(1, cras_alsa_mixer_get_control_name_called); 1380 EXPECT_EQ(1, sys_set_capture_gain_limits_called); 1381 EXPECT_EQ(2, cras_iodev_add_node_called); 1382 EXPECT_EQ(2, ucm_get_dma_period_for_dev_called); 1383 EXPECT_EQ(0, aio->dma_period_set_microsecs); 1384 1385 aio->handle = (snd_pcm_t *)0x24; 1386 1387 ResetStubData(); 1388 rc = alsa_iodev_set_active_node(iodev, aio->base.nodes->next, 1); 1389 EXPECT_EQ(0, rc); 1390 EXPECT_EQ(1, alsa_mixer_set_capture_dBFS_called); 1391 EXPECT_EQ(inputs[1], alsa_mixer_set_capture_dBFS_input); 1392 EXPECT_EQ(0, alsa_mixer_set_capture_dBFS_value); 1393 EXPECT_EQ(1, cras_iodev_update_dsp_called); 1394 EXPECT_EQ(1, cras_alsa_jack_enable_ucm_called); 1395 EXPECT_EQ(1, ucm_set_enabled_called); 1396 EXPECT_EQ(1, sys_set_capture_gain_limits_called); 1397 EXPECT_EQ(1, alsa_mixer_set_capture_mute_called); 1398 EXPECT_EQ(1, iodev->active_node->software_volume_needed); 1399 EXPECT_EQ(2000, iodev->active_node->max_software_gain); 1400 1401 alsa_iodev_destroy(iodev); 1402 } 1403 1404 TEST(AlsaOutputNode, InputNoControlsUCM) { 1405 struct alsa_io *aio; 1406 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr*)3; 1407 struct cras_iodev *iodev; 1408 struct ucm_section *section; 1409 1410 ResetStubData(); 1411 1412 // Create the IO device. 1413 iodev = alsa_iodev_create_with_default_parameters(1, NULL, 1414 ALSA_CARD_TYPE_INTERNAL, 1, 1415 fake_mixer, fake_config, 1416 fake_ucm, 1417 CRAS_STREAM_INPUT); 1418 ASSERT_NE(iodev, (void *)NULL); 1419 aio = reinterpret_cast<struct alsa_io *>(iodev); 1420 1421 // Node without controls or jacks. 1422 section = ucm_section_create(INTERNAL_MICROPHONE, 1, CRAS_STREAM_INPUT, 1423 NULL, NULL); 1424 // Device index doesn't match. 1425 EXPECT_EQ(-22, alsa_iodev_ucm_add_nodes_and_jacks(iodev, section)); 1426 section->dev_idx = 0; 1427 ASSERT_EQ(0, alsa_iodev_ucm_add_nodes_and_jacks(iodev, section)); 1428 EXPECT_EQ(1, cras_alsa_jack_list_add_jack_for_section_called); 1429 EXPECT_EQ(1, cras_alsa_mixer_get_control_for_section_called); 1430 EXPECT_EQ(0, cras_alsa_mixer_get_control_name_called); 1431 EXPECT_EQ(1, cras_iodev_add_node_called); 1432 ucm_section_free_list(section); 1433 1434 // Complete initialization, and make first node active. 1435 alsa_iodev_ucm_complete_init(iodev); 1436 EXPECT_EQ(SND_PCM_STREAM_CAPTURE, aio->alsa_stream); 1437 EXPECT_EQ(0, cras_alsa_mixer_get_control_name_called); 1438 EXPECT_EQ(1, cras_iodev_update_dsp_called); 1439 EXPECT_EQ(0, cras_alsa_jack_enable_ucm_called); 1440 EXPECT_EQ(1, ucm_set_enabled_called); 1441 1442 alsa_iodev_destroy(iodev); 1443 } 1444 1445 TEST(AlsaOutputNode, InputFromJackUCM) { 1446 struct alsa_io *aio; 1447 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr*)3; 1448 struct cras_iodev *iodev; 1449 static const char *jack_name = "TestCard - Headset Jack"; 1450 struct ucm_section *section; 1451 1452 ResetStubData(); 1453 1454 // Create the IO device. 1455 iodev = alsa_iodev_create_with_default_parameters(1, NULL, 1456 ALSA_CARD_TYPE_INTERNAL, 1, 1457 fake_mixer, fake_config, 1458 fake_ucm, 1459 CRAS_STREAM_INPUT); 1460 ASSERT_NE(iodev, (void *)NULL); 1461 aio = reinterpret_cast<struct alsa_io *>(iodev); 1462 1463 // Node without controls or jacks. 1464 cras_alsa_jack_list_add_jack_for_section_result_jack = 1465 reinterpret_cast<struct cras_alsa_jack *>(1); 1466 section = ucm_section_create("Mic", 0, CRAS_STREAM_INPUT, jack_name, "hctl"); 1467 ASSERT_EQ(0, alsa_iodev_ucm_add_nodes_and_jacks(iodev, section)); 1468 EXPECT_EQ(1, cras_alsa_mixer_get_control_for_section_called); 1469 EXPECT_EQ(1, cras_iodev_add_node_called); 1470 EXPECT_EQ(1, cras_alsa_jack_list_add_jack_for_section_called); 1471 ucm_section_free_list(section); 1472 1473 // Complete initialization, and make first node active. 1474 alsa_iodev_ucm_complete_init(iodev); 1475 EXPECT_EQ(SND_PCM_STREAM_CAPTURE, aio->alsa_stream); 1476 EXPECT_EQ(0, cras_alsa_mixer_get_control_name_called); 1477 EXPECT_EQ(1, cras_iodev_update_dsp_called); 1478 EXPECT_EQ(1, cras_alsa_jack_enable_ucm_called); 1479 EXPECT_EQ(0, ucm_set_enabled_called); 1480 1481 alsa_iodev_destroy(iodev); 1482 } 1483 1484 TEST(AlsaOutputNode, AutoUnplugOutputNode) { 1485 struct alsa_io *aio; 1486 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer*)2; 1487 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr*)3; 1488 struct mixer_control *outputs[2]; 1489 const struct cras_alsa_jack *jack = (struct cras_alsa_jack*)4; 1490 1491 ResetStubData(); 1492 outputs[0] = reinterpret_cast<struct mixer_control *>(5); 1493 outputs[1] = reinterpret_cast<struct mixer_control *>(6); 1494 1495 cras_alsa_mixer_list_outputs_outputs = outputs; 1496 cras_alsa_mixer_list_outputs_outputs_length = ARRAY_SIZE(outputs); 1497 1498 cras_alsa_mixer_get_control_name_values[outputs[0]] = INTERNAL_SPEAKER; 1499 cras_alsa_mixer_get_control_name_values[outputs[1]] = "Headphone"; 1500 auto_unplug_output_node_ret = 1; 1501 1502 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 1503 0, NULL, ALSA_CARD_TYPE_INTERNAL, 1, fake_mixer, fake_config, fake_ucm, 1504 CRAS_STREAM_OUTPUT); 1505 1506 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 1507 EXPECT_EQ(3, cras_card_config_get_volume_curve_for_control_called); 1508 EXPECT_EQ(1, cras_alsa_mixer_list_outputs_called); 1509 EXPECT_EQ(2, cras_alsa_mixer_get_control_name_called); 1510 1511 // Assert that the the internal speaker is plugged and other nodes aren't. 1512 ASSERT_NE(aio->base.nodes, (void *)NULL); 1513 EXPECT_EQ(aio->base.nodes->plugged, 1); 1514 ASSERT_NE(aio->base.nodes->next, (void *)NULL); 1515 EXPECT_EQ(aio->base.nodes->next->plugged, 0); 1516 1517 // Plug headphone jack 1518 cras_alsa_jack_get_name_ret_value = "Headphone Jack"; 1519 is_utf8_string_ret_value = 1; 1520 cras_alsa_jack_get_mixer_output_ret = outputs[1]; 1521 cras_alsa_jack_list_create_cb(jack, 1, cras_alsa_jack_list_create_cb_data); 1522 1523 // Assert internal speaker is auto unplugged 1524 EXPECT_EQ(aio->base.nodes->plugged, 0); 1525 EXPECT_EQ(aio->base.nodes->next->plugged, 1); 1526 1527 alsa_iodev_destroy((struct cras_iodev *)aio); 1528 } 1529 1530 TEST(AlsaOutputNode, AutoUnplugInputNode) { 1531 struct alsa_io *aio; 1532 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer*)2; 1533 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr*)3; 1534 struct mixer_control *inputs[2]; 1535 const struct cras_alsa_jack *jack = (struct cras_alsa_jack*)4; 1536 1537 ResetStubData(); 1538 inputs[0] = reinterpret_cast<struct mixer_control *>(5); 1539 inputs[1] = reinterpret_cast<struct mixer_control *>(6); 1540 1541 cras_alsa_mixer_list_inputs_outputs = inputs; 1542 cras_alsa_mixer_list_inputs_outputs_length = ARRAY_SIZE(inputs); 1543 1544 cras_alsa_mixer_get_control_name_values[inputs[0]] = INTERNAL_MICROPHONE; 1545 cras_alsa_mixer_get_control_name_values[inputs[1]] = "Mic"; 1546 auto_unplug_input_node_ret = 1; 1547 1548 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 1549 0, NULL, ALSA_CARD_TYPE_INTERNAL, 1, fake_mixer, fake_config, fake_ucm, 1550 CRAS_STREAM_INPUT); 1551 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 1552 EXPECT_EQ(1, cras_alsa_mixer_list_inputs_called); 1553 EXPECT_EQ(2, cras_alsa_mixer_get_control_name_called); 1554 1555 // Assert that the the internal speaker is plugged and other nodes aren't. 1556 ASSERT_NE(aio->base.nodes, (void *)NULL); 1557 EXPECT_EQ(aio->base.nodes->plugged, 1); 1558 ASSERT_NE(aio->base.nodes->next, (void *)NULL); 1559 EXPECT_EQ(aio->base.nodes->next->plugged, 0); 1560 1561 // Plug headphone jack 1562 cras_alsa_jack_get_name_ret_value = "Mic Jack"; 1563 is_utf8_string_ret_value = 1; 1564 cras_alsa_jack_get_mixer_input_ret = inputs[1]; 1565 cras_alsa_jack_list_create_cb(jack, 1, cras_alsa_jack_list_create_cb_data); 1566 1567 // Assert internal speaker is auto unplugged 1568 EXPECT_EQ(aio->base.nodes->plugged, 0); 1569 EXPECT_EQ(aio->base.nodes->next->plugged, 1); 1570 1571 alsa_iodev_destroy((struct cras_iodev *)aio); 1572 } 1573 1574 TEST(AlsaInitNode, SetNodeInitialState) { 1575 struct cras_ionode node; 1576 struct cras_iodev dev; 1577 1578 memset(&dev, 0, sizeof(dev)); 1579 memset(&node, 0, sizeof(node)); 1580 node.dev = &dev; 1581 strcpy(node.name, "Unknown"); 1582 dev.direction = CRAS_STREAM_OUTPUT; 1583 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1584 ASSERT_EQ(0, node.plugged); 1585 ASSERT_EQ(0, node.plugged_time.tv_sec); 1586 ASSERT_EQ(CRAS_NODE_TYPE_UNKNOWN, node.type); 1587 ASSERT_EQ(NODE_POSITION_EXTERNAL, node.position); 1588 1589 memset(&node, 0, sizeof(node)); 1590 node.dev = &dev; 1591 strcpy(node.name, "Speaker"); 1592 dev.direction = CRAS_STREAM_OUTPUT; 1593 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1594 ASSERT_EQ(1, node.plugged); 1595 ASSERT_GT(node.plugged_time.tv_sec, 0); 1596 ASSERT_EQ(CRAS_NODE_TYPE_INTERNAL_SPEAKER, node.type); 1597 ASSERT_EQ(NODE_POSITION_INTERNAL, node.position); 1598 1599 memset(&node, 0, sizeof(node)); 1600 node.dev = &dev; 1601 strcpy(node.name, "Internal Mic"); 1602 dev.direction = CRAS_STREAM_INPUT; 1603 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1604 ASSERT_EQ(1, node.plugged); 1605 ASSERT_GT(node.plugged_time.tv_sec, 0); 1606 ASSERT_EQ(CRAS_NODE_TYPE_MIC, node.type); 1607 ASSERT_EQ(NODE_POSITION_INTERNAL, node.position); 1608 1609 memset(&node, 0, sizeof(node)); 1610 node.dev = &dev; 1611 strcpy(node.name, "HDMI"); 1612 dev.direction = CRAS_STREAM_OUTPUT; 1613 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1614 ASSERT_EQ(0, node.plugged); 1615 ASSERT_EQ(0, node.plugged_time.tv_sec); 1616 ASSERT_EQ(CRAS_NODE_TYPE_HDMI, node.type); 1617 ASSERT_EQ(NODE_POSITION_EXTERNAL, node.position); 1618 1619 memset(&node, 0, sizeof(node)); 1620 node.dev = &dev; 1621 strcpy(node.name, "IEC958"); 1622 dev.direction = CRAS_STREAM_OUTPUT; 1623 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1624 ASSERT_EQ(0, node.plugged); 1625 ASSERT_EQ(CRAS_NODE_TYPE_HDMI, node.type); 1626 ASSERT_EQ(NODE_POSITION_EXTERNAL, node.position); 1627 1628 memset(&node, 0, sizeof(node)); 1629 node.dev = &dev; 1630 strcpy(node.name, "HDMI Jack"); 1631 dev.direction = CRAS_STREAM_OUTPUT; 1632 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1633 ASSERT_EQ(0, node.plugged); 1634 ASSERT_EQ(CRAS_NODE_TYPE_HDMI, node.type); 1635 ASSERT_EQ(NODE_POSITION_EXTERNAL, node.position); 1636 1637 memset(&node, 0, sizeof(node)); 1638 node.dev = &dev; 1639 strcpy(node.name, "Something HDMI Jack"); 1640 dev.direction = CRAS_STREAM_OUTPUT; 1641 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1642 ASSERT_EQ(0, node.plugged); 1643 ASSERT_EQ(CRAS_NODE_TYPE_HDMI, node.type); 1644 ASSERT_EQ(NODE_POSITION_EXTERNAL, node.position); 1645 1646 memset(&node, 0, sizeof(node)); 1647 node.dev = &dev; 1648 strcpy(node.name, "Headphone"); 1649 dev.direction = CRAS_STREAM_OUTPUT; 1650 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1651 ASSERT_EQ(0, node.plugged); 1652 ASSERT_EQ(CRAS_NODE_TYPE_HEADPHONE, node.type); 1653 ASSERT_EQ(NODE_POSITION_EXTERNAL, node.position); 1654 1655 memset(&node, 0, sizeof(node)); 1656 node.dev = &dev; 1657 strcpy(node.name, "Headphone Jack"); 1658 dev.direction = CRAS_STREAM_OUTPUT; 1659 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1660 ASSERT_EQ(0, node.plugged); 1661 ASSERT_EQ(CRAS_NODE_TYPE_HEADPHONE, node.type); 1662 ASSERT_EQ(NODE_POSITION_EXTERNAL, node.position); 1663 1664 memset(&node, 0, sizeof(node)); 1665 node.dev = &dev; 1666 strcpy(node.name, "Mic"); 1667 dev.direction = CRAS_STREAM_INPUT; 1668 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1669 ASSERT_EQ(0, node.plugged); 1670 ASSERT_EQ(CRAS_NODE_TYPE_MIC, node.type); 1671 ASSERT_EQ(NODE_POSITION_EXTERNAL, node.position); 1672 1673 memset(&node, 0, sizeof(node)); 1674 node.dev = &dev; 1675 strcpy(node.name, "Front Mic"); 1676 dev.direction = CRAS_STREAM_INPUT; 1677 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1678 ASSERT_EQ(1, node.plugged); 1679 ASSERT_EQ(CRAS_NODE_TYPE_MIC, node.type); 1680 ASSERT_EQ(NODE_POSITION_FRONT, node.position); 1681 1682 memset(&node, 0, sizeof(node)); 1683 node.dev = &dev; 1684 strcpy(node.name, "Rear Mic"); 1685 dev.direction = CRAS_STREAM_INPUT; 1686 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1687 ASSERT_EQ(1, node.plugged); 1688 ASSERT_EQ(CRAS_NODE_TYPE_MIC, node.type); 1689 ASSERT_EQ(NODE_POSITION_REAR, node.position); 1690 1691 memset(&node, 0, sizeof(node)); 1692 node.dev = &dev; 1693 strcpy(node.name, "Mic Jack"); 1694 dev.direction = CRAS_STREAM_INPUT; 1695 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1696 ASSERT_EQ(0, node.plugged); 1697 ASSERT_EQ(CRAS_NODE_TYPE_MIC, node.type); 1698 ASSERT_EQ(NODE_POSITION_EXTERNAL, node.position); 1699 1700 memset(&node, 0, sizeof(node)); 1701 node.dev = &dev; 1702 strcpy(node.name, "Unknown"); 1703 dev.direction = CRAS_STREAM_OUTPUT; 1704 set_node_initial_state(&node, ALSA_CARD_TYPE_USB); 1705 ASSERT_EQ(0, node.plugged); 1706 ASSERT_EQ(CRAS_NODE_TYPE_USB, node.type); 1707 ASSERT_EQ(NODE_POSITION_EXTERNAL, node.position); 1708 1709 memset(&node, 0, sizeof(node)); 1710 node.dev = &dev; 1711 dev.direction = CRAS_STREAM_INPUT; 1712 strcpy(node.name, "DAISY-I2S Mic Jack"); 1713 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1714 ASSERT_EQ(0, node.plugged); 1715 ASSERT_EQ(CRAS_NODE_TYPE_MIC, node.type); 1716 ASSERT_EQ(NODE_POSITION_EXTERNAL, node.position); 1717 // Node name is changed to "Mic". 1718 ASSERT_EQ(0, strcmp(node.name, "Mic")); 1719 1720 memset(&node, 0, sizeof(node)); 1721 node.dev = &dev; 1722 dev.direction = CRAS_STREAM_OUTPUT; 1723 strcpy(node.name, "DAISY-I2S Headphone Jack"); 1724 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1725 ASSERT_EQ(0, node.plugged); 1726 ASSERT_EQ(CRAS_NODE_TYPE_HEADPHONE, node.type); 1727 ASSERT_EQ(NODE_POSITION_EXTERNAL, node.position); 1728 // Node name is changed to "Headphone". 1729 ASSERT_EQ(0, strcmp(node.name, "Headphone")); 1730 1731 memset(&node, 0, sizeof(node)); 1732 node.dev = &dev; 1733 strcpy(node.name, "Speaker"); 1734 dev.direction = CRAS_STREAM_OUTPUT; 1735 set_node_initial_state(&node, ALSA_CARD_TYPE_USB); 1736 ASSERT_EQ(1, node.plugged); 1737 ASSERT_GT(node.plugged_time.tv_sec, 0); 1738 ASSERT_EQ(CRAS_NODE_TYPE_USB, node.type); 1739 ASSERT_EQ(NODE_POSITION_EXTERNAL, node.position); 1740 1741 memset(&node, 0, sizeof(node)); 1742 node.dev = &dev; 1743 strcpy(node.name, "Haptic"); 1744 dev.direction = CRAS_STREAM_OUTPUT; 1745 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1746 ASSERT_EQ(1, node.plugged); 1747 ASSERT_GT(node.plugged_time.tv_sec, 0); 1748 ASSERT_EQ(CRAS_NODE_TYPE_HAPTIC, node.type); 1749 ASSERT_EQ(NODE_POSITION_INTERNAL, node.position); 1750 1751 memset(&node, 0, sizeof(node)); 1752 node.dev = &dev; 1753 strcpy(node.name, "Rumbler"); 1754 dev.direction = CRAS_STREAM_OUTPUT; 1755 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1756 ASSERT_EQ(1, node.plugged); 1757 ASSERT_GT(node.plugged_time.tv_sec, 0); 1758 ASSERT_EQ(CRAS_NODE_TYPE_HAPTIC, node.type); 1759 ASSERT_EQ(NODE_POSITION_INTERNAL, node.position); 1760 } 1761 1762 TEST(AlsaInitNode, SetNodeInitialStateDropInvalidUTF8NodeName) { 1763 struct cras_ionode node; 1764 struct cras_iodev dev; 1765 1766 memset(&dev, 0, sizeof(dev)); 1767 memset(&node, 0, sizeof(node)); 1768 node.dev = &dev; 1769 1770 memset(&node, 0, sizeof(node)); 1771 node.dev = &dev; 1772 strcpy(node.name, "Something USB"); 1773 //0xfe can not appear in a valid UTF-8 string. 1774 node.name[0] = 0xfe; 1775 is_utf8_string_ret_value = 0; 1776 dev.direction = CRAS_STREAM_OUTPUT; 1777 set_node_initial_state(&node, ALSA_CARD_TYPE_USB); 1778 ASSERT_EQ(CRAS_NODE_TYPE_USB, node.type); 1779 ASSERT_STREQ("USB", node.name); 1780 1781 memset(&node, 0, sizeof(node)); 1782 node.dev = &dev; 1783 strcpy(node.name, "Something HDMI Jack"); 1784 //0xfe can not appear in a valid UTF-8 string. 1785 node.name[0] = 0xfe; 1786 is_utf8_string_ret_value = 0; 1787 dev.direction = CRAS_STREAM_OUTPUT; 1788 set_node_initial_state(&node, ALSA_CARD_TYPE_INTERNAL); 1789 ASSERT_EQ(CRAS_NODE_TYPE_HDMI, node.type); 1790 ASSERT_STREQ("HDMI", node.name); 1791 } 1792 1793 TEST(AlsaIoInit, HDMIJackUpdateInvalidUTF8MonitorName) { 1794 struct alsa_io *aio; 1795 struct cras_alsa_mixer * const fake_mixer = (struct cras_alsa_mixer*)2; 1796 struct cras_use_case_mgr * const fake_ucm = (struct cras_use_case_mgr*)3; 1797 const struct cras_alsa_jack *jack = (struct cras_alsa_jack*)4; 1798 1799 ResetStubData(); 1800 aio = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 1801 0, NULL, ALSA_CARD_TYPE_INTERNAL, 0, fake_mixer, fake_config, fake_ucm, 1802 CRAS_STREAM_OUTPUT); 1803 ASSERT_EQ(0, alsa_iodev_legacy_complete_init((struct cras_iodev *)aio)); 1804 1805 // Prepare the stub data such that the jack will be identified as an 1806 // HDMI jack, and thus the callback creates an HDMI node. 1807 cras_alsa_jack_get_name_ret_value = "HDMI Jack"; 1808 // Set the jack name updated from monitor to be an invalid UTF8 string. 1809 cras_alsa_jack_update_monitor_fake_name = "\xfeomething"; 1810 is_utf8_string_ret_value = 0; 1811 1812 // Add the jack node. 1813 cras_alsa_jack_list_create_cb(jack, 1, cras_alsa_jack_list_create_cb_data); 1814 1815 EXPECT_EQ(2, cras_alsa_jack_get_name_called); 1816 ASSERT_EQ(CRAS_NODE_TYPE_HDMI, aio->base.nodes->next->type); 1817 // The node name should be "HDMI". 1818 ASSERT_STREQ("HDMI", aio->base.nodes->next->name); 1819 1820 alsa_iodev_destroy((struct cras_iodev *)aio); 1821 } 1822 1823 // Test thread add/rm stream, open_alsa, and iodev config. 1824 class AlsaVolumeMuteSuite : public testing::Test { 1825 protected: 1826 virtual void SetUp() { 1827 ResetStubData(); 1828 output_control_ = reinterpret_cast<struct mixer_control *>(10); 1829 cras_alsa_mixer_list_outputs_outputs = &output_control_; 1830 cras_alsa_mixer_list_outputs_outputs_length = 1; 1831 cras_alsa_mixer_get_control_name_values[output_control_] = "Speaker"; 1832 cras_alsa_mixer_list_outputs_outputs_length = 1; 1833 aio_output_ = (struct alsa_io *)alsa_iodev_create_with_default_parameters( 1834 0, NULL, 1835 ALSA_CARD_TYPE_INTERNAL, 1, 1836 fake_mixer, fake_config, NULL, 1837 CRAS_STREAM_OUTPUT); 1838 alsa_iodev_legacy_complete_init((struct cras_iodev *)aio_output_); 1839 EXPECT_EQ(2, cras_card_config_get_volume_curve_for_control_called); 1840 1841 struct cras_ionode *node; 1842 int count = 0; 1843 DL_FOREACH(aio_output_->base.nodes, node) { 1844 printf("node %d \n", count); 1845 } 1846 aio_output_->base.direction = CRAS_STREAM_OUTPUT; 1847 fmt_.frame_rate = 44100; 1848 fmt_.num_channels = 2; 1849 fmt_.format = SND_PCM_FORMAT_S16_LE; 1850 aio_output_->base.format = &fmt_; 1851 cras_alsa_get_avail_frames_ret = -1; 1852 } 1853 1854 virtual void TearDown() { 1855 alsa_iodev_destroy((struct cras_iodev *)aio_output_); 1856 cras_alsa_get_avail_frames_ret = 0; 1857 } 1858 1859 struct mixer_control *output_control_; 1860 struct alsa_io *aio_output_; 1861 struct cras_audio_format fmt_; 1862 }; 1863 1864 TEST_F(AlsaVolumeMuteSuite, GetDefaultVolumeCurve) { 1865 int rc; 1866 struct cras_audio_format *fmt; 1867 1868 fmt = (struct cras_audio_format *)malloc(sizeof(*fmt)); 1869 memcpy(fmt, &fmt_, sizeof(fmt_)); 1870 aio_output_->base.format = fmt; 1871 aio_output_->handle = (snd_pcm_t *)0x24; 1872 1873 rc = aio_output_->base.configure_dev(&aio_output_->base); 1874 ASSERT_EQ(0, rc); 1875 EXPECT_EQ(&default_curve, fake_get_dBFS_volume_curve_val); 1876 1877 aio_output_->base.set_volume(&aio_output_->base); 1878 EXPECT_EQ(&default_curve, fake_get_dBFS_volume_curve_val); 1879 free(fmt); 1880 } 1881 1882 TEST_F(AlsaVolumeMuteSuite, GetVolumeCurveFromNode) 1883 { 1884 int rc; 1885 struct cras_audio_format *fmt; 1886 struct cras_alsa_jack *jack = (struct cras_alsa_jack*)4; 1887 struct cras_ionode *node; 1888 struct cras_volume_curve hp_curve = { 1889 .get_dBFS = fake_get_dBFS, 1890 }; 1891 1892 fmt = (struct cras_audio_format *)malloc(sizeof(*fmt)); 1893 memcpy(fmt, &fmt_, sizeof(fmt_)); 1894 aio_output_->base.format = fmt; 1895 aio_output_->handle = (snd_pcm_t *)0x24; 1896 1897 // Headphone jack plugged and has its own volume curve. 1898 cras_alsa_jack_get_mixer_output_ret = NULL; 1899 cras_alsa_jack_get_name_ret_value = "Headphone"; 1900 cras_card_config_get_volume_curve_vals["Headphone"] = &hp_curve; 1901 cras_alsa_jack_list_create_cb(jack, 1, cras_alsa_jack_list_create_cb_data); 1902 EXPECT_EQ(1, cras_alsa_jack_update_node_type_called); 1903 EXPECT_EQ(3, cras_card_config_get_volume_curve_for_control_called); 1904 1905 // Switch to node 'Headphone'. 1906 node = aio_output_->base.nodes->next; 1907 aio_output_->base.active_node = node; 1908 1909 rc = aio_output_->base.configure_dev(&aio_output_->base); 1910 ASSERT_EQ(0, rc); 1911 EXPECT_EQ(&hp_curve, fake_get_dBFS_volume_curve_val); 1912 1913 aio_output_->base.set_volume(&aio_output_->base); 1914 EXPECT_EQ(&hp_curve, fake_get_dBFS_volume_curve_val); 1915 free(fmt); 1916 } 1917 1918 TEST_F(AlsaVolumeMuteSuite, SetVolume) { 1919 int rc; 1920 struct cras_audio_format *fmt; 1921 const size_t fake_system_volume = 55; 1922 const size_t fake_system_volume_dB = (fake_system_volume - 100) * 100; 1923 1924 fmt = (struct cras_audio_format *)malloc(sizeof(*fmt)); 1925 memcpy(fmt, &fmt_, sizeof(fmt_)); 1926 aio_output_->base.format = fmt; 1927 aio_output_->handle = (snd_pcm_t *)0x24; 1928 1929 aio_output_->num_underruns = 3; // Something non-zero. 1930 sys_get_volume_return_value = fake_system_volume; 1931 rc = aio_output_->base.configure_dev(&aio_output_->base); 1932 ASSERT_EQ(0, rc); 1933 EXPECT_EQ(1, alsa_mixer_set_dBFS_called); 1934 EXPECT_EQ(fake_system_volume_dB, alsa_mixer_set_dBFS_value); 1935 1936 alsa_mixer_set_dBFS_called = 0; 1937 alsa_mixer_set_dBFS_value = 0; 1938 sys_get_volume_return_value = 50; 1939 sys_get_volume_called = 0; 1940 aio_output_->base.set_volume(&aio_output_->base); 1941 EXPECT_EQ(1, sys_get_volume_called); 1942 EXPECT_EQ(1, alsa_mixer_set_dBFS_called); 1943 EXPECT_EQ(-5000, alsa_mixer_set_dBFS_value); 1944 EXPECT_EQ(output_control_, alsa_mixer_set_dBFS_output); 1945 1946 alsa_mixer_set_dBFS_called = 0; 1947 alsa_mixer_set_dBFS_value = 0; 1948 sys_get_volume_return_value = 0; 1949 sys_get_volume_called = 0; 1950 aio_output_->base.set_volume(&aio_output_->base); 1951 EXPECT_EQ(1, sys_get_volume_called); 1952 EXPECT_EQ(1, alsa_mixer_set_dBFS_called); 1953 EXPECT_EQ(-10000, alsa_mixer_set_dBFS_value); 1954 1955 sys_get_volume_return_value = 80; 1956 aio_output_->base.active_node->volume = 90; 1957 aio_output_->base.set_volume(&aio_output_->base); 1958 EXPECT_EQ(-3000, alsa_mixer_set_dBFS_value); 1959 1960 // close the dev. 1961 rc = aio_output_->base.close_dev(&aio_output_->base); 1962 EXPECT_EQ(0, rc); 1963 EXPECT_EQ((void *)NULL, aio_output_->handle); 1964 1965 free(fmt); 1966 } 1967 1968 TEST_F(AlsaVolumeMuteSuite, SetMute) { 1969 int muted; 1970 1971 aio_output_->handle = (snd_pcm_t *)0x24; 1972 1973 // Test mute. 1974 ResetStubData(); 1975 muted = 1; 1976 1977 sys_get_mute_return_value = muted; 1978 1979 aio_output_->base.set_mute(&aio_output_->base); 1980 1981 EXPECT_EQ(1, sys_get_mute_called); 1982 EXPECT_EQ(1, alsa_mixer_set_mute_called); 1983 EXPECT_EQ(muted, alsa_mixer_set_mute_value); 1984 EXPECT_EQ(output_control_, alsa_mixer_set_mute_output); 1985 1986 // Test unmute. 1987 ResetStubData(); 1988 muted = 0; 1989 1990 sys_get_mute_return_value = muted; 1991 1992 aio_output_->base.set_mute(&aio_output_->base); 1993 1994 EXPECT_EQ(1, sys_get_mute_called); 1995 EXPECT_EQ(1, alsa_mixer_set_mute_called); 1996 EXPECT_EQ(muted, alsa_mixer_set_mute_value); 1997 EXPECT_EQ(output_control_, alsa_mixer_set_mute_output); 1998 } 1999 2000 // Test free run. 2001 class AlsaFreeRunTestSuite: public testing::Test { 2002 protected: 2003 virtual void SetUp() { 2004 ResetStubData(); 2005 memset(&aio, 0, sizeof(aio)); 2006 fmt_.format = SND_PCM_FORMAT_S16_LE; 2007 fmt_.frame_rate = 48000; 2008 fmt_.num_channels = 2; 2009 aio.base.frames_queued = frames_queued; 2010 aio.base.direction = CRAS_STREAM_OUTPUT; 2011 aio.base.format = &fmt_; 2012 aio.base.buffer_size = BUFFER_SIZE; 2013 aio.base.min_cb_level = 240; 2014 aio.base.min_buffer_level = 0; 2015 aio.filled_zeros_for_draining = 0; 2016 cras_alsa_mmap_begin_buffer = (uint8_t *)calloc( 2017 BUFFER_SIZE * 2 * 2, 2018 sizeof(*cras_alsa_mmap_begin_buffer)); 2019 memset(cras_alsa_mmap_begin_buffer, 0xff, 2020 sizeof(*cras_alsa_mmap_begin_buffer)); 2021 } 2022 2023 virtual void TearDown() { 2024 free(cras_alsa_mmap_begin_buffer); 2025 } 2026 2027 struct alsa_io aio; 2028 struct cras_audio_format fmt_; 2029 }; 2030 2031 TEST_F(AlsaFreeRunTestSuite, FillWholeBufferWithZeros) { 2032 int rc; 2033 int16_t *zeros; 2034 2035 2036 rc = fill_whole_buffer_with_zeros(&aio.base); 2037 2038 EXPECT_EQ(0, rc); 2039 zeros = (int16_t *)calloc(BUFFER_SIZE * 2, sizeof(*zeros)); 2040 EXPECT_EQ(0, memcmp(zeros, cras_alsa_mmap_begin_buffer, BUFFER_SIZE * 2 * 2)); 2041 2042 free(zeros); 2043 } 2044 2045 TEST_F(AlsaFreeRunTestSuite, EnterFreeRunAlreadyFreeRunning) { 2046 int rc; 2047 2048 // Device is in free run state, no need to fill zeros or fill whole buffer. 2049 aio.is_free_running = 1; 2050 2051 rc = no_stream(&aio.base, 1); 2052 2053 EXPECT_EQ(0, rc); 2054 EXPECT_EQ(0, cras_alsa_mmap_get_whole_buffer_called); 2055 EXPECT_EQ(0, cras_iodev_fill_odev_zeros_called); 2056 EXPECT_EQ(0, cras_iodev_fill_odev_zeros_frames); 2057 } 2058 2059 TEST_F(AlsaFreeRunTestSuite, EnterFreeRunNotDrainedYetNeedToFillZeros) { 2060 int rc, real_hw_level; 2061 struct timespec hw_tstamp; 2062 // Device is not in free run state. There are still valid samples to play. 2063 // The number of valid samples is less than min_cb_level * 2. 2064 // Need to fill zeros targeting min_cb_level * 2 = 480. 2065 // The number of zeros to be filled is 480 - 200 = 280. 2066 real_hw_level = 200; 2067 cras_alsa_get_avail_frames_avail = BUFFER_SIZE - real_hw_level; 2068 2069 rc = aio.base.frames_queued(&aio.base, &hw_tstamp); 2070 EXPECT_EQ(200, rc); 2071 2072 rc = no_stream(&aio.base, 1); 2073 2074 EXPECT_EQ(0, rc); 2075 EXPECT_EQ(0, cras_alsa_mmap_get_whole_buffer_called); 2076 EXPECT_EQ(1, cras_iodev_fill_odev_zeros_called); 2077 EXPECT_EQ(280, cras_iodev_fill_odev_zeros_frames); 2078 EXPECT_EQ(280, aio.filled_zeros_for_draining); 2079 EXPECT_EQ(0, aio.is_free_running); 2080 } 2081 2082 TEST_F(AlsaFreeRunTestSuite, EnterFreeRunNotDrainedYetNoNeedToFillZeros) { 2083 int rc, real_hw_level; 2084 2085 // Device is not in free run state. There are still valid samples to play. 2086 // The number of valid samples is more than min_cb_level * 2. 2087 // No need to fill zeros. 2088 real_hw_level = 500; 2089 cras_alsa_get_avail_frames_avail = BUFFER_SIZE - real_hw_level; 2090 2091 rc = no_stream(&aio.base, 1); 2092 2093 EXPECT_EQ(0, rc); 2094 EXPECT_EQ(0, cras_alsa_mmap_get_whole_buffer_called); 2095 EXPECT_EQ(0, cras_iodev_fill_odev_zeros_called); 2096 EXPECT_EQ(0, aio.is_free_running); 2097 } 2098 2099 TEST_F(AlsaFreeRunTestSuite, EnterFreeRunDrained) { 2100 int rc, real_hw_level; 2101 2102 // Device is not in free run state. There are still valid samples to play. 2103 // The number of valid samples is less than filled zeros. 2104 // Should enter free run state and fill whole buffer with zeros. 2105 real_hw_level = 40; 2106 cras_alsa_get_avail_frames_avail = BUFFER_SIZE - real_hw_level; 2107 aio.filled_zeros_for_draining = 100; 2108 2109 rc = no_stream(&aio.base, 1); 2110 2111 EXPECT_EQ(0, rc); 2112 EXPECT_EQ(1, cras_alsa_mmap_get_whole_buffer_called); 2113 EXPECT_EQ(0, cras_iodev_fill_odev_zeros_called); 2114 EXPECT_EQ(1, aio.is_free_running); 2115 } 2116 2117 TEST_F(AlsaFreeRunTestSuite, EnterFreeRunNoSamples) { 2118 int rc, real_hw_level; 2119 2120 // Device is not in free run state. There is no sample to play. 2121 // Should enter free run state and fill whole buffer with zeros. 2122 real_hw_level = 0; 2123 cras_alsa_get_avail_frames_avail = BUFFER_SIZE - real_hw_level; 2124 2125 rc = no_stream(&aio.base, 1); 2126 2127 EXPECT_EQ(0, rc); 2128 EXPECT_EQ(1, cras_alsa_mmap_get_whole_buffer_called); 2129 EXPECT_EQ(0, cras_iodev_fill_odev_zeros_called); 2130 EXPECT_EQ(1, aio.is_free_running); 2131 } 2132 2133 TEST_F(AlsaFreeRunTestSuite, OutputShouldWake) { 2134 2135 aio.is_free_running = 1; 2136 2137 EXPECT_EQ(0, output_should_wake(&aio.base)); 2138 2139 aio.is_free_running = 0; 2140 aio.base.state = CRAS_IODEV_STATE_NO_STREAM_RUN; 2141 EXPECT_EQ(1, output_should_wake(&aio.base)); 2142 2143 aio.base.state = CRAS_IODEV_STATE_NORMAL_RUN; 2144 EXPECT_EQ(1, output_should_wake(&aio.base)); 2145 2146 aio.base.state = CRAS_IODEV_STATE_OPEN; 2147 EXPECT_EQ(0, output_should_wake(&aio.base)); 2148 } 2149 2150 TEST_F(AlsaFreeRunTestSuite, LeaveFreeRunNotInFreeRunMoreRemain) { 2151 int rc, real_hw_level; 2152 2153 // Compare min_buffer_level + min_cb_level with valid samples left. 2154 // 240 + 512 < 900 - 100, so we will get 900 - 100 in appl_ptr_ahead. 2155 2156 aio.is_free_running = 0; 2157 aio.filled_zeros_for_draining = 100; 2158 aio.base.min_buffer_level = 512; 2159 real_hw_level = 900; 2160 cras_alsa_get_avail_frames_avail = BUFFER_SIZE - real_hw_level; 2161 2162 rc = no_stream(&aio.base, 0); 2163 2164 EXPECT_EQ(0, rc); 2165 EXPECT_EQ(1, cras_alsa_resume_appl_ptr_called); 2166 EXPECT_EQ(800, cras_alsa_resume_appl_ptr_ahead); 2167 EXPECT_EQ(0, cras_iodev_fill_odev_zeros_frames); 2168 EXPECT_EQ(0, aio.is_free_running); 2169 EXPECT_EQ(0, aio.filled_zeros_for_draining); 2170 } 2171 2172 TEST_F(AlsaFreeRunTestSuite, LeaveFreeRunNotInFreeRunLessRemain) { 2173 int rc, real_hw_level; 2174 2175 // Compare min_buffer_level + min_cb_level with valid samples left. 2176 // 240 + 256 > 400 - 500, so we will get 240 + 256 in appl_ptr_ahead. 2177 // And it will fill 240 + 256 - 400 = 96 zeros frames into device. 2178 2179 aio.is_free_running = 0; 2180 aio.filled_zeros_for_draining = 500; 2181 aio.base.min_buffer_level = 256; 2182 real_hw_level = 400; 2183 cras_alsa_get_avail_frames_avail = BUFFER_SIZE - real_hw_level; 2184 2185 rc = no_stream(&aio.base, 0); 2186 2187 EXPECT_EQ(0, rc); 2188 EXPECT_EQ(1, cras_alsa_resume_appl_ptr_called); 2189 EXPECT_EQ(aio.base.min_buffer_level + aio.base.min_cb_level, 2190 cras_alsa_resume_appl_ptr_ahead); 2191 EXPECT_EQ(96, cras_iodev_fill_odev_zeros_frames); 2192 EXPECT_EQ(0, aio.is_free_running); 2193 EXPECT_EQ(0, aio.filled_zeros_for_draining); 2194 } 2195 2196 TEST_F(AlsaFreeRunTestSuite, LeaveFreeRunInFreeRun) { 2197 int rc; 2198 2199 aio.is_free_running = 1; 2200 aio.filled_zeros_for_draining = 100; 2201 aio.base.min_buffer_level = 512; 2202 2203 rc = no_stream(&aio.base, 0); 2204 2205 EXPECT_EQ(0, rc); 2206 EXPECT_EQ(1, cras_alsa_resume_appl_ptr_called); 2207 EXPECT_EQ(aio.base.min_buffer_level + aio.base.min_cb_level, 2208 cras_alsa_resume_appl_ptr_ahead); 2209 EXPECT_EQ(0, aio.is_free_running); 2210 EXPECT_EQ(0, aio.filled_zeros_for_draining); 2211 } 2212 2213 // Reuse AlsaFreeRunTestSuite for output underrun handling because they are 2214 // similar. 2215 TEST_F(AlsaFreeRunTestSuite, OutputUnderrun) { 2216 int rc; 2217 int16_t *zeros; 2218 2219 aio.num_underruns = 0; 2220 2221 // Ask alsa_io to handle output underrun. 2222 rc = alsa_output_underrun(&aio.base); 2223 EXPECT_EQ(0, rc); 2224 EXPECT_EQ(1, aio.num_underruns); 2225 2226 // mmap buffer should be filled with zeros. 2227 zeros = (int16_t *)calloc(BUFFER_SIZE * 2, sizeof(*zeros)); 2228 EXPECT_EQ(0, memcmp(zeros, cras_alsa_mmap_begin_buffer, BUFFER_SIZE * 2 * 2)); 2229 2230 // appl_ptr should be moved to min_buffer_level + min_cb_level ahead of 2231 // hw_ptr. 2232 EXPECT_EQ(1, cras_alsa_resume_appl_ptr_called); 2233 EXPECT_EQ(aio.base.min_buffer_level + aio.base.min_cb_level, 2234 cras_alsa_resume_appl_ptr_ahead); 2235 2236 free(zeros); 2237 } 2238 2239 TEST(AlsaHotwordNode, HotwordTriggeredSendMessage) { 2240 struct cras_iodev *iodev; 2241 struct cras_audio_format format; 2242 struct alsa_input_node alsa_node; 2243 struct cras_ionode *node = &alsa_node.base; 2244 int rc; 2245 2246 ResetStubData(); 2247 iodev = alsa_iodev_create_with_default_parameters( 2248 0, NULL, ALSA_CARD_TYPE_INTERNAL, 0, fake_mixer, fake_config, NULL, 2249 CRAS_STREAM_INPUT); 2250 format.frame_rate = 16000; 2251 format.num_channels = 1; 2252 cras_iodev_set_format(iodev, &format); 2253 2254 memset(&alsa_node, 0, sizeof(alsa_node)); 2255 node->dev = iodev; 2256 strcpy(node->name, "Wake on Voice"); 2257 set_node_initial_state(node, ALSA_CARD_TYPE_INTERNAL); 2258 EXPECT_EQ(CRAS_NODE_TYPE_HOTWORD, node->type); 2259 2260 iodev->active_node = node; 2261 iodev->open_dev(iodev); 2262 rc = iodev->configure_dev(iodev); 2263 free(fake_format); 2264 ASSERT_EQ(0, rc); 2265 2266 ASSERT_NE(reinterpret_cast<thread_callback>(NULL), audio_thread_cb); 2267 audio_thread_cb(audio_thread_cb_data); 2268 EXPECT_EQ(1, hotword_send_triggered_msg_called); 2269 alsa_iodev_destroy(iodev); 2270 } 2271 2272 } // namespace 2273 2274 int main(int argc, char **argv) { 2275 ::testing::InitGoogleTest(&argc, argv); 2276 openlog(NULL, LOG_PERROR, LOG_USER); 2277 return RUN_ALL_TESTS(); 2278 } 2279 2280 // Stubs 2281 2282 extern "C" { 2283 2284 // From iodev. 2285 int cras_iodev_list_add_output(struct cras_iodev *output) 2286 { 2287 return 0; 2288 } 2289 int cras_iodev_list_rm_output(struct cras_iodev *dev) 2290 { 2291 return 0; 2292 } 2293 2294 int cras_iodev_list_add_input(struct cras_iodev *input) 2295 { 2296 return 0; 2297 } 2298 int cras_iodev_list_rm_input(struct cras_iodev *dev) 2299 { 2300 return 0; 2301 } 2302 2303 char *cras_iodev_list_get_hotword_models(cras_node_id_t node_id) 2304 { 2305 return NULL; 2306 } 2307 2308 int cras_iodev_list_set_hotword_model(cras_node_id_t node_id, 2309 const char *model_name) 2310 { 2311 return 0; 2312 } 2313 2314 int cras_iodev_list_suspend_hotword_streams() 2315 { 2316 return 0; 2317 } 2318 2319 int cras_iodev_list_resume_hotword_stream() 2320 { 2321 return 0; 2322 } 2323 2324 struct audio_thread *cras_iodev_list_get_audio_thread() 2325 { 2326 return NULL; 2327 } 2328 2329 // From alsa helper. 2330 int cras_alsa_set_channel_map(snd_pcm_t *handle, 2331 struct cras_audio_format *fmt) 2332 { 2333 return 0; 2334 } 2335 int cras_alsa_get_channel_map(snd_pcm_t *handle, 2336 struct cras_audio_format *fmt) 2337 { 2338 return 0; 2339 } 2340 int cras_alsa_pcm_open(snd_pcm_t **handle, const char *dev, 2341 snd_pcm_stream_t stream) 2342 { 2343 *handle = (snd_pcm_t *)0x24; 2344 cras_alsa_open_called++; 2345 return 0; 2346 } 2347 int cras_alsa_pcm_close(snd_pcm_t *handle) 2348 { 2349 return 0; 2350 } 2351 int cras_alsa_pcm_start(snd_pcm_t *handle) 2352 { 2353 cras_alsa_start_called++; 2354 return 0; 2355 } 2356 int cras_alsa_pcm_drain(snd_pcm_t *handle) 2357 { 2358 return 0; 2359 } 2360 int cras_alsa_fill_properties(snd_pcm_t *handle, 2361 size_t **rates, 2362 size_t **channel_counts, 2363 snd_pcm_format_t **formats) 2364 { 2365 *rates = (size_t *)malloc(sizeof(**rates) * 3); 2366 (*rates)[0] = 44100; 2367 (*rates)[1] = 48000; 2368 (*rates)[2] = 0; 2369 *channel_counts = (size_t *)malloc(sizeof(**channel_counts) * 2); 2370 (*channel_counts)[0] = 2; 2371 (*channel_counts)[1] = 0; 2372 *formats = (snd_pcm_format_t *)malloc(sizeof(**formats) * 2); 2373 (*formats)[0] = SND_PCM_FORMAT_S16_LE; 2374 (*formats)[1] = (snd_pcm_format_t)0; 2375 2376 cras_alsa_fill_properties_called++; 2377 return 0; 2378 } 2379 int cras_alsa_set_hwparams(snd_pcm_t *handle, struct cras_audio_format *format, 2380 snd_pcm_uframes_t *buffer_size, int period_wakeup, 2381 unsigned int dma_period_time) 2382 { 2383 return 0; 2384 } 2385 int cras_alsa_set_swparams(snd_pcm_t *handle, int *enable_htimestamp) 2386 { 2387 return 0; 2388 } 2389 int cras_alsa_get_avail_frames(snd_pcm_t *handle, snd_pcm_uframes_t buf_size, 2390 snd_pcm_uframes_t severe_underrun_frames, 2391 const char* dev_name, 2392 snd_pcm_uframes_t *used, 2393 struct timespec *tstamp) 2394 { 2395 *used = cras_alsa_get_avail_frames_avail; 2396 clock_gettime(CLOCK_MONOTONIC_RAW, tstamp); 2397 return cras_alsa_get_avail_frames_ret; 2398 } 2399 int cras_alsa_get_delay_frames(snd_pcm_t *handle, snd_pcm_uframes_t buf_size, 2400 snd_pcm_sframes_t *delay) 2401 { 2402 *delay = 0; 2403 return 0; 2404 } 2405 int cras_alsa_mmap_begin(snd_pcm_t *handle, unsigned int format_bytes, 2406 uint8_t **dst, snd_pcm_uframes_t *offset, 2407 snd_pcm_uframes_t *frames) 2408 { 2409 *dst = cras_alsa_mmap_begin_buffer; 2410 *frames = cras_alsa_mmap_begin_frames; 2411 return 0; 2412 } 2413 int cras_alsa_mmap_commit(snd_pcm_t *handle, snd_pcm_uframes_t offset, 2414 snd_pcm_uframes_t frames) 2415 { 2416 return 0; 2417 } 2418 int cras_alsa_attempt_resume(snd_pcm_t *handle) 2419 { 2420 cras_alsa_attempt_resume_called++; 2421 return 0; 2422 } 2423 2424 // ALSA stubs. 2425 int snd_pcm_format_physical_width(snd_pcm_format_t format) 2426 { 2427 return 16; 2428 } 2429 2430 snd_pcm_state_t snd_pcm_state(snd_pcm_t *handle) 2431 { 2432 return snd_pcm_state_ret; 2433 } 2434 2435 const char *snd_strerror(int errnum) 2436 { 2437 return "Alsa Error in UT"; 2438 } 2439 2440 struct mixer_control *cras_alsa_mixer_get_control_for_section( 2441 struct cras_alsa_mixer *cras_mixer, 2442 const struct ucm_section *section) 2443 { 2444 cras_alsa_mixer_get_control_for_section_called++; 2445 return cras_alsa_mixer_get_control_for_section_return_value; 2446 } 2447 2448 const char *cras_alsa_mixer_get_control_name( 2449 const struct mixer_control *control) 2450 { 2451 ControlNameMap::iterator it; 2452 cras_alsa_mixer_get_control_name_called++; 2453 it = cras_alsa_mixer_get_control_name_values.find(control); 2454 if (it == cras_alsa_mixer_get_control_name_values.end()) 2455 return ""; 2456 return it->second.c_str(); 2457 } 2458 2459 // From system_state. 2460 size_t cras_system_get_volume() 2461 { 2462 sys_get_volume_called++; 2463 return sys_get_volume_return_value; 2464 } 2465 2466 long cras_system_get_capture_gain() 2467 { 2468 sys_get_capture_gain_called++; 2469 return sys_get_capture_gain_return_value; 2470 } 2471 2472 int cras_system_get_mute() 2473 { 2474 sys_get_mute_called++; 2475 return sys_get_mute_return_value; 2476 } 2477 2478 int cras_system_get_capture_mute() 2479 { 2480 sys_get_capture_mute_called++; 2481 return sys_get_capture_mute_return_value; 2482 } 2483 2484 void cras_system_set_volume_limits(long min, long max) 2485 { 2486 sys_set_volume_limits_called++; 2487 } 2488 2489 void cras_system_set_capture_gain_limits(long min, long max) 2490 { 2491 cras_system_set_capture_gain_limits_set_value[0] = min; 2492 cras_system_set_capture_gain_limits_set_value[1] = max; 2493 sys_set_capture_gain_limits_called++; 2494 } 2495 2496 // From cras_alsa_mixer. 2497 void cras_alsa_mixer_set_dBFS(struct cras_alsa_mixer *m, 2498 long dB_level, 2499 struct mixer_control *output) 2500 { 2501 alsa_mixer_set_dBFS_called++; 2502 alsa_mixer_set_dBFS_value = dB_level; 2503 alsa_mixer_set_dBFS_output = output; 2504 } 2505 2506 void cras_alsa_mixer_set_mute(struct cras_alsa_mixer *cras_mixer, 2507 int muted, 2508 struct mixer_control *mixer_output) 2509 { 2510 alsa_mixer_set_mute_called++; 2511 alsa_mixer_set_mute_value = muted; 2512 alsa_mixer_set_mute_output = mixer_output; 2513 } 2514 2515 long cras_alsa_mixer_get_dB_range(struct cras_alsa_mixer *cras_mixer) 2516 { 2517 alsa_mixer_get_dB_range_called++; 2518 return alsa_mixer_get_dB_range_value; 2519 } 2520 2521 long cras_alsa_mixer_get_output_dB_range( 2522 struct mixer_control *mixer_output) 2523 { 2524 alsa_mixer_get_output_dB_range_called++; 2525 return alsa_mixer_get_output_dB_range_value; 2526 } 2527 2528 void cras_alsa_mixer_set_capture_dBFS(struct cras_alsa_mixer *m, long dB_level, 2529 struct mixer_control *mixer_input) 2530 { 2531 alsa_mixer_set_capture_dBFS_called++; 2532 alsa_mixer_set_capture_dBFS_value = dB_level; 2533 alsa_mixer_set_capture_dBFS_input = mixer_input; 2534 } 2535 2536 void cras_alsa_mixer_set_capture_mute(struct cras_alsa_mixer *m, int mute, 2537 struct mixer_control *mixer_input) 2538 { 2539 alsa_mixer_set_capture_mute_called++; 2540 alsa_mixer_set_capture_mute_value = mute; 2541 alsa_mixer_set_capture_mute_input = mixer_input; 2542 } 2543 2544 void cras_alsa_mixer_list_outputs(struct cras_alsa_mixer *cras_mixer, 2545 cras_alsa_mixer_control_callback cb, 2546 void *callback_arg) 2547 { 2548 cras_alsa_mixer_list_outputs_called++; 2549 for (size_t i = 0; i < cras_alsa_mixer_list_outputs_outputs_length; i++) { 2550 cb(cras_alsa_mixer_list_outputs_outputs[i], callback_arg); 2551 } 2552 } 2553 2554 void cras_alsa_mixer_list_inputs(struct cras_alsa_mixer *cras_mixer, 2555 cras_alsa_mixer_control_callback cb, 2556 void *callback_arg) 2557 { 2558 cras_alsa_mixer_list_inputs_called++; 2559 for (size_t i = 0; i < cras_alsa_mixer_list_inputs_outputs_length; i++) { 2560 cb(cras_alsa_mixer_list_inputs_outputs[i], callback_arg); 2561 } 2562 } 2563 2564 int cras_alsa_mixer_set_output_active_state( 2565 struct mixer_control *output, 2566 int active) 2567 { 2568 cras_alsa_mixer_set_output_active_state_called++; 2569 cras_alsa_mixer_set_output_active_state_outputs.push_back(output); 2570 cras_alsa_mixer_set_output_active_state_values.push_back(active); 2571 return 0; 2572 } 2573 2574 void cras_volume_curve_destroy(struct cras_volume_curve *curve) 2575 { 2576 } 2577 2578 long cras_alsa_mixer_get_minimum_capture_gain(struct cras_alsa_mixer *cmix, 2579 struct mixer_control *mixer_input) 2580 { 2581 cras_alsa_mixer_get_minimum_capture_gain_called++; 2582 cras_alsa_mixer_get_minimum_capture_gain_mixer_input = mixer_input; 2583 return cras_alsa_mixer_get_minimum_capture_gain_ret_value; 2584 } 2585 2586 long cras_alsa_mixer_get_maximum_capture_gain(struct cras_alsa_mixer *cmix, 2587 struct mixer_control *mixer_input) 2588 { 2589 cras_alsa_mixer_get_maximum_capture_gain_called++; 2590 cras_alsa_mixer_get_maximum_capture_gain_mixer_input = mixer_input; 2591 return cras_alsa_mixer_get_maximum_capture_gain_ret_value; 2592 } 2593 2594 int cras_alsa_mixer_has_main_volume(const struct cras_alsa_mixer *cras_mixer) 2595 { 2596 return 1; 2597 } 2598 2599 int cras_alsa_mixer_has_volume(const struct mixer_control *mixer_control) 2600 { 2601 return 1; 2602 } 2603 2604 // From cras_alsa_jack 2605 struct cras_alsa_jack_list *cras_alsa_jack_list_create( 2606 unsigned int card_index, 2607 const char *card_name, 2608 unsigned int device_index, 2609 int check_gpio_jack, 2610 struct cras_alsa_mixer *mixer, 2611 struct cras_use_case_mgr *ucm, 2612 snd_hctl_t *hctl, 2613 enum CRAS_STREAM_DIRECTION direction, 2614 jack_state_change_callback *cb, 2615 void *cb_data) 2616 { 2617 cras_alsa_jack_list_create_called++; 2618 cras_alsa_jack_list_create_cb = cb; 2619 cras_alsa_jack_list_create_cb_data = cb_data; 2620 return (struct cras_alsa_jack_list *)0xfee; 2621 } 2622 2623 int cras_alsa_jack_list_find_jacks_by_name_matching( 2624 struct cras_alsa_jack_list *jack_list) 2625 { 2626 cras_alsa_jack_list_find_jacks_by_name_matching_called++; 2627 return 0; 2628 } 2629 2630 int cras_alsa_jack_list_add_jack_for_section( 2631 struct cras_alsa_jack_list *jack_list, 2632 struct ucm_section *ucm_section, 2633 struct cras_alsa_jack **result_jack) 2634 { 2635 cras_alsa_jack_list_add_jack_for_section_called++; 2636 if (result_jack) 2637 *result_jack = cras_alsa_jack_list_add_jack_for_section_result_jack; 2638 return 0; 2639 } 2640 2641 void cras_alsa_jack_list_destroy(struct cras_alsa_jack_list *jack_list) 2642 { 2643 cras_alsa_jack_list_destroy_called++; 2644 } 2645 2646 int cras_alsa_jack_list_has_hctl_jacks(struct cras_alsa_jack_list *jack_list) 2647 { 2648 return cras_alsa_jack_list_has_hctl_jacks_return_val; 2649 } 2650 2651 void cras_alsa_jack_list_report(const struct cras_alsa_jack_list *jack_list) 2652 { 2653 } 2654 2655 void cras_alsa_jack_enable_ucm(const struct cras_alsa_jack *jack, int enable) { 2656 cras_alsa_jack_enable_ucm_called++; 2657 } 2658 2659 const char *cras_alsa_jack_get_name(const struct cras_alsa_jack *jack) 2660 { 2661 cras_alsa_jack_get_name_called++; 2662 return cras_alsa_jack_get_name_ret_value; 2663 } 2664 2665 const char *cras_alsa_jack_get_dsp_name(const struct cras_alsa_jack *jack) 2666 { 2667 cras_alsa_jack_get_dsp_name_called++; 2668 return jack ? cras_alsa_jack_get_dsp_name_value : NULL; 2669 } 2670 2671 const char *ucm_get_dsp_name_default(struct cras_use_case_mgr *mgr, 2672 int direction) 2673 { 2674 ucm_get_dsp_name_default_called++; 2675 if (ucm_get_dsp_name_default_value) 2676 return strdup(ucm_get_dsp_name_default_value); 2677 else 2678 return NULL; 2679 } 2680 2681 struct mixer_control *cras_alsa_jack_get_mixer_output( 2682 const struct cras_alsa_jack *jack) 2683 { 2684 return cras_alsa_jack_get_mixer_output_ret; 2685 } 2686 2687 struct mixer_control *cras_alsa_jack_get_mixer_input( 2688 const struct cras_alsa_jack *jack) 2689 { 2690 return cras_alsa_jack_get_mixer_input_ret; 2691 } 2692 2693 int ucm_set_enabled( 2694 struct cras_use_case_mgr *mgr, const char *dev, int enabled) { 2695 ucm_set_enabled_called++; 2696 return 0; 2697 } 2698 2699 char *ucm_get_flag(struct cras_use_case_mgr *mgr, const char *flag_name) { 2700 if ((!strcmp(flag_name, "AutoUnplugInputNode") && 2701 auto_unplug_input_node_ret) || 2702 (!strcmp(flag_name, "AutoUnplugOutputNode") && 2703 auto_unplug_output_node_ret)) { 2704 char *ret = (char *)malloc(8); 2705 snprintf(ret, 8, "%s", "1"); 2706 return ret; 2707 } 2708 2709 return NULL; 2710 } 2711 2712 char *ucm_get_mic_positions(struct cras_use_case_mgr *mgr) { 2713 return NULL; 2714 } 2715 2716 int ucm_swap_mode_exists(struct cras_use_case_mgr *mgr) 2717 { 2718 return ucm_swap_mode_exists_ret_value; 2719 } 2720 2721 int ucm_enable_swap_mode(struct cras_use_case_mgr *mgr, const char *node_name, 2722 int enable) 2723 { 2724 ucm_enable_swap_mode_called++; 2725 return ucm_enable_swap_mode_ret_value; 2726 } 2727 2728 int ucm_get_min_buffer_level(struct cras_use_case_mgr *mgr, 2729 unsigned int *level) 2730 { 2731 *level = 0; 2732 return 0; 2733 } 2734 2735 unsigned int ucm_get_enable_htimestamp_flag(struct cras_use_case_mgr *mgr) 2736 { 2737 return ucm_get_enable_htimestamp_flag_ret; 2738 } 2739 2740 unsigned int ucm_get_disable_software_volume(struct cras_use_case_mgr *mgr) 2741 { 2742 return 0; 2743 } 2744 2745 int ucm_get_min_software_gain(struct cras_use_case_mgr *mgr, const char *dev, 2746 long *gain) 2747 { 2748 ucm_get_min_software_gain_called++; 2749 *gain = ucm_get_min_software_gain_value; 2750 return ucm_get_min_software_gain_ret_value; 2751 } 2752 2753 int ucm_get_max_software_gain(struct cras_use_case_mgr *mgr, const char *dev, 2754 long *gain) 2755 { 2756 ucm_get_max_software_gain_called++; 2757 *gain = ucm_get_max_software_gain_value; 2758 return ucm_get_max_software_gain_ret_value; 2759 } 2760 2761 char *ucm_get_hotword_models(struct cras_use_case_mgr *mgr) 2762 { 2763 return NULL; 2764 } 2765 2766 int ucm_set_hotword_model(struct cras_use_case_mgr *mgr, const char *model) 2767 { 2768 return 0; 2769 } 2770 2771 unsigned int ucm_get_dma_period_for_dev(struct cras_use_case_mgr *mgr, 2772 const char *dev) 2773 { 2774 ucm_get_dma_period_for_dev_called++; 2775 return ucm_get_dma_period_for_dev_ret; 2776 } 2777 2778 int ucm_get_sample_rate_for_dev(struct cras_use_case_mgr *mgr, const char *dev, 2779 enum CRAS_STREAM_DIRECTION direction) 2780 { 2781 return -EINVAL; 2782 } 2783 2784 int ucm_get_capture_chmap_for_dev(struct cras_use_case_mgr *mgr, 2785 const char *dev, 2786 int8_t *channel_layout) 2787 { 2788 return -EINVAL; 2789 } 2790 2791 int ucm_get_preempt_hotword(struct cras_use_case_mgr *mgr, const char *dev) 2792 { 2793 return 0; 2794 } 2795 2796 struct cras_volume_curve *cras_volume_curve_create_default() 2797 { 2798 return &default_curve; 2799 } 2800 2801 struct cras_volume_curve *cras_card_config_get_volume_curve_for_control( 2802 const struct cras_card_config *card_config, 2803 const char *control_name) 2804 { 2805 VolCurveMap::iterator it; 2806 cras_card_config_get_volume_curve_for_control_called++; 2807 if (!control_name) 2808 return NULL; 2809 it = cras_card_config_get_volume_curve_vals.find(control_name); 2810 if (it == cras_card_config_get_volume_curve_vals.end()) 2811 return NULL; 2812 return it->second; 2813 } 2814 2815 void cras_iodev_free_format(struct cras_iodev *iodev) 2816 { 2817 } 2818 2819 int cras_iodev_set_format(struct cras_iodev *iodev, 2820 const struct cras_audio_format *fmt) 2821 { 2822 fake_format = (struct cras_audio_format *)calloc( 2823 1, 2824 sizeof(cras_audio_format)); 2825 // Copy the content of format from fmt into format of iodev. 2826 memcpy(fake_format, fmt, sizeof(cras_audio_format)); 2827 iodev->format = fake_format; 2828 return 0; 2829 } 2830 2831 struct audio_thread *audio_thread_create() { 2832 return reinterpret_cast<audio_thread*>(0x323); 2833 } 2834 2835 void audio_thread_destroy(audio_thread* thread) { 2836 } 2837 2838 2839 2840 void cras_iodev_update_dsp(struct cras_iodev *iodev) 2841 { 2842 cras_iodev_update_dsp_called++; 2843 cras_iodev_update_dsp_name = iodev->dsp_name; 2844 } 2845 2846 int cras_iodev_set_node_attr(struct cras_ionode *ionode, 2847 enum ionode_attr attr, int value) 2848 { 2849 cras_iodev_set_node_attr_called++; 2850 cras_iodev_set_node_attr_ionode = ionode; 2851 cras_iodev_set_node_attr_attr = attr; 2852 cras_iodev_set_node_attr_value = value; 2853 if (ionode && (attr == IONODE_ATTR_PLUGGED)) 2854 ionode->plugged = value; 2855 return 0; 2856 } 2857 2858 void cras_iodev_add_node(struct cras_iodev *iodev, struct cras_ionode *node) 2859 { 2860 cras_iodev_add_node_called++; 2861 DL_APPEND(iodev->nodes, node); 2862 } 2863 2864 void cras_iodev_rm_node(struct cras_iodev *iodev, struct cras_ionode *node) 2865 { 2866 DL_DELETE(iodev->nodes, node); 2867 } 2868 2869 void cras_iodev_set_active_node(struct cras_iodev *iodev, 2870 struct cras_ionode *node) 2871 { 2872 iodev->active_node = node; 2873 } 2874 2875 void cras_iodev_free_resources(struct cras_iodev *iodev) 2876 { 2877 cras_iodev_free_resources_called++; 2878 } 2879 2880 void cras_alsa_jack_update_monitor_name(const struct cras_alsa_jack *jack, 2881 char *name_buf, 2882 unsigned int buf_size) 2883 { 2884 if (cras_alsa_jack_update_monitor_fake_name) 2885 strcpy(name_buf, cras_alsa_jack_update_monitor_fake_name); 2886 } 2887 2888 void cras_alsa_jack_update_node_type(const struct cras_alsa_jack *jack, 2889 enum CRAS_NODE_TYPE *type) 2890 { 2891 cras_alsa_jack_update_node_type_called++; 2892 } 2893 2894 const char *cras_alsa_jack_get_ucm_device(const struct cras_alsa_jack *jack) 2895 { 2896 return NULL; 2897 } 2898 2899 int ucm_get_default_node_gain(struct cras_use_case_mgr *mgr, const char *dev, 2900 long *gain) 2901 { 2902 if (ucm_get_default_node_gain_values.find(dev) == 2903 ucm_get_default_node_gain_values.end()) 2904 return 1; 2905 2906 *gain = ucm_get_default_node_gain_values[dev]; 2907 return 0; 2908 } 2909 2910 void cras_iodev_init_audio_area(struct cras_iodev *iodev, 2911 int num_channels) { 2912 } 2913 2914 void cras_iodev_free_audio_area(struct cras_iodev *iodev) { 2915 } 2916 2917 int cras_iodev_reset_rate_estimator(const struct cras_iodev *iodev) 2918 { 2919 return 0; 2920 } 2921 2922 int cras_iodev_frames_queued(struct cras_iodev *iodev, struct timespec *tstamp) 2923 { 2924 clock_gettime(CLOCK_MONOTONIC_RAW, tstamp); 2925 return cras_iodev_frames_queued_ret; 2926 } 2927 2928 int cras_iodev_buffer_avail(struct cras_iodev *iodev, unsigned hw_level) 2929 { 2930 return cras_iodev_buffer_avail_ret; 2931 } 2932 2933 int cras_iodev_fill_odev_zeros(struct cras_iodev *odev, unsigned int frames) 2934 { 2935 cras_iodev_fill_odev_zeros_called++; 2936 cras_iodev_fill_odev_zeros_frames = frames; 2937 return 0; 2938 } 2939 2940 void cras_audio_area_config_buf_pointers(struct cras_audio_area *area, 2941 const struct cras_audio_format *fmt, 2942 uint8_t *base_buffer) 2943 { 2944 } 2945 2946 void audio_thread_add_callback(int fd, thread_callback cb, void *data) 2947 { 2948 audio_thread_cb = cb; 2949 audio_thread_cb_data = data; 2950 } 2951 2952 void audio_thread_rm_callback(int fd) 2953 { 2954 } 2955 2956 int audio_thread_rm_callback_sync(struct audio_thread *thread, int fd) { 2957 return 0; 2958 } 2959 2960 int cras_hotword_send_triggered_msg() 2961 { 2962 hotword_send_triggered_msg_called++; 2963 return 0; 2964 } 2965 2966 int snd_pcm_poll_descriptors_count(snd_pcm_t *pcm) 2967 { 2968 return 1; 2969 } 2970 2971 int snd_pcm_poll_descriptors(snd_pcm_t *pcm, struct pollfd *pfds, 2972 unsigned int space) 2973 { 2974 if (space >= 1) { 2975 pfds[0].events = POLLIN; 2976 pfds[0].fd = 99; 2977 } 2978 return 0; 2979 } 2980 2981 int is_utf8_string(const char* string) 2982 { 2983 return is_utf8_string_ret_value; 2984 } 2985 2986 int cras_alsa_mmap_get_whole_buffer(snd_pcm_t *handle, uint8_t **dst) 2987 { 2988 snd_pcm_uframes_t offset, frames; 2989 2990 cras_alsa_mmap_get_whole_buffer_called++; 2991 return cras_alsa_mmap_begin(handle, 0, dst, &offset, &frames); 2992 } 2993 2994 int cras_alsa_resume_appl_ptr(snd_pcm_t *handle, snd_pcm_uframes_t ahead) 2995 { 2996 cras_alsa_resume_appl_ptr_called++; 2997 cras_alsa_resume_appl_ptr_ahead = ahead; 2998 return 0; 2999 } 3000 3001 int cras_iodev_default_no_stream_playback(struct cras_iodev *odev, int enable) 3002 { 3003 return 0; 3004 } 3005 3006 enum CRAS_IODEV_STATE cras_iodev_state(const struct cras_iodev *iodev) 3007 { 3008 return iodev->state; 3009 } 3010 3011 int cras_iodev_dsp_set_swap_mode_for_node(struct cras_iodev *iodev, 3012 struct cras_ionode *node, 3013 int enable) 3014 { 3015 cras_iodev_dsp_set_swap_mode_for_node_called++; 3016 return 0; 3017 } 3018 3019 struct cras_ramp* cras_ramp_create() { 3020 return (struct cras_ramp*)0x1; 3021 } 3022 3023 } 3024
