"Fossies" - the Fresh Open Source Software Archive

Member "alsa-lib-1.1.9/test/timer.c" (10 May 2019, 6063 Bytes) of package /linux/misc/alsa-lib-1.1.9.tar.bz2:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "timer.c" see the Fossies "Dox" file reference documentation.

    1 #include <stdio.h>
    2 #include <stdlib.h>
    3 #include <string.h>
    4 #include <sys/time.h>
    5 #include "../include/asoundlib.h"
    6 
    7 void show_status(void *handle)
    8 {
    9     int err;
   10     snd_timer_status_t *status;
   11     
   12     snd_timer_status_alloca(&status);
   13     if ((err = snd_timer_status(handle, status)) < 0) {
   14         fprintf(stderr, "timer status %i (%s)\n", err, snd_strerror(err));
   15         return;
   16     }
   17     printf("STATUS:\n");
   18     printf("  resolution = %li\n", snd_timer_status_get_resolution(status));
   19     printf("  lost = %li\n", snd_timer_status_get_lost(status));
   20     printf("  overrun = %li\n", snd_timer_status_get_overrun(status));
   21     printf("  queue = %li\n", snd_timer_status_get_queue(status));
   22 }
   23 
   24 void read_loop(void *handle, int master_ticks, int timeout)
   25 {
   26     int count, err;
   27     struct pollfd *fds;
   28     snd_timer_read_t tr;
   29     
   30     count = snd_timer_poll_descriptors_count(handle);
   31     fds = calloc(count, sizeof(struct pollfd));
   32     if (fds == NULL) {
   33         fprintf(stderr, "malloc error\n");
   34         exit(EXIT_FAILURE);
   35     }
   36     while (master_ticks-- > 0) {
   37         if ((err = snd_timer_poll_descriptors(handle, fds, count)) < 0) {
   38             fprintf(stderr, "snd_timer_poll_descriptors error: %s\n", snd_strerror(err));
   39             exit(EXIT_FAILURE);
   40         }
   41         if ((err = poll(fds, count, timeout)) < 0) {
   42             fprintf(stderr, "poll error %i (%s)\n", err, strerror(err));
   43             exit(EXIT_FAILURE);
   44         }
   45         if (err == 0) {
   46             fprintf(stderr, "timer time out!!\n");
   47             exit(EXIT_FAILURE);
   48         }
   49         while (snd_timer_read(handle, &tr, sizeof(tr)) == sizeof(tr)) {
   50             printf("TIMER: resolution = %uns, ticks = %u\n",
   51                 tr.resolution, tr.ticks);
   52         }
   53     }
   54     free(fds);
   55 }
   56 
   57 static void async_callback(snd_async_handler_t *ahandler)
   58 {
   59     snd_timer_t *handle = snd_async_handler_get_timer(ahandler);
   60     int *acount = snd_async_handler_get_callback_private(ahandler);
   61     snd_timer_read_t tr;
   62     
   63     while (snd_timer_read(handle, &tr, sizeof(tr)) == sizeof(tr)) {
   64         printf("TIMER: resolution = %uns, ticks = %u\n",
   65             tr.resolution, tr.ticks);
   66     }
   67     (*acount)++;
   68 }
   69 
   70 int main(int argc, char *argv[])
   71 {
   72     int idx, err;
   73     int class = SND_TIMER_CLASS_GLOBAL;
   74     int sclass = SND_TIMER_CLASS_NONE;
   75     int card = 0;
   76     int device = SND_TIMER_GLOBAL_SYSTEM;
   77     int subdevice = 0;
   78     int list = 0;
   79     int async = 0;
   80     int acount = 0;
   81     snd_timer_t *handle;
   82     snd_timer_id_t *id;
   83     snd_timer_info_t *info;
   84     snd_timer_params_t *params;
   85     char timername[64];
   86     snd_async_handler_t *ahandler;
   87 
   88     snd_timer_id_alloca(&id);
   89     snd_timer_info_alloca(&info);
   90     snd_timer_params_alloca(&params);
   91 
   92     idx = 1;
   93     while (idx < argc) {
   94         if (!strncmp(argv[idx], "class=", 5)) {
   95             class = atoi(argv[idx]+6);
   96         } else if (!strncmp(argv[idx], "sclass=", 6)) {
   97             sclass = atoi(argv[idx]+7);
   98         } else if (!strncmp(argv[idx], "card=", 5)) {
   99             card = atoi(argv[idx]+5);
  100         } else if (!strncmp(argv[idx], "device=", 7)) {
  101             device = atoi(argv[idx]+7);
  102         } else if (!strncmp(argv[idx], "subdevice=", 10)) {
  103             subdevice = atoi(argv[idx]+10);
  104         } else if (!strcmp(argv[idx], "list")) {
  105             list = 1;
  106         } else if (!strcmp(argv[idx], "async")) {
  107             async = 1;
  108         }
  109         idx++;
  110     }
  111     if (class == SND_TIMER_CLASS_SLAVE && sclass == SND_TIMER_SCLASS_NONE) {
  112         fprintf(stderr, "slave class is not set\n");
  113         exit(EXIT_FAILURE);
  114     }
  115     if (list) {
  116         snd_timer_query_t *qhandle;
  117         if ((err = snd_timer_query_open(&qhandle, "hw", 0)) < 0) {
  118             fprintf(stderr, "snd_timer_query_open error: %s\n", snd_strerror(err));
  119             exit(EXIT_FAILURE);
  120         }
  121         snd_timer_id_set_class(id, SND_TIMER_CLASS_NONE);
  122         while (1) {
  123             if ((err = snd_timer_query_next_device(qhandle, id)) < 0) {
  124                 fprintf(stderr, "timer next device error: %s\n", snd_strerror(err));
  125                 break;
  126             }
  127             if (snd_timer_id_get_class(id) < 0)
  128                 break;
  129             printf("Timer device: class %i, sclass %i, card %i, device %i, subdevice %i\n",
  130                     snd_timer_id_get_class(id),
  131                     snd_timer_id_get_sclass(id),
  132                     snd_timer_id_get_card(id),
  133                     snd_timer_id_get_device(id),
  134                     snd_timer_id_get_subdevice(id));
  135         }
  136         snd_timer_query_close(qhandle);
  137         exit(EXIT_SUCCESS);
  138     }
  139     sprintf(timername, "hw:CLASS=%i,SCLASS=%i,CARD=%i,DEV=%i,SUBDEV=%i", class, sclass, card, device, subdevice);
  140     if ((err = snd_timer_open(&handle, timername, SND_TIMER_OPEN_NONBLOCK))<0) {
  141         fprintf(stderr, "timer open %i (%s)\n", err, snd_strerror(err));
  142         exit(EXIT_FAILURE);
  143     }
  144     printf("Using timer class %i, slave class %i, card %i, device %i, subdevice %i\n", class, sclass, card, device, subdevice);
  145     if ((err = snd_timer_info(handle, info)) < 0) {
  146         fprintf(stderr, "timer info %i (%s)\n", err, snd_strerror(err));
  147         exit(0);
  148     }
  149     printf("Timer info:\n");
  150     printf("  slave = %s\n", snd_timer_info_is_slave(info) ? "yes" : "no");
  151     printf("  card = %i\n", snd_timer_info_get_card(info));
  152     printf("  id = '%s'\n", snd_timer_info_get_id(info));
  153     printf("  name = '%s'\n", snd_timer_info_get_name(info));
  154     printf("  average resolution = %li\n", snd_timer_info_get_resolution(info));
  155     snd_timer_params_set_auto_start(params, 1);
  156     if (!snd_timer_info_is_slave(info)) {
  157         snd_timer_params_set_ticks(params, (1000000000 / snd_timer_info_get_resolution(info)) / 50); /* 50Hz */
  158         if (snd_timer_params_get_ticks(params) < 1)
  159             snd_timer_params_set_ticks(params, 1);
  160         printf("Using %li tick(s)\n", snd_timer_params_get_ticks(params));
  161     } else {
  162         snd_timer_params_set_ticks(params, 1);
  163     }
  164     if ((err = snd_timer_params(handle, params)) < 0) {
  165         fprintf(stderr, "timer params %i (%s)\n", err, snd_strerror(err));
  166         exit(0);
  167     }
  168     show_status(handle);
  169     if (async) {
  170         err = snd_async_add_timer_handler(&ahandler, handle, async_callback, &acount);
  171         if (err < 0) {
  172             fprintf(stderr, "unable to add async handler %i (%s)\n", err, snd_strerror(err));
  173             exit(EXIT_FAILURE);
  174         }
  175     }
  176     if ((err = snd_timer_start(handle)) < 0) {
  177         fprintf(stderr, "timer start %i (%s)\n", err, snd_strerror(err));
  178         exit(EXIT_FAILURE);
  179     }
  180     if (async) {
  181         /* because all other work is done in the signal handler,
  182            suspend the process */
  183         while (acount < 25)
  184             sleep(1);
  185         snd_timer_stop(handle);
  186     } else {
  187         read_loop(handle, 25, snd_timer_info_is_slave(info) ? 10000 : 25);
  188     }
  189     show_status(handle);
  190     snd_timer_close(handle);
  191     printf("Done\n");
  192     return EXIT_SUCCESS;
  193 }