1 /*
2 * Latency test program
3 *
4 * Author: Jaroslav Kysela <perex@perex.cz>
5 *
6 * Author of bandpass filter sweep effect:
7 * Maarten de Boer <mdeboer@iua.upf.es>
8 *
9 * This small demo program can be used for measuring latency between
10 * capture and playback. This latency is measured from driver (diff when
11 * playback and capture was started). Scheduler is set to SCHED_RR.
12 *
13 *
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
18 *
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, write to the Free Software
26 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 *
28 */
29
30 #include "config.h"
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <sched.h>
35 #include <errno.h>
36 #include <getopt.h>
37 #include <time.h>
38 #include "../include/asoundlib.h"
39 #include <sys/time.h>
40 #include <math.h>
41
42 #ifndef CLOCK_MONOTONIC_RAW
43 #define CLOCK_MONOTONIC_RAW CLOCK_MONOTONIC
44 #endif
45
46 #if defined(__OpenBSD__)
47 #define sched_getparam(pid, parm) (-1)
48 #define sched_setscheduler(pid, policy, parm) (-1)
49 #endif
50
51 typedef struct timespec timestamp_t;
52
53 char *sched_policy = "rr";
54 char *pdevice = "hw:0,0";
55 char *cdevice = "hw:0,0";
56 snd_pcm_format_t format = SND_PCM_FORMAT_S16_LE;
57 int rate = 22050;
58 int channels = 2;
59 int buffer_size = 0; /* auto */
60 int period_size = 0; /* auto */
61 int latency_min = 32; /* in frames / 2 */
62 int latency_max = 2048; /* in frames / 2 */
63 int loop_sec = 30; /* seconds */
64 int block = 0; /* block mode */
65 int use_poll = 0;
66 int usleep_val = 0;
67 int resample = 1;
68 int sys_latency = 0; /* data I/O: use system timings instead driver wakeups */
69 int pos_dump = 0; /* dump positions */
70 int realtime_check = 0;
71 unsigned long loop_limit;
72 snd_pcm_uframes_t playback_buffer_size;
73
74 snd_output_t *output = NULL;
75
frames_to_micro(size_t frames)76 static inline long long frames_to_micro(size_t frames)
77 {
78 return (long long)((frames * 1000000LL) + (rate / 2)) / rate;
79 }
80
timestamp_now(timestamp_t * tstamp)81 void timestamp_now(timestamp_t *tstamp)
82 {
83 if (clock_gettime(CLOCK_MONOTONIC_RAW, tstamp))
84 printf("clock_gettime() failed\n");
85 }
86
timestamp_diff_micro(timestamp_t * tstamp)87 long long timestamp_diff_micro(timestamp_t *tstamp)
88 {
89 timestamp_t now, diff;
90 timestamp_now(&now);
91 if (tstamp->tv_nsec > now.tv_nsec) {
92 diff.tv_sec = now.tv_sec - tstamp->tv_sec - 1;
93 diff.tv_nsec = (now.tv_nsec + 1000000000L) - tstamp->tv_nsec;
94 } else {
95 diff.tv_sec = now.tv_sec - tstamp->tv_sec;
96 diff.tv_nsec = now.tv_nsec - tstamp->tv_nsec;
97 }
98 /* microseconds */
99 return (diff.tv_sec * 1000000) + ((diff.tv_nsec + 500L) / 1000L);
100 }
101
setparams_stream(snd_pcm_t * handle,snd_pcm_hw_params_t * params,const char * id)102 int setparams_stream(snd_pcm_t *handle,
103 snd_pcm_hw_params_t *params,
104 const char *id)
105 {
106 int err;
107 unsigned int rrate;
108
109 err = snd_pcm_hw_params_any(handle, params);
110 if (err < 0) {
111 printf("Broken configuration for %s PCM: no configurations available: %s\n", snd_strerror(err), id);
112 return err;
113 }
114 err = snd_pcm_hw_params_set_rate_resample(handle, params, resample);
115 if (err < 0) {
116 printf("Resample setup failed for %s (val %i): %s\n", id, resample, snd_strerror(err));
117 return err;
118 }
119 err = snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
120 if (err < 0) {
121 printf("Access type not available for %s: %s\n", id, snd_strerror(err));
122 return err;
123 }
124 err = snd_pcm_hw_params_set_format(handle, params, format);
125 if (err < 0) {
126 printf("Sample format not available for %s: %s\n", id, snd_strerror(err));
127 return err;
128 }
129 err = snd_pcm_hw_params_set_channels(handle, params, channels);
130 if (err < 0) {
131 printf("Channels count (%i) not available for %s: %s\n", channels, id, snd_strerror(err));
132 return err;
133 }
134 rrate = rate;
135 err = snd_pcm_hw_params_set_rate_near(handle, params, &rrate, 0);
136 if (err < 0) {
137 printf("Rate %iHz not available for %s: %s\n", rate, id, snd_strerror(err));
138 return err;
139 }
140 if ((int)rrate != rate) {
141 printf("Rate doesn't match (requested %iHz, get %iHz)\n", rate, err);
142 return -EINVAL;
143 }
144 /* we do not want driver wakeups */
145 if (sys_latency > 0 && snd_pcm_hw_params_can_disable_period_wakeup(params)) {
146 err = snd_pcm_hw_params_set_period_wakeup(handle, params, 0);
147 if (err < 0) {
148 printf("Cannot disable period wakeups for %s\n", id);
149 return err;
150 }
151 }
152 return 0;
153 }
154
setparams_bufsize(snd_pcm_t * handle,snd_pcm_hw_params_t * params,snd_pcm_hw_params_t * tparams,snd_pcm_uframes_t bufsize,const char * id)155 int setparams_bufsize(snd_pcm_t *handle,
156 snd_pcm_hw_params_t *params,
157 snd_pcm_hw_params_t *tparams,
158 snd_pcm_uframes_t bufsize,
159 const char *id)
160 {
161 int err;
162 snd_pcm_uframes_t periodsize;
163
164 snd_pcm_hw_params_copy(params, tparams);
165 periodsize = bufsize * 2;
166 err = snd_pcm_hw_params_set_buffer_size_near(handle, params, &periodsize);
167 if (err < 0) {
168 printf("Unable to set buffer size %li for %s: %s\n", bufsize * 2, id, snd_strerror(err));
169 return err;
170 }
171 if (period_size > 0)
172 periodsize = period_size;
173 else
174 periodsize /= 2;
175 err = snd_pcm_hw_params_set_period_size_near(handle, params, &periodsize, 0);
176 if (err < 0) {
177 printf("Unable to set period size %li for %s: %s\n", periodsize, id, snd_strerror(err));
178 return err;
179 }
180 return 0;
181 }
182
setparams_set(snd_pcm_t * handle,snd_pcm_hw_params_t * params,snd_pcm_sw_params_t * swparams,const char * id)183 int setparams_set(snd_pcm_t *handle,
184 snd_pcm_hw_params_t *params,
185 snd_pcm_sw_params_t *swparams,
186 const char *id)
187 {
188 int err;
189 snd_pcm_uframes_t val;
190
191 err = snd_pcm_hw_params(handle, params);
192 if (err < 0) {
193 printf("Unable to set hw params for %s: %s\n", id, snd_strerror(err));
194 return err;
195 }
196 err = snd_pcm_sw_params_current(handle, swparams);
197 if (err < 0) {
198 printf("Unable to determine current swparams for %s: %s\n", id, snd_strerror(err));
199 return err;
200 }
201 err = snd_pcm_sw_params_set_start_threshold(handle, swparams, 0x7fffffff);
202 if (err < 0) {
203 printf("Unable to set start threshold mode for %s: %s\n", id, snd_strerror(err));
204 return err;
205 }
206 if (!block)
207 val = 4;
208 else
209 snd_pcm_hw_params_get_period_size(params, &val, NULL);
210 err = snd_pcm_sw_params_set_avail_min(handle, swparams, val);
211 if (err < 0) {
212 printf("Unable to set avail min for %s: %s\n", id, snd_strerror(err));
213 return err;
214 }
215 err = snd_pcm_sw_params(handle, swparams);
216 if (err < 0) {
217 printf("Unable to set sw params for %s: %s\n", id, snd_strerror(err));
218 return err;
219 }
220 return 0;
221 }
222
setparams(snd_pcm_t * phandle,snd_pcm_t * chandle,int * bufsize)223 int setparams(snd_pcm_t *phandle, snd_pcm_t *chandle, int *bufsize)
224 {
225 int err, last_bufsize = *bufsize;
226 snd_pcm_hw_params_t *pt_params, *ct_params; /* templates with rate, format and channels */
227 snd_pcm_hw_params_t *p_params, *c_params;
228 snd_pcm_sw_params_t *p_swparams, *c_swparams;
229 snd_pcm_uframes_t p_size, c_size, p_psize, c_psize;
230 unsigned int p_time, c_time;
231 unsigned int val;
232
233 snd_pcm_hw_params_alloca(&p_params);
234 snd_pcm_hw_params_alloca(&c_params);
235 snd_pcm_hw_params_alloca(&pt_params);
236 snd_pcm_hw_params_alloca(&ct_params);
237 snd_pcm_sw_params_alloca(&p_swparams);
238 snd_pcm_sw_params_alloca(&c_swparams);
239 if ((err = setparams_stream(phandle, pt_params, "playback")) < 0) {
240 printf("Unable to set parameters for playback stream: %s\n", snd_strerror(err));
241 exit(0);
242 }
243 if ((err = setparams_stream(chandle, ct_params, "capture")) < 0) {
244 printf("Unable to set parameters for playback stream: %s\n", snd_strerror(err));
245 exit(0);
246 }
247
248 if (buffer_size > 0) {
249 *bufsize = buffer_size;
250 goto __set_it;
251 }
252
253 __again:
254 if (buffer_size > 0)
255 return -1;
256 if (last_bufsize == *bufsize)
257 *bufsize += 4;
258 last_bufsize = *bufsize;
259 if (*bufsize > latency_max)
260 return -1;
261 __set_it:
262 if ((err = setparams_bufsize(phandle, p_params, pt_params, *bufsize, "playback")) < 0) {
263 printf("Unable to set hw parameters for playback stream: %s\n", snd_strerror(err));
264 exit(0);
265 }
266 if ((err = setparams_bufsize(chandle, c_params, ct_params, *bufsize, "capture")) < 0) {
267 printf("Unable to set hw parameters for capture stream: %s\n", snd_strerror(err));
268 exit(0);
269 }
270
271 snd_pcm_hw_params_get_period_size(p_params, &p_psize, NULL);
272 if (p_psize > (unsigned int)*bufsize)
273 *bufsize = p_psize;
274 snd_pcm_hw_params_get_period_size(c_params, &c_psize, NULL);
275 if (c_psize > (unsigned int)*bufsize)
276 *bufsize = c_psize;
277 snd_pcm_hw_params_get_period_time(p_params, &p_time, NULL);
278 snd_pcm_hw_params_get_period_time(c_params, &c_time, NULL);
279 if (p_time != c_time)
280 goto __again;
281
282 snd_pcm_hw_params_get_buffer_size(p_params, &p_size);
283 playback_buffer_size = p_size;
284 if (p_psize * 2 < p_size) {
285 snd_pcm_hw_params_get_periods_min(p_params, &val, NULL);
286 if (val > 2) {
287 printf("playback device does not support 2 periods per buffer\n");
288 exit(0);
289 }
290 goto __again;
291 }
292 snd_pcm_hw_params_get_buffer_size(c_params, &c_size);
293 if (c_psize * 2 < c_size) {
294 snd_pcm_hw_params_get_periods_min(c_params, &val, NULL);
295 if (val > 2 ) {
296 printf("capture device does not support 2 periods per buffer\n");
297 exit(0);
298 }
299 goto __again;
300 }
301 if ((err = setparams_set(phandle, p_params, p_swparams, "playback")) < 0) {
302 printf("Unable to set sw parameters for playback stream: %s\n", snd_strerror(err));
303 exit(0);
304 }
305 if ((err = setparams_set(chandle, c_params, c_swparams, "capture")) < 0) {
306 printf("Unable to set sw parameters for playback stream: %s\n", snd_strerror(err));
307 exit(0);
308 }
309
310 if ((err = snd_pcm_prepare(phandle)) < 0) {
311 printf("Prepare error: %s\n", snd_strerror(err));
312 exit(0);
313 }
314
315 snd_pcm_dump(phandle, output);
316 snd_pcm_dump(chandle, output);
317 fflush(stdout);
318 return 0;
319 }
320
showstat(snd_pcm_t * handle,size_t frames)321 void showstat(snd_pcm_t *handle, size_t frames)
322 {
323 int err;
324 snd_pcm_status_t *status;
325
326 snd_pcm_status_alloca(&status);
327 if ((err = snd_pcm_status(handle, status)) < 0) {
328 printf("Stream status error: %s\n", snd_strerror(err));
329 exit(0);
330 }
331 printf("*** frames = %li ***\n", (long)frames);
332 snd_pcm_status_dump(status, output);
333 }
334
showlatency(size_t latency)335 void showlatency(size_t latency)
336 {
337 double d;
338 latency *= 2;
339 d = (double)latency / (double)rate;
340 printf("Trying latency %li frames, %.3fus, %.6fms (%.4fHz)\n", (long)latency, d * 1000000, d * 1000, (double)1 / d);
341 }
342
showinmax(size_t in_max)343 void showinmax(size_t in_max)
344 {
345 double d;
346
347 printf("Maximum read: %li frames\n", (long)in_max);
348 d = (double)in_max / (double)rate;
349 printf("Maximum read latency: %.3fus, %.6fms (%.4fHz)\n", d * 1000000, d * 1000, (double)1 / d);
350 }
351
gettimestamp(snd_pcm_t * handle,snd_timestamp_t * timestamp)352 void gettimestamp(snd_pcm_t *handle, snd_timestamp_t *timestamp)
353 {
354 int err;
355 snd_pcm_status_t *status;
356
357 snd_pcm_status_alloca(&status);
358 if ((err = snd_pcm_status(handle, status)) < 0) {
359 printf("Stream status error: %s\n", snd_strerror(err));
360 exit(0);
361 }
362 snd_pcm_status_get_trigger_tstamp(status, timestamp);
363 }
364
setscheduler(void)365 void setscheduler(void)
366 {
367 struct sched_param sched_param;
368 int policy = SCHED_RR;
369 const char *spolicy = "Round Robin";
370
371 if (strcasecmp(sched_policy, "fifo") == 0) {
372 policy = SCHED_FIFO;
373 spolicy = "FIFO";
374 } else if (strcasecmp(sched_policy, "other") == 0) {
375 policy = SCHED_OTHER;
376 spolicy = "OTHER";
377 }
378 if (sched_getparam(0, &sched_param) < 0) {
379 printf("Scheduler getparam failed...\n");
380 return;
381 }
382 sched_param.sched_priority = sched_get_priority_max(policy);
383 if (!sched_setscheduler(0, policy, &sched_param)) {
384 printf("Scheduler set to %s with priority %i...\n", spolicy, sched_param.sched_priority);
385 fflush(stdout);
386 return;
387 }
388 printf("!!!Scheduler set to %s with priority %i FAILED!!!\n", spolicy, sched_param.sched_priority);
389 }
390
timediff(snd_timestamp_t t1,snd_timestamp_t t2)391 long timediff(snd_timestamp_t t1, snd_timestamp_t t2)
392 {
393 signed long l;
394
395 t1.tv_sec -= t2.tv_sec;
396 l = (signed long) t1.tv_usec - (signed long) t2.tv_usec;
397 if (l < 0) {
398 t1.tv_sec--;
399 l = 1000000 + l;
400 l %= 1000000;
401 }
402 return (t1.tv_sec * 1000000) + l;
403 }
404
readbuf(snd_pcm_t * handle,char * buf,long len,size_t * frames,size_t * max)405 long readbuf(snd_pcm_t *handle, char *buf, long len, size_t *frames, size_t *max)
406 {
407 long r;
408
409 if (!block) {
410 do {
411 r = snd_pcm_readi(handle, buf, len);
412 } while (r == -EAGAIN);
413 if (r > 0) {
414 *frames += r;
415 if ((long)*max < r)
416 *max = r;
417 }
418 // printf("read = %li\n", r);
419 } else {
420 int frame_bytes = (snd_pcm_format_physical_width(format) / 8) * channels;
421 do {
422 r = snd_pcm_readi(handle, buf, len);
423 if (r > 0) {
424 buf += r * frame_bytes;
425 len -= r;
426 *frames += r;
427 if ((long)*max < r)
428 *max = r;
429 }
430 // printf("r = %li, len = %li\n", r, len);
431 } while (r >= 1 && len > 0);
432 }
433 // showstat(handle, 0);
434 return r;
435 }
436
writebuf(snd_pcm_t * handle,char * buf,long len,size_t * frames)437 long writebuf(snd_pcm_t *handle, char *buf, long len, size_t *frames)
438 {
439 long r;
440 int frame_bytes = (snd_pcm_format_physical_width(format) / 8) * channels;
441
442 while (len > 0) {
443 r = snd_pcm_writei(handle, buf, len);
444 if (r == -EAGAIN)
445 continue;
446 // printf("write = %li\n", r);
447 if (r < 0)
448 return r;
449 // showstat(handle, 0);
450 buf += r * frame_bytes;
451 len -= r;
452 *frames += r;
453 }
454 return 0;
455 }
456
457 #define FILTERSWEEP_LFO_CENTER 2000.
458 #define FILTERSWEEP_LFO_DEPTH 1800.
459 #define FILTERSWEEP_LFO_FREQ 0.2
460 #define FILTER_BANDWIDTH 50
461
462 /* filter the sweep variables */
463 float lfo,dlfo,fs,fc,BW,C,D,a0,a1,a2,b1,b2,*x[3],*y[3];
464
applyeffect(char * buffer,int r)465 void applyeffect(char* buffer,int r)
466 {
467 short* samples = (short*) buffer;
468 int i;
469 for (i=0;i<r;i++)
470 {
471 int chn;
472
473 fc = sin(lfo)*FILTERSWEEP_LFO_DEPTH+FILTERSWEEP_LFO_CENTER;
474 lfo += dlfo;
475 if (lfo>2.*M_PI) lfo -= 2.*M_PI;
476 C = 1./tan(M_PI*BW/fs);
477 D = 2.*cos(2*M_PI*fc/fs);
478 a0 = 1./(1.+C);
479 a1 = 0;
480 a2 = -a0;
481 b1 = -C*D*a0;
482 b2 = (C-1)*a0;
483
484 for (chn=0;chn<channels;chn++)
485 {
486 x[chn][2] = x[chn][1];
487 x[chn][1] = x[chn][0];
488
489 y[chn][2] = y[chn][1];
490 y[chn][1] = y[chn][0];
491
492 x[chn][0] = samples[i*channels+chn];
493 y[chn][0] = a0*x[chn][0] + a1*x[chn][1] + a2*x[chn][2]
494 - b1*y[chn][1] - b2*y[chn][2];
495 samples[i*channels+chn] = y[chn][0];
496 }
497 }
498 }
499
get_avail(snd_pcm_t * pcm)500 static ssize_t get_avail(snd_pcm_t *pcm)
501 {
502 ssize_t avail;
503
504 while (1) {
505 avail = snd_pcm_avail(pcm);
506 if (avail == -EAGAIN)
507 continue;
508 break;
509 }
510 return avail;
511 }
512
help(void)513 void help(void)
514 {
515 int k;
516 printf(
517 "Usage: latency [OPTION]... [FILE]...\n"
518 "-h,--help help\n"
519 "-P,--pdevice playback device\n"
520 "-C,--cdevice capture device\n"
521 "-m,--min minimum latency in frames\n"
522 "-M,--max maximum latency in frames\n"
523 "-U,--updates I/O updates in milliseconds (0 = off)\n"
524 "-F,--frames frames to transfer\n"
525 "-f,--format sample format\n"
526 "-c,--channels channels\n"
527 "-r,--rate rate\n"
528 "-B,--buffer buffer size in frames\n"
529 "-E,--period period size in frames\n"
530 "-s,--seconds duration of test in seconds\n"
531 "-b,--block block mode\n"
532 "-p,--poll use poll (wait for event - reduces CPU usage)\n"
533 "-y,--usleep sleep for the specified amount of microseconds between\n"
534 " stream updates (default 0 - off)\n"
535 "-e,--effect apply an effect (bandpass filter sweep)\n"
536 "-x,--posdump dump buffer positions\n"
537 "-X,--realtime do a realtime check (buffering)\n"
538 "-O,--policy set scheduler policy (RR, FIFO or OTHER)\n"
539 );
540 printf("Recognized sample formats are:");
541 for (k = 0; k < SND_PCM_FORMAT_LAST; ++k) {
542 const char *s = snd_pcm_format_name(k);
543 if (s)
544 printf(" %s", s);
545 }
546 printf("\n\n");
547 printf(
548 "Tip #1 (usable latency with large periods, non-blocking mode, good CPU usage,\n"
549 " superb xrun prevention):\n"
550 " latency -m 8192 -M 8192 -t 1 -p\n"
551 "Tip #2 (superb latency, non-blocking mode, but heavy CPU usage):\n"
552 " latency -m 128 -M 128\n"
553 );
554 }
555
main(int argc,char * argv[])556 int main(int argc, char *argv[])
557 {
558 struct option long_option[] =
559 {
560 {"help", 0, NULL, 'h'},
561 {"pdevice", 1, NULL, 'P'},
562 {"cdevice", 1, NULL, 'C'},
563 {"min", 1, NULL, 'm'},
564 {"max", 1, NULL, 'M'},
565 {"updates", 1, NULL, 'U'},
566 {"frames", 1, NULL, 'F'},
567 {"format", 1, NULL, 'f'},
568 {"channels", 1, NULL, 'c'},
569 {"rate", 1, NULL, 'r'},
570 {"buffer", 1, NULL, 'B'},
571 {"period", 1, NULL, 'E'},
572 {"seconds", 1, NULL, 's'},
573 {"block", 0, NULL, 'b'},
574 {"poll", 0, NULL, 'p'},
575 {"usleep", 1, NULL, 'y'},
576 {"effect", 0, NULL, 'e'},
577 {"posdump", 0, NULL, 'x'},
578 {"realtime", 0, NULL, 'X'},
579 {"policy", 1, NULL, 'O'},
580 {NULL, 0, NULL, 0},
581 };
582 snd_pcm_t *phandle, *chandle;
583 char *buffer;
584 int err, latency, morehelp;
585 int ok;
586 snd_timestamp_t p_tstamp, c_tstamp;
587 ssize_t r, cap_avail, cap_avail_max, pbk_fill, pbk_fill_min;
588 size_t frames_in, frames_out, in_max;
589 timestamp_t tstamp_start;
590 int effect = 0;
591 morehelp = 0;
592 while (1) {
593 int c;
594 if ((c = getopt_long(argc, argv, "hP:C:m:M:U:F:f:c:r:B:E:s:y:O:bpenxX", long_option, NULL)) < 0)
595 break;
596 switch (c) {
597 case 'h':
598 morehelp++;
599 break;
600 case 'P':
601 pdevice = strdup(optarg);
602 break;
603 case 'C':
604 cdevice = strdup(optarg);
605 break;
606 case 'm':
607 err = atoi(optarg) / 2;
608 latency_min = err >= 4 ? err : 4;
609 if (latency_max < latency_min)
610 latency_max = latency_min;
611 break;
612 case 'M':
613 err = atoi(optarg) / 2;
614 latency_max = latency_min > err ? latency_min : err;
615 break;
616 case 'U':
617 err = atoi(optarg);
618 sys_latency = err <= 0 ? 0 : err;
619 break;
620 case 'f':
621 format = snd_pcm_format_value(optarg);
622 if (format == SND_PCM_FORMAT_UNKNOWN) {
623 printf("Unknown format, setting to default S16_LE\n");
624 format = SND_PCM_FORMAT_S16_LE;
625 }
626 break;
627 case 'c':
628 err = atoi(optarg);
629 channels = err >= 1 && err < 1024 ? err : 1;
630 break;
631 case 'r':
632 err = atoi(optarg);
633 rate = err >= 4000 && err < 200000 ? err : 44100;
634 break;
635 case 'B':
636 err = atoi(optarg);
637 buffer_size = err >= 32 && err < 200000 ? err : 0;
638 break;
639 case 'E':
640 err = atoi(optarg);
641 period_size = err >= 32 && err < 200000 ? err : 0;
642 break;
643 case 's':
644 err = atoi(optarg);
645 loop_sec = err >= 1 && err <= 100000 ? err : 30;
646 break;
647 case 'b':
648 block = 1;
649 break;
650 case 'p':
651 use_poll = 1;
652 break;
653 case 'y':
654 usleep_val = atoi(optarg);
655 break;
656 case 'e':
657 effect = 1;
658 break;
659 case 'n':
660 resample = 0;
661 break;
662 case 'x':
663 pos_dump = 1;
664 break;
665 case 'X':
666 realtime_check = 1;
667 break;
668 case 'O':
669 sched_policy = optarg;
670 break;
671 }
672 }
673
674 if (morehelp) {
675 help();
676 return 0;
677 }
678 err = snd_output_stdio_attach(&output, stdout, 0);
679 if (err < 0) {
680 printf("Output failed: %s\n", snd_strerror(err));
681 return 0;
682 }
683
684 loop_limit = loop_sec * rate;
685 latency = latency_min - 4;
686 buffer = malloc((latency_max * 2 * snd_pcm_format_physical_width(format) / 8) * channels);
687
688 /* I/O updates based on a system timer */
689 if (sys_latency > 0) {
690 block = 0;
691 use_poll = 0;
692 }
693
694 setscheduler();
695
696 printf("Playback device is %s\n", pdevice);
697 printf("Capture device is %s\n", cdevice);
698 printf("Parameters are %iHz, %s, %i channels, %s mode, use poll %s\n",
699 rate, snd_pcm_format_name(format),
700 channels, block ? "blocking" : "non-blocking",
701 use_poll ? "yes" : "no");
702 printf("Loop limit is %lu frames, minimum latency = %i, maximum latency = %i",
703 loop_limit, latency_min * 2, latency_max * 2);
704 if (sys_latency > 0)
705 printf(", I/O updates %ims", sys_latency);
706 else if (!block && !use_poll)
707 printf(", I/O usleep %ius", usleep_val);
708 printf("\n");
709
710 if ((err = snd_pcm_open(&phandle, pdevice, SND_PCM_STREAM_PLAYBACK, block ? 0 : SND_PCM_NONBLOCK)) < 0) {
711 printf("Playback open error: %s\n", snd_strerror(err));
712 return 0;
713 }
714 if ((err = snd_pcm_open(&chandle, cdevice, SND_PCM_STREAM_CAPTURE, block ? 0 : SND_PCM_NONBLOCK)) < 0) {
715 printf("Record open error: %s\n", snd_strerror(err));
716 return 0;
717 }
718
719 /* initialize the filter sweep variables */
720 if (effect) {
721 fs = (float) rate;
722 BW = FILTER_BANDWIDTH;
723
724 lfo = 0;
725 dlfo = 2.*M_PI*FILTERSWEEP_LFO_FREQ/fs;
726
727 x[0] = (float*) malloc(channels*sizeof(float));
728 x[1] = (float*) malloc(channels*sizeof(float));
729 x[2] = (float*) malloc(channels*sizeof(float));
730 y[0] = (float*) malloc(channels*sizeof(float));
731 y[1] = (float*) malloc(channels*sizeof(float));
732 y[2] = (float*) malloc(channels*sizeof(float));
733 }
734
735 cap_avail_max = 0;
736 pbk_fill_min = latency * 2;
737
738 while (1) {
739 frames_in = frames_out = 0;
740 if (setparams(phandle, chandle, &latency) < 0)
741 break;
742 showlatency(latency);
743 if ((err = snd_pcm_link(chandle, phandle)) < 0) {
744 printf("Streams link error: %s\n", snd_strerror(err));
745 exit(0);
746 }
747 if (snd_pcm_format_set_silence(format, buffer, latency * channels) < 0) {
748 fprintf(stderr, "silence error\n");
749 break;
750 }
751 if (writebuf(phandle, buffer, latency, &frames_out) < 0) {
752 fprintf(stderr, "write error\n");
753 break;
754 }
755 if (writebuf(phandle, buffer, latency, &frames_out) < 0) {
756 fprintf(stderr, "write error\n");
757 break;
758 }
759
760 if (realtime_check)
761 timestamp_now(&tstamp_start);
762 if ((err = snd_pcm_start(chandle)) < 0) {
763 printf("Go error: %s\n", snd_strerror(err));
764 exit(0);
765 }
766 if (realtime_check)
767 printf("[%lldus] Stream start\n", timestamp_diff_micro(&tstamp_start));
768 gettimestamp(phandle, &p_tstamp);
769 gettimestamp(chandle, &c_tstamp);
770 #if 0
771 printf("Playback:\n");
772 showstat(phandle, frames_out);
773 printf("Capture:\n");
774 showstat(chandle, frames_in);
775 #endif
776
777 ok = 1;
778 in_max = 0;
779 while (ok && frames_in < loop_limit) {
780 cap_avail = latency;
781 if (sys_latency > 0) {
782 poll(NULL, 0, sys_latency);
783 cap_avail = get_avail(chandle);
784 if (cap_avail < 0) {
785 printf("Avail failed: %s\n", snd_strerror(cap_avail));
786 ok = 0;
787 break;
788 }
789 } else if (use_poll) {
790 /* use poll to wait for next event */
791 snd_pcm_wait(chandle, 1000);
792 } else if (!block && usleep_val > 0) {
793 usleep(usleep_val);
794 }
795 if (pos_dump || realtime_check) {
796 if (sys_latency <= 0)
797 cap_avail = get_avail(chandle);
798 pbk_fill = get_avail(phandle);
799 if (pbk_fill >= 0)
800 pbk_fill = playback_buffer_size - pbk_fill;
801 if (cap_avail > cap_avail_max)
802 cap_avail_max = cap_avail;
803 if (pbk_fill >= 0 && pbk_fill < pbk_fill_min)
804 pbk_fill_min = pbk_fill;
805 if (realtime_check) {
806 long long diff = timestamp_diff_micro(&tstamp_start);
807 long long cap_pos = frames_to_micro(frames_in + cap_avail);
808 long long pbk_pos = frames_to_micro(frames_out - pbk_fill);
809 printf("[%lldus] POS: p=%zd (min=%zd, rt=%lldus) c=%zd (max=%zd, rt=%lldus)\n",
810 diff, pbk_fill, pbk_fill_min, pbk_pos - diff,
811 cap_avail, cap_avail_max, cap_pos - diff);
812 } else if (pos_dump) {
813 printf("POS: p=%zd (min=%zd), c=%zd (max=%zd)\n",
814 pbk_fill, pbk_fill_min, cap_avail, cap_avail_max);
815 }
816 }
817 if ((r = readbuf(chandle, buffer, cap_avail, &frames_in, &in_max)) < 0)
818 ok = 0;
819 else {
820 if (effect)
821 applyeffect(buffer, r);
822 if (writebuf(phandle, buffer, r, &frames_out) < 0)
823 ok = 0;
824 }
825 }
826 if (ok)
827 printf("Success\n");
828 else
829 printf("Failure\n");
830 printf("Playback:\n");
831 showstat(phandle, frames_out);
832 printf("Capture:\n");
833 showstat(chandle, frames_in);
834 showinmax(in_max);
835 if (p_tstamp.tv_sec == c_tstamp.tv_sec &&
836 p_tstamp.tv_usec == c_tstamp.tv_usec)
837 printf("Hardware sync\n");
838 if (realtime_check) {
839 long long diff = timestamp_diff_micro(&tstamp_start);
840 long long mtime = frames_to_micro(frames_in);
841 printf("Elapsed real time: %lldus\n", diff);
842 printf("Elapsed device time: %lldus\n", mtime);
843 printf("Test time diff (device - real): %lldus\n", mtime - diff);
844 }
845 snd_pcm_drop(chandle);
846 snd_pcm_nonblock(phandle, 0);
847 snd_pcm_drain(phandle);
848 snd_pcm_nonblock(phandle, !block ? 1 : 0);
849 if (ok) {
850 #if 1
851 printf("Playback time = %li.%i, Record time = %li.%i, diff = %li\n",
852 (long)p_tstamp.tv_sec,
853 (int)p_tstamp.tv_usec,
854 (long)c_tstamp.tv_sec,
855 (int)c_tstamp.tv_usec,
856 timediff(p_tstamp, c_tstamp));
857 #endif
858 break;
859 }
860 snd_pcm_unlink(chandle);
861 snd_pcm_hw_free(phandle);
862 snd_pcm_hw_free(chandle);
863 }
864 snd_pcm_close(phandle);
865 snd_pcm_close(chandle);
866 snd_output_close(output);
867 snd_config_update_free_global();
868 free(buffer);
869 free(pdevice);
870 free(cdevice);
871 return 0;
872 }
873