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
ResetStubData()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
fake_get_dBFS(const struct cras_volume_curve * curve,size_t volume)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
alsa_iodev_create_with_default_parameters(size_t card_index,const char * dev_id,enum CRAS_ALSA_CARD_TYPE card_type,int is_first,struct cras_alsa_mixer * mixer,struct cras_card_config * config,struct cras_use_case_mgr * ucm,enum CRAS_STREAM_DIRECTION direction)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
TEST(AlsaIoInit,InitializeInvalidDirection)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
TEST(AlsaIoInit,InitializePlayback)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
TEST(AlsaIoInit,DefaultNodeInternalCard)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
TEST(AlsaIoInit,DefaultNodeUSBCard)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
TEST(AlsaIoInit,OpenPlayback)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
TEST(AlsaIoInit,UsbCardAutoPlug)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
TEST(AlsaIoInit,UsbCardUseSoftwareVolume)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
TEST(AlsaIoInit,UseSoftwareGain)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
TEST(AlsaIoInit,SoftwareGainWithDefaultNodeGain)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
TEST(AlsaIoInit,RouteBasedOnJackCallback)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
TEST(AlsaIoInit,RouteBasedOnInputJackCallback)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
TEST(AlsaIoInit,InitializeCapture)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
TEST(AlsaIoInit,OpenCapture)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
TEST(AlsaIoInit,OpenCaptureSetCaptureGainWithDefaultNodeGain)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
TEST(AlsaIoInit,OpenCaptureSetCaptureGainWithSoftwareGain)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
TEST(AlsaIoInit,UpdateActiveNode)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
TEST(AlsaIoInit,StartDevice)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
TEST(AlsaIoInit,ResumeDevice)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
TEST(AlsaIoInit,DspNameDefault)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
TEST(AlsaIoInit,DspNameJackOverride)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
TEST(AlsaIoInit,NodeTypeOverride)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
TEST(AlsaIoInit,SwapMode)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.
TEST(AlsaOutputNode,SystemSettingsWhenInactive)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.
TEST(AlsaOutputNode,TwoOutputs)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
TEST(AlsaOutputNode,TwoJacksHeadphoneLineout)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
TEST(AlsaOutputNode,OutputsFromUCM)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
TEST(AlsaOutputNode,OutputNoControlsUCM)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
TEST(AlsaOutputNode,OutputFromJackUCM)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
TEST(AlsaOutputNode,InputsFromUCM)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
TEST(AlsaOutputNode,InputNoControlsUCM)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
TEST(AlsaOutputNode,InputFromJackUCM)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
TEST(AlsaOutputNode,AutoUnplugOutputNode)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
TEST(AlsaOutputNode,AutoUnplugInputNode)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
TEST(AlsaInitNode,SetNodeInitialState)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
TEST(AlsaInitNode,SetNodeInitialStateDropInvalidUTF8NodeName)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
TEST(AlsaIoInit,HDMIJackUpdateInvalidUTF8MonitorName)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:
SetUp()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
TearDown()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
TEST_F(AlsaVolumeMuteSuite,GetDefaultVolumeCurve)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
TEST_F(AlsaVolumeMuteSuite,GetVolumeCurveFromNode)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
TEST_F(AlsaVolumeMuteSuite,SetVolume)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
TEST_F(AlsaVolumeMuteSuite,SetMute)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:
SetUp()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
TearDown()1927 virtual void TearDown() {
1928 }
1929
1930 struct alsa_io aio;
1931 struct cras_audio_format fmt_;
1932 };
1933
TEST_F(AlsaFreeRunTestSuite,FillWholeBufferWithZeros)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
TEST_F(AlsaFreeRunTestSuite,EnterFreeRunAlreadyFreeRunning)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
TEST_F(AlsaFreeRunTestSuite,EnterFreeRunNotDrainedYetNeedToFillZeros)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
TEST_F(AlsaFreeRunTestSuite,EnterFreeRunNotDrainedYetNoNeedToFillZeros)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
TEST_F(AlsaFreeRunTestSuite,EnterFreeRunDrained)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
TEST_F(AlsaFreeRunTestSuite,EnterFreeRunNoSamples)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
TEST_F(AlsaFreeRunTestSuite,OutputShouldWake)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
TEST_F(AlsaFreeRunTestSuite,LeaveFreeRunNotInFreeRun)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
TEST_F(AlsaFreeRunTestSuite,LeaveFreeRunInFreeRun)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.
TEST_F(AlsaFreeRunTestSuite,OutputUnderrun)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
main(int argc,char ** argv)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.
cras_iodev_list_add_output(struct cras_iodev * output)2126 int cras_iodev_list_add_output(struct cras_iodev *output)
2127 {
2128 return 0;
2129 }
cras_iodev_list_rm_output(struct cras_iodev * dev)2130 int cras_iodev_list_rm_output(struct cras_iodev *dev)
2131 {
2132 return 0;
2133 }
2134
cras_iodev_list_add_input(struct cras_iodev * input)2135 int cras_iodev_list_add_input(struct cras_iodev *input)
2136 {
2137 return 0;
2138 }
cras_iodev_list_rm_input(struct cras_iodev * dev)2139 int cras_iodev_list_rm_input(struct cras_iodev *dev)
2140 {
2141 return 0;
2142 }
2143
cras_iodev_list_get_hotword_models(cras_node_id_t node_id)2144 char *cras_iodev_list_get_hotword_models(cras_node_id_t node_id)
2145 {
2146 return NULL;
2147 }
2148
cras_iodev_list_set_hotword_model(cras_node_id_t node_id,const char * model_name)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
cras_iodev_list_get_audio_thread()2155 struct audio_thread *cras_iodev_list_get_audio_thread()
2156 {
2157 return NULL;
2158 }
2159
2160 // From alsa helper.
cras_alsa_set_channel_map(snd_pcm_t * handle,struct cras_audio_format * fmt)2161 int cras_alsa_set_channel_map(snd_pcm_t *handle,
2162 struct cras_audio_format *fmt)
2163 {
2164 return 0;
2165 }
cras_alsa_get_channel_map(snd_pcm_t * handle,struct cras_audio_format * fmt)2166 int cras_alsa_get_channel_map(snd_pcm_t *handle,
2167 struct cras_audio_format *fmt)
2168 {
2169 return 0;
2170 }
cras_alsa_pcm_open(snd_pcm_t ** handle,const char * dev,snd_pcm_stream_t stream)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 }
cras_alsa_pcm_close(snd_pcm_t * handle)2178 int cras_alsa_pcm_close(snd_pcm_t *handle)
2179 {
2180 return 0;
2181 }
cras_alsa_pcm_start(snd_pcm_t * handle)2182 int cras_alsa_pcm_start(snd_pcm_t *handle)
2183 {
2184 cras_alsa_start_called++;
2185 return 0;
2186 }
cras_alsa_pcm_drain(snd_pcm_t * handle)2187 int cras_alsa_pcm_drain(snd_pcm_t *handle)
2188 {
2189 return 0;
2190 }
cras_alsa_fill_properties(const char * dev,snd_pcm_stream_t stream,size_t ** rates,size_t ** channel_counts,snd_pcm_format_t ** formats)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 }
cras_alsa_set_hwparams(snd_pcm_t * handle,struct cras_audio_format * format,snd_pcm_uframes_t * buffer_size,int period_wakeup,unsigned int dma_period_time)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 }
cras_alsa_set_swparams(snd_pcm_t * handle,int * enable_htimestamp)2217 int cras_alsa_set_swparams(snd_pcm_t *handle, int *enable_htimestamp)
2218 {
2219 return 0;
2220 }
cras_alsa_get_avail_frames(snd_pcm_t * handle,snd_pcm_uframes_t buf_size,snd_pcm_uframes_t severe_underrun_frames,const char * dev_name,snd_pcm_uframes_t * used,struct timespec * tstamp,unsigned int * num_underruns)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 }
cras_alsa_get_delay_frames(snd_pcm_t * handle,snd_pcm_uframes_t buf_size,snd_pcm_sframes_t * delay)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 }
cras_alsa_mmap_begin(snd_pcm_t * handle,unsigned int format_bytes,uint8_t ** dst,snd_pcm_uframes_t * offset,snd_pcm_uframes_t * frames,unsigned int * underruns)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 }
cras_alsa_mmap_commit(snd_pcm_t * handle,snd_pcm_uframes_t offset,snd_pcm_uframes_t frames,unsigned int * underruns)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 }
cras_alsa_attempt_resume(snd_pcm_t * handle)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.
snd_pcm_format_physical_width(snd_pcm_format_t format)2258 int snd_pcm_format_physical_width(snd_pcm_format_t format)
2259 {
2260 return 16;
2261 }
2262
snd_pcm_state(snd_pcm_t * handle)2263 snd_pcm_state_t snd_pcm_state(snd_pcm_t *handle)
2264 {
2265 return snd_pcm_state_ret;
2266 }
2267
snd_strerror(int errnum)2268 const char *snd_strerror(int errnum)
2269 {
2270 return "Alsa Error in UT";
2271 }
2272
cras_alsa_mixer_get_control_for_section(struct cras_alsa_mixer * cras_mixer,const struct ucm_section * section)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
cras_alsa_mixer_get_control_name(const struct mixer_control * control)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.
cras_system_get_volume()2293 size_t cras_system_get_volume()
2294 {
2295 sys_get_volume_called++;
2296 return sys_get_volume_return_value;
2297 }
2298
cras_system_get_capture_gain()2299 long cras_system_get_capture_gain()
2300 {
2301 sys_get_capture_gain_called++;
2302 return sys_get_capture_gain_return_value;
2303 }
2304
cras_system_get_mute()2305 int cras_system_get_mute()
2306 {
2307 sys_get_mute_called++;
2308 return sys_get_mute_return_value;
2309 }
2310
cras_system_get_capture_mute()2311 int cras_system_get_capture_mute()
2312 {
2313 sys_get_capture_mute_called++;
2314 return sys_get_capture_mute_return_value;
2315 }
2316
cras_system_set_volume_limits(long min,long max)2317 void cras_system_set_volume_limits(long min, long max)
2318 {
2319 sys_set_volume_limits_called++;
2320 }
2321
cras_system_set_capture_gain_limits(long min,long max)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.
cras_alsa_mixer_set_dBFS(struct cras_alsa_mixer * m,long dB_level,struct mixer_control * output)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
cras_alsa_mixer_set_mute(struct cras_alsa_mixer * cras_mixer,int muted,struct mixer_control * mixer_output)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
cras_alsa_mixer_get_dB_range(struct cras_alsa_mixer * cras_mixer)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
cras_alsa_mixer_get_output_dB_range(struct mixer_control * mixer_output)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
cras_alsa_mixer_set_capture_dBFS(struct cras_alsa_mixer * m,long dB_level,struct mixer_control * mixer_input)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
cras_alsa_mixer_set_capture_mute(struct cras_alsa_mixer * m,int mute,struct mixer_control * mixer_input)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
cras_alsa_mixer_list_outputs(struct cras_alsa_mixer * cras_mixer,cras_alsa_mixer_control_callback cb,void * callback_arg)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
cras_alsa_mixer_list_inputs(struct cras_alsa_mixer * cras_mixer,cras_alsa_mixer_control_callback cb,void * callback_arg)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
cras_alsa_mixer_set_output_active_state(struct mixer_control * output,int active)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
cras_volume_curve_destroy(struct cras_volume_curve * curve)2407 void cras_volume_curve_destroy(struct cras_volume_curve *curve)
2408 {
2409 }
2410
cras_alsa_mixer_get_minimum_capture_gain(struct cras_alsa_mixer * cmix,struct mixer_control * mixer_input)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
cras_alsa_mixer_get_maximum_capture_gain(struct cras_alsa_mixer * cmix,struct mixer_control * mixer_input)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
cras_alsa_mixer_has_main_volume(const struct cras_alsa_mixer * cras_mixer)2427 int cras_alsa_mixer_has_main_volume(const struct cras_alsa_mixer *cras_mixer)
2428 {
2429 return 1;
2430 }
2431
cras_alsa_mixer_has_volume(const struct mixer_control * mixer_control)2432 int cras_alsa_mixer_has_volume(const struct mixer_control *mixer_control)
2433 {
2434 return 1;
2435 }
2436
2437 // From cras_alsa_jack
cras_alsa_jack_list_create(unsigned int card_index,const char * card_name,unsigned int device_index,int check_gpio_jack,struct cras_alsa_mixer * mixer,struct cras_use_case_mgr * ucm,snd_hctl_t * hctl,enum CRAS_STREAM_DIRECTION direction,jack_state_change_callback * cb,void * cb_data)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
cras_alsa_jack_list_find_jacks_by_name_matching(struct cras_alsa_jack_list * jack_list)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
cras_alsa_jack_list_add_jack_for_section(struct cras_alsa_jack_list * jack_list,struct ucm_section * ucm_section,struct cras_alsa_jack ** result_jack)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
cras_alsa_jack_list_destroy(struct cras_alsa_jack_list * jack_list)2474 void cras_alsa_jack_list_destroy(struct cras_alsa_jack_list *jack_list)
2475 {
2476 cras_alsa_jack_list_destroy_called++;
2477 }
2478
cras_alsa_jack_list_has_hctl_jacks(struct cras_alsa_jack_list * jack_list)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
cras_alsa_jack_list_report(const struct cras_alsa_jack_list * jack_list)2484 void cras_alsa_jack_list_report(const struct cras_alsa_jack_list *jack_list)
2485 {
2486 }
2487
cras_alsa_jack_enable_ucm(const struct cras_alsa_jack * jack,int enable)2488 void cras_alsa_jack_enable_ucm(const struct cras_alsa_jack *jack, int enable) {
2489 cras_alsa_jack_enable_ucm_called++;
2490 }
2491
cras_alsa_jack_get_name(const struct cras_alsa_jack * jack)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
cras_alsa_jack_get_dsp_name(const struct cras_alsa_jack * jack)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
ucm_get_dsp_name_default(struct cras_use_case_mgr * mgr,int direction)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
cras_alsa_jack_get_mixer_output(const struct cras_alsa_jack * jack)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
cras_alsa_jack_get_mixer_input(const struct cras_alsa_jack * jack)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
ucm_set_enabled(struct cras_use_case_mgr * mgr,const char * dev,int enabled)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
ucm_get_flag(struct cras_use_case_mgr * mgr,const char * flag_name)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
ucm_get_mic_positions(struct cras_use_case_mgr * mgr)2545 char *ucm_get_mic_positions(struct cras_use_case_mgr *mgr) {
2546 return NULL;
2547 }
2548
ucm_swap_mode_exists(struct cras_use_case_mgr * mgr)2549 int ucm_swap_mode_exists(struct cras_use_case_mgr *mgr)
2550 {
2551 return ucm_swap_mode_exists_ret_value;
2552 }
2553
ucm_enable_swap_mode(struct cras_use_case_mgr * mgr,const char * node_name,int enable)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
ucm_get_min_buffer_level(struct cras_use_case_mgr * mgr)2561 unsigned int ucm_get_min_buffer_level(struct cras_use_case_mgr *mgr)
2562 {
2563 return 0;
2564 }
2565
ucm_get_enable_htimestamp_flag(struct cras_use_case_mgr * mgr)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
ucm_get_disable_software_volume(struct cras_use_case_mgr * mgr)2571 unsigned int ucm_get_disable_software_volume(struct cras_use_case_mgr *mgr)
2572 {
2573 return 0;
2574 }
2575
ucm_get_max_software_gain(struct cras_use_case_mgr * mgr,const char * dev,long * gain)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
ucm_get_hotword_models(struct cras_use_case_mgr * mgr)2584 char *ucm_get_hotword_models(struct cras_use_case_mgr *mgr)
2585 {
2586 return NULL;
2587 }
2588
ucm_set_hotword_model(struct cras_use_case_mgr * mgr,const char * model)2589 int ucm_set_hotword_model(struct cras_use_case_mgr *mgr, const char *model)
2590 {
2591 return 0;
2592 }
2593
ucm_get_dma_period_for_dev(struct cras_use_case_mgr * mgr,const char * dev)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
ucm_get_sample_rate_for_dev(struct cras_use_case_mgr * mgr,const char * dev,enum CRAS_STREAM_DIRECTION direction)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
ucm_get_capture_chmap_for_dev(struct cras_use_case_mgr * mgr,const char * dev,int8_t * channel_layout)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
cras_volume_curve_create_default()2614 struct cras_volume_curve *cras_volume_curve_create_default()
2615 {
2616 return &default_curve;
2617 }
2618
cras_card_config_get_volume_curve_for_control(const struct cras_card_config * card_config,const char * control_name)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
cras_iodev_free_format(struct cras_iodev * iodev)2633 void cras_iodev_free_format(struct cras_iodev *iodev)
2634 {
2635 }
2636
cras_iodev_set_format(struct cras_iodev * iodev,const struct cras_audio_format * fmt)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
audio_thread_create()2647 struct audio_thread *audio_thread_create() {
2648 return reinterpret_cast<audio_thread*>(0x323);
2649 }
2650
audio_thread_destroy(audio_thread * thread)2651 void audio_thread_destroy(audio_thread* thread) {
2652 }
2653
2654
2655
cras_iodev_update_dsp(struct cras_iodev * iodev)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
cras_iodev_set_node_attr(struct cras_ionode * ionode,enum ionode_attr attr,int value)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
cras_iodev_add_node(struct cras_iodev * iodev,struct cras_ionode * node)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
cras_iodev_rm_node(struct cras_iodev * iodev,struct cras_ionode * node)2680 void cras_iodev_rm_node(struct cras_iodev *iodev, struct cras_ionode *node)
2681 {
2682 DL_DELETE(iodev->nodes, node);
2683 }
2684
cras_iodev_set_active_node(struct cras_iodev * iodev,struct cras_ionode * node)2685 void cras_iodev_set_active_node(struct cras_iodev *iodev,
2686 struct cras_ionode *node)
2687 {
2688 iodev->active_node = node;
2689 }
2690
cras_iodev_free_resources(struct cras_iodev * iodev)2691 void cras_iodev_free_resources(struct cras_iodev *iodev)
2692 {
2693 cras_iodev_free_resources_called++;
2694 }
2695
cras_alsa_jack_update_monitor_name(const struct cras_alsa_jack * jack,char * name_buf,unsigned int buf_size)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
cras_alsa_jack_update_node_type(const struct cras_alsa_jack * jack,enum CRAS_NODE_TYPE * type)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
cras_alsa_jack_get_ucm_device(const struct cras_alsa_jack * jack)2710 const char *cras_alsa_jack_get_ucm_device(const struct cras_alsa_jack *jack)
2711 {
2712 return NULL;
2713 }
2714
ucm_get_default_node_gain(struct cras_use_case_mgr * mgr,const char * dev,long * gain)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
cras_iodev_init_audio_area(struct cras_iodev * iodev,int num_channels)2726 void cras_iodev_init_audio_area(struct cras_iodev *iodev,
2727 int num_channels) {
2728 }
2729
cras_iodev_free_audio_area(struct cras_iodev * iodev)2730 void cras_iodev_free_audio_area(struct cras_iodev *iodev) {
2731 }
2732
cras_iodev_reset_rate_estimator(const struct cras_iodev * iodev)2733 int cras_iodev_reset_rate_estimator(const struct cras_iodev *iodev)
2734 {
2735 return 0;
2736 }
2737
cras_iodev_frames_queued(struct cras_iodev * iodev,struct timespec * tstamp)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
cras_iodev_buffer_avail(struct cras_iodev * iodev,unsigned hw_level)2744 int cras_iodev_buffer_avail(struct cras_iodev *iodev, unsigned hw_level)
2745 {
2746 return cras_iodev_buffer_avail_ret;
2747 }
2748
cras_iodev_fill_odev_zeros(struct cras_iodev * odev,unsigned int frames)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
cras_audio_area_config_buf_pointers(struct cras_audio_area * area,const struct cras_audio_format * fmt,uint8_t * base_buffer)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
audio_thread_add_callback(int fd,thread_callback cb,void * data)2762 void audio_thread_add_callback(int fd, thread_callback cb, void *data)
2763 {
2764 }
2765
audio_thread_rm_callback(int fd)2766 void audio_thread_rm_callback(int fd)
2767 {
2768 }
2769
audio_thread_rm_callback_sync(struct audio_thread * thread,int fd)2770 int audio_thread_rm_callback_sync(struct audio_thread *thread, int fd) {
2771 return 0;
2772 }
2773
is_utf8_string(const char * string)2774 int is_utf8_string(const char* string)
2775 {
2776 return is_utf8_string_ret_value;
2777 }
2778
cras_alsa_mmap_get_whole_buffer(snd_pcm_t * handle,uint8_t ** dst,unsigned int * underruns)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
cras_alsa_resume_appl_ptr(snd_pcm_t * handle,snd_pcm_uframes_t ahead)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
cras_iodev_default_no_stream_playback(struct cras_iodev * odev,int enable)2795 int cras_iodev_default_no_stream_playback(struct cras_iodev *odev, int enable)
2796 {
2797 return 0;
2798 }
2799
cras_iodev_state(const struct cras_iodev * iodev)2800 enum CRAS_IODEV_STATE cras_iodev_state(const struct cras_iodev *iodev)
2801 {
2802 return iodev->state;
2803 }
2804
cras_iodev_dsp_set_swap_mode_for_node(struct cras_iodev * iodev,struct cras_ionode * node,int enable)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
cras_ramp_create()2813 struct cras_ramp* cras_ramp_create() {
2814 return (struct cras_ramp*)0x1;
2815 }
2816
2817 }
2818