Pastebin launched a little side project called VERYVIRAL.com, check it out ;-) Want more features on Pastebin? Sign Up, it's FREE!
Guest

Latest list.c that causes segfault in pcm_params.c

By: a guest on Nov 24th, 2011  |  syntax: C  |  size: 9.13 KB  |  views: 31  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  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.  
clone this paste RAW Paste Data