Alc/backends/qsa.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 2011-2013 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <sched.h>
  26 #include <errno.h>
  27 #include <memory.h>
  28 #include <sys/select.h>
  29 #include <sys/asoundlib.h>
  30 #include <sys/neutrino.h>
  31
  32 #include "alMain.h"
  33 #include "alu.h"
  34 #include "threads.h"
  35
  36
  37 typedef struct {
  38     snd_pcm_t* pcmHandle;
  39     int audio_fd;
  40
  41     snd_pcm_channel_setup_t  csetup;
  42     snd_pcm_channel_params_t cparams;
  43
  44     ALvoid* buffer;
  45     ALsizei size;
  46
  47     volatile int killNow;
  48     althrd_t thread;
  49 } qsa_data;
  50
  51 typedef struct {
  52     ALCchar* name;
  53     int card;
  54     int dev;
  55 } DevMap;
  56
  57 static const ALCchar qsaDevice[] = "QSA Default";
  58 static DevMap* allDevNameMap;
  59 static ALuint numDevNames;
  60 static DevMap* allCaptureDevNameMap;
  61 static ALuint numCaptureDevNames;
  62
  63 static const struct {
  64     int32_t format;
  65 } formatlist[] = {
  66     {SND_PCM_SFMT_FLOAT_LE},
  67     {SND_PCM_SFMT_S32_LE},
  68     {SND_PCM_SFMT_U32_LE},
  69     {SND_PCM_SFMT_S16_LE},
  70     {SND_PCM_SFMT_U16_LE},
  71     {SND_PCM_SFMT_S8},
  72     {SND_PCM_SFMT_U8},
  73     {0},
  74 };
  75
  76 static const struct {
  77     int32_t rate;
  78 } ratelist[] = {
  79     {192000},
  80     {176400},
  81     {96000},
  82     {88200},
  83     {48000},
  84     {44100},
  85     {32000},
  86     {24000},
  87     {22050},
  88     {16000},
  89     {12000},
  90     {11025},
  91     {8000},
  92     {0},
  93 };
  94
  95 static const struct {
  96     int32_t channels;
  97 } channellist[] = {
  98     {8},
  99     {7},
 100     {6},
 101     {4},
 102     {2},
 103     {1},
 104     {0},
 105 };
 106
 107 static DevMap *deviceList(int type, ALuint *count)
 108 {
 109     snd_ctl_t* handle;
 110     snd_pcm_info_t pcminfo;
 111     int max_cards, card, err, dev, num_devices, idx;
 112     DevMap* dev_list;
 113     char name[1024];
 114     struct snd_ctl_hw_info info;
 115     void* temp;
 116
 117     idx=0;
 118     num_devices=0;
 119     max_cards=snd_cards();
 120
 121     if (max_cards<=0)
 122     {
 123         return 0;
 124     }
 125
 126     dev_list=malloc(sizeof(DevMap)*1);
 127     dev_list[0].name=strdup(qsaDevice);
 128     num_devices=1;
 129
 130     for (card=0; card<max_cards; card++)
 131     {
 132         if ((err=snd_ctl_open(&handle, card))<0)
 133         {
 134             continue;
 135         }
 136         if ((err=snd_ctl_hw_info(handle, &info))<0)
 137         {
 138             snd_ctl_close(handle);
 139             continue;
 140         }
 141
 142         for (dev=0; dev<(int)info.pcmdevs; dev++)
 143         {
 144             if ((err=snd_ctl_pcm_info(handle, dev, &pcminfo)) < 0)
 145             {
 146                 continue;
 147             }
 148
 149             if ((type==SND_PCM_CHANNEL_PLAYBACK && (pcminfo.flags&SND_PCM_INFO_PLAYBACK)) ||
 150                 (type==SND_PCM_CHANNEL_CAPTURE && (pcminfo.flags&SND_PCM_INFO_CAPTURE)))
 151             {
 152                 temp=realloc(dev_list, sizeof(DevMap)*(num_devices+1));
 153                 if (temp)
 154                 {
 155                     dev_list=temp;
 156                     snprintf(name, sizeof(name), "%s [%s] (hw:%d,%d)", info.name, pcminfo.name, card, dev);
 157                     dev_list[num_devices].name=strdup(name);
 158                     dev_list[num_devices].card=card;
 159                     dev_list[num_devices].dev=dev;
 160                     num_devices++;
 161                 }
 162             }
 163         }
 164         snd_ctl_close (handle);
 165     }
 166
 167     *count=num_devices;
 168
 169     return dev_list;
 170 }
 171
 172
 173 FORCE_ALIGN static int qsa_proc_playback(void* ptr)
 174 {
 175     ALCdevice* device=(ALCdevice*)ptr;
 176     qsa_data* data=(qsa_data*)device->ExtraData;
 177     char* write_ptr;
 178     int avail;
 179     snd_pcm_channel_status_t status;
 180     struct sched_param param;
 181     fd_set wfds;
 182     int selectret;
 183     struct timeval timeout;
 184
 185     SetRTPriority();
 186     althrd_setname(althrd_current(), MIXER_THREAD_NAME);
 187
 188     /* Increase default 10 priority to 11 to avoid jerky sound */
 189     SchedGet(0, 0, &param);
 190     param.sched_priority=param.sched_curpriority+1;
 191     SchedSet(0, 0, SCHED_NOCHANGE, &param);
 192
 193     ALint frame_size=FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
 194
 195     while (!data->killNow)
 196     {
 197         ALint len=data->size;
 198         write_ptr=data->buffer;
 199
 200         avail=len/frame_size;
 201         aluMixData(device, write_ptr, avail);
 202
 203         while (len>0 && !data->killNow)
 204         {
 205             FD_ZERO(&wfds);
 206             FD_SET(data->audio_fd, &wfds);
 207             timeout.tv_sec=2;
 208             timeout.tv_usec=0;
 209
 210             /* Select also works like time slice to OS */
 211             selectret=select(data->audio_fd+1, NULL, &wfds, NULL, &timeout);
 212             switch (selectret)
 213             {
 214                 case -1:
 215                      aluHandleDisconnect(device);
 216                      return 1;
 217                 case 0:
 218                      break;
 219                 default:
 220                      if (FD_ISSET(data->audio_fd, &wfds))
 221                      {
 222                          break;
 223                      }
 224                      break;
 225             }
 226
 227             int wrote=snd_pcm_plugin_write(data->pcmHandle, write_ptr, len);
 228
 229             if (wrote<=0)
 230             {
 231                 if ((errno==EAGAIN) || (errno==EWOULDBLOCK))
 232                 {
 233                     continue;
 234                 }
 235
 236                 memset(&status, 0, sizeof (status));
 237                 status.channel=SND_PCM_CHANNEL_PLAYBACK;
 238
 239                 snd_pcm_plugin_status(data->pcmHandle, &status);
 240
 241                 /* we need to reinitialize the sound channel if we've underrun the buffer */
 242                 if ((status.status==SND_PCM_STATUS_UNDERRUN) ||
 243                     (status.status==SND_PCM_STATUS_READY))
 244                 {
 245                     if ((snd_pcm_plugin_prepare(data->pcmHandle, SND_PCM_CHANNEL_PLAYBACK))<0)
 246                     {
 247                         aluHandleDisconnect(device);
 248                         break;
 249                     }
 250                 }
 251             }
 252             else
 253             {
 254                 write_ptr+=wrote;
 255                 len-=wrote;
 256             }
 257         }
 258     }
 259
 260     return 0;
 261 }
 262
 263 /************/
 264 /* Playback */
 265 /************/
 266
 267 static ALCenum qsa_open_playback(ALCdevice* device, const ALCchar* deviceName)
 268 {
 269     qsa_data* data;
 270     char driver[64];
 271     int status;
 272     int card, dev;
 273
 274     strncpy(driver, GetConfigValue("qsa", "device", qsaDevice), sizeof(driver)-1);
 275     driver[sizeof(driver)-1]=0;
 276
 277     data=(qsa_data*)calloc(1, sizeof(qsa_data));
 278     if (data==NULL)
 279     {
 280         return ALC_OUT_OF_MEMORY;
 281     }
 282
 283     if (!deviceName)
 284     {
 285         deviceName=driver;
 286     }
 287
 288     if (strcmp(deviceName, qsaDevice)==0)
 289     {
 290         if (!deviceName)
 291         {
 292             deviceName=qsaDevice;
 293         }
 294
 295         status=snd_pcm_open_preferred(&data->pcmHandle, &card, &dev, SND_PCM_OPEN_PLAYBACK);
 296     }
 297     else
 298     {
 299         size_t idx;
 300
 301         if (!allDevNameMap)
 302         {
 303             allDevNameMap=deviceList(SND_PCM_CHANNEL_PLAYBACK, &numDevNames);
 304         }
 305
 306         for (idx=0; idx<numDevNames; idx++)
 307         {
 308             if (allDevNameMap[idx].name && strcmp(deviceName, allDevNameMap[idx].name)==0)
 309             {
 310                 if (idx>0)
 311                 {
 312                     break;
 313                 }
 314             }
 315         }
 316         if (idx==numDevNames)
 317         {
 318             free(data);
 319             return ALC_INVALID_DEVICE;
 320         }
 321
 322         status=snd_pcm_open(&data->pcmHandle, allDevNameMap[idx].card, allDevNameMap[idx].dev, SND_PCM_OPEN_PLAYBACK);
 323     }
 324
 325     if (status<0)
 326     {
 327         free(data);
 328         return ALC_INVALID_DEVICE;
 329     }
 330
 331     data->audio_fd=snd_pcm_file_descriptor(data->pcmHandle, SND_PCM_CHANNEL_PLAYBACK);
 332     if (data->audio_fd<0)
 333     {
 334         free(data);
 335         return ALC_INVALID_DEVICE;
 336     }
 337
 338     al_string_copy_cstr(&device->DeviceName, deviceName);
 339     device->ExtraData = data;
 340
 341     return ALC_NO_ERROR;
 342 }
 343
 344 static void qsa_close_playback(ALCdevice* device)
 345 {
 346     qsa_data* data=(qsa_data*)device->ExtraData;
 347
 348     if (data->buffer!=NULL)
 349     {
 350         free(data->buffer);
 351         data->buffer=NULL;
 352     }
 353
 354     snd_pcm_close(data->pcmHandle);
 355     free(data);
 356
 357     device->ExtraData=NULL;
 358 }
 359
 360 static ALCboolean qsa_reset_playback(ALCdevice* device)
 361 {
 362     qsa_data* data=(qsa_data*)device->ExtraData;
 363     int32_t format=-1;
 364
 365     switch(device->FmtType)
 366     {
 367         case DevFmtByte:
 368              format=SND_PCM_SFMT_S8;
 369              break;
 370         case DevFmtUByte:
 371              format=SND_PCM_SFMT_U8;
 372              break;
 373         case DevFmtShort:
 374              format=SND_PCM_SFMT_S16_LE;
 375              break;
 376         case DevFmtUShort:
 377              format=SND_PCM_SFMT_U16_LE;
 378              break;
 379         case DevFmtInt:
 380              format=SND_PCM_SFMT_S32_LE;
 381              break;
 382         case DevFmtUInt:
 383              format=SND_PCM_SFMT_U32_LE;
 384              break;
 385         case DevFmtFloat:
 386              format=SND_PCM_SFMT_FLOAT_LE;
 387              break;
 388     }
 389
 390     /* we actually don't want to block on writes */
 391     snd_pcm_nonblock_mode(data->pcmHandle, 1);
 392     /* Disable mmap to control data transfer to the audio device */
 393     snd_pcm_plugin_set_disable(data->pcmHandle, PLUGIN_DISABLE_MMAP);
 394     snd_pcm_plugin_set_disable(data->pcmHandle, PLUGIN_DISABLE_BUFFER_PARTIAL_BLOCKS);
 395
 396     // configure a sound channel
 397     memset(&data->cparams, 0, sizeof(data->cparams));
 398     data->cparams.channel=SND_PCM_CHANNEL_PLAYBACK;
 399     data->cparams.mode=SND_PCM_MODE_BLOCK;
 400     data->cparams.start_mode=SND_PCM_START_FULL;
 401     data->cparams.stop_mode=SND_PCM_STOP_STOP;
 402
 403     data->cparams.buf.block.frag_size=device->UpdateSize*
 404         ChannelsFromDevFmt(device->FmtChans)*BytesFromDevFmt(device->FmtType);
 405     data->cparams.buf.block.frags_max=device->NumUpdates;
 406     data->cparams.buf.block.frags_min=device->NumUpdates;
 407
 408     data->cparams.format.interleave=1;
 409     data->cparams.format.rate=device->Frequency;
 410     data->cparams.format.voices=ChannelsFromDevFmt(device->FmtChans);
 411     data->cparams.format.format=format;
 412
 413     if ((snd_pcm_plugin_params(data->pcmHandle, &data->cparams))<0)
 414     {
 415         int original_rate=data->cparams.format.rate;
 416         int original_voices=data->cparams.format.voices;
 417         int original_format=data->cparams.format.format;
 418         int it;
 419         int jt;
 420
 421         for (it=0; it<1; it++)
 422         {
 423             /* Check for second pass */
 424             if (it==1)
 425             {
 426                 original_rate=ratelist[0].rate;
 427                 original_voices=channellist[0].channels;
 428                 original_format=formatlist[0].format;
 429             }
 430
 431             do {
 432                 /* At first downgrade sample format */
 433                 jt=0;
 434                 do {
 435                     if (formatlist[jt].format==data->cparams.format.format)
 436                     {
 437                         data->cparams.format.format=formatlist[jt+1].format;
 438                         break;
 439                     }
 440                     if (formatlist[jt].format==0)
 441                     {
 442                         data->cparams.format.format=0;
 443                         break;
 444                     }
 445                     jt++;
 446                 } while(1);
 447
 448                 if (data->cparams.format.format==0)
 449                 {
 450                     data->cparams.format.format=original_format;
 451
 452                     /* At secod downgrade sample rate */
 453                     jt=0;
 454                     do {
 455                         if (ratelist[jt].rate==data->cparams.format.rate)
 456                         {
 457                             data->cparams.format.rate=ratelist[jt+1].rate;
 458                             break;
 459                         }
 460                         if (ratelist[jt].rate==0)
 461                         {
 462                             data->cparams.format.rate=0;
 463                             break;
 464                         }
 465                         jt++;
 466                     } while(1);
 467
 468                     if (data->cparams.format.rate==0)
 469                     {
 470                         data->cparams.format.rate=original_rate;
 471                         data->cparams.format.format=original_format;
 472
 473                         /* At third downgrade channels number */
 474                         jt=0;
 475                         do {
 476                             if(channellist[jt].channels==data->cparams.format.voices)
 477                             {
 478                                 data->cparams.format.voices=channellist[jt+1].channels;
 479                                 break;
 480                             }
 481                             if (channellist[jt].channels==0)
 482                             {
 483                                 data->cparams.format.voices=0;
 484                                 break;
 485                             }
 486                            jt++;
 487                         } while(1);
 488                     }
 489
 490                     if (data->cparams.format.voices==0)
 491                     {
 492                         break;
 493                     }
 494                 }
 495
 496                 data->cparams.buf.block.frag_size=device->UpdateSize*
 497                     data->cparams.format.voices*
 498                     snd_pcm_format_width(data->cparams.format.format)/8;
 499                 data->cparams.buf.block.frags_max=device->NumUpdates;
 500                 data->cparams.buf.block.frags_min=device->NumUpdates;
 501                 if ((snd_pcm_plugin_params(data->pcmHandle, &data->cparams))<0)
 502                 {
 503                     continue;
 504                 }
 505                 else
 506                 {
 507                     break;
 508                 }
 509             } while(1);
 510
 511             if (data->cparams.format.voices!=0)
 512             {
 513                 break;
 514             }
 515         }
 516
 517         if (data->cparams.format.voices==0)
 518         {
 519             return ALC_FALSE;
 520         }
 521     }
 522
 523     if ((snd_pcm_plugin_prepare(data->pcmHandle, SND_PCM_CHANNEL_PLAYBACK))<0)
 524     {
 525         return ALC_FALSE;
 526     }
 527
 528     memset(&data->csetup, 0, sizeof(data->csetup));
 529     data->csetup.channel=SND_PCM_CHANNEL_PLAYBACK;
 530     if (snd_pcm_plugin_setup(data->pcmHandle, &data->csetup)<0)
 531     {
 532         return ALC_FALSE;
 533     }
 534
 535     /* now fill back to the our AL device */
 536     device->Frequency=data->cparams.format.rate;
 537
 538     switch (data->cparams.format.voices)
 539     {
 540         case 1:
 541              device->FmtChans=DevFmtMono;
 542              break;
 543         case 2:
 544              device->FmtChans=DevFmtStereo;
 545              break;
 546         case 4:
 547              device->FmtChans=DevFmtQuad;
 548              break;
 549         case 6:
 550              device->FmtChans=DevFmtX51;
 551              break;
 552         case 7:
 553              device->FmtChans=DevFmtX61;
 554              break;
 555         case 8:
 556              device->FmtChans=DevFmtX71;
 557              break;
 558         default:
 559              device->FmtChans=DevFmtMono;
 560              break;
 561     }
 562
 563     switch (data->cparams.format.format)
 564     {
 565         case SND_PCM_SFMT_S8:
 566              device->FmtType=DevFmtByte;
 567              break;
 568         case SND_PCM_SFMT_U8:
 569              device->FmtType=DevFmtUByte;
 570              break;
 571         case SND_PCM_SFMT_S16_LE:
 572              device->FmtType=DevFmtShort;
 573              break;
 574         case SND_PCM_SFMT_U16_LE:
 575              device->FmtType=DevFmtUShort;
 576              break;
 577         case SND_PCM_SFMT_S32_LE:
 578              device->FmtType=DevFmtInt;
 579              break;
 580         case SND_PCM_SFMT_U32_LE:
 581              device->FmtType=DevFmtUInt;
 582              break;
 583         case SND_PCM_SFMT_FLOAT_LE:
 584              device->FmtType=DevFmtFloat;
 585              break;
 586         default:
 587              device->FmtType=DevFmtShort;
 588              break;
 589     }
 590
 591     SetDefaultChannelOrder(device);
 592
 593     device->UpdateSize=data->csetup.buf.block.frag_size/
 594         (ChannelsFromDevFmt(device->FmtChans)*BytesFromDevFmt(device->FmtType));
 595     device->NumUpdates=data->csetup.buf.block.frags;
 596
 597     data->size=data->csetup.buf.block.frag_size;
 598     data->buffer=malloc(data->size);
 599     if (!data->buffer)
 600     {
 601         return ALC_FALSE;
 602     }
 603
 604     return ALC_TRUE;
 605 }
 606
 607 static ALCboolean qsa_start_playback(ALCdevice* device)
 608 {
 609     qsa_data *data = (qsa_data*)device->ExtraData;
 610
 611     data->killNow = 0;
 612     if(althrd_create(&data->thread, qsa_proc_playback, device) != althrd_success)
 613         return ALC_FALSE;
 614
 615     return ALC_TRUE;
 616 }
 617
 618 static void qsa_stop_playback(ALCdevice* device)
 619 {
 620     qsa_data *data = (qsa_data*)device->ExtraData;
 621     int res;
 622
 623     if(data->killNow)
 624         return;
 625
 626     data->killNow = 1;
 627     althrd_join(data->thread, &res);
 628 }
 629
 630 /***********/
 631 /* Capture */
 632 /***********/
 633
 634 static ALCenum qsa_open_capture(ALCdevice* device, const ALCchar* deviceName)
 635 {
 636     qsa_data* data;
 637     int format=-1;
 638     char driver[64];
 639     int card, dev;
 640     int status;
 641
 642     strncpy(driver, GetConfigValue("qsa", "capture", qsaDevice), sizeof(driver)-1);
 643     driver[sizeof(driver)-1]=0;
 644
 645     data=(qsa_data*)calloc(1, sizeof(qsa_data));
 646     if (data==NULL)
 647     {
 648         return ALC_OUT_OF_MEMORY;
 649     }
 650
 651     if (!deviceName)
 652     {
 653         deviceName=driver;
 654     }
 655
 656     if (strcmp(deviceName, qsaDevice)==0)
 657     {
 658         if (!deviceName)
 659         {
 660             deviceName=qsaDevice;
 661         }
 662
 663         status=snd_pcm_open_preferred(&data->pcmHandle, &card, &dev, SND_PCM_OPEN_CAPTURE);
 664     }
 665     else
 666     {
 667         size_t idx;
 668
 669         if (!allCaptureDevNameMap)
 670         {
 671             allCaptureDevNameMap=deviceList(SND_PCM_CHANNEL_CAPTURE, &numDevNames);
 672         }
 673
 674         for (idx=0; idx<numDevNames; idx++)
 675         {
 676             if (allCaptureDevNameMap[idx].name && strcmp(deviceName, allCaptureDevNameMap[idx].name)==0)
 677             {
 678                 if (idx>0)
 679                 {
 680                     break;
 681                 }
 682             }
 683         }
 684         if (idx==numDevNames)
 685         {
 686             free(data);
 687             return ALC_INVALID_DEVICE;
 688         }
 689
 690         status=snd_pcm_open(&data->pcmHandle, allCaptureDevNameMap[idx].card, allCaptureDevNameMap[idx].dev, SND_PCM_OPEN_CAPTURE);
 691     }
 692
 693     if (status<0)
 694     {
 695         free(data);
 696         return ALC_INVALID_DEVICE;
 697     }
 698
 699     data->audio_fd=snd_pcm_file_descriptor(data->pcmHandle, SND_PCM_CHANNEL_CAPTURE);
 700     if (data->audio_fd<0)
 701     {
 702         free(data);
 703         return ALC_INVALID_DEVICE;
 704     }
 705
 706     al_string_copy_cstr(&device->DeviceName, deviceName);
 707     device->ExtraData = data;
 708
 709     switch (device->FmtType)
 710     {
 711         case DevFmtByte:
 712              format=SND_PCM_SFMT_S8;
 713              break;
 714         case DevFmtUByte:
 715              format=SND_PCM_SFMT_U8;
 716              break;
 717         case DevFmtShort:
 718              format=SND_PCM_SFMT_S16_LE;
 719              break;
 720         case DevFmtUShort:
 721              format=SND_PCM_SFMT_U16_LE;
 722              break;
 723         case DevFmtInt:
 724              format=SND_PCM_SFMT_S32_LE;
 725              break;
 726         case DevFmtUInt:
 727              format=SND_PCM_SFMT_U32_LE;
 728              break;
 729         case DevFmtFloat:
 730              format=SND_PCM_SFMT_FLOAT_LE;
 731              break;
 732     }
 733
 734     /* we actually don't want to block on reads */
 735     snd_pcm_nonblock_mode(data->pcmHandle, 1);
 736     /* Disable mmap to control data transfer to the audio device */
 737     snd_pcm_plugin_set_disable(data->pcmHandle, PLUGIN_DISABLE_MMAP);
 738
 739     /* configure a sound channel */
 740     memset(&data->cparams, 0, sizeof(data->cparams));
 741     data->cparams.mode=SND_PCM_MODE_BLOCK;
 742     data->cparams.channel=SND_PCM_CHANNEL_CAPTURE;
 743     data->cparams.start_mode=SND_PCM_START_GO;
 744     data->cparams.stop_mode=SND_PCM_STOP_STOP;
 745
 746     data->cparams.buf.block.frag_size=device->UpdateSize*
 747         ChannelsFromDevFmt(device->FmtChans)*BytesFromDevFmt(device->FmtType);
 748     data->cparams.buf.block.frags_max=device->NumUpdates;
 749     data->cparams.buf.block.frags_min=device->NumUpdates;
 750
 751     data->cparams.format.interleave=1;
 752     data->cparams.format.rate=device->Frequency;
 753     data->cparams.format.voices=ChannelsFromDevFmt(device->FmtChans);
 754     data->cparams.format.format=format;
 755
 756     if ((snd_pcm_plugin_params(data->pcmHandle, &data->cparams))<0)
 757     {
 758         int original_rate=data->cparams.format.rate;
 759         int original_voices=data->cparams.format.voices;
 760         int original_format=data->cparams.format.format;
 761         int it;
 762         int jt;
 763
 764         for (it=0; it<1; it++)
 765         {
 766             /* Check for second pass */
 767             if (it==1)
 768             {
 769                 original_rate=ratelist[0].rate;
 770                 original_voices=channellist[0].channels;
 771                 original_format=formatlist[0].format;
 772             }
 773
 774             do {
 775                 /* At first downgrade sample format */
 776                 jt=0;
 777                 do {
 778                     if (formatlist[jt].format==data->cparams.format.format)
 779                     {
 780                         data->cparams.format.format=formatlist[jt+1].format;
 781                         break;
 782                     }
 783                     if (formatlist[jt].format==0)
 784                     {
 785                         data->cparams.format.format=0;
 786                         break;
 787                     }
 788                     jt++;
 789                 } while(1);
 790
 791                 if (data->cparams.format.format==0)
 792                 {
 793                     data->cparams.format.format=original_format;
 794
 795                     /* At secod downgrade sample rate */
 796                     jt=0;
 797                     do {
 798                         if (ratelist[jt].rate==data->cparams.format.rate)
 799                         {
 800                             data->cparams.format.rate=ratelist[jt+1].rate;
 801                             break;
 802                         }
 803                         if (ratelist[jt].rate==0)
 804                         {
 805                             data->cparams.format.rate=0;
 806                             break;
 807                         }
 808                         jt++;
 809                     } while(1);
 810
 811                     if (data->cparams.format.rate==0)
 812                     {
 813                         data->cparams.format.rate=original_rate;
 814                         data->cparams.format.format=original_format;
 815
 816                         /* At third downgrade channels number */
 817                         jt=0;
 818                         do {
 819                             if(channellist[jt].channels==data->cparams.format.voices)
 820                             {
 821                                 data->cparams.format.voices=channellist[jt+1].channels;
 822                                 break;
 823                             }
 824                             if (channellist[jt].channels==0)
 825                             {
 826                                 data->cparams.format.voices=0;
 827                                 break;
 828                             }
 829                            jt++;
 830                         } while(1);
 831                     }
 832
 833                     if (data->cparams.format.voices==0)
 834                     {
 835                         break;
 836                     }
 837                 }
 838
 839                 data->cparams.buf.block.frag_size=device->UpdateSize*
 840                     data->cparams.format.voices*
 841                     snd_pcm_format_width(data->cparams.format.format)/8;
 842                 data->cparams.buf.block.frags_max=device->NumUpdates;
 843                 data->cparams.buf.block.frags_min=device->NumUpdates;
 844                 if ((snd_pcm_plugin_params(data->pcmHandle, &data->cparams))<0)
 845                 {
 846                     continue;
 847                 }
 848                 else
 849                 {
 850                     break;
 851                 }
 852             } while(1);
 853
 854             if (data->cparams.format.voices!=0)
 855             {
 856                 break;
 857             }
 858         }
 859
 860         if (data->cparams.format.voices==0)
 861         {
 862             return ALC_INVALID_VALUE;
 863         }
 864     }
 865
 866     /* now fill back to the our AL device */
 867     device->Frequency=data->cparams.format.rate;
 868
 869     switch (data->cparams.format.voices)
 870     {
 871         case 1:
 872              device->FmtChans=DevFmtMono;
 873              break;
 874         case 2:
 875              device->FmtChans=DevFmtStereo;
 876              break;
 877         case 4:
 878              device->FmtChans=DevFmtQuad;
 879              break;
 880         case 6:
 881              device->FmtChans=DevFmtX51;
 882              break;
 883         case 7:
 884              device->FmtChans=DevFmtX61;
 885              break;
 886         case 8:
 887              device->FmtChans=DevFmtX71;
 888              break;
 889         default:
 890              device->FmtChans=DevFmtMono;
 891              break;
 892     }
 893
 894     switch (data->cparams.format.format)
 895     {
 896         case SND_PCM_SFMT_S8:
 897              device->FmtType=DevFmtByte;
 898              break;
 899         case SND_PCM_SFMT_U8:
 900              device->FmtType=DevFmtUByte;
 901              break;
 902         case SND_PCM_SFMT_S16_LE:
 903              device->FmtType=DevFmtShort;
 904              break;
 905         case SND_PCM_SFMT_U16_LE:
 906              device->FmtType=DevFmtUShort;
 907              break;
 908         case SND_PCM_SFMT_S32_LE:
 909              device->FmtType=DevFmtInt;
 910              break;
 911         case SND_PCM_SFMT_U32_LE:
 912              device->FmtType=DevFmtUInt;
 913              break;
 914         case SND_PCM_SFMT_FLOAT_LE:
 915              device->FmtType=DevFmtFloat;
 916              break;
 917         default:
 918              device->FmtType=DevFmtShort;
 919              break;
 920     }
 921
 922     return ALC_NO_ERROR;
 923 }
 924
 925 static void qsa_close_capture(ALCdevice* device)
 926 {
 927     qsa_data* data=(qsa_data*)device->ExtraData;
 928
 929     if (data->pcmHandle!=NULL)
 930     {
 931         snd_pcm_close(data->pcmHandle);
 932     }
 933     free(data);
 934     device->ExtraData=NULL;
 935 }
 936
 937 static void qsa_start_capture(ALCdevice* device)
 938 {
 939     qsa_data* data=(qsa_data*)device->ExtraData;
 940     int rstatus;
 941
 942     if ((rstatus=snd_pcm_plugin_prepare(data->pcmHandle, SND_PCM_CHANNEL_CAPTURE))<0)
 943     {
 944         ERR("capture prepare failed: %s\n", snd_strerror(rstatus));
 945         return;
 946     }
 947
 948     memset(&data->csetup, 0, sizeof(data->csetup));
 949     data->csetup.channel=SND_PCM_CHANNEL_CAPTURE;
 950     if ((rstatus=snd_pcm_plugin_setup(data->pcmHandle, &data->csetup))<0)
 951     {
 952         ERR("capture setup failed: %s\n", snd_strerror(rstatus));
 953         return;
 954     }
 955
 956     snd_pcm_capture_go(data->pcmHandle);
 957
 958     device->UpdateSize=data->csetup.buf.block.frag_size/
 959         (ChannelsFromDevFmt(device->FmtChans)*BytesFromDevFmt(device->FmtType));
 960     device->NumUpdates=data->csetup.buf.block.frags;
 961 }
 962
 963 static void qsa_stop_capture(ALCdevice* device)
 964 {
 965     qsa_data* data=(qsa_data*)device->ExtraData;
 966
 967     snd_pcm_capture_flush(data->pcmHandle);
 968 }
 969
 970 static ALCuint qsa_available_samples(ALCdevice* device)
 971 {
 972     qsa_data* data=(qsa_data*)device->ExtraData;
 973     snd_pcm_channel_status_t status;
 974     ALint frame_size=FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
 975     ALint free_size;
 976     int rstatus;
 977
 978     memset(&status, 0, sizeof (status));
 979     status.channel=SND_PCM_CHANNEL_CAPTURE;
 980     snd_pcm_plugin_status(data->pcmHandle, &status);
 981     if ((status.status==SND_PCM_STATUS_OVERRUN) ||
 982         (status.status==SND_PCM_STATUS_READY))
 983     {
 984         if ((rstatus=snd_pcm_plugin_prepare(data->pcmHandle, SND_PCM_CHANNEL_CAPTURE))<0)
 985         {
 986             ERR("capture prepare failed: %s\n", snd_strerror(rstatus));
 987             aluHandleDisconnect(device);
 988             return 0;
 989         }
 990
 991         snd_pcm_capture_go(data->pcmHandle);
 992         return 0;
 993     }
 994
 995     free_size=data->csetup.buf.block.frag_size*data->csetup.buf.block.frags;
 996     free_size-=status.free;
 997
 998     return free_size/frame_size;
 999 }
1000
1001 static ALCenum qsa_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples)
1002 {
1003     qsa_data* data=(qsa_data*)device->ExtraData;
1004     char* read_ptr;
1005     snd_pcm_channel_status_t status;
1006     fd_set rfds;
1007     int selectret;
1008     struct timeval timeout;
1009     int bytes_read;
1010     ALint frame_size=FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
1011     ALint len=samples*frame_size;
1012     int rstatus;
1013
1014     read_ptr=buffer;
1015
1016     while (len>0)
1017     {
1018         FD_ZERO(&rfds);
1019         FD_SET(data->audio_fd, &rfds);
1020         timeout.tv_sec=2;
1021         timeout.tv_usec=0;
1022
1023         /* Select also works like time slice to OS */
1024         bytes_read=0;
1025         selectret=select(data->audio_fd+1, &rfds, NULL, NULL, &timeout);
1026         switch (selectret)
1027         {
1028             case -1:
1029                  aluHandleDisconnect(device);
1030                  return ALC_INVALID_DEVICE;
1031             case 0:
1032                  break;
1033             default:
1034                  if (FD_ISSET(data->audio_fd, &rfds))
1035                  {
1036                      bytes_read=snd_pcm_plugin_read(data->pcmHandle, read_ptr, len);
1037                      break;
1038                  }
1039                  break;
1040         }
1041
1042         if (bytes_read<=0)
1043         {
1044             if ((errno==EAGAIN) || (errno==EWOULDBLOCK))
1045             {
1046                 continue;
1047             }
1048
1049             memset(&status, 0, sizeof (status));
1050             status.channel=SND_PCM_CHANNEL_CAPTURE;
1051             snd_pcm_plugin_status(data->pcmHandle, &status);
1052
1053             /* we need to reinitialize the sound channel if we've overrun the buffer */
1054             if ((status.status==SND_PCM_STATUS_OVERRUN) ||
1055                 (status.status==SND_PCM_STATUS_READY))
1056             {
1057                 if ((rstatus=snd_pcm_plugin_prepare(data->pcmHandle, SND_PCM_CHANNEL_CAPTURE))<0)
1058                 {
1059                     ERR("capture prepare failed: %s\n", snd_strerror(rstatus));
1060                     aluHandleDisconnect(device);
1061                     return ALC_INVALID_DEVICE;
1062                 }
1063                 snd_pcm_capture_go(data->pcmHandle);
1064             }
1065         }
1066         else
1067         {
1068             read_ptr+=bytes_read;
1069             len-=bytes_read;
1070         }
1071     }
1072
1073     return ALC_NO_ERROR;
1074 }
1075
1076 static const BackendFuncs qsa_funcs= {
1077     qsa_open_playback,
1078     qsa_close_playback,
1079     qsa_reset_playback,
1080     qsa_start_playback,
1081     qsa_stop_playback,
1082     qsa_open_capture,
1083     qsa_close_capture,
1084     qsa_start_capture,
1085     qsa_stop_capture,
1086     qsa_capture_samples,
1087     qsa_available_samples
1088 };
1089
1090 ALCboolean alc_qsa_init(BackendFuncs* func_list)
1091 {
1092     *func_list=qsa_funcs;
1093
1094     return ALC_TRUE;
1095 }
1096
1097 void alc_qsa_deinit(void)
1098 {
1099     ALuint i;
1100
1101     for (i=0; i<numDevNames; ++i)
1102     {
1103         free(allDevNameMap[i].name);
1104     }
1105     free(allDevNameMap);
1106     allDevNameMap=NULL;
1107     numDevNames=0;
1108
1109     for (i=0; i<numCaptureDevNames; ++i)
1110     {
1111         free(allCaptureDevNameMap[i].name);
1112     }
1113     free(allCaptureDevNameMap);
1114     allCaptureDevNameMap=NULL;
1115     numCaptureDevNames=0;
1116 }
1117
1118 void alc_qsa_probe(enum DevProbe type)
1119 {
1120     ALuint i;
1121
1122     switch (type)
1123     {
1124         case ALL_DEVICE_PROBE:
1125              for (i=0; i<numDevNames; ++i)
1126              {
1127                  free(allDevNameMap[i].name);
1128              }
1129              free(allDevNameMap);
1130
1131              allDevNameMap=deviceList(SND_PCM_CHANNEL_PLAYBACK, &numDevNames);
1132              for (i=0; i<numDevNames; ++i)
1133              {
1134                  AppendAllDevicesList(allDevNameMap[i].name);
1135              }
1136              break;
1137         case CAPTURE_DEVICE_PROBE:
1138              for (i=0; i<numCaptureDevNames; ++i)
1139              {
1140                  free(allCaptureDevNameMap[i].name);
1141              }
1142              free(allCaptureDevNameMap);
1143
1144              allCaptureDevNameMap=deviceList(SND_PCM_CHANNEL_CAPTURE, &numCaptureDevNames);
1145              for (i=0; i<numCaptureDevNames; ++i)
1146              {
1147                  AppendCaptureDeviceList(allCaptureDevNameMap[i].name);
1148              }
1149              break;
1150     }
1151 }