1 // Copyright (c) 2014 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 <stdio.h>
7
8 extern "C" {
9 #include "audio_thread_log.h"
10 #include "byte_buffer.h"
11 #include "cras_audio_area.h"
12 #include "cras_rstream.h"
13 #include "cras_shm.h"
14 #include "cras_types.h"
15 #include "dev_stream.h"
16 }
17
18 namespace {
19
20 extern "C" {
21 struct audio_thread_event_log* atlog;
22 // For audio_thread_log.h use.
23 int atlog_rw_shm_fd;
24 int atlog_ro_shm_fd;
25 unsigned int max_frames_for_conversion(unsigned int stream_frames,
26 unsigned int stream_rate,
27 unsigned int device_rate);
28 };
29
30 static struct timespec clock_gettime_retspec;
31 static struct timespec cb_ts;
32
33 static const int kBufferFrames = 1024;
34 static const struct cras_audio_format fmt_s16le_44_1 = {
35 SND_PCM_FORMAT_S16_LE,
36 44100,
37 2,
38 };
39 static const struct cras_audio_format fmt_s16le_48 = {
40 SND_PCM_FORMAT_S16_LE,
41 48000,
42 2,
43 };
44 static const struct cras_audio_format fmt_s16le_48_mono = {
45 SND_PCM_FORMAT_S16_LE,
46 48000,
47 1,
48 };
49 static const struct cras_audio_format fmt_s16le_8 = {
50 SND_PCM_FORMAT_S16_LE,
51 8000,
52 2,
53 };
54
55 struct cras_audio_area_copy_call {
56 const struct cras_audio_area* dst;
57 unsigned int dst_offset;
58 unsigned int dst_format_bytes;
59 const struct cras_audio_area* src;
60 unsigned int src_offset;
61 float software_gain_scaler;
62 };
63
64 struct fmt_conv_call {
65 struct cras_fmt_conv* conv;
66 uint8_t* in_buf;
67 uint8_t* out_buf;
68 size_t in_frames;
69 size_t out_frames;
70 };
71
72 struct mix_add_call {
73 int16_t* dst;
74 int16_t* src;
75 unsigned int count;
76 unsigned int index;
77 int mute;
78 float mix_vol;
79 };
80
81 struct rstream_get_readable_call {
82 struct cras_rstream* rstream;
83 unsigned int offset;
84 unsigned int num_called;
85 };
86
87 static int config_format_converter_called;
88 static const struct cras_audio_format* config_format_converter_from_fmt;
89 static int config_format_converter_frames;
90 static struct cras_fmt_conv* config_format_converter_conv;
91 static struct cras_audio_format in_fmt;
92 static struct cras_audio_format out_fmt;
93 static struct cras_audio_area_copy_call copy_area_call;
94 static struct fmt_conv_call conv_frames_call;
95 static int cras_audio_area_create_num_channels_val;
96 static int cras_fmt_conversion_needed_val;
97 static int cras_fmt_conv_set_linear_resample_rates_called;
98 static float cras_fmt_conv_set_linear_resample_rates_from;
99 static float cras_fmt_conv_set_linear_resample_rates_to;
100
101 static unsigned int rstream_playable_frames_ret;
102 static struct mix_add_call mix_add_call;
103 static struct rstream_get_readable_call rstream_get_readable_call;
104 static unsigned int rstream_get_readable_num;
105 static uint8_t* rstream_get_readable_ptr;
106
107 static struct cras_audio_format* cras_rstream_post_processing_format_val;
108 static int cras_rstream_audio_ready_called;
109 static int cras_rstream_audio_ready_count;
110 static int cras_rstream_is_pending_reply_ret;
111 static int cras_rstream_flush_old_audio_messages_called;
112 static int cras_server_metrics_missed_cb_event_called;
113
114 static char* atlog_name;
115
116 class CreateSuite : public testing::Test {
117 protected:
SetUp()118 virtual void SetUp() {
119 in_fmt.format = SND_PCM_FORMAT_S16_LE;
120 out_fmt.format = SND_PCM_FORMAT_S16_LE;
121 in_fmt.num_channels = 2;
122 out_fmt.num_channels = 2;
123
124 SetupShm(&rstream_.shm);
125
126 rstream_.stream_id = 0x10001;
127 rstream_.buffer_frames = kBufferFrames;
128 rstream_.cb_threshold = kBufferFrames / 2;
129 rstream_.is_draining = 0;
130 rstream_.stream_type = CRAS_STREAM_TYPE_DEFAULT;
131 rstream_.direction = CRAS_STREAM_OUTPUT;
132 rstream_.format.format = SND_PCM_FORMAT_S16_LE;
133 rstream_.format.num_channels = 2;
134 rstream_.format = fmt_s16le_44_1;
135 rstream_.flags = 0;
136 rstream_.num_missed_cb = 0;
137
138 config_format_converter_from_fmt = NULL;
139 config_format_converter_called = 0;
140 cras_fmt_conversion_needed_val = 0;
141 cras_fmt_conv_set_linear_resample_rates_called = 0;
142
143 cras_rstream_audio_ready_called = 0;
144 cras_rstream_audio_ready_count = 0;
145 cras_rstream_is_pending_reply_ret = 0;
146 cras_rstream_flush_old_audio_messages_called = 0;
147 cras_server_metrics_missed_cb_event_called = 0;
148
149 memset(©_area_call, 0xff, sizeof(copy_area_call));
150 memset(&conv_frames_call, 0xff, sizeof(conv_frames_call));
151
152 ASSERT_FALSE(asprintf(&atlog_name, "/ATlog-%d", getpid()) < 0);
153 /* To avoid un-used variable warning. */
154 atlog_rw_shm_fd = atlog_ro_shm_fd = -1;
155 atlog = audio_thread_event_log_init(atlog_name);
156
157 devstr.stream = &rstream_;
158 devstr.conv = NULL;
159 devstr.conv_buffer = NULL;
160 devstr.conv_buffer_size_frames = 0;
161
162 area = (struct cras_audio_area*)calloc(
163 1, sizeof(*area) + 2 * sizeof(struct cras_channel_area));
164 area->num_channels = 2;
165 channel_area_set_channel(&area->channels[0], CRAS_CH_FL);
166 channel_area_set_channel(&area->channels[1], CRAS_CH_FR);
167 area->channels[0].step_bytes = 4;
168 area->channels[0].buf = (uint8_t*)(cap_buf);
169 area->channels[1].step_bytes = 4;
170 area->channels[1].buf = (uint8_t*)(cap_buf + 1);
171 area->frames = kBufferFrames;
172
173 stream_area = (struct cras_audio_area*)calloc(
174 1, sizeof(*area) + 2 * sizeof(struct cras_channel_area));
175 stream_area->num_channels = 2;
176 rstream_.audio_area = stream_area;
177 int16_t* shm_samples = (int16_t*)rstream_.shm->samples;
178 stream_area->channels[0].step_bytes = 4;
179 stream_area->channels[0].buf = (uint8_t*)(shm_samples);
180 stream_area->channels[1].step_bytes = 4;
181 stream_area->channels[1].buf = (uint8_t*)(shm_samples + 1);
182 }
183
TearDown()184 virtual void TearDown() {
185 free(area);
186 free(stream_area);
187 free(rstream_.shm->header);
188 free(rstream_.shm->samples);
189 free(rstream_.shm);
190 audio_thread_event_log_deinit(atlog, atlog_name);
191 free(atlog_name);
192 }
193
SetupShm(struct cras_audio_shm ** shm_out)194 void SetupShm(struct cras_audio_shm** shm_out) {
195 int16_t* buf;
196 struct cras_audio_shm* shm;
197 uint32_t used_size;
198
199 shm = static_cast<struct cras_audio_shm*>(
200 calloc(1, sizeof(struct cras_audio_shm)));
201
202 shm->header = static_cast<struct cras_audio_shm_header*>(
203 calloc(1, sizeof(struct cras_audio_shm_header)));
204 cras_shm_set_frame_bytes(shm, 4);
205 used_size = kBufferFrames * cras_shm_frame_bytes(shm);
206 cras_shm_set_used_size(shm, used_size);
207
208 shm->samples = static_cast<uint8_t*>(
209 calloc(1, cras_shm_calculate_samples_size(used_size)));
210 shm->samples_info.length = cras_shm_calculate_samples_size(used_size);
211
212 buf = (int16_t*)shm->samples;
213 for (size_t i = 0; i < kBufferFrames * 2; i++)
214 buf[i] = i;
215 cras_shm_set_mute(shm, 0);
216 cras_shm_set_volume_scaler(shm, 1.0);
217
218 *shm_out = shm;
219 }
220
SetUpFmtConv(unsigned int in_rate,unsigned int out_rate,unsigned int conv_buf_size)221 void SetUpFmtConv(unsigned int in_rate,
222 unsigned int out_rate,
223 unsigned int conv_buf_size) {
224 in_fmt.frame_rate = in_rate;
225 out_fmt.frame_rate = out_rate;
226 cras_fmt_conversion_needed_val = 1;
227
228 devstr.conv = (struct cras_fmt_conv*)0xdead;
229 devstr.conv_buffer =
230 (struct byte_buffer*)byte_buffer_create(conv_buf_size * 4);
231 devstr.conv_buffer_size_frames = kBufferFrames * 2;
232
233 devstr.conv_area = (struct cras_audio_area*)calloc(
234 1, sizeof(*area) + 2 * sizeof(*area->channels));
235 devstr.conv_area->num_channels = 2;
236 devstr.conv_area->channels[0].step_bytes = 4;
237 devstr.conv_area->channels[0].buf = (uint8_t*)(devstr.conv_buffer->bytes);
238 devstr.conv_area->channels[1].step_bytes = 4;
239 devstr.conv_area->channels[1].buf =
240 (uint8_t*)(devstr.conv_buffer->bytes + 1);
241 }
242
243 struct dev_stream devstr;
244 struct cras_audio_area* area;
245 struct cras_audio_area* stream_area;
246 int16_t cap_buf[kBufferFrames * 2];
247 struct cras_rstream rstream_;
248 };
249
TEST_F(CreateSuite,CaptureNoSRC)250 TEST_F(CreateSuite, CaptureNoSRC) {
251 float software_gain_scaler = 10;
252
253 dev_stream_capture(&devstr, area, 0, software_gain_scaler);
254
255 EXPECT_EQ(stream_area, copy_area_call.dst);
256 EXPECT_EQ(0, copy_area_call.dst_offset);
257 EXPECT_EQ(4, copy_area_call.dst_format_bytes);
258 EXPECT_EQ(area, copy_area_call.src);
259 EXPECT_EQ(software_gain_scaler, copy_area_call.software_gain_scaler);
260 }
261
TEST_F(CreateSuite,CaptureSRCSmallConverterBuffer)262 TEST_F(CreateSuite, CaptureSRCSmallConverterBuffer) {
263 float software_gain_scaler = 10;
264 unsigned int conv_buf_avail_at_input_rate;
265 int nread;
266
267 SetUpFmtConv(44100, 32000, kBufferFrames / 4);
268 nread = dev_stream_capture(&devstr, area, 0, software_gain_scaler);
269
270 // |nread| is bound by small converter buffer size (kBufferFrames / 4)
271 conv_buf_avail_at_input_rate = cras_frames_at_rate(
272 out_fmt.frame_rate, (kBufferFrames / 4), in_fmt.frame_rate);
273
274 EXPECT_EQ(conv_buf_avail_at_input_rate, nread);
275 EXPECT_EQ((struct cras_fmt_conv*)0xdead, conv_frames_call.conv);
276 EXPECT_EQ((uint8_t*)cap_buf, conv_frames_call.in_buf);
277 EXPECT_EQ(devstr.conv_buffer->bytes, conv_frames_call.out_buf);
278
279 EXPECT_EQ(conv_buf_avail_at_input_rate, conv_frames_call.in_frames);
280
281 // Expect number of output frames is limited by the size of converter buffer.
282 EXPECT_EQ(kBufferFrames / 4, conv_frames_call.out_frames);
283
284 EXPECT_EQ(stream_area, copy_area_call.dst);
285 EXPECT_EQ(0, copy_area_call.dst_offset);
286 EXPECT_EQ(4, copy_area_call.dst_format_bytes);
287 EXPECT_EQ(devstr.conv_area, copy_area_call.src);
288 EXPECT_EQ(software_gain_scaler, copy_area_call.software_gain_scaler);
289
290 free(devstr.conv_area);
291 byte_buffer_destroy(&devstr.conv_buffer);
292 }
293
TEST_F(CreateSuite,CaptureSRCLargeConverterBuffer)294 TEST_F(CreateSuite, CaptureSRCLargeConverterBuffer) {
295 float software_gain_scaler = 10;
296 unsigned int stream_avail_at_input_rate;
297 int nread;
298
299 SetUpFmtConv(44100, 32000, kBufferFrames * 2);
300 nread = dev_stream_capture(&devstr, area, 0, software_gain_scaler);
301
302 // Available frames at stream side is bound by cb_threshold, which
303 // equals to kBufferFrames / 2.
304 stream_avail_at_input_rate = cras_frames_at_rate(
305 out_fmt.frame_rate, (kBufferFrames / 2), in_fmt.frame_rate);
306
307 EXPECT_EQ(stream_avail_at_input_rate, nread);
308 EXPECT_EQ((struct cras_fmt_conv*)0xdead, conv_frames_call.conv);
309 EXPECT_EQ((uint8_t*)cap_buf, conv_frames_call.in_buf);
310 EXPECT_EQ(devstr.conv_buffer->bytes, conv_frames_call.out_buf);
311
312 // Expect number of input frames is limited by |stream_avail_at_input_rate|
313 // at format conversion.
314 EXPECT_EQ(stream_avail_at_input_rate, conv_frames_call.in_frames);
315
316 // Expect number of output frames is limited by the size of converter buffer.
317 EXPECT_EQ(kBufferFrames * 2, conv_frames_call.out_frames);
318
319 EXPECT_EQ(stream_area, copy_area_call.dst);
320 EXPECT_EQ(0, copy_area_call.dst_offset);
321 EXPECT_EQ(4, copy_area_call.dst_format_bytes);
322 EXPECT_EQ(devstr.conv_area, copy_area_call.src);
323 EXPECT_EQ(software_gain_scaler, copy_area_call.software_gain_scaler);
324
325 free(devstr.conv_area);
326 byte_buffer_destroy(&devstr.conv_buffer);
327 }
328
TEST_F(CreateSuite,CreateSRC44to48)329 TEST_F(CreateSuite, CreateSRC44to48) {
330 struct dev_stream* dev_stream;
331
332 rstream_.format = fmt_s16le_44_1;
333 in_fmt.frame_rate = 44100; // Input to converter is stream rate.
334 out_fmt.frame_rate = 48000; // Output from converter is device rate.
335 config_format_converter_conv = reinterpret_cast<struct cras_fmt_conv*>(0x33);
336 dev_stream =
337 dev_stream_create(&rstream_, 0, &fmt_s16le_48, (void*)0x55, &cb_ts, NULL);
338 EXPECT_EQ(1, config_format_converter_called);
339 EXPECT_NE(static_cast<byte_buffer*>(NULL), dev_stream->conv_buffer);
340 // Converter tmp and output buffers are large enough for device output.
341 unsigned int device_frames =
342 cras_frames_at_rate(in_fmt.frame_rate, kBufferFrames, out_fmt.frame_rate);
343 EXPECT_LE(kBufferFrames, device_frames); // Soundness check.
344 EXPECT_LE(device_frames, config_format_converter_frames);
345 EXPECT_LE(device_frames, dev_stream->conv_buffer_size_frames);
346 dev_stream_destroy(dev_stream);
347 }
348
TEST_F(CreateSuite,CreateOutputWithSchedule)349 TEST_F(CreateSuite, CreateOutputWithSchedule) {
350 struct dev_stream* dev_stream;
351 unsigned int dev_id = 9;
352 // init_cb_ts and non-null init_sleep_ts will be used.
353 struct timespec init_cb_ts = {1, 2};
354 struct timespec init_sleep_ts = {3, 4};
355
356 rstream_.direction = CRAS_STREAM_OUTPUT;
357 dev_stream = dev_stream_create(&rstream_, dev_id, &fmt_s16le_48, (void*)0x55,
358 &init_cb_ts, &init_sleep_ts);
359
360 EXPECT_EQ(init_cb_ts.tv_sec, rstream_.next_cb_ts.tv_sec);
361 EXPECT_EQ(init_cb_ts.tv_nsec, rstream_.next_cb_ts.tv_nsec);
362 EXPECT_EQ(init_sleep_ts.tv_sec, rstream_.sleep_interval_ts.tv_sec);
363 EXPECT_EQ(init_sleep_ts.tv_nsec, rstream_.sleep_interval_ts.tv_nsec);
364 dev_stream_destroy(dev_stream);
365 }
366
TEST_F(CreateSuite,CreateSRC44from48Input)367 TEST_F(CreateSuite, CreateSRC44from48Input) {
368 struct dev_stream* dev_stream;
369 struct cras_audio_format processed_fmt = fmt_s16le_48;
370
371 processed_fmt.num_channels = 1;
372 rstream_.format = fmt_s16le_44_1;
373 rstream_.direction = CRAS_STREAM_INPUT;
374 in_fmt.frame_rate = 48000; // Input to converter is device rate.
375 out_fmt.frame_rate = 44100; // Output from converter is stream rate.
376 config_format_converter_conv = reinterpret_cast<struct cras_fmt_conv*>(0x33);
377 cras_rstream_post_processing_format_val = &processed_fmt;
378 dev_stream =
379 dev_stream_create(&rstream_, 0, &fmt_s16le_48, (void*)0x55, &cb_ts, NULL);
380 EXPECT_EQ(1, config_format_converter_called);
381 EXPECT_NE(static_cast<byte_buffer*>(NULL), dev_stream->conv_buffer);
382 // Converter tmp and output buffers are large enough for device input.
383 unsigned int device_frames =
384 cras_frames_at_rate(out_fmt.frame_rate, kBufferFrames, in_fmt.frame_rate);
385 EXPECT_LE(kBufferFrames, device_frames); // Soundness check.
386 EXPECT_LE(device_frames, config_format_converter_frames);
387 EXPECT_EQ(&processed_fmt, config_format_converter_from_fmt);
388 EXPECT_LE(device_frames, dev_stream->conv_buffer_size_frames);
389 dev_stream_destroy(dev_stream);
390 }
391
TEST_F(CreateSuite,CreateSRC48to44)392 TEST_F(CreateSuite, CreateSRC48to44) {
393 struct dev_stream* dev_stream;
394
395 rstream_.format = fmt_s16le_48;
396 in_fmt.frame_rate = 48000; // Stream rate.
397 out_fmt.frame_rate = 44100; // Device rate.
398 config_format_converter_conv = reinterpret_cast<struct cras_fmt_conv*>(0x33);
399 dev_stream = dev_stream_create(&rstream_, 0, &fmt_s16le_44_1, (void*)0x55,
400 &cb_ts, NULL);
401 EXPECT_EQ(1, config_format_converter_called);
402 EXPECT_NE(static_cast<byte_buffer*>(NULL), dev_stream->conv_buffer);
403 // Converter tmp and output buffers are large enough for stream input.
404 EXPECT_LE(kBufferFrames, config_format_converter_frames);
405 EXPECT_LE(kBufferFrames, dev_stream->conv_buffer_size_frames);
406 dev_stream_destroy(dev_stream);
407 }
408
TEST_F(CreateSuite,CreateSRC48from44Input)409 TEST_F(CreateSuite, CreateSRC48from44Input) {
410 struct dev_stream* dev_stream;
411
412 rstream_.format = fmt_s16le_48;
413 rstream_.direction = CRAS_STREAM_INPUT;
414 in_fmt.frame_rate = 44100; // Device rate.
415 out_fmt.frame_rate = 48000; // Stream rate.
416 config_format_converter_conv = reinterpret_cast<struct cras_fmt_conv*>(0x33);
417 dev_stream = dev_stream_create(&rstream_, 0, &fmt_s16le_44_1, (void*)0x55,
418 &cb_ts, NULL);
419 EXPECT_EQ(1, config_format_converter_called);
420 EXPECT_NE(static_cast<byte_buffer*>(NULL), dev_stream->conv_buffer);
421 // Converter tmp and output buffers are large enough for stream output.
422 EXPECT_LE(kBufferFrames, config_format_converter_frames);
423 EXPECT_LE(kBufferFrames, dev_stream->conv_buffer_size_frames);
424 dev_stream_destroy(dev_stream);
425 }
426
TEST_F(CreateSuite,CreateSRC8to48)427 TEST_F(CreateSuite, CreateSRC8to48) {
428 struct dev_stream* dev_stream;
429
430 rstream_.format = fmt_s16le_8;
431 in_fmt.frame_rate = 8000; // Stream rate.
432 out_fmt.frame_rate = 48000; // Device rate.
433 config_format_converter_conv = reinterpret_cast<struct cras_fmt_conv*>(0x33);
434 dev_stream =
435 dev_stream_create(&rstream_, 0, &fmt_s16le_48, (void*)0x55, &cb_ts, NULL);
436 EXPECT_EQ(1, config_format_converter_called);
437 EXPECT_NE(static_cast<byte_buffer*>(NULL), dev_stream->conv_buffer);
438 // Converter tmp and output buffers are large enough for device output.
439 unsigned int device_frames =
440 cras_frames_at_rate(in_fmt.frame_rate, kBufferFrames, out_fmt.frame_rate);
441 EXPECT_LE(kBufferFrames, device_frames); // Soundness check.
442 EXPECT_LE(device_frames, config_format_converter_frames);
443 EXPECT_LE(device_frames, dev_stream->conv_buffer_size_frames);
444 dev_stream_destroy(dev_stream);
445 }
446
TEST_F(CreateSuite,CreateSRC8from48Input)447 TEST_F(CreateSuite, CreateSRC8from48Input) {
448 struct dev_stream* dev_stream;
449
450 rstream_.format = fmt_s16le_8;
451 rstream_.direction = CRAS_STREAM_INPUT;
452 in_fmt.frame_rate = 48000; // Device rate.
453 out_fmt.frame_rate = 8000; // Stream rate.
454 config_format_converter_conv = reinterpret_cast<struct cras_fmt_conv*>(0x33);
455 dev_stream =
456 dev_stream_create(&rstream_, 0, &fmt_s16le_48, (void*)0x55, &cb_ts, NULL);
457 EXPECT_EQ(1, config_format_converter_called);
458 EXPECT_NE(static_cast<byte_buffer*>(NULL), dev_stream->conv_buffer);
459 // Converter tmp and output buffers are large enough for device input.
460 unsigned int device_frames =
461 cras_frames_at_rate(out_fmt.frame_rate, kBufferFrames, in_fmt.frame_rate);
462 EXPECT_LE(kBufferFrames, device_frames); // Soundness check.
463 EXPECT_LE(device_frames, config_format_converter_frames);
464 EXPECT_LE(device_frames, dev_stream->conv_buffer_size_frames);
465 dev_stream_destroy(dev_stream);
466 }
467
TEST_F(CreateSuite,CreateSRC48to8)468 TEST_F(CreateSuite, CreateSRC48to8) {
469 struct dev_stream* dev_stream;
470
471 rstream_.format = fmt_s16le_48;
472 in_fmt.frame_rate = 48000; // Stream rate.
473 out_fmt.frame_rate = 8000; // Device rate.
474 config_format_converter_conv = reinterpret_cast<struct cras_fmt_conv*>(0x33);
475 dev_stream =
476 dev_stream_create(&rstream_, 0, &fmt_s16le_8, (void*)0x55, &cb_ts, NULL);
477 EXPECT_EQ(1, config_format_converter_called);
478 EXPECT_NE(static_cast<byte_buffer*>(NULL), dev_stream->conv_buffer);
479 // Converter tmp and output buffers are large enough for stream input.
480 EXPECT_LE(kBufferFrames, config_format_converter_frames);
481 EXPECT_LE(kBufferFrames, dev_stream->conv_buffer_size_frames);
482 dev_stream_destroy(dev_stream);
483 }
484
TEST_F(CreateSuite,CreateSRC48from8Input)485 TEST_F(CreateSuite, CreateSRC48from8Input) {
486 struct dev_stream* dev_stream;
487
488 rstream_.format = fmt_s16le_48;
489 rstream_.direction = CRAS_STREAM_INPUT;
490 in_fmt.frame_rate = 8000; // Device rate.
491 out_fmt.frame_rate = 48000; // Stream rate.
492 config_format_converter_conv = reinterpret_cast<struct cras_fmt_conv*>(0x33);
493 dev_stream =
494 dev_stream_create(&rstream_, 0, &fmt_s16le_8, (void*)0x55, &cb_ts, NULL);
495 EXPECT_EQ(1, config_format_converter_called);
496 EXPECT_NE(static_cast<byte_buffer*>(NULL), dev_stream->conv_buffer);
497 // Converter tmp and output buffers are large enough for stream output.
498 EXPECT_LE(kBufferFrames, config_format_converter_frames);
499 EXPECT_LE(kBufferFrames, dev_stream->conv_buffer_size_frames);
500 dev_stream_destroy(dev_stream);
501 }
502
TEST_F(CreateSuite,CreateSRC48MonoFrom44StereoInput)503 TEST_F(CreateSuite, CreateSRC48MonoFrom44StereoInput) {
504 struct dev_stream* dev_stream;
505
506 rstream_.format = fmt_s16le_48_mono;
507 rstream_.direction = CRAS_STREAM_INPUT;
508 in_fmt.frame_rate = 44100; // Device rate.
509 out_fmt.frame_rate = 48000; // Stream rate.
510 config_format_converter_conv = reinterpret_cast<struct cras_fmt_conv*>(0x33);
511 dev_stream = dev_stream_create(&rstream_, 0, &fmt_s16le_44_1, (void*)0x55,
512 &cb_ts, NULL);
513 EXPECT_EQ(1, config_format_converter_called);
514 EXPECT_NE(static_cast<byte_buffer*>(NULL), dev_stream->conv_buffer);
515 // Converter tmp and output buffers are large enough for stream output.
516 EXPECT_LE(kBufferFrames, config_format_converter_frames);
517 EXPECT_LE(kBufferFrames, dev_stream->conv_buffer_size_frames);
518 EXPECT_EQ(dev_stream->conv_buffer_size_frames * 4,
519 dev_stream->conv_buffer->max_size);
520 EXPECT_EQ(2, cras_audio_area_create_num_channels_val);
521 dev_stream_destroy(dev_stream);
522 }
523
TEST_F(CreateSuite,CaptureAvailConvBufHasSamples)524 TEST_F(CreateSuite, CaptureAvailConvBufHasSamples) {
525 struct dev_stream* dev_stream;
526 unsigned int avail;
527
528 rstream_.format = fmt_s16le_48;
529 rstream_.direction = CRAS_STREAM_INPUT;
530 config_format_converter_conv = reinterpret_cast<struct cras_fmt_conv*>(0x33);
531 dev_stream = dev_stream_create(&rstream_, 0, &fmt_s16le_44_1, (void*)0x55,
532 &cb_ts, NULL);
533 EXPECT_EQ(1, config_format_converter_called);
534 EXPECT_NE(static_cast<byte_buffer*>(NULL), dev_stream->conv_buffer);
535 EXPECT_LE(
536 cras_frames_at_rate(in_fmt.frame_rate, kBufferFrames, out_fmt.frame_rate),
537 dev_stream->conv_buffer_size_frames);
538 EXPECT_EQ(dev_stream->conv_buffer_size_frames * 4,
539 dev_stream->conv_buffer->max_size);
540 EXPECT_EQ(2, cras_audio_area_create_num_channels_val);
541
542 buf_increment_write(dev_stream->conv_buffer, 50 * 4);
543 avail = dev_stream_capture_avail(dev_stream);
544
545 EXPECT_EQ(cras_frames_at_rate(48000, 512 - 50, 44100), avail);
546
547 dev_stream_destroy(dev_stream);
548 }
549
TEST_F(CreateSuite,SetDevRateNotMainDev)550 TEST_F(CreateSuite, SetDevRateNotMainDev) {
551 struct dev_stream* dev_stream;
552 unsigned int dev_id = 9;
553
554 rstream_.format = fmt_s16le_48;
555 rstream_.direction = CRAS_STREAM_INPUT;
556 rstream_.main_dev.dev_id = 4;
557 config_format_converter_conv = reinterpret_cast<struct cras_fmt_conv*>(0x33);
558 dev_stream = dev_stream_create(&rstream_, dev_id, &fmt_s16le_44_1,
559 (void*)0x55, &cb_ts, NULL);
560
561 dev_stream_set_dev_rate(dev_stream, 44100, 1.01, 1.0, 0);
562 EXPECT_EQ(1, cras_fmt_conv_set_linear_resample_rates_called);
563 EXPECT_EQ(44100, cras_fmt_conv_set_linear_resample_rates_from);
564 EXPECT_EQ(44541, cras_fmt_conv_set_linear_resample_rates_to);
565
566 dev_stream_set_dev_rate(dev_stream, 44100, 1.01, 1.0, 1);
567 EXPECT_EQ(2, cras_fmt_conv_set_linear_resample_rates_called);
568 EXPECT_EQ(44100, cras_fmt_conv_set_linear_resample_rates_from);
569 EXPECT_LE(44541, cras_fmt_conv_set_linear_resample_rates_to);
570
571 dev_stream_set_dev_rate(dev_stream, 44100, 1.0, 1.01, -1);
572 EXPECT_EQ(3, cras_fmt_conv_set_linear_resample_rates_called);
573 EXPECT_EQ(44100, cras_fmt_conv_set_linear_resample_rates_from);
574 EXPECT_GE(43663, cras_fmt_conv_set_linear_resample_rates_to);
575 dev_stream_destroy(dev_stream);
576 }
577
TEST_F(CreateSuite,SetDevRateMainDev)578 TEST_F(CreateSuite, SetDevRateMainDev) {
579 struct dev_stream* dev_stream;
580 unsigned int dev_id = 9;
581 unsigned int expected_ts_nsec;
582
583 rstream_.format = fmt_s16le_48;
584 rstream_.direction = CRAS_STREAM_INPUT;
585 rstream_.main_dev.dev_id = dev_id;
586 config_format_converter_conv = reinterpret_cast<struct cras_fmt_conv*>(0x33);
587 dev_stream = dev_stream_create(&rstream_, dev_id, &fmt_s16le_44_1,
588 (void*)0x55, &cb_ts, NULL);
589
590 dev_stream_set_dev_rate(dev_stream, 44100, 1.01, 1.0, 0);
591 EXPECT_EQ(1, cras_fmt_conv_set_linear_resample_rates_called);
592 EXPECT_EQ(44100, cras_fmt_conv_set_linear_resample_rates_from);
593 EXPECT_EQ(44100, cras_fmt_conv_set_linear_resample_rates_to);
594 expected_ts_nsec = 1000000000.0 * kBufferFrames / 2.0 / 48000.0 / 1.01;
595 EXPECT_EQ(0, rstream_.sleep_interval_ts.tv_sec);
596 EXPECT_EQ(expected_ts_nsec, rstream_.sleep_interval_ts.tv_nsec);
597
598 dev_stream_set_dev_rate(dev_stream, 44100, 1.01, 1.0, 1);
599 EXPECT_EQ(2, cras_fmt_conv_set_linear_resample_rates_called);
600 EXPECT_EQ(44100, cras_fmt_conv_set_linear_resample_rates_from);
601 EXPECT_LE(44100, cras_fmt_conv_set_linear_resample_rates_to);
602 expected_ts_nsec = 1000000000.0 * kBufferFrames / 2.0 / 48000.0 / 1.01;
603 EXPECT_EQ(0, rstream_.sleep_interval_ts.tv_sec);
604 EXPECT_EQ(expected_ts_nsec, rstream_.sleep_interval_ts.tv_nsec);
605
606 dev_stream_set_dev_rate(dev_stream, 44100, 1.0, 1.33, -1);
607 EXPECT_EQ(3, cras_fmt_conv_set_linear_resample_rates_called);
608 EXPECT_EQ(44100, cras_fmt_conv_set_linear_resample_rates_from);
609 EXPECT_GE(44100, cras_fmt_conv_set_linear_resample_rates_to);
610 expected_ts_nsec = 1000000000.0 * kBufferFrames / 2.0 / 48000.0;
611 EXPECT_EQ(0, rstream_.sleep_interval_ts.tv_sec);
612 EXPECT_EQ(expected_ts_nsec, rstream_.sleep_interval_ts.tv_nsec);
613 dev_stream_destroy(dev_stream);
614 }
615
TEST_F(CreateSuite,StreamMixNoFrames)616 TEST_F(CreateSuite, StreamMixNoFrames) {
617 struct dev_stream dev_stream;
618 struct cras_audio_format fmt;
619
620 dev_stream.conv = NULL;
621 rstream_playable_frames_ret = 0;
622 fmt.num_channels = 2;
623 fmt.format = SND_PCM_FORMAT_S16_LE;
624 EXPECT_EQ(0, dev_stream_mix(&dev_stream, &fmt, 0, 3));
625 }
626
TEST_F(CreateSuite,StreamMixNoConv)627 TEST_F(CreateSuite, StreamMixNoConv) {
628 struct dev_stream dev_stream;
629 const unsigned int nfr = 100;
630 struct cras_audio_format fmt;
631
632 dev_stream.conv = NULL;
633 dev_stream.stream = reinterpret_cast<cras_rstream*>(0x5446);
634 rstream_playable_frames_ret = nfr;
635 rstream_get_readable_num = nfr;
636 rstream_get_readable_ptr = reinterpret_cast<uint8_t*>(0x4000);
637 rstream_get_readable_call.num_called = 0;
638 fmt.num_channels = 2;
639 fmt.format = SND_PCM_FORMAT_S16_LE;
640 EXPECT_EQ(nfr, dev_stream_mix(&dev_stream, &fmt, (uint8_t*)0x5000, nfr));
641 EXPECT_EQ((int16_t*)0x5000, mix_add_call.dst);
642 EXPECT_EQ((int16_t*)0x4000, mix_add_call.src);
643 EXPECT_EQ(200, mix_add_call.count);
644 EXPECT_EQ(1, mix_add_call.index);
645 EXPECT_EQ(dev_stream.stream, rstream_get_readable_call.rstream);
646 EXPECT_EQ(0, rstream_get_readable_call.offset);
647 EXPECT_EQ(1, rstream_get_readable_call.num_called);
648 }
649
TEST_F(CreateSuite,StreamMixNoConvTwoPass)650 TEST_F(CreateSuite, StreamMixNoConvTwoPass) {
651 struct dev_stream dev_stream;
652 const unsigned int nfr = 100;
653 const unsigned int bytes_per_sample = 2;
654 const unsigned int num_channels = 2;
655 const unsigned int bytes_per_frame = bytes_per_sample * num_channels;
656 struct cras_audio_format fmt;
657
658 dev_stream.conv = NULL;
659 dev_stream.stream = reinterpret_cast<cras_rstream*>(0x5446);
660 rstream_playable_frames_ret = nfr;
661 rstream_get_readable_num = nfr / 2;
662 rstream_get_readable_ptr = reinterpret_cast<uint8_t*>(0x4000);
663 rstream_get_readable_call.num_called = 0;
664 fmt.num_channels = 2;
665 fmt.format = SND_PCM_FORMAT_S16_LE;
666 EXPECT_EQ(nfr, dev_stream_mix(&dev_stream, &fmt, (uint8_t*)0x5000, nfr));
667 const unsigned int half_offset = nfr / 2 * bytes_per_frame;
668 EXPECT_EQ((int16_t*)(0x5000 + half_offset), mix_add_call.dst);
669 EXPECT_EQ((int16_t*)0x4000, mix_add_call.src);
670 EXPECT_EQ(nfr / 2 * num_channels, mix_add_call.count);
671 EXPECT_EQ(1, mix_add_call.index);
672 EXPECT_EQ(dev_stream.stream, rstream_get_readable_call.rstream);
673 EXPECT_EQ(nfr / 2, rstream_get_readable_call.offset);
674 EXPECT_EQ(2, rstream_get_readable_call.num_called);
675 }
676
TEST_F(CreateSuite,DevStreamFlushAudioMessages)677 TEST_F(CreateSuite, DevStreamFlushAudioMessages) {
678 struct dev_stream* dev_stream;
679 unsigned int dev_id = 9;
680
681 dev_stream = dev_stream_create(&rstream_, dev_id, &fmt_s16le_44_1,
682 (void*)0x55, &cb_ts, NULL);
683
684 dev_stream_flush_old_audio_messages(dev_stream);
685 EXPECT_EQ(1, cras_rstream_flush_old_audio_messages_called);
686 dev_stream_destroy(dev_stream);
687 }
688
TEST_F(CreateSuite,DevStreamIsPending)689 TEST_F(CreateSuite, DevStreamIsPending) {
690 struct dev_stream* dev_stream;
691 unsigned int dev_id = 9;
692
693 dev_stream = dev_stream_create(&rstream_, dev_id, &fmt_s16le_44_1,
694 (void*)0x55, &cb_ts, NULL);
695
696 // dev_stream_is_pending_reply is only a wrapper.
697 cras_rstream_is_pending_reply_ret = 0;
698 EXPECT_EQ(0, dev_stream_is_pending_reply(dev_stream));
699
700 cras_rstream_is_pending_reply_ret = 1;
701 EXPECT_EQ(1, dev_stream_is_pending_reply(dev_stream));
702
703 dev_stream_destroy(dev_stream);
704 }
705
TEST_F(CreateSuite,StreamCanSend)706 TEST_F(CreateSuite, StreamCanSend) {
707 struct dev_stream* dev_stream;
708 unsigned int dev_id = 9;
709 int written_frames;
710 int rc;
711 struct timespec expected_next_cb_ts;
712
713 rstream_.direction = CRAS_STREAM_INPUT;
714 dev_stream = dev_stream_create(&rstream_, dev_id, &fmt_s16le_44_1,
715 (void*)0x55, &cb_ts, NULL);
716
717 // Assume there is a next_cb_ts on rstream.
718 rstream_.next_cb_ts.tv_sec = 1;
719 rstream_.next_cb_ts.tv_nsec = 0;
720
721 // Case 1: Not enough samples. Time is not late enough.
722 // Stream can not send data to client.
723 clock_gettime_retspec.tv_sec = 0;
724 clock_gettime_retspec.tv_nsec = 0;
725 rc = dev_stream_capture_update_rstream(dev_stream);
726 EXPECT_EQ(0, cras_rstream_audio_ready_called);
727 EXPECT_EQ(0, cras_server_metrics_missed_cb_event_called);
728 EXPECT_EQ(0, rc);
729
730 // Case 2: Not enough samples. Time is late enough.
731 // Stream can not send data to client.
732
733 // Assume time is greater than next_cb_ts.
734 clock_gettime_retspec.tv_sec = 1;
735 clock_gettime_retspec.tv_nsec = 500;
736 // However, written frames is less than cb_threshold.
737 // Stream still can not send samples to client.
738 rc = dev_stream_capture_update_rstream(dev_stream);
739 EXPECT_EQ(0, cras_rstream_audio_ready_called);
740 EXPECT_EQ(0, cras_server_metrics_missed_cb_event_called);
741 EXPECT_EQ(0, rc);
742
743 // Case 3: Enough samples. Time is not late enough.
744 // Stream can not send data to client.
745
746 // Assume time is less than next_cb_ts.
747 clock_gettime_retspec.tv_sec = 0;
748 clock_gettime_retspec.tv_nsec = 0;
749 // Enough samples are written.
750 written_frames = rstream_.cb_threshold + 10;
751 cras_shm_buffer_written(rstream_.shm, written_frames);
752 // Stream still can not send samples to client.
753 rc = dev_stream_capture_update_rstream(dev_stream);
754 EXPECT_EQ(0, cras_rstream_audio_ready_called);
755 EXPECT_EQ(0, cras_server_metrics_missed_cb_event_called);
756 EXPECT_EQ(0, rc);
757
758 // Case 4: Enough samples. Time is late enough.
759 // Stream should send one cb_threshold to client.
760 clock_gettime_retspec.tv_sec = 1;
761 clock_gettime_retspec.tv_nsec = 500;
762 rc = dev_stream_capture_update_rstream(dev_stream);
763 EXPECT_EQ(1, cras_rstream_audio_ready_called);
764 EXPECT_EQ(rstream_.cb_threshold, cras_rstream_audio_ready_count);
765 EXPECT_EQ(0, cras_server_metrics_missed_cb_event_called);
766 EXPECT_EQ(0, rc);
767
768 // Check next_cb_ts is increased by one sleep interval.
769 expected_next_cb_ts.tv_sec = 1;
770 expected_next_cb_ts.tv_nsec = 0;
771 add_timespecs(&expected_next_cb_ts, &rstream_.sleep_interval_ts);
772 EXPECT_EQ(expected_next_cb_ts.tv_sec, rstream_.next_cb_ts.tv_sec);
773 EXPECT_EQ(expected_next_cb_ts.tv_nsec, rstream_.next_cb_ts.tv_nsec);
774
775 // Reset stub data of interest.
776 cras_rstream_audio_ready_called = 0;
777 cras_rstream_audio_ready_count = 0;
778 rstream_.next_cb_ts.tv_sec = 1;
779 rstream_.next_cb_ts.tv_nsec = 0;
780
781 // Case 5: Enough samples. Time is late enough and it is too late
782 // such that a new next_cb_ts is in the past.
783 // Stream should send one cb_threshold to client and reset schedule.
784 clock_gettime_retspec.tv_sec = 2;
785 clock_gettime_retspec.tv_nsec = 0;
786 rc = dev_stream_capture_update_rstream(dev_stream);
787 EXPECT_EQ(1, cras_rstream_audio_ready_called);
788 EXPECT_EQ(rstream_.cb_threshold, cras_rstream_audio_ready_count);
789 EXPECT_EQ(1, cras_server_metrics_missed_cb_event_called);
790 EXPECT_EQ(0, rc);
791
792 // Check next_cb_ts is rest to be now plus one sleep interval.
793 expected_next_cb_ts.tv_sec = 2;
794 expected_next_cb_ts.tv_nsec = 0;
795 add_timespecs(&expected_next_cb_ts, &rstream_.sleep_interval_ts);
796 EXPECT_EQ(expected_next_cb_ts.tv_sec, rstream_.next_cb_ts.tv_sec);
797 EXPECT_EQ(expected_next_cb_ts.tv_nsec, rstream_.next_cb_ts.tv_nsec);
798
799 dev_stream_destroy(dev_stream);
800 }
801
TEST_F(CreateSuite,StreamCanSendBulkAudio)802 TEST_F(CreateSuite, StreamCanSendBulkAudio) {
803 struct dev_stream* dev_stream;
804 unsigned int dev_id = 9;
805 int written_frames;
806 int rc;
807 struct timespec expected_next_cb_ts;
808
809 rstream_.direction = CRAS_STREAM_INPUT;
810 rstream_.flags |= BULK_AUDIO_OK;
811 dev_stream = dev_stream_create(&rstream_, dev_id, &fmt_s16le_44_1,
812 (void*)0x55, &cb_ts, NULL);
813
814 // Assume there is a next_cb_ts on rstream.
815 rstream_.next_cb_ts.tv_sec = 1;
816 rstream_.next_cb_ts.tv_nsec = 0;
817
818 // Case 1: Not enough samples. Time is not late enough.
819 // Bulk audio stream can not send data to client.
820 clock_gettime_retspec.tv_sec = 0;
821 clock_gettime_retspec.tv_nsec = 0;
822 rc = dev_stream_capture_update_rstream(dev_stream);
823 EXPECT_EQ(0, cras_rstream_audio_ready_called);
824 EXPECT_EQ(0, rc);
825
826 // Case 2: Not enough samples. Time is late enough.
827 // Bulk audio stream can not send data to client.
828
829 // Assume time is greater than next_cb_ts.
830 clock_gettime_retspec.tv_sec = 1;
831 clock_gettime_retspec.tv_nsec = 500;
832 // However, written frames is less than cb_threshold.
833 // Stream still can not send samples to client.
834 rc = dev_stream_capture_update_rstream(dev_stream);
835 EXPECT_EQ(0, cras_rstream_audio_ready_called);
836 EXPECT_EQ(0, rc);
837
838 // Case 3: Enough samples. Time is not late enough.
839 // Bulk audio stream CAN send data to client.
840
841 // Assume time is less than next_cb_ts.
842 clock_gettime_retspec.tv_sec = 0;
843 clock_gettime_retspec.tv_nsec = 0;
844 // Enough samples are written.
845 written_frames = rstream_.cb_threshold + 10;
846 cras_shm_buffer_written(rstream_.shm, written_frames);
847 // Bulk audio stream can send all written samples to client.
848 rc = dev_stream_capture_update_rstream(dev_stream);
849 EXPECT_EQ(1, cras_rstream_audio_ready_called);
850 EXPECT_EQ(written_frames, cras_rstream_audio_ready_count);
851 EXPECT_EQ(0, rc);
852
853 // Case 4: Enough samples. Time is late enough.
854 // Bulk audio stream can send all written samples to client.
855
856 // Reset stub data of interest.
857 cras_rstream_audio_ready_called = 0;
858 cras_rstream_audio_ready_count = 0;
859 rstream_.next_cb_ts.tv_sec = 1;
860 rstream_.next_cb_ts.tv_nsec = 0;
861
862 clock_gettime_retspec.tv_sec = 1;
863 clock_gettime_retspec.tv_nsec = 500;
864 rc = dev_stream_capture_update_rstream(dev_stream);
865 EXPECT_EQ(1, cras_rstream_audio_ready_called);
866 EXPECT_EQ(written_frames, cras_rstream_audio_ready_count);
867 EXPECT_EQ(0, rc);
868
869 // Check next_cb_ts is increased by one sleep interval.
870 expected_next_cb_ts.tv_sec = 1;
871 expected_next_cb_ts.tv_nsec = 0;
872 add_timespecs(&expected_next_cb_ts, &rstream_.sleep_interval_ts);
873 EXPECT_EQ(expected_next_cb_ts.tv_sec, rstream_.next_cb_ts.tv_sec);
874 EXPECT_EQ(expected_next_cb_ts.tv_nsec, rstream_.next_cb_ts.tv_nsec);
875
876 dev_stream_destroy(dev_stream);
877 }
878
TEST_F(CreateSuite,TriggerOnlyStreamSendOnlyOnce)879 TEST_F(CreateSuite, TriggerOnlyStreamSendOnlyOnce) {
880 struct dev_stream* dev_stream;
881 unsigned int dev_id = 9;
882
883 rstream_.direction = CRAS_STREAM_INPUT;
884 dev_stream = dev_stream_create(&rstream_, dev_id, &fmt_s16le_44_1,
885 (void*)0x55, &cb_ts, NULL);
886 dev_stream->stream->flags = TRIGGER_ONLY;
887 dev_stream->stream->triggered = 0;
888
889 // Check first trigger callback called.
890 cras_shm_buffer_written(rstream_.shm, rstream_.cb_threshold);
891 clock_gettime_retspec.tv_sec = 1;
892 clock_gettime_retspec.tv_nsec = 0;
893 dev_stream_capture_update_rstream(dev_stream);
894 EXPECT_EQ(1, cras_rstream_audio_ready_called);
895 EXPECT_EQ(1, dev_stream->stream->triggered);
896
897 // No future callback will be called for TRIGGER_ONLY streams.
898 cras_shm_buffer_written(rstream_.shm, rstream_.cb_threshold);
899 clock_gettime_retspec.tv_sec = 2;
900 clock_gettime_retspec.tv_nsec = 0;
901 dev_stream_capture_update_rstream(dev_stream);
902 EXPECT_EQ(1, cras_rstream_audio_ready_called);
903 dev_stream_destroy(dev_stream);
904 }
905
TEST_F(CreateSuite,InputDevStreamWakeTimeByNextCbTs)906 TEST_F(CreateSuite, InputDevStreamWakeTimeByNextCbTs) {
907 struct dev_stream* dev_stream;
908 unsigned int dev_id = 9;
909 int rc;
910 unsigned int curr_level = 0;
911 int written_frames;
912 struct timespec level_tstamp = {.tv_sec = 1, .tv_nsec = 0};
913 struct timespec wake_time_out = {.tv_sec = 0, .tv_nsec = 0};
914
915 rstream_.direction = CRAS_STREAM_INPUT;
916 dev_stream = dev_stream_create(&rstream_, dev_id, &fmt_s16le_44_1,
917 (void*)0x55, &cb_ts, NULL);
918
919 // Assume there is a next_cb_ts on rstream.
920 rstream_.next_cb_ts.tv_sec = 1;
921 rstream_.next_cb_ts.tv_nsec = 500000;
922
923 // Assume there are enough samples for stream.
924 written_frames = rstream_.cb_threshold + 10;
925 cras_shm_buffer_written(rstream_.shm, written_frames);
926
927 rc = dev_stream_wake_time(dev_stream, curr_level, &level_tstamp,
928 rstream_.cb_threshold, 0, &wake_time_out);
929
930 // The next wake up time is determined by next_cb_ts on dev_stream.
931 EXPECT_EQ(rstream_.next_cb_ts.tv_sec, wake_time_out.tv_sec);
932 EXPECT_EQ(rstream_.next_cb_ts.tv_nsec, wake_time_out.tv_nsec);
933 EXPECT_EQ(0, rc);
934 dev_stream_destroy(dev_stream);
935 }
936
TEST_F(CreateSuite,InputDevStreamWakeTimeByDevice)937 TEST_F(CreateSuite, InputDevStreamWakeTimeByDevice) {
938 struct dev_stream* dev_stream;
939 unsigned int dev_id = 9;
940 int rc;
941 unsigned int curr_level = 100;
942 int written_frames;
943 struct timespec level_tstamp = {.tv_sec = 1, .tv_nsec = 0};
944 struct timespec wake_time_out = {.tv_sec = 0, .tv_nsec = 0};
945 struct timespec expected_tstamp = {.tv_sec = 0, .tv_nsec = 0};
946 struct timespec needed_time_for_device = {.tv_sec = 0, .tv_nsec = 0};
947 int needed_frames_from_device = 0;
948
949 rstream_.direction = CRAS_STREAM_INPUT;
950 dev_stream = dev_stream_create(&rstream_, dev_id, &fmt_s16le_48, (void*)0x55,
951 &cb_ts, NULL);
952
953 // Assume there is a next_cb_ts on rstream, that is, 1.005 seconds.
954 rstream_.next_cb_ts.tv_sec = 1;
955 rstream_.next_cb_ts.tv_nsec = 5000000; // 5ms
956
957 // Assume there are not enough samples for stream.
958 written_frames = 123;
959 cras_shm_buffer_written(rstream_.shm, written_frames);
960
961 // Compute wake up time for device level to reach enough samples
962 // for one cb_threshold:
963 // Device has 100 samples (48K rate).
964 // Stream has 123 samples (44.1K rate)
965 // cb_threshold = 512 samples.
966 // Stream needs 512 - 123 = 389 samples.
967 // Converted to device rate => 389 * 48000.0 / 44100 = 423.4 samples
968 // => 424 samples.
969 // Device needs another 424 - 100 = 324 samples.
970 // Time for 252 samples = 324 / 48000 = 0.00675 sec.
971 // So expected wake up time for samples is at level_tstamp + 0.00675 sec =
972 // 1.00675 seconds.
973 needed_frames_from_device =
974 cras_frames_at_rate(44100, rstream_.cb_threshold - written_frames, 48000);
975 needed_frames_from_device -= curr_level;
976 cras_frames_to_time(needed_frames_from_device, 48000,
977 &needed_time_for_device);
978
979 expected_tstamp.tv_sec = level_tstamp.tv_sec;
980 expected_tstamp.tv_nsec = level_tstamp.tv_nsec;
981
982 add_timespecs(&expected_tstamp, &needed_time_for_device);
983
984 // Set the stub data for cras_fmt_conv_out_frames_to_in.
985 out_fmt.frame_rate = 44100;
986 in_fmt.frame_rate = 48000;
987
988 rc = dev_stream_wake_time(dev_stream, curr_level, &level_tstamp,
989 rstream_.cb_threshold, 0, &wake_time_out);
990
991 // The next wake up time is determined by needed time for device level
992 // to reach enough samples for one cb_threshold.
993 EXPECT_EQ(expected_tstamp.tv_sec, wake_time_out.tv_sec);
994 EXPECT_EQ(expected_tstamp.tv_nsec, wake_time_out.tv_nsec);
995 EXPECT_EQ(0, rc);
996
997 // Assume current level is larger than cb_threshold.
998 // The wake up time is determined by next_cb_ts.
999 curr_level += rstream_.cb_threshold;
1000 rc = dev_stream_wake_time(dev_stream, curr_level, &level_tstamp,
1001 rstream_.cb_threshold, 0, &wake_time_out);
1002 EXPECT_EQ(rstream_.next_cb_ts.tv_sec, wake_time_out.tv_sec);
1003 EXPECT_EQ(rstream_.next_cb_ts.tv_nsec, wake_time_out.tv_nsec);
1004 EXPECT_EQ(0, rc);
1005 dev_stream_destroy(dev_stream);
1006 }
1007
TEST_F(CreateSuite,UpdateNextWakeTime)1008 TEST_F(CreateSuite, UpdateNextWakeTime) {
1009 struct dev_stream* dev_stream;
1010 unsigned int dev_id = 9;
1011 struct timespec expected_next_cb_ts;
1012
1013 rstream_.direction = CRAS_STREAM_OUTPUT;
1014 dev_stream = dev_stream_create(&rstream_, dev_id, &fmt_s16le_44_1,
1015 (void*)0x55, &cb_ts, NULL);
1016
1017 // Case 1: The new next_cb_ts is greater than now. Do not need to reschedule.
1018 rstream_.next_cb_ts.tv_sec = 2;
1019 rstream_.next_cb_ts.tv_nsec = 0;
1020 clock_gettime_retspec.tv_sec = 2;
1021 clock_gettime_retspec.tv_nsec = 500;
1022 expected_next_cb_ts = rstream_.next_cb_ts;
1023
1024 dev_stream_update_next_wake_time(dev_stream);
1025 EXPECT_EQ(0, cras_server_metrics_missed_cb_event_called);
1026 add_timespecs(&expected_next_cb_ts, &rstream_.sleep_interval_ts);
1027 EXPECT_EQ(expected_next_cb_ts.tv_sec, rstream_.next_cb_ts.tv_sec);
1028 EXPECT_EQ(expected_next_cb_ts.tv_nsec, rstream_.next_cb_ts.tv_nsec);
1029
1030 // Case 2: The new next_cb_ts is less than now. Need to reset schedule.
1031 rstream_.next_cb_ts.tv_sec = 2;
1032 rstream_.next_cb_ts.tv_nsec = 0;
1033 clock_gettime_retspec.tv_sec = 3;
1034 clock_gettime_retspec.tv_nsec = 0;
1035 expected_next_cb_ts = clock_gettime_retspec;
1036
1037 dev_stream_update_next_wake_time(dev_stream);
1038 EXPECT_EQ(1, cras_server_metrics_missed_cb_event_called);
1039 add_timespecs(&expected_next_cb_ts, &rstream_.sleep_interval_ts);
1040 EXPECT_EQ(expected_next_cb_ts.tv_sec, rstream_.next_cb_ts.tv_sec);
1041 EXPECT_EQ(expected_next_cb_ts.tv_nsec, rstream_.next_cb_ts.tv_nsec);
1042 dev_stream_destroy(dev_stream);
1043 }
1044
1045 // Test set_playback_timestamp.
TEST(DevStreamTimimg,SetPlaybackTimeStampSimple)1046 TEST(DevStreamTimimg, SetPlaybackTimeStampSimple) {
1047 struct cras_timespec ts;
1048
1049 clock_gettime_retspec.tv_sec = 1;
1050 clock_gettime_retspec.tv_nsec = 0;
1051 cras_set_playback_timestamp(48000, 24000, &ts);
1052 EXPECT_EQ(1, ts.tv_sec);
1053 EXPECT_GE(ts.tv_nsec, 499900000);
1054 EXPECT_LE(ts.tv_nsec, 500100000);
1055 }
1056
TEST(DevStreamTimimg,SetPlaybackTimeStampWrap)1057 TEST(DevStreamTimimg, SetPlaybackTimeStampWrap) {
1058 struct cras_timespec ts;
1059
1060 clock_gettime_retspec.tv_sec = 1;
1061 clock_gettime_retspec.tv_nsec = 750000000;
1062 cras_set_playback_timestamp(48000, 24000, &ts);
1063 EXPECT_EQ(2, ts.tv_sec);
1064 EXPECT_GE(ts.tv_nsec, 249900000);
1065 EXPECT_LE(ts.tv_nsec, 250100000);
1066 }
1067
TEST(DevStreamTimimg,SetPlaybackTimeStampWrapTwice)1068 TEST(DevStreamTimimg, SetPlaybackTimeStampWrapTwice) {
1069 struct cras_timespec ts;
1070
1071 clock_gettime_retspec.tv_sec = 1;
1072 clock_gettime_retspec.tv_nsec = 750000000;
1073 cras_set_playback_timestamp(48000, 72000, &ts);
1074 EXPECT_EQ(3, ts.tv_sec);
1075 EXPECT_GE(ts.tv_nsec, 249900000);
1076 EXPECT_LE(ts.tv_nsec, 250100000);
1077 }
1078
1079 // Test set_capture_timestamp.
TEST(DevStreamTimimg,SetCaptureTimeStampSimple)1080 TEST(DevStreamTimimg, SetCaptureTimeStampSimple) {
1081 struct cras_timespec ts;
1082
1083 clock_gettime_retspec.tv_sec = 1;
1084 clock_gettime_retspec.tv_nsec = 750000000;
1085 cras_set_capture_timestamp(48000, 24000, &ts);
1086 EXPECT_EQ(1, ts.tv_sec);
1087 EXPECT_GE(ts.tv_nsec, 249900000);
1088 EXPECT_LE(ts.tv_nsec, 250100000);
1089 }
1090
TEST(DevStreamTimimg,SetCaptureTimeStampWrap)1091 TEST(DevStreamTimimg, SetCaptureTimeStampWrap) {
1092 struct cras_timespec ts;
1093
1094 clock_gettime_retspec.tv_sec = 1;
1095 clock_gettime_retspec.tv_nsec = 0;
1096 cras_set_capture_timestamp(48000, 24000, &ts);
1097 EXPECT_EQ(0, ts.tv_sec);
1098 EXPECT_GE(ts.tv_nsec, 499900000);
1099 EXPECT_LE(ts.tv_nsec, 500100000);
1100 }
1101
TEST(DevStreamTimimg,SetCaptureTimeStampWrapPartial)1102 TEST(DevStreamTimimg, SetCaptureTimeStampWrapPartial) {
1103 struct cras_timespec ts;
1104
1105 clock_gettime_retspec.tv_sec = 2;
1106 clock_gettime_retspec.tv_nsec = 750000000;
1107 cras_set_capture_timestamp(48000, 72000, &ts);
1108 EXPECT_EQ(1, ts.tv_sec);
1109 EXPECT_GE(ts.tv_nsec, 249900000);
1110 EXPECT_LE(ts.tv_nsec, 250100000);
1111 }
1112
1113 TEST(MaxFramesForConverter, 8to48) {
1114 EXPECT_EQ(481, max_frames_for_conversion(80, // Stream frames.
1115 8000, // Stream rate.
1116 48000)); // Device rate.
1117 }
1118
1119 TEST(MaxFramesForConverter, 48to8) {
1120 EXPECT_EQ(81, max_frames_for_conversion(80, // Stream frames.
1121 48000, // Stream rate.
1122 8000)); // Device rate.
1123 }
1124
1125 /* Stubs */
1126 extern "C" {
1127
cras_rstream_audio_ready(struct cras_rstream * stream,size_t count)1128 int cras_rstream_audio_ready(struct cras_rstream* stream, size_t count) {
1129 cras_rstream_audio_ready_count = count;
1130 cras_rstream_audio_ready_called++;
1131 return 0;
1132 }
1133
cras_rstream_request_audio(struct cras_rstream * stream,const struct timespec * now)1134 int cras_rstream_request_audio(struct cras_rstream* stream,
1135 const struct timespec* now) {
1136 return 0;
1137 }
1138
cras_rstream_record_fetch_interval(struct cras_rstream * rstream,const struct timespec * now)1139 void cras_rstream_record_fetch_interval(struct cras_rstream* rstream,
1140 const struct timespec* now) {}
1141
cras_rstream_update_input_write_pointer(struct cras_rstream * rstream)1142 void cras_rstream_update_input_write_pointer(struct cras_rstream* rstream) {}
1143
cras_rstream_update_output_read_pointer(struct cras_rstream * rstream)1144 void cras_rstream_update_output_read_pointer(struct cras_rstream* rstream) {}
1145
cras_rstream_dev_offset_update(struct cras_rstream * rstream,unsigned int frames,unsigned int dev_id)1146 void cras_rstream_dev_offset_update(struct cras_rstream* rstream,
1147 unsigned int frames,
1148 unsigned int dev_id) {}
1149
cras_rstream_dev_attach(struct cras_rstream * rstream,unsigned int dev_id,void * dev_ptr)1150 void cras_rstream_dev_attach(struct cras_rstream* rstream,
1151 unsigned int dev_id,
1152 void* dev_ptr) {}
1153
cras_rstream_dev_detach(struct cras_rstream * rstream,unsigned int dev_id)1154 void cras_rstream_dev_detach(struct cras_rstream* rstream,
1155 unsigned int dev_id) {}
1156
cras_rstream_dev_offset(const struct cras_rstream * rstream,unsigned int dev_id)1157 unsigned int cras_rstream_dev_offset(const struct cras_rstream* rstream,
1158 unsigned int dev_id) {
1159 return 0;
1160 }
1161
cras_rstream_playable_frames(struct cras_rstream * rstream,unsigned int dev_id)1162 unsigned int cras_rstream_playable_frames(struct cras_rstream* rstream,
1163 unsigned int dev_id) {
1164 return rstream_playable_frames_ret;
1165 }
1166
cras_rstream_get_volume_scaler(struct cras_rstream * rstream)1167 float cras_rstream_get_volume_scaler(struct cras_rstream* rstream) {
1168 return 1.0;
1169 }
1170
cras_rstream_get_readable_frames(struct cras_rstream * rstream,unsigned int offset,size_t * frames)1171 uint8_t* cras_rstream_get_readable_frames(struct cras_rstream* rstream,
1172 unsigned int offset,
1173 size_t* frames) {
1174 rstream_get_readable_call.rstream = rstream;
1175 rstream_get_readable_call.offset = offset;
1176 rstream_get_readable_call.num_called++;
1177 *frames = rstream_get_readable_num;
1178 return rstream_get_readable_ptr;
1179 }
1180
cras_rstream_get_mute(const struct cras_rstream * rstream)1181 int cras_rstream_get_mute(const struct cras_rstream* rstream) {
1182 return 0;
1183 }
cras_rstream_update_queued_frames(struct cras_rstream * rstream)1184 void cras_rstream_update_queued_frames(struct cras_rstream* rstream) {}
1185
cras_rstream_post_processing_format(const struct cras_rstream * stream,void * dev_ptr)1186 struct cras_audio_format* cras_rstream_post_processing_format(
1187 const struct cras_rstream* stream,
1188 void* dev_ptr) {
1189 return cras_rstream_post_processing_format_val;
1190 }
buffer_share_get_data(const struct buffer_share * mix,unsigned int id)1191 void* buffer_share_get_data(const struct buffer_share* mix, unsigned int id) {
1192 return NULL;
1193 };
cras_apm_list_start_apm(struct cras_apm_list * list,void * dev_ptr)1194 void cras_apm_list_start_apm(struct cras_apm_list* list, void* dev_ptr){};
cras_apm_list_stop_apm(struct cras_apm_list * list,void * dev_ptr)1195 void cras_apm_list_stop_apm(struct cras_apm_list* list, void* dev_ptr){};
1196
config_format_converter(struct cras_fmt_conv ** conv,enum CRAS_STREAM_DIRECTION dir,const struct cras_audio_format * from,const struct cras_audio_format * to,unsigned int frames)1197 int config_format_converter(struct cras_fmt_conv** conv,
1198 enum CRAS_STREAM_DIRECTION dir,
1199 const struct cras_audio_format* from,
1200 const struct cras_audio_format* to,
1201 unsigned int frames) {
1202 config_format_converter_called++;
1203 config_format_converter_from_fmt = from;
1204 config_format_converter_frames = frames;
1205 *conv = config_format_converter_conv;
1206 return 0;
1207 }
1208
cras_fmt_conv_destroy(struct cras_fmt_conv * conv)1209 void cras_fmt_conv_destroy(struct cras_fmt_conv* conv) {}
1210
cras_fmt_conv_convert_frames(struct cras_fmt_conv * conv,uint8_t * in_buf,uint8_t * out_buf,unsigned int * in_frames,unsigned int out_frames)1211 size_t cras_fmt_conv_convert_frames(struct cras_fmt_conv* conv,
1212 uint8_t* in_buf,
1213 uint8_t* out_buf,
1214 unsigned int* in_frames,
1215 unsigned int out_frames) {
1216 unsigned int ret;
1217 conv_frames_call.conv = conv;
1218 conv_frames_call.in_buf = in_buf;
1219 conv_frames_call.out_buf = out_buf;
1220 conv_frames_call.in_frames = *in_frames;
1221 ret = cras_frames_at_rate(in_fmt.frame_rate, *in_frames, out_fmt.frame_rate);
1222 conv_frames_call.out_frames = out_frames;
1223 if (ret > out_frames) {
1224 ret = out_frames;
1225 *in_frames =
1226 cras_frames_at_rate(out_fmt.frame_rate, ret, in_fmt.frame_rate);
1227 }
1228
1229 return ret;
1230 }
1231
cras_mix_add(snd_pcm_format_t fmt,uint8_t * dst,uint8_t * src,unsigned int count,unsigned int index,int mute,float mix_vol)1232 void cras_mix_add(snd_pcm_format_t fmt,
1233 uint8_t* dst,
1234 uint8_t* src,
1235 unsigned int count,
1236 unsigned int index,
1237 int mute,
1238 float mix_vol) {
1239 mix_add_call.dst = (int16_t*)dst;
1240 mix_add_call.src = (int16_t*)src;
1241 mix_add_call.count = count;
1242 mix_add_call.index = index;
1243 mix_add_call.mute = mute;
1244 mix_add_call.mix_vol = mix_vol;
1245 }
1246
cras_audio_area_create(int num_channels)1247 struct cras_audio_area* cras_audio_area_create(int num_channels) {
1248 cras_audio_area_create_num_channels_val = num_channels;
1249 return NULL;
1250 }
1251
cras_audio_area_destroy(struct cras_audio_area * area)1252 void cras_audio_area_destroy(struct cras_audio_area* area) {}
1253
cras_audio_area_config_buf_pointers(struct cras_audio_area * area,const struct cras_audio_format * fmt,uint8_t * base_buffer)1254 void cras_audio_area_config_buf_pointers(struct cras_audio_area* area,
1255 const struct cras_audio_format* fmt,
1256 uint8_t* base_buffer) {}
1257
cras_audio_area_config_channels(struct cras_audio_area * area,const struct cras_audio_format * fmt)1258 void cras_audio_area_config_channels(struct cras_audio_area* area,
1259 const struct cras_audio_format* fmt) {}
1260
cras_audio_area_copy(const struct cras_audio_area * dst,unsigned int dst_offset,const struct cras_audio_format * dst_fmt,const struct cras_audio_area * src,unsigned int src_offset,float software_gain_scaler)1261 unsigned int cras_audio_area_copy(const struct cras_audio_area* dst,
1262 unsigned int dst_offset,
1263 const struct cras_audio_format* dst_fmt,
1264 const struct cras_audio_area* src,
1265 unsigned int src_offset,
1266 float software_gain_scaler) {
1267 copy_area_call.dst = dst;
1268 copy_area_call.dst_offset = dst_offset;
1269 copy_area_call.dst_format_bytes = cras_get_format_bytes(dst_fmt);
1270 copy_area_call.src = src;
1271 copy_area_call.src_offset = src_offset;
1272 copy_area_call.software_gain_scaler = software_gain_scaler;
1273 return src->frames;
1274 }
1275
cras_fmt_conv_in_frames_to_out(struct cras_fmt_conv * conv,size_t in_frames)1276 size_t cras_fmt_conv_in_frames_to_out(struct cras_fmt_conv* conv,
1277 size_t in_frames) {
1278 return cras_frames_at_rate(in_fmt.frame_rate, in_frames, out_fmt.frame_rate);
1279 }
1280
cras_fmt_conv_out_frames_to_in(struct cras_fmt_conv * conv,size_t out_frames)1281 size_t cras_fmt_conv_out_frames_to_in(struct cras_fmt_conv* conv,
1282 size_t out_frames) {
1283 return cras_frames_at_rate(out_fmt.frame_rate, out_frames, in_fmt.frame_rate);
1284 }
1285
cras_fmt_conv_in_format(const struct cras_fmt_conv * conv)1286 const struct cras_audio_format* cras_fmt_conv_in_format(
1287 const struct cras_fmt_conv* conv) {
1288 return &in_fmt;
1289 }
1290
cras_fmt_conv_out_format(const struct cras_fmt_conv * conv)1291 const struct cras_audio_format* cras_fmt_conv_out_format(
1292 const struct cras_fmt_conv* conv) {
1293 return &out_fmt;
1294 }
1295
cras_fmt_conversion_needed(const struct cras_fmt_conv * conv)1296 int cras_fmt_conversion_needed(const struct cras_fmt_conv* conv) {
1297 return cras_fmt_conversion_needed_val;
1298 }
1299
cras_fmt_conv_set_linear_resample_rates(struct cras_fmt_conv * conv,float from,float to)1300 void cras_fmt_conv_set_linear_resample_rates(struct cras_fmt_conv* conv,
1301 float from,
1302 float to) {
1303 cras_fmt_conv_set_linear_resample_rates_from = from;
1304 cras_fmt_conv_set_linear_resample_rates_to = to;
1305 cras_fmt_conv_set_linear_resample_rates_called++;
1306 }
1307
cras_rstream_is_pending_reply(const struct cras_rstream * stream)1308 int cras_rstream_is_pending_reply(const struct cras_rstream* stream) {
1309 return cras_rstream_is_pending_reply_ret;
1310 }
1311
cras_rstream_flush_old_audio_messages(struct cras_rstream * stream)1312 int cras_rstream_flush_old_audio_messages(struct cras_rstream* stream) {
1313 cras_rstream_flush_old_audio_messages_called++;
1314 return 0;
1315 }
1316
cras_server_metrics_missed_cb_event(struct cras_rstream * stream)1317 int cras_server_metrics_missed_cb_event(struct cras_rstream* stream) {
1318 cras_server_metrics_missed_cb_event_called++;
1319 return 0;
1320 }
1321
1322 // From librt.
clock_gettime(clockid_t clk_id,struct timespec * tp)1323 int clock_gettime(clockid_t clk_id, struct timespec* tp) {
1324 tp->tv_sec = clock_gettime_retspec.tv_sec;
1325 tp->tv_nsec = clock_gettime_retspec.tv_nsec;
1326 return 0;
1327 }
1328
1329 } // extern "C"
1330
1331 } // namespace
1332
main(int argc,char ** argv)1333 int main(int argc, char** argv) {
1334 ::testing::InitGoogleTest(&argc, argv);
1335 return RUN_ALL_TESTS();
1336 }
1337