libs/backends/alsa/zita-alsa-pcmi.cc

   1 // ----------------------------------------------------------------------------
   2 //
   3 //  Copyright (C) 2006-2012 Fons Adriaensen <fons@linuxaudio.org>
   4 //
   5 //  This program is free software; you can redistribute it and/or modify
   6 //  it under the terms of the GNU General Public License as published by
   7 //  the Free Software Foundation; either version 3 of the License, or
   8 //  (at your option) any later version.
   9 //
  10 //  This program is distributed in the hope that it will be useful,
  11 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 //  GNU General Public License for more details.
  14 //
  15 //  You should have received a copy of the GNU General Public License
  16 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 //
  18 // ----------------------------------------------------------------------------
  19
  20
  21 #include <endian.h>
  22 #include <sys/time.h>
  23 #include "zita-alsa-pcmi.h"
  24
  25
  26 // Public members ----------------------------------------------------------------------
  27
  28
  29 int zita_alsa_pcmi_major_version (void)
  30 {
  31         return ZITA_ALSA_PCMI_MAJOR_VERSION;
  32 }
  33
  34
  35 int zita_alsa_pcmi_minor_version (void)
  36 {
  37         return ZITA_ALSA_PCMI_MINOR_VERSION;
  38 }
  39
  40
  41 Alsa_pcmi::Alsa_pcmi (
  42                 const char        *play_name,
  43                 const char        *capt_name,
  44                 const char        *ctrl_name,
  45                 unsigned int       fsamp,
  46                 unsigned int       fsize,
  47                 unsigned int       nfrag,
  48                 unsigned int       debug)
  49         : _fsamp (fsamp)
  50         , _fsize (fsize)
  51         , _nfrag (nfrag)
  52         , _debug (debug)
  53         , _state (-1)
  54         , _play_handle (0)
  55         , _capt_handle (0)
  56         , _ctrl_handle (0)
  57         , _play_hwpar (0)
  58         , _play_swpar (0)
  59         , _capt_hwpar (0)
  60         , _capt_swpar (0)
  61         , _play_nchan (0)
  62         , _capt_nchan (0)
  63         , _play_xrun (0)
  64         , _capt_xrun (0)
  65         , _synced (false)
  66         , _play_npfd (0)
  67         , _capt_npfd (0)
  68 {
  69         const char *p;
  70
  71         p = getenv ("ZITA_ALSA_PCMI_DEBUG");
  72         if (p && *p) _debug = atoi (p);
  73         initialise (play_name, capt_name, ctrl_name);
  74 }
  75
  76
  77 Alsa_pcmi::~Alsa_pcmi (void)
  78 {
  79         if (_play_handle) snd_pcm_close (_play_handle);
  80         if (_capt_handle) snd_pcm_close (_capt_handle);
  81         if (_ctrl_handle) snd_ctl_close (_ctrl_handle);
  82
  83         snd_pcm_sw_params_free (_capt_swpar);
  84         snd_pcm_hw_params_free (_capt_hwpar);
  85         snd_pcm_sw_params_free (_play_swpar);
  86         snd_pcm_hw_params_free (_play_hwpar);
  87 }
  88
  89
  90 int Alsa_pcmi::pcm_start (void)
  91 {
  92         unsigned int i, j, n;
  93         int          err;
  94
  95         if (_play_handle)
  96         {
  97                 n = snd_pcm_avail_update (_play_handle);
  98                 if (n != _fsize * _nfrag)
  99                 {
 100                         if (_debug & DEBUG_STAT) fprintf  (stderr, "Alsa_pcmi: full buffer not available at start.\n");
 101                         return -1;
 102                 }
 103                 for (i = 0; i < _nfrag; i++)
 104                 {
 105                         play_init (_fsize);
 106                         for (j = 0; j < _play_nchan; j++) clear_chan (j, _fsize);
 107                         play_done (_fsize);
 108                 }
 109                 if ((err = snd_pcm_start (_play_handle)) < 0)
 110                 {
 111                         if (_debug & DEBUG_STAT) fprintf (stderr, "Alsa_pcmi: pcm_start(play): %s.\n", snd_strerror (err));
 112                         return -1;
 113                 }
 114         }
 115         if (_capt_handle && !_synced && ((err = snd_pcm_start (_capt_handle)) < 0))
 116         {
 117                 if (_debug & DEBUG_STAT) fprintf (stderr, "Alsa_pcmi: pcm_start(capt): %s.\n", snd_strerror (err));
 118                 return -1;
 119         }
 120
 121         return 0;
 122 }
 123
 124
 125 int Alsa_pcmi::pcm_stop (void)
 126 {
 127         int err;
 128
 129         if (_play_handle && ((err = snd_pcm_drop (_play_handle)) < 0))
 130         {
 131                 if (_debug & DEBUG_STAT) fprintf (stderr, "Alsa_pcmi: pcm_drop(play): %s.\n", snd_strerror (err));
 132                 return -1;
 133         }
 134         if (_capt_handle && !_synced && ((err = snd_pcm_drop (_capt_handle)) < 0))
 135         {
 136                 if (_debug & DEBUG_STAT) fprintf (stderr, "Alsa_pcmi: pcm_drop(capt): %s.\n", snd_strerror (err));
 137                 return -1;
 138         }
 139
 140         return 0;
 141 }
 142
 143
 144 snd_pcm_sframes_t Alsa_pcmi::pcm_wait (void)
 145 {
 146         bool              need_capt;
 147         bool              need_play;
 148         snd_pcm_sframes_t capt_av;
 149         snd_pcm_sframes_t play_av;
 150         unsigned short    rev;
 151         int               i, r, n1, n2;
 152
 153         _state = 0;
 154         need_capt = _capt_handle ? true : false;
 155         need_play = _play_handle ? true : false;
 156
 157         while (need_play || need_capt)
 158         {
 159                 n1 = 0;
 160                 if (need_play)
 161                 {
 162                         snd_pcm_poll_descriptors (_play_handle, _poll_fd, _play_npfd);
 163                         n1 += _play_npfd;
 164                 }
 165                 n2 = n1;
 166                 if (need_capt)
 167                 {
 168                         snd_pcm_poll_descriptors (_capt_handle, _poll_fd + n1, _capt_npfd);
 169                         n2 += _capt_npfd;
 170                 }
 171                 for (i = 0; i < n2; i++) _poll_fd [i].events |= POLLERR;
 172
 173                 r = poll (_poll_fd, n2, 1000);
 174                 if (r < 0)
 175                 {
 176                         if (errno == EINTR) return 0;
 177                         if (_debug & DEBUG_WAIT) fprintf (stderr, "Alsa_pcmi: poll(): %s\n.", strerror (errno));
 178                         _state = -1;
 179                         return 0;
 180                 }
 181                 if (r == 0)
 182                 {
 183                         if (_debug & DEBUG_WAIT) fprintf (stderr, "Alsa_pcmi: poll timed out.\n");
 184                         _state = -1;
 185                         return 0;
 186                 }
 187
 188                 if (need_play)
 189                 {
 190                         snd_pcm_poll_descriptors_revents (_play_handle, _poll_fd, n1, &rev);
 191                         if (rev & POLLERR)
 192                         {
 193                                 if (_debug & DEBUG_WAIT) fprintf (stderr, "Alsa_pcmi: error on playback pollfd.\n");
 194                                 _state = 1;
 195                                 recover ();
 196                                 return 0;
 197                         }
 198                         if (rev & POLLOUT) need_play = false;
 199                 }
 200                 if (need_capt)
 201                 {
 202                         snd_pcm_poll_descriptors_revents (_capt_handle, _poll_fd + n1, n2 - n1, &rev);
 203                         if (rev & POLLERR)
 204                         {
 205                                 if (_debug & DEBUG_WAIT) fprintf (stderr, "Alsa_pcmi: error on capture pollfd.\n");
 206                                 _state = 1;
 207                                 recover ();
 208                                 return 0;
 209                         }
 210                         if (rev & POLLIN) need_capt = false;
 211                 }
 212         }
 213
 214         play_av = 999999999;
 215         if (_play_handle && (play_av = snd_pcm_avail_update (_play_handle)) < 0)
 216         {
 217                 _state = -1;
 218                 recover ();
 219                 return 0;
 220         }
 221         capt_av = 999999999;
 222         if (_capt_handle && (capt_av = snd_pcm_avail_update (_capt_handle)) < 0)
 223         {
 224                 _state = -1;
 225                 recover ();
 226                 return 0;
 227         }
 228
 229         return (capt_av < play_av) ? capt_av : play_av;
 230 }
 231
 232
 233 int Alsa_pcmi::pcm_idle (int len)
 234 {
 235         unsigned int       i;
 236         snd_pcm_uframes_t  n, k;
 237
 238         if (_capt_handle)
 239         {
 240                 n = len;
 241                 while (n)
 242                 {
 243                         k = capt_init (n);
 244                         capt_done (k);
 245                         n -= k;
 246                 }
 247         }
 248         if (_play_handle)
 249         {
 250                 n = len;
 251                 while (n)
 252                 {
 253                         k = play_init (n);
 254                         for (i = 0; i < _play_nchan; i++) clear_chan (i, k);
 255                         play_done (k);
 256                         n -= k;
 257                 }
 258         }
 259         return 0;
 260 }
 261
 262
 263 int Alsa_pcmi::play_init (snd_pcm_uframes_t len)
 264 {
 265         unsigned int                   i;
 266         const snd_pcm_channel_area_t   *a;
 267         int                            err;
 268
 269         if ((err = snd_pcm_mmap_begin (_play_handle, &a, &_play_offs, &len)) < 0)
 270         {
 271                 if (_debug & DEBUG_DATA) fprintf (stderr, "Alsa_pcmi: snd_pcm_mmap_begin(play): %s.\n", snd_strerror (err));
 272                 return -1;
 273         }
 274         _play_step = (a->step) >> 3;
 275         for (i = 0; i < _play_nchan; i++, a++)
 276         {
 277                 _play_ptr [i] = (char *) a->addr + ((a->first + a->step * _play_offs) >> 3);
 278         }
 279
 280         return len;
 281 }
 282
 283
 284 int Alsa_pcmi::capt_init (snd_pcm_uframes_t len)
 285 {
 286         unsigned int                  i;
 287         const snd_pcm_channel_area_t  *a;
 288         int                           err;
 289
 290         if ((err = snd_pcm_mmap_begin (_capt_handle, &a, &_capt_offs, &len)) < 0)
 291         {
 292                 if (_debug & DEBUG_DATA) fprintf (stderr, "Alsa_pcmi: snd_pcm_mmap_begin(capt): %s.\n", snd_strerror (err));
 293                 return -1;
 294         }
 295         _capt_step = (a->step) >> 3;
 296         for (i = 0; i < _capt_nchan; i++, a++)
 297         {
 298                 _capt_ptr [i] = (char *) a->addr + ((a->first + a->step * _capt_offs) >> 3);
 299         }
 300
 301         return len;
 302 }
 303
 304
 305 void Alsa_pcmi::clear_chan (int chan, int len)
 306 {
 307         _play_ptr [chan] = (this->*Alsa_pcmi::_clear_func)(_play_ptr [chan], len);
 308 }
 309
 310
 311 void Alsa_pcmi::play_chan (int chan, const float *src, int len, int step)
 312 {
 313         _play_ptr [chan] = (this->*Alsa_pcmi::_play_func)(src, _play_ptr [chan], len, step);
 314 }
 315
 316
 317 void Alsa_pcmi::capt_chan  (int chan, float *dst, int len, int step)
 318 {
 319         _capt_ptr [chan] = (this->*Alsa_pcmi::_capt_func)(_capt_ptr [chan], dst, len, step);
 320 }
 321
 322
 323 int Alsa_pcmi::play_done (int len)
 324 {
 325         return snd_pcm_mmap_commit (_play_handle, _play_offs, len);
 326 }
 327
 328
 329 int Alsa_pcmi::capt_done (int len)
 330 {
 331         return snd_pcm_mmap_commit (_capt_handle, _capt_offs, len);
 332 }
 333
 334
 335 void Alsa_pcmi::printinfo (void)
 336 {
 337         fprintf (stdout, "playback :");
 338         if (_play_handle)
 339         {
 340                 fprintf (stdout, "\n  nchan  : %d\n", _play_nchan);
 341                 fprintf (stdout, "  fsamp  : %d\n", _fsamp);
 342                 fprintf (stdout, "  fsize  : %ld\n", _fsize);
 343                 fprintf (stdout, "  nfrag  : %d\n", _nfrag);
 344                 fprintf (stdout, "  format : %s\n", snd_pcm_format_name (_play_format));
 345         }
 346         else fprintf (stdout, " not enabled\n");
 347         fprintf (stdout, "capture  :");
 348         if (_capt_handle)
 349         {
 350                 fprintf (stdout, "\n  nchan  : %d\n", _capt_nchan);
 351                 fprintf (stdout, "  fsamp  : %d\n", _fsamp);
 352                 fprintf (stdout, "  fsize  : %ld\n", _fsize);
 353                 fprintf (stdout, "  nfrag  : %d\n", _nfrag);
 354                 fprintf (stdout, "  format : %s\n", snd_pcm_format_name (_capt_format));
 355                 if (_play_handle) fprintf (stdout, "%s\n", _synced ? "synced" : "not synced");
 356         }
 357         else fprintf (stdout, " not enabled\n");
 358 }
 359
 360
 361 // Private members ---------------------------------------------------------------------
 362
 363
 364 void Alsa_pcmi::initialise (const char *play_name, const char *capt_name, const char *ctrl_name)
 365 {
 366         unsigned int          fsamp;
 367         snd_pcm_uframes_t     fsize;
 368         unsigned int          nfrag;
 369         int                   err;
 370         int                   dir;
 371         snd_ctl_card_info_t  *card;
 372
 373         if (play_name)
 374         {
 375                 if (snd_pcm_open (&_play_handle, play_name, SND_PCM_STREAM_PLAYBACK, 0) < 0)
 376                 {
 377                         _play_handle = 0;
 378                         if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: Cannot open PCM device %s for playback.\n",
 379                                         play_name);
 380                 }
 381         }
 382
 383         if (capt_name)
 384         {
 385                 if (snd_pcm_open (&_capt_handle, capt_name, SND_PCM_STREAM_CAPTURE, 0) < 0)
 386                 {
 387                         _capt_handle = 0;
 388                         if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: Cannot open PCM device %s for capture.\n",
 389                                         capt_name);
 390                 }
 391         }
 392
 393         if (! _play_handle && ! _capt_handle) return;
 394
 395         if (ctrl_name)
 396         {
 397                 snd_ctl_card_info_alloca (&card);
 398
 399                 if ((err = snd_ctl_open (&_ctrl_handle, ctrl_name, 0)) < 0)
 400                 {
 401                         if (_debug & DEBUG_INIT) fprintf  (stderr, "Alse_driver: ctl_open(): %s\n",
 402                                         snd_strerror (err));
 403                         return;
 404                 }
 405                 if ((err = snd_ctl_card_info (_ctrl_handle, card)) < 0)
 406                 {
 407                         if (_debug & DEBUG_INIT) fprintf  (stderr, "Alsa_pcmi: ctl_card_info(): %s\n",
 408                                         snd_strerror (err));
 409                         return;
 410                 }
 411         }
 412
 413         if (_play_handle)
 414         {
 415                 if (snd_pcm_hw_params_malloc (&_play_hwpar) < 0)
 416                 {
 417                         if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't allocate playback hw params\n");
 418                         return;
 419                 }
 420                 if (snd_pcm_sw_params_malloc (&_play_swpar) < 0)
 421                 {
 422                         if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't allocate playback sw params\n");
 423                         return;
 424                 }
 425                 if (set_hwpar (_play_handle, _play_hwpar, "playback", &_play_nchan) < 0) return;
 426                 if (set_swpar (_play_handle, _play_swpar, "playback") < 0) return;
 427         }
 428
 429         if (_capt_handle)
 430         {
 431                 if (snd_pcm_hw_params_malloc (&_capt_hwpar) < 0)
 432                 {
 433                         if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't allocate capture hw params\n");
 434                         return;
 435                 }
 436                 if (snd_pcm_sw_params_malloc (&_capt_swpar) < 0)
 437                 {
 438                         if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't allocate capture sw params\n");
 439                         return;
 440                 }
 441                 if (set_hwpar (_capt_handle, _capt_hwpar, "capture", &_capt_nchan) < 0) return;
 442                 if (set_swpar (_capt_handle, _capt_swpar, "capture") < 0) return;
 443         }
 444
 445         if (_play_handle)
 446         {
 447                 if (snd_pcm_hw_params_get_rate (_play_hwpar, &fsamp, &dir) || (fsamp != _fsamp) || dir)
 448                 {
 449                         if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't get requested sample rate for playback.\n");
 450                         return;
 451                 }
 452                 if (snd_pcm_hw_params_get_period_size (_play_hwpar, &fsize, &dir) || (fsize != _fsize) || dir)
 453                 {
 454                         if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't get requested period size for playback.\n");
 455                         return;
 456                 }
 457                 if (snd_pcm_hw_params_get_periods (_play_hwpar, &nfrag, &dir) || (nfrag != _nfrag) || dir)
 458                 {
 459                         if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't get requested number of periods for playback.\n");
 460                         return;
 461                 }
 462
 463                 snd_pcm_hw_params_get_format (_play_hwpar, &_play_format);
 464                 snd_pcm_hw_params_get_access (_play_hwpar, &_play_access);
 465
 466 #if __BYTE_ORDER == __LITTLE_ENDIAN
 467                 switch (_play_format)
 468                 {
 469                         case SND_PCM_FORMAT_FLOAT_LE:
 470                                 _clear_func = &Alsa_pcmi::clear_32;
 471                                 _play_func  = &Alsa_pcmi::play_float;
 472                                 break;
 473
 474                         case SND_PCM_FORMAT_S32_LE:
 475                                 _clear_func = &Alsa_pcmi::clear_32;
 476                                 _play_func  = &Alsa_pcmi::play_32;
 477                                 break;
 478
 479                         case SND_PCM_FORMAT_S32_BE:
 480                                 _clear_func = &Alsa_pcmi::clear_32;
 481                                 _play_func  = &Alsa_pcmi::play_32swap;
 482                                 break;
 483
 484                         case SND_PCM_FORMAT_S24_3LE:
 485                                 _clear_func = &Alsa_pcmi::clear_24;
 486                                 _play_func  = &Alsa_pcmi::play_24;
 487                                 break;
 488
 489                         case SND_PCM_FORMAT_S24_3BE:
 490                                 _clear_func = &Alsa_pcmi::clear_24;
 491                                 _play_func  = &Alsa_pcmi::play_24swap;
 492                                 break;
 493
 494                         case SND_PCM_FORMAT_S16_LE:
 495                                 _clear_func = &Alsa_pcmi::clear_16;
 496                                 _play_func  = &Alsa_pcmi::play_16;
 497                                 break;
 498
 499                         case SND_PCM_FORMAT_S16_BE:
 500                                 _clear_func = &Alsa_pcmi::clear_16;
 501                                 _play_func  = &Alsa_pcmi::play_16swap;
 502                                 break;
 503
 504                         default:
 505                                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't handle playback sample format.\n");
 506                                 return;
 507                 }
 508 #elif __BYTE_ORDER == __BIG_ENDIAN
 509                 switch (_play_format)
 510                 {
 511                         case SND_PCM_FORMAT_S32_LE:
 512                                 _clear_func = &Alsa_pcmi::clear_32;
 513                                 _play_func  = &Alsa_pcmi::play_32swap;
 514                                 break;
 515
 516                         case SND_PCM_FORMAT_S32_BE:
 517                                 _clear_func = &Alsa_pcmi::clear_32;
 518                                 _play_func  = &Alsa_pcmi::play_32;
 519                                 break;
 520
 521                         case SND_PCM_FORMAT_S24_3LE:
 522                                 _clear_func = &Alsa_pcmi::clear_24;
 523                                 _play_func  = &Alsa_pcmi::play_24swap;
 524                                 break;
 525
 526                         case SND_PCM_FORMAT_S24_3BE:
 527                                 _clear_func = &Alsa_pcmi::clear_24;
 528                                 _play_func  = &Alsa_pcmi::play_24;
 529                                 break;
 530
 531                         case SND_PCM_FORMAT_S16_LE:
 532                                 _clear_func = &Alsa_pcmi::clear_16;
 533                                 _play_func  = &Alsa_pcmi::play_16swap;
 534                                 break;
 535
 536                         case SND_PCM_FORMAT_S16_BE:
 537                                 _clear_func = &Alsa_pcmi::clear_16;
 538                                 _play_func  = &Alsa_pcmi::play_16;
 539                                 break;
 540
 541                         default:
 542                                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't handle playback sample format.\n");
 543                                 return;
 544                 }
 545 #else
 546 #error "System byte order is undefined or not supported"
 547 #endif
 548
 549                 _play_npfd = snd_pcm_poll_descriptors_count (_play_handle);
 550         }
 551
 552         if (_capt_handle)
 553         {
 554                 if (snd_pcm_hw_params_get_rate (_capt_hwpar, &fsamp, &dir) || (fsamp != _fsamp) || dir)
 555                 {
 556                         if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't get requested sample rate for capture.\n");
 557                         return;
 558                 }
 559                 if (snd_pcm_hw_params_get_period_size (_capt_hwpar, &fsize, &dir) || (fsize != _fsize) || dir)
 560                 {
 561                         if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't get requested period size for capture.\n");
 562                         return;
 563                 }
 564                 if (snd_pcm_hw_params_get_periods (_capt_hwpar, &nfrag, &dir) || (nfrag != _nfrag) || dir)
 565                 {
 566                         if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't get requested number of periods for capture.\n");
 567                         return;
 568                 }
 569
 570                 if (_play_handle) _synced = ! snd_pcm_link (_play_handle, _capt_handle);
 571
 572                 snd_pcm_hw_params_get_format (_capt_hwpar, &_capt_format);
 573                 snd_pcm_hw_params_get_access (_capt_hwpar, &_capt_access);
 574
 575 #if __BYTE_ORDER == __LITTLE_ENDIAN
 576                 switch (_capt_format)
 577                 {
 578                         case SND_PCM_FORMAT_FLOAT_LE:
 579                                 _capt_func  = &Alsa_pcmi::capt_float;
 580                                 break;
 581
 582                         case SND_PCM_FORMAT_S32_LE:
 583                                 _capt_func  = &Alsa_pcmi::capt_32;
 584                                 break;
 585
 586                         case SND_PCM_FORMAT_S32_BE:
 587                                 _capt_func  = &Alsa_pcmi::capt_32swap;
 588                                 break;
 589
 590                         case SND_PCM_FORMAT_S24_3LE:
 591                                 _capt_func  = &Alsa_pcmi::capt_24;
 592                                 break;
 593
 594                         case SND_PCM_FORMAT_S24_3BE:
 595                                 _capt_func  = &Alsa_pcmi::capt_24swap;
 596                                 break;
 597
 598                         case SND_PCM_FORMAT_S16_LE:
 599                                 _capt_func  = &Alsa_pcmi::capt_16;
 600                                 break;
 601
 602                         case SND_PCM_FORMAT_S16_BE:
 603                                 _capt_func  = &Alsa_pcmi::capt_16swap;
 604                                 break;
 605
 606                         default:
 607                                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't handle capture sample format.\n");
 608                                 return;
 609                 }
 610 #elif __BYTE_ORDER == __BIG_ENDIAN
 611                 switch (_capt_format)
 612                 {
 613                         case SND_PCM_FORMAT_S32_LE:
 614                                 _capt_func  = &Alsa_pcmi::capt_32swap;
 615                                 break;
 616
 617                         case SND_PCM_FORMAT_S32_BE:
 618                                 _capt_func  = &Alsa_pcmi::capt_32;
 619                                 break;
 620
 621                         case SND_PCM_FORMAT_S24_3LE:
 622                                 _capt_func  = &Alsa_pcmi::capt_24swap;
 623                                 break;
 624
 625                         case SND_PCM_FORMAT_S24_3BE:
 626                                 _capt_func  = &Alsa_pcmi::capt_24;
 627                                 break;
 628
 629                         case SND_PCM_FORMAT_S16_LE:
 630                                 _capt_func  = &Alsa_pcmi::capt_16swap;
 631                                 break;
 632
 633                         case SND_PCM_FORMAT_S16_BE:
 634                                 _capt_func  = &Alsa_pcmi::capt_16;
 635                                 break;
 636
 637                         default:
 638                                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't handle capture sample format.\n");
 639                                 return;
 640                 }
 641 #else
 642 #error "System byte order is undefined or not supported"
 643 #endif
 644
 645                 _capt_npfd = snd_pcm_poll_descriptors_count (_capt_handle);
 646         }
 647
 648         if (_play_npfd + _capt_npfd > MAXPFD)
 649         {
 650                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: interface requires more than %d pollfd\n", MAXPFD);
 651                 return;
 652         }
 653
 654         _state = 0;
 655 }
 656
 657
 658 int Alsa_pcmi::set_hwpar (snd_pcm_t *handle,  snd_pcm_hw_params_t *hwpar, const char *sname, unsigned int *nchan)
 659 {
 660         bool err;
 661
 662         if (snd_pcm_hw_params_any (handle, hwpar) < 0)
 663         {
 664                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: no %s hw configurations available.\n",
 665                                 sname);
 666                 return -1;
 667         }
 668         if (snd_pcm_hw_params_set_periods_integer (handle, hwpar) < 0)
 669         {
 670                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't set %s period size to integral value.\n",
 671                                 sname);
 672                 return -1;
 673         }
 674         if (   (snd_pcm_hw_params_set_access (handle, hwpar, SND_PCM_ACCESS_MMAP_NONINTERLEAVED) < 0)
 675                         && (snd_pcm_hw_params_set_access (handle, hwpar, SND_PCM_ACCESS_MMAP_INTERLEAVED) < 0)
 676                         && (snd_pcm_hw_params_set_access (handle, hwpar, SND_PCM_ACCESS_MMAP_COMPLEX) < 0))
 677         {
 678                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: the %s interface doesn't support mmap-based access.\n",
 679                                 sname);
 680                 return -1;
 681         }
 682         if (_debug & FORCE_16B)
 683         {
 684                 err =    (snd_pcm_hw_params_set_format (handle, hwpar, SND_PCM_FORMAT_S16_LE) < 0)
 685                         && (snd_pcm_hw_params_set_format (handle, hwpar, SND_PCM_FORMAT_S16_BE) < 0);
 686         }
 687         else
 688         {
 689                 err =    (snd_pcm_hw_params_set_format (handle, hwpar, SND_PCM_FORMAT_FLOAT_LE) < 0)
 690                         && (snd_pcm_hw_params_set_format (handle, hwpar, SND_PCM_FORMAT_S32_LE) < 0)
 691                         && (snd_pcm_hw_params_set_format (handle, hwpar, SND_PCM_FORMAT_S32_BE) < 0)
 692                         && (snd_pcm_hw_params_set_format (handle, hwpar, SND_PCM_FORMAT_S24_3LE) < 0)
 693                         && (snd_pcm_hw_params_set_format (handle, hwpar, SND_PCM_FORMAT_S24_3BE) < 0)
 694                         && (snd_pcm_hw_params_set_format (handle, hwpar, SND_PCM_FORMAT_S16_LE) < 0)
 695                         && (snd_pcm_hw_params_set_format (handle, hwpar, SND_PCM_FORMAT_S16_BE) < 0);
 696         }
 697         if (err)
 698         {
 699                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: no supported sample format on %s interface.\n.",
 700                                 sname);
 701                 return -1;
 702         }
 703         if (snd_pcm_hw_params_set_rate (handle, hwpar, _fsamp, 0) < 0)
 704         {
 705                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't set %s sample rate to %u.\n",
 706                                 sname, _fsamp);
 707                 return -1;
 708         }
 709         snd_pcm_hw_params_get_channels_max (hwpar, nchan);
 710         if (*nchan > 1024)
 711         {
 712                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: detected more than 1024 %s channnels, reset to 2.\n",
 713                                 sname);
 714                 *nchan = 2;
 715         }
 716         if (_debug & FORCE_2CH)
 717         {
 718                 *nchan = 2;
 719         }
 720         if (*nchan > MAXCHAN)
 721         {
 722                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: number of %s channels reduced to %d.\n",
 723                                 sname, MAXCHAN);
 724                 *nchan = MAXCHAN;
 725         }
 726
 727         if (snd_pcm_hw_params_set_channels (handle, hwpar, *nchan) < 0)
 728         {
 729                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't set %s channel count to %u.\n",
 730                                 sname, *nchan);
 731                 return -1;
 732         }
 733         if (snd_pcm_hw_params_set_period_size (handle, hwpar, _fsize, 0) < 0)
 734         {
 735                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't set %s period size to %lu.\n",
 736                                 sname, _fsize);
 737                 return -1;
 738         }
 739         if (snd_pcm_hw_params_set_periods (handle, hwpar, _nfrag, 0) < 0)
 740         {
 741                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't set %s periods to %u.\n",
 742                                 sname, _nfrag);
 743                 return -1;
 744         }
 745         if (snd_pcm_hw_params_set_buffer_size (handle, hwpar, _fsize * _nfrag) < 0)
 746         {
 747                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't set %s buffer length to %lu.\n",
 748                                 sname, _fsize * _nfrag);
 749                 return -1;
 750         }
 751         if (snd_pcm_hw_params (handle, hwpar) < 0)
 752         {
 753                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't set %s hardware parameters.\n",
 754                                 sname);
 755                 return -1;
 756         }
 757
 758         return 0;
 759 }
 760
 761
 762 int Alsa_pcmi::set_swpar (snd_pcm_t *handle, snd_pcm_sw_params_t *swpar, const char *sname)
 763 {
 764         int err;
 765
 766         snd_pcm_sw_params_current (handle, swpar);
 767
 768         if ((err = snd_pcm_sw_params_set_tstamp_mode (handle, swpar, SND_PCM_TSTAMP_MMAP)) < 0)
 769         {
 770                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't set %s timestamp mode to %u.\n",
 771                                 sname, SND_PCM_TSTAMP_MMAP);
 772                 return -1;
 773         }
 774         if ((err = snd_pcm_sw_params_set_avail_min (handle, swpar, _fsize)) < 0)
 775         {
 776                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't set %s avail_min to %lu.\n",
 777                                 sname, _fsize);
 778                 return -1;
 779         }
 780         if ((err = snd_pcm_sw_params (handle, swpar)) < 0)
 781         {
 782                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: can't set %s software parameters.\n",
 783                                 sname);
 784                 return -1;
 785         }
 786
 787         return 0;
 788 }
 789
 790
 791 int Alsa_pcmi::recover (void)
 792 {
 793         int                err;
 794         snd_pcm_status_t   *stat;
 795
 796         snd_pcm_status_alloca (&stat);
 797
 798         if (_play_handle)
 799         {
 800                 if ((err = snd_pcm_status (_play_handle, stat)) < 0)
 801                 {
 802                         if (_debug & DEBUG_STAT) fprintf (stderr, "Alsa_pcmi: pcm_status(play): %s\n",
 803                                         snd_strerror (err));
 804                 }
 805                 _play_xrun = xruncheck (stat);
 806         }
 807         if (_capt_handle)
 808         {
 809                 if ((err = snd_pcm_status (_capt_handle, stat)) < 0)
 810                 {
 811                         if (_debug & DEBUG_STAT) fprintf (stderr, "Alsa_pcmi: pcm_status(capt): %s\n",
 812                                         snd_strerror (err));
 813                 }
 814                 _capt_xrun = xruncheck (stat);
 815         }
 816
 817         if (pcm_stop ()) return -1;
 818         if (_play_handle && ((err = snd_pcm_prepare (_play_handle)) < 0))
 819         {
 820                 if (_debug & DEBUG_STAT) fprintf (stderr, "Alsa_pcmi: pcm_prepare(play): %s\n",
 821                                 snd_strerror (err));
 822                 return -1;
 823         }
 824         if (_capt_handle && !_synced && ((err = snd_pcm_prepare (_capt_handle)) < 0))
 825         {
 826                 if (_debug & DEBUG_INIT) fprintf (stderr, "Alsa_pcmi: pcm_prepare(capt): %s\n",
 827                                 snd_strerror (err));
 828                 return -1;
 829         }
 830         if (pcm_start ()) return -1;
 831
 832         return 0;
 833 }
 834
 835
 836 float Alsa_pcmi::xruncheck (snd_pcm_status_t *stat)
 837 {
 838         struct timeval   tupd, trig;
 839         int              ds, du;
 840
 841         if (snd_pcm_status_get_state (stat) == SND_PCM_STATE_XRUN)
 842         {
 843                 snd_pcm_status_get_tstamp (stat, &tupd);
 844                 snd_pcm_status_get_trigger_tstamp (stat, &trig);
 845                 ds = tupd.tv_sec - trig.tv_sec;
 846                 du = tupd.tv_usec - trig.tv_usec;
 847                 if (du < 0)
 848                 {
 849                         du += 1000000;
 850                         ds -= 1;
 851                 }
 852                 return ds + 1e-6f * du;
 853         }
 854         return 0.0f;
 855 }
 856
 857
 858 char *Alsa_pcmi::clear_16 (char *dst, int nfrm)
 859 {
 860         while (nfrm--)
 861         {
 862                 *((short int *) dst) = 0;
 863                 dst += _play_step;
 864         }
 865         return dst;
 866 }
 867
 868 char *Alsa_pcmi::clear_24 (char *dst, int nfrm)
 869 {
 870         while (nfrm--)
 871         {
 872                 dst [0] = 0;
 873                 dst [1] = 0;
 874                 dst [2] = 0;
 875                 dst += _play_step;
 876         }
 877         return dst;
 878 }
 879
 880 char *Alsa_pcmi::clear_32 (char *dst, int nfrm)
 881 {
 882         while (nfrm--)
 883         {
 884                 *((int *) dst) = 0;
 885                 dst += _play_step;
 886         }
 887         return dst;
 888 }
 889
 890
 891 char *Alsa_pcmi::play_16 (const float *src, char *dst, int nfrm, int step)
 892 {
 893         float     s;
 894         short int d;
 895
 896         while (nfrm--)
 897         {
 898                 s = *src;
 899                 if      (s >  1) d = 0x7fff;
 900                 else if (s < -1) d = 0x8001;
 901                 else d = (short int)((float) 0x7fff * s);
 902                 *((short int *) dst) = d;
 903                 dst += _play_step;
 904                 src += step;
 905         }
 906         return dst;
 907 }
 908
 909 char *Alsa_pcmi::play_16swap (const float *src, char *dst, int nfrm, int step)
 910 {
 911         float     s;
 912         short int d;
 913
 914         while (nfrm--)
 915         {
 916                 s = *src;
 917                 if      (s >  1) d = 0x7fff;
 918                 else if (s < -1) d = 0x8001;
 919                 else d = (short int)((float) 0x7fff * s);
 920                 dst [0] = d >> 8;
 921                 dst [1] = d;
 922                 dst += _play_step;
 923                 src += step;
 924         }
 925         return dst;
 926 }
 927
 928 char *Alsa_pcmi::play_24 (const float *src, char *dst, int nfrm, int step)
 929 {
 930         float   s;
 931         int     d;
 932
 933         while (nfrm--)
 934         {
 935                 s = *src;
 936                 if      (s >  1) d = 0x007fffff;
 937                 else if (s < -1) d = 0x00800001;
 938                 else d = (int)((float) 0x007fffff * s);
 939                 dst [0] = d;
 940                 dst [1] = d >> 8;
 941                 dst [2] = d >> 16;
 942                 dst += _play_step;
 943                 src += step;
 944         }
 945         return dst;
 946 }
 947
 948 char *Alsa_pcmi::play_24swap (const float *src, char *dst, int nfrm, int step)
 949 {
 950         float   s;
 951         int     d;
 952
 953         while (nfrm--)
 954         {
 955                 s = *src;
 956                 if      (s >  1) d = 0x007fffff;
 957                 else if (s < -1) d = 0x00800001;
 958                 else d = (int)((float) 0x007fffff * s);
 959                 dst [0] = d >> 16;
 960                 dst [1] = d >> 8;
 961                 dst [2] = d;
 962                 dst += _play_step;
 963                 src += step;
 964         }
 965         return dst;
 966 }
 967
 968 char *Alsa_pcmi::play_32 (const float *src, char *dst, int nfrm, int step)
 969 {
 970         float   s;
 971         int     d;
 972
 973         while (nfrm--)
 974         {
 975                 s = *src;
 976                 if      (s >  1) d = 0x007fffff;
 977                 else if (s < -1) d = 0x00800001;
 978                 else d = (int)((float) 0x007fffff * s);
 979                 *((int *) dst) = d << 8;
 980                 dst += _play_step;
 981                 src += step;
 982         }
 983         return dst;
 984 }
 985
 986 char *Alsa_pcmi::play_32swap (const float *src, char *dst, int nfrm, int step)
 987 {
 988         float   s;
 989         int     d;
 990
 991         while (nfrm--)
 992         {
 993                 s = *src;
 994                 if      (s >  1) d = 0x007fffff;
 995                 else if (s < -1) d = 0x00800001;
 996                 else d = (int)((float) 0x007fffff * s);
 997                 dst [0] = d >> 16;
 998                 dst [1] = d >> 8;
 999                 dst [2] = d;
1000                 dst [3] = 0;
1001                 dst += _play_step;
1002                 src += step;
1003         }
1004         return dst;
1005 }
1006
1007 char *Alsa_pcmi::play_float (const float *src, char *dst, int nfrm, int step)
1008 {
1009         while (nfrm--)
1010         {
1011                 *((float *) dst) = *src;
1012                 dst += _play_step;
1013                 src += step;
1014         }
1015         return dst;
1016 }
1017
1018
1019 const char *Alsa_pcmi::capt_16 (const char *src, float *dst, int nfrm, int step)
1020 {
1021         while (nfrm--)
1022         {
1023                 const short int s = *((short int const *) src);
1024                 const float d = (float) s / (float) 0x7fff;
1025                 *dst = d;
1026                 dst += step;
1027                 src += _capt_step;
1028         }
1029         return src;
1030 }
1031
1032 const char *Alsa_pcmi::capt_16swap (const char *src, float *dst, int nfrm, int step)
1033 {
1034         float     d;
1035         short int s;
1036
1037         while (nfrm--)
1038         {
1039                 s =  (src [0] & 0xFF) << 8;
1040                 s += (src [1] & 0xFF);
1041                 d = (float) s / (float) 0x7fff;
1042                 *dst = d;
1043                 dst += step;
1044                 src += _capt_step;
1045         }
1046         return src;
1047 }
1048
1049 const char *Alsa_pcmi::capt_24 (const char *src, float *dst, int nfrm, int step)
1050 {
1051         float   d;
1052         int     s;
1053
1054         while (nfrm--)
1055         {
1056                 s  = (src [0] & 0xFF);
1057                 s += (src [1] & 0xFF) << 8;
1058                 s += (src [2] & 0xFF) << 16;
1059                 if (s & 0x00800000) s-= 0x01000000;
1060                 d = (float) s / (float) 0x007fffff;
1061                 *dst = d;
1062                 dst += step;
1063                 src += _capt_step;
1064         }
1065         return src;
1066 }
1067
1068 const char *Alsa_pcmi::capt_24swap (const char *src, float *dst, int nfrm, int step)
1069 {
1070         float   d;
1071         int     s;
1072
1073         while (nfrm--)
1074         {
1075                 s  = (src [0] & 0xFF) << 16;
1076                 s += (src [1] & 0xFF) << 8;
1077                 s += (src [2] & 0xFF);
1078                 if (s & 0x00800000) s-= 0x01000000;
1079                 d = (float) s / (float) 0x007fffff;
1080                 *dst = d;
1081                 dst += step;
1082                 src += _capt_step;
1083         }
1084         return src;
1085 }
1086
1087 const char *Alsa_pcmi::capt_32 (const char *src, float *dst, int nfrm, int step)
1088 {
1089         while (nfrm--)
1090         {
1091                 const int s = *((int const *) src);
1092                 const float d = (float) s / (float) 0x7fffff00;
1093                 *dst = d;
1094                 dst += step;
1095                 src += _capt_step;
1096         }
1097         return src;
1098 }
1099
1100 const char *Alsa_pcmi::capt_32swap (const char *src, float *dst, int nfrm, int step)
1101 {
1102         float   d;
1103         int     s;
1104
1105         while (nfrm--)
1106         {
1107                 s  = (src [0] & 0xFF) << 24;
1108                 s += (src [1] & 0xFF) << 16;
1109                 s += (src [2] & 0xFF) << 8;
1110                 d = (float) s / (float) 0x7fffff00;
1111                 *dst = d;
1112                 dst += step;
1113                 src += _capt_step;
1114         }
1115         return src;
1116 }
1117
1118 const char *Alsa_pcmi::capt_float (const char *src, float *dst, int nfrm, int step)
1119 {
1120         while (nfrm--)
1121         {
1122                 *dst = *((float const *) src);
1123                 dst += step;
1124                 src += _capt_step;
1125         }
1126         return src;
1127 }