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