src/tests/alsa-time-test.c

   1 #ifndef _GNU_SOURCE
   2 #define _GNU_SOURCE
   3 #endif
   4
   5 #include <assert.h>
   6 #include <inttypes.h>
   7 #include <time.h>
   8
   9 #include <check.h>
  10
  11 #include <alsa/asoundlib.h>
  12
  13 static const char *dev;
  14 static int cap;
  15
  16 static uint64_t timespec_us(const struct timespec *ts) {
  17     return
  18         ts->tv_sec * 1000000LLU +
  19         ts->tv_nsec / 1000LLU;
  20 }
  21
  22 START_TEST (alsa_time_test) {
  23     int r;
  24     snd_pcm_hw_params_t *hwparams;
  25     snd_pcm_sw_params_t *swparams;
  26     snd_pcm_status_t *status;
  27     snd_pcm_t *pcm;
  28     unsigned rate = 44100;
  29     unsigned periods = 2;
  30     snd_pcm_uframes_t boundary, buffer_size = 44100/10; /* 100s */
  31     int dir = 1;
  32     struct timespec start, last_timestamp = { 0, 0 };
  33     uint64_t start_us;
  34     snd_pcm_sframes_t last_avail = 0, last_delay = 0;
  35     struct pollfd *pollfds;
  36     int n_pollfd;
  37     int64_t sample_count = 0;
  38
  39     snd_pcm_hw_params_alloca(&hwparams);
  40     snd_pcm_sw_params_alloca(&swparams);
  41     snd_pcm_status_alloca(&status);
  42
  43     r = clock_gettime(CLOCK_MONOTONIC, &start);
  44     fail_unless(r == 0);
  45
  46     start_us = timespec_us(&start);
  47
  48     if (cap == 0)
  49       r = snd_pcm_open(&pcm, dev, SND_PCM_STREAM_PLAYBACK, 0);
  50     else
  51       r = snd_pcm_open(&pcm, dev, SND_PCM_STREAM_CAPTURE, 0);
  52     fail_unless(r == 0);
  53
  54     r = snd_pcm_hw_params_any(pcm, hwparams);
  55     fail_unless(r == 0);
  56
  57     r = snd_pcm_hw_params_set_rate_resample(pcm, hwparams, 0);
  58     fail_unless(r == 0);
  59
  60     r = snd_pcm_hw_params_set_access(pcm, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED);
  61     fail_unless(r == 0);
  62
  63     r = snd_pcm_hw_params_set_format(pcm, hwparams, SND_PCM_FORMAT_S16_LE);
  64     fail_unless(r == 0);
  65
  66     r = snd_pcm_hw_params_set_rate_near(pcm, hwparams, &rate, NULL);
  67     fail_unless(r == 0);
  68
  69     r = snd_pcm_hw_params_set_channels(pcm, hwparams, 2);
  70     fail_unless(r == 0);
  71
  72     r = snd_pcm_hw_params_set_periods_integer(pcm, hwparams);
  73     fail_unless(r == 0);
  74
  75     r = snd_pcm_hw_params_set_periods_near(pcm, hwparams, &periods, &dir);
  76     fail_unless(r == 0);
  77
  78     r = snd_pcm_hw_params_set_buffer_size_near(pcm, hwparams, &buffer_size);
  79     fail_unless(r == 0);
  80
  81     r = snd_pcm_hw_params(pcm, hwparams);
  82     fail_unless(r == 0);
  83
  84     r = snd_pcm_hw_params_current(pcm, hwparams);
  85     fail_unless(r == 0);
  86
  87     r = snd_pcm_sw_params_current(pcm, swparams);
  88     fail_unless(r == 0);
  89
  90     if (cap == 0)
  91       r = snd_pcm_sw_params_set_avail_min(pcm, swparams, 1);
  92     else
  93       r = snd_pcm_sw_params_set_avail_min(pcm, swparams, 0);
  94     fail_unless(r == 0);
  95
  96     r = snd_pcm_sw_params_set_period_event(pcm, swparams, 0);
  97     fail_unless(r == 0);
  98
  99     r = snd_pcm_hw_params_get_buffer_size(hwparams, &buffer_size);
 100     fail_unless(r == 0);
 101     r = snd_pcm_sw_params_set_start_threshold(pcm, swparams, buffer_size);
 102     fail_unless(r == 0);
 103
 104     r = snd_pcm_sw_params_get_boundary(swparams, &boundary);
 105     fail_unless(r == 0);
 106     r = snd_pcm_sw_params_set_stop_threshold(pcm, swparams, boundary);
 107     fail_unless(r == 0);
 108
 109     r = snd_pcm_sw_params_set_tstamp_mode(pcm, swparams, SND_PCM_TSTAMP_ENABLE);
 110     fail_unless(r == 0);
 111
 112     r = snd_pcm_sw_params(pcm, swparams);
 113     fail_unless(r == 0);
 114
 115     r = snd_pcm_prepare(pcm);
 116     fail_unless(r == 0);
 117
 118     r = snd_pcm_sw_params_current(pcm, swparams);
 119     fail_unless(r == 0);
 120
 121 /*     fail_unless(snd_pcm_hw_params_is_monotonic(hwparams) > 0); */
 122
 123     n_pollfd = snd_pcm_poll_descriptors_count(pcm);
 124     fail_unless(n_pollfd > 0);
 125
 126     pollfds = malloc(sizeof(struct pollfd) * n_pollfd);
 127     fail_unless(pollfds != NULL);
 128
 129     r = snd_pcm_poll_descriptors(pcm, pollfds, n_pollfd);
 130     fail_unless(r == n_pollfd);
 131
 132     if (cap) {
 133       r = snd_pcm_start(pcm);
 134       fail_unless(r == 0);
 135     }
 136
 137     for (;;) {
 138         snd_pcm_sframes_t avail, delay;
 139         struct timespec now, timestamp;
 140         unsigned short revents;
 141         int handled = 0;
 142         uint64_t now_us, timestamp_us;
 143         snd_pcm_state_t state;
 144         unsigned long long pos;
 145
 146         r = poll(pollfds, n_pollfd, 0);
 147         fail_unless(r >= 0);
 148
 149         r = snd_pcm_poll_descriptors_revents(pcm, pollfds, n_pollfd, &revents);
 150         fail_unless(r == 0);
 151
 152         if (cap == 0)
 153           fail_unless((revents & ~POLLOUT) == 0);
 154         else
 155           fail_unless((revents & ~POLLIN) == 0);
 156
 157         avail = snd_pcm_avail(pcm);
 158         fail_unless(avail >= 0);
 159
 160         r = snd_pcm_status(pcm, status);
 161         fail_unless(r == 0);
 162
 163         /* This assertion fails from time to time. ALSA seems to be broken */
 164 /*         fail_unless(avail == (snd_pcm_sframes_t) snd_pcm_status_get_avail(status)); */
 165 /*         printf("%lu %lu\n", (unsigned long) avail, (unsigned long) snd_pcm_status_get_avail(status)); */
 166
 167         snd_pcm_status_get_htstamp(status, &timestamp);
 168         delay = snd_pcm_status_get_delay(status);
 169         state = snd_pcm_status_get_state(status);
 170
 171         r = clock_gettime(CLOCK_MONOTONIC, &now);
 172         fail_unless(r == 0);
 173
 174         fail_unless(!revents || avail > 0);
 175
 176         if ((!cap && avail) || (cap && (unsigned)avail >= buffer_size)) {
 177             snd_pcm_sframes_t sframes;
 178             static const uint16_t psamples[2] = { 0, 0 };
 179             uint16_t csamples[2];
 180
 181             if (cap == 0)
 182               sframes = snd_pcm_writei(pcm, psamples, 1);
 183             else
 184               sframes = snd_pcm_readi(pcm, csamples, 1);
 185             fail_unless(sframes == 1);
 186
 187             handled = 1;
 188             sample_count++;
 189         }
 190
 191         if (!handled &&
 192             memcmp(&timestamp, &last_timestamp, sizeof(timestamp)) == 0 &&
 193             avail == last_avail &&
 194             delay == last_delay) {
 195             /* This is boring */
 196             continue;
 197         }
 198
 199         now_us = timespec_us(&now);
 200         timestamp_us = timespec_us(&timestamp);
 201
 202         if (cap == 0)
 203             pos = (unsigned long long) ((sample_count - handled - delay) * 1000000LU / 44100);
 204         else
 205             pos = (unsigned long long) ((sample_count - handled + delay) * 1000000LU / 44100);
 206
 207         printf("%llu\t%llu\t%llu\t%llu\t%li\t%li\t%i\t%i\t%i\n",
 208                (unsigned long long) (now_us - start_us),
 209                (unsigned long long) (timestamp_us ? timestamp_us - start_us : 0),
 210                pos,
 211                (unsigned long long) sample_count,
 212                (signed long) avail,
 213                (signed long) delay,
 214                revents,
 215                handled,
 216                state);
 217
 218         if (cap == 0)
 219           /** When this fail_unless is hit, most likely something bad
 220            * happened, i.e. the avail jumped suddenly. */
 221           fail_unless((unsigned) avail <= buffer_size);
 222
 223         last_avail = avail;
 224         last_delay = delay;
 225         last_timestamp = timestamp;
 226     }
 227 }
 228 END_TEST
 229
 230 int main(int argc, char *argv[]) {
 231     int failed = 0;
 232     Suite *s;
 233     TCase *tc;
 234     SRunner *sr;
 235
 236     dev = argc > 1 ? argv[1] : "front:AudioPCI";
 237     cap = argc > 2 ? atoi(argv[2]) : 0;
 238
 239     s = suite_create("ALSA Time");
 240     tc = tcase_create("alsatime");
 241     tcase_add_test(tc, alsa_time_test);
 242     suite_add_tcase(s, tc);
 243
 244     sr = srunner_create(s);
 245     srunner_run_all(sr, CK_NORMAL);
 246     failed = srunner_ntests_failed(sr);
 247     srunner_free(sr);
 248
 249     return (failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
 250 }