API tools faq
paste
Advertisement
Guest User

Latest list.c that causes segfault in pcm_params.c

a guest
Nov 24th, 2011
67
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 9.13 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <alsa/asoundlib.h>
  3.  
  4. void print_card_info(snd_ctl_card_info_t *info)
  5. {
  6.         printf("Card #%d: id=%s, driver=%s, name=%s, longname=%s, mixername=%s, components=%s\n",
  7.                 snd_ctl_card_info_get_card(info),
  8.                 snd_ctl_card_info_get_id(info),
  9.                 snd_ctl_card_info_get_driver(info),
  10.                 snd_ctl_card_info_get_name(info),
  11.                 snd_ctl_card_info_get_longname(info),
  12.                 snd_ctl_card_info_get_mixername(info),
  13.                 snd_ctl_card_info_get_components(info));
  14. }
  15.  
  16. void print_elem_id(snd_ctl_elem_id_t *id)
  17. {
  18.         printf("elem_id: numid=%d, interface=%s, device=%d, subdevice=%d, name=%s, index=%d\n",
  19.                 snd_ctl_elem_id_get_numid(id),
  20.                 snd_ctl_elem_iface_name(snd_ctl_elem_id_get_interface(id)),
  21.                 snd_ctl_elem_id_get_device(id),
  22.                 snd_ctl_elem_id_get_subdevice(id),
  23.                 snd_ctl_elem_id_get_name(id),
  24.                 snd_ctl_elem_id_get_index(id));
  25. }
  26.  
  27. void print_elem_info(snd_ctl_elem_list_t *list, unsigned int i)
  28. {
  29.         snd_ctl_elem_id_t *id;
  30.  
  31.         printf("Element #%d: numid=%d, interface=%s, device=%d, subdevice=%d, name=%s, index=%d, elem_id follows:\n\t",
  32.                 i,
  33.                 snd_ctl_elem_list_get_numid(list, i),
  34.                 snd_ctl_elem_iface_name(snd_ctl_elem_list_get_interface(list, i)),
  35.                 snd_ctl_elem_list_get_device(list, i),
  36.                 snd_ctl_elem_list_get_subdevice(list, i),
  37.                 snd_ctl_elem_list_get_name(list, i),
  38.                 snd_ctl_elem_list_get_index(list, i));
  39.  
  40.         if (snd_ctl_elem_id_malloc(&id))
  41.         {
  42.                 printf("Error allocating snd_ctl_elem_id_t, aborting\n");
  43.                 return;
  44.         }
  45.         snd_ctl_elem_list_get_id(list, i, id);
  46.         print_elem_id(id);
  47.         snd_ctl_elem_id_free(id);
  48. }
  49.  
  50. void print_power_state(unsigned int state)
  51. {
  52.         char *str;
  53.  
  54.         switch(state & SND_CTL_POWER_MASK) {
  55.         case SND_CTL_POWER_D0:
  56.                 str = "D0";
  57.                 break;
  58.         case SND_CTL_POWER_D1:
  59.                 str = "D1";
  60.                 break;
  61.         case SND_CTL_POWER_D2:
  62.                 str = "D2";
  63.                 break;
  64.         case SND_CTL_POWER_D3hot:
  65.                 str = "D3 hot";
  66.                 break;
  67.         case SND_CTL_POWER_D3cold:
  68.                 str = "D3 cold";
  69.                 break;
  70.         default:
  71.                 str = "Unknown";
  72.         }
  73.  
  74.         printf("Power state = %s\n", str);
  75. }
  76.  
  77. void print_ctl_type(snd_ctl_type_t type)
  78. {
  79.         char *str;
  80.  
  81.         switch(type) {
  82.         case SND_CTL_TYPE_HW:
  83.                 str = "Kernel level CTL";
  84.                 break;
  85.         case SND_CTL_TYPE_SHM:
  86.                 str = "Shared memory client CTL";
  87.                 break;
  88.         case SND_CTL_TYPE_INET:
  89.                 str = "INET client CTL";
  90.                 break;
  91.         case SND_CTL_TYPE_EXT:
  92.                 str = "External control plugin";
  93.                 break;
  94.         default:
  95.                 str = "Unknown";
  96.         }
  97.  
  98.         printf("CTL type = %s\n", str);
  99. }
  100.  
  101. void print_pcm_hw_params(snd_pcm_t *pcm)
  102. {
  103.         snd_pcm_hw_params_t *params;
  104.  
  105.         if (snd_pcm_hw_params_malloc(&params)) {
  106.                 printf("Error allocating hw params, skipping\n");
  107.                 return;
  108.         }
  109.         if (snd_pcm_hw_params_any(pcm, params)) {
  110.                 printf("Error getting hw params, skipping\n");
  111.                 snd_pcm_hw_params_free(params);
  112.                 return;
  113.         }
  114.         snd_pcm_hw_params_free(params);
  115. }
  116.  
  117. void print_pcm_devices(snd_ctl_t *handle)
  118. {
  119.         int card;
  120.         int device = -1;
  121.         char deviceascii[25];
  122.         snd_ctl_card_info_t *card_info;
  123.         snd_pcm_t *pcm_playback, *pcm_capture;
  124.         int playback, capture;
  125.  
  126.         if (snd_ctl_card_info_malloc(&card_info)) {
  127.                 printf("Error allocating snd_ctl_card_info_t structure, aborting print_pcm_devices\n");
  128.                 return;
  129.         }
  130.         if (snd_ctl_card_info(handle, card_info)) {
  131.                 printf("Error getting card info, aborting print_pcm_devices\n");
  132.                 snd_ctl_card_info_free(card_info);
  133.                 return;
  134.         }
  135.         card = snd_ctl_card_info_get_card(card_info);
  136.         snd_ctl_card_info_free(card_info);
  137.         while (!snd_ctl_pcm_next_device(handle, &device) && device >= 0) {
  138.                 printf("Found PCM device #%d\n", device);
  139.                 snprintf(deviceascii, sizeof(deviceascii), "hw:%d,%d", card, device);
  140.                 playback = capture = -1;
  141.                 playback = snd_pcm_open(&pcm_playback, deviceascii, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
  142.                 capture = snd_pcm_open(&pcm_capture, deviceascii, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
  143.                 printf("Playback=%s, Capture=%s, Full Duplex=%s\n", playback ? "no" : "yes", capture ? "no" : "yes", (!playback && !capture) ? "yes" : "no");
  144.                 printf("Playback capabilities:\n");
  145.                 print_pcm_hw_params(pcm_playback);
  146.                 printf("Capture capabilities:\n");
  147.                 print_pcm_hw_params(pcm_capture);
  148.                 if (!playback && snd_pcm_close(pcm_playback)) {
  149.                         printf("Error closing PCM device #%d, LEAKING MEMORY\n", device);
  150.                 }
  151.                 if (!capture && snd_pcm_close(pcm_capture)) {
  152.                         printf("Error closing PCM device #%d, LEAKING MEMORY\n", device);
  153.                 }
  154.         }
  155. }
  156.  
  157. int main(int argc, char **argv)
  158. {
  159.         int card = -1;
  160.         char cardascii[14];
  161.         snd_ctl_t *handle;
  162.         snd_ctl_card_info_t *card_info;
  163.         snd_ctl_elem_list_t *elem_list;
  164.         unsigned int used, count, power_state;
  165.  
  166.         while (snd_card_next(&card) >= 0 && card >= 0) {
  167.                 snprintf(cardascii, sizeof(cardascii), "hw:%d", card);
  168.                 if (snd_ctl_open(&handle, cardascii, 0)) {
  169.                         printf("Error opening card #%d, skipping\n", card);
  170.                         continue;
  171.                 }
  172.                 if (snd_ctl_card_info_malloc(&card_info)) {
  173.                         printf("Error allocating snd_ctl_card_info_t structure, skipping\n");
  174.                         snd_ctl_close(handle);
  175.                         continue;
  176.                 }
  177.                 if (snd_ctl_card_info(handle, card_info)) {
  178.                         printf("Error getting info for card #%d, skipping\n", card);
  179.                         snd_ctl_close(handle);
  180.                         snd_ctl_card_info_free(card_info);
  181.                         continue;
  182.                 }
  183.                 print_card_info(card_info);
  184.                 snd_ctl_card_info_free(card_info);
  185.                 if (snd_ctl_elem_list_malloc(&elem_list)) {
  186.                         printf("Error allocating snd_ctl_elem_list_t, skipping\n");
  187.                         snd_ctl_close(handle);
  188.                         continue;
  189.                 }
  190.                 if (snd_ctl_elem_list(handle, elem_list)) {
  191.                         printf("Error getting element list, skipping\n");
  192.                         snd_ctl_close(handle);
  193.                         snd_ctl_elem_list_free(elem_list);
  194.                         continue;
  195.                 }
  196.                 used = snd_ctl_elem_list_get_used(elem_list);
  197.                 count = snd_ctl_elem_list_get_count(elem_list);
  198.                 printf("Element used = %d, count = %d.  Allocating space for %d entries...\n", used, count, count);
  199.                 if (snd_ctl_elem_list_alloc_space(elem_list, count)) {
  200.                         printf("Error allocating element list space, skipping\n");
  201.                         snd_ctl_close(handle);
  202.                         snd_ctl_elem_list_free(elem_list);
  203.                         continue;
  204.                 }
  205.                 if (snd_ctl_elem_list(handle, elem_list)) {
  206.                         printf("Error getting element list, skipping\n");
  207.                         snd_ctl_close(handle);
  208.                         snd_ctl_elem_list_free(elem_list);
  209.                         snd_ctl_elem_list_free_space(elem_list);
  210.                         continue;
  211.                 }
  212.                 used = snd_ctl_elem_list_get_used(elem_list);
  213.                 count = snd_ctl_elem_list_get_count(elem_list);
  214.                 printf("Element used = %d, count = %d\n", used, count);
  215.                 for (unsigned int i = 0; i < used; i++) {
  216.                         print_elem_info(elem_list, i);
  217.                 }
  218.                 snd_ctl_elem_list_free_space(elem_list);
  219.                 snd_ctl_elem_list_free(elem_list);
  220.                 if (snd_ctl_get_power_state(handle, &power_state)) {
  221.                         printf("Error getting power state, skipping\n");
  222.                         snd_ctl_close(handle);
  223.                         continue;
  224.                 }
  225.                 print_power_state(power_state);
  226.                 print_ctl_type(snd_ctl_type(handle));
  227.                 print_pcm_devices(handle);
  228.                 snd_ctl_close(handle);
  229.         }
  230.  
  231.         printf("No more cards!\n");
  232.  
  233.         return 0;
  234. }
  235.  
  236.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!