plugins/sound_alsa/sound_alsa.cxx

   1 /*
   2  * sound_alsa.cxx
   3  *
   4  * Sound driver implementation.
   5  *
   6  * Portable Windows Library
   7  *
   8  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
   9  *
  10  * The contents of this file are subject to the Mozilla Public License
  11  * Version 1.0 (the "License"); you may not use this file except in
  12  * compliance with the License. You may obtain a copy of the License at
  13  * http://www.mozilla.org/MPL/
  14  *
  15  * Software distributed under the License is distributed on an "AS IS"
  16  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17  * the License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * The Original Code is Portable Windows Library.
  21  *
  22  * The Initial Developer of the Original ALSA Code is
  23  * Damien Sandras <dsandras@seconix.com>
  24  *
  25  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  26  * All Rights Reserved.
  27  *
  28  * Contributor(s): /
  29  *
  30  * $Log$
  31  * Revision 1.14  2004/02/12 09:07:57  csoutheren
  32  * Fixed typo in ALSA driver, thanks to Julien Puydt
  33  *
  34  * Revision 1.13  2004/01/04 20:59:30  dsandras
  35  * Use set_rate_near instead of set_rate.
  36  *
  37  * Revision 1.12  2003/12/28 15:10:35  dsandras
  38  * Updated to the new PCM API.
  39  *
  40  * Revision 1.11  2003/12/18 11:16:41  dominance
  41  * Removed the ALSA Abort completely upon Damien's request ;)
  42  *
  43  * Revision 1.10  2003/12/18 10:38:55  dominance
  44  * Removed ALSA Abort as it segfaults in various circumstances.
  45  * Fix proposed by Damien Sandras <dsandras@seconix.com>.
  46  *
  47  * Revision 1.9  2003/12/09 22:47:10  dsandras
  48  * Use less aggressive Abort.
  49  *
  50  * Revision 1.8  2003/12/03 21:48:21  dsandras
  51  * Better handling of buffer sizes. Removed unuseful code.
  52  *
  53  * Revision 1.7  2003/11/25 20:13:48  dsandras
  54  * Added #pragma.
  55  *
  56  * Revision 1.6  2003/11/25 09:58:01  dsandras
  57  * Removed Abort call from PlaySound ().
  58  *
  59  * Revision 1.5  2003/11/25 09:52:07  dsandras
  60  * Modified WaitForPlayCompletion so that it uses snd_pcm_drain instead of active waiting.
  61  *
  62  * Revision 1.4  2003/11/23 22:09:57  dsandras
  63  * Removed unuseful stuff and added implementation for functions permitting to play a file or a PSound.
  64  *
  65  * Revision 1.3  2003/11/14 05:28:47  csoutheren
  66  * Updated for new plugin code thanks to Damien and Snark
  67  *
  68  */
  69
  70 #pragma implementation "sound_alsa.h"
  71
  72 #include "sound_alsa.h"
  73
  74
  75 PCREATE_SOUND_PLUGIN(ALSA, PSoundChannelALSA)
  76
  77
  78 static PStringArray playback_devices;
  79 static PStringArray capture_devices;
  80
  81 ///////////////////////////////////////////////////////////////////////////////
  82
  83 PSoundChannelALSA::PSoundChannelALSA()
  84 {
  85   PSoundChannelALSA::Construct();
  86 }
  87
  88
  89 PSoundChannelALSA::PSoundChannelALSA (const PString &device,
  90                                       Directions dir,
  91                                       unsigned numChannels,
  92                                       unsigned sampleRate,
  93                                       unsigned bitsPerSample)
  94 {
  95   Construct();
  96   Open (device, dir, numChannels, sampleRate, bitsPerSample);
  97 }
  98
  99
 100 void PSoundChannelALSA::Construct()
 101 {
 102   frame_bytes = 0;
 103   period_size = 0;
 104   periods = 0;
 105   card_nr = 0;
 106   os_handle = NULL;
 107 }
 108
 109
 110 PSoundChannelALSA::~PSoundChannelALSA()
 111 {
 112   Close();
 113 }
 114
 115
 116 PStringArray PSoundChannelALSA::GetDeviceNames (Directions dir)
 117 {
 118   int card = -1, dev = -1;
 119
 120   snd_ctl_t *handle = NULL;
 121   snd_ctl_card_info_t *info = NULL;
 122   snd_pcm_info_t *pcminfo = NULL;
 123   snd_pcm_stream_t stream;
 124
 125   char *name = NULL;
 126   char card_id [32];
 127
 128   if (dir == Recorder) {
 129
 130     stream = SND_PCM_STREAM_CAPTURE;
 131     capture_devices = PStringArray ();
 132   }
 133   else {
 134
 135     stream = SND_PCM_STREAM_PLAYBACK;
 136     playback_devices = PStringArray ();
 137   }
 138
 139   snd_ctl_card_info_alloca (&info);
 140   snd_pcm_info_alloca (&pcminfo);
 141
 142   /* No sound card found */
 143   if (snd_card_next (&card) < 0 || card < 0) {
 144
 145     return PStringArray ();
 146   }
 147
 148
 149   while (card >= 0) {
 150
 151     snprintf (card_id, 32, "hw:%d", card);
 152
 153     snd_ctl_open (&handle, card_id, 0);
 154     snd_ctl_card_info (handle, info);
 155
 156     while (1) {
 157
 158       snd_ctl_pcm_next_device (handle, &dev);
 159
 160       if (dev < 0)
 161         break;
 162
 163       snd_pcm_info_set_device (pcminfo, dev);
 164       snd_pcm_info_set_subdevice (pcminfo, 0);
 165       snd_pcm_info_set_stream (pcminfo, stream);
 166
 167       if (snd_ctl_pcm_info (handle, pcminfo) >= 0) {
 168
 169         snd_card_get_name (card, &name);
 170         if (dir == Recorder) {
 171
 172           if (capture_devices.GetStringsIndex (name) == P_MAX_INDEX)
 173             capture_devices.AppendString (name);
 174         }
 175         else {
 176
 177           if (playback_devices.GetStringsIndex (name) == P_MAX_INDEX)
 178             playback_devices.AppendString (name);
 179         }
 180
 181         free (name);
 182       }
 183     }
 184
 185
 186     snd_ctl_close(handle);
 187     snd_card_next (&card);
 188   }
 189
 190
 191   if (dir == Recorder)
 192     return capture_devices;
 193   else
 194     return playback_devices;
 195 }
 196
 197
 198 PString PSoundChannelALSA::GetDefaultDevice(Directions dir)
 199 {
 200   PStringArray devicenames;
 201   devicenames = PSoundChannelALSA::GetDeviceNames (dir);
 202
 203   return devicenames[0];
 204 }
 205
 206
 207 BOOL PSoundChannelALSA::Open (const PString & _device,
 208                               Directions _dir,
 209                               unsigned _numChannels,
 210                               unsigned _sampleRate,
 211                               unsigned _bitsPerSample)
 212 {
 213   PString real_device_name;
 214   PINDEX i = 0;
 215   snd_pcm_stream_t stream;
 216
 217   Close();
 218
 219   os_handle = NULL;
 220
 221   if (_dir == Recorder)
 222     stream = SND_PCM_STREAM_CAPTURE;
 223   else
 224     stream = SND_PCM_STREAM_PLAYBACK;
 225
 226   /* Open in NONBLOCK mode */
 227   if ((i = (_dir == Recorder) ? capture_devices.GetStringsIndex (_device) : playback_devices.GetStringsIndex (_device)) != P_MAX_INDEX) {
 228
 229     real_device_name = "plughw:" + PString (i);
 230     card_nr = i;
 231   }
 232   else {
 233
 234     PTRACE (1, "ALSA\tDevice unavailable");
 235     return FALSE;
 236   }
 237
 238   if (snd_pcm_open (&os_handle, real_device_name, stream, SND_PCM_NONBLOCK) < 0) {
 239
 240     PTRACE (1, "ALSA\tOpen Failed");
 241     return FALSE;
 242   }
 243   else
 244     snd_pcm_nonblock (os_handle, 0);
 245
 246   /* save internal parameters */
 247   direction = _dir;
 248   device = real_device_name;
 249   mNumChannels = _numChannels;
 250   mSampleRate = _sampleRate;
 251   mBitsPerSample = _bitsPerSample;
 252   isInitialised = FALSE;
 253
 254   PTRACE (1, "ALSA\tDevice " << real_device_name << " Opened");
 255
 256   return TRUE;
 257 }
 258
 259
 260 BOOL PSoundChannelALSA::Setup()
 261 {
 262   snd_pcm_hw_params_t *hw_params = NULL;
 263   snd_pcm_uframes_t buffer_size = 0;
 264
 265   int err = 0;
 266   enum _snd_pcm_format val = SND_PCM_FORMAT_UNKNOWN;
 267   BOOL no_error = TRUE;
 268
 269
 270   if (os_handle == NULL) {
 271
 272     PTRACE(6, "ALSA\tSkipping setup of " << device << " as not open");
 273     return FALSE;
 274   }
 275
 276   if (isInitialised) {
 277
 278     PTRACE(6, "ALSA\tSkipping setup of " << device << " as instance already initialised");
 279     return TRUE;
 280   }
 281
 282
 283 #if PBYTE_ORDER == PLITTLE_ENDIAN
 284   val = (mBitsPerSample == 16) ? SND_PCM_FORMAT_S16_LE : SND_PCM_FORMAT_U8;
 285 #else
 286   val = (mBitsPerSample == 16) ? SND_PCM_FORMAT_S16_BE : SND_PCM_FORMAT_U8;
 287 #endif
 288
 289   frame_bytes = (mNumChannels * (snd_pcm_format_width (val) / 8));
 290
 291   snd_pcm_hw_params_alloca (&hw_params);
 292
 293   if ((err = snd_pcm_hw_params_any (os_handle, hw_params)) < 0) {
 294
 295     PTRACE (1, "ALSA\tCannot initialize hardware parameter structure " <<
 296             snd_strerror (err));
 297     no_error = FALSE;
 298   }
 299
 300
 301   if ((err = snd_pcm_hw_params_set_access (os_handle, hw_params,
 302                                            SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
 303
 304     PTRACE (1, "ALSA\tCannot set access type " <<
 305             snd_strerror (err));
 306     no_error = FALSE;
 307   }
 308
 309
 310   if ((err = snd_pcm_hw_params_set_format (os_handle, hw_params, val)) < 0) {
 311
 312     PTRACE (1, "ALSA\tCannot set sample format " <<
 313              snd_strerror (err));
 314     no_error = FALSE;
 315   }
 316
 317
 318   if ((err = snd_pcm_hw_params_set_rate_near (os_handle,
 319                                               hw_params,
 320                                               &mSampleRate,
 321                                               NULL)) < 0) {
 322
 323     PTRACE (1, "ALSA\tCannot set sample rate " <<
 324             snd_strerror (err));
 325     no_error = FALSE;
 326   }
 327
 328
 329   if ((err = snd_pcm_hw_params_set_channels (os_handle, hw_params,
 330                                              mNumChannels)) < 0) {
 331
 332     PTRACE (1, "ALSA\tCannot set channel count " <<
 333              snd_strerror (err));
 334     no_error = FALSE;
 335   }
 336
 337
 338   // Ignore errors here
 339   if (periods && period_size) {
 340
 341     if ((err = snd_pcm_hw_params_set_period_size_near (os_handle,
 342                                                        hw_params,
 343                                                        &period_size,
 344                                                        0)) < 0)
 345       PTRACE (1, "ALSA\tCannot set period size " <<
 346               snd_strerror (err));
 347
 348     if ((err = snd_pcm_hw_params_set_periods_near (os_handle,
 349                                                    hw_params,
 350                                                    &periods,
 351                                                    0)) < 0)
 352       PTRACE (1, "ALSA\tCannot set number of periods " <<
 353               snd_strerror (err));
 354
 355     buffer_size = periods*period_size/frame_bytes;
 356
 357     if ((err = (int) snd_pcm_hw_params_set_buffer_size_near (os_handle,
 358                                                              hw_params,
 359                                                              &buffer_size))
 360         < 0)
 361       PTRACE (1, "ALSA\tCannot set buffer size " <<
 362               snd_strerror (err));
 363   }
 364
 365
 366   if ((err = snd_pcm_hw_params (os_handle, hw_params)) < 0) {
 367
 368     PTRACE (1, "ALSA\tCannot set parameters " <<
 369             snd_strerror (err));
 370     no_error = FALSE;
 371   }
 372
 373
 374   isInitialised = TRUE;
 375
 376   return no_error;
 377 }
 378
 379
 380 BOOL PSoundChannelALSA::Close()
 381 {
 382   PWaitAndSignal m(device_mutex);
 383
 384   /* if the channel isn't open, do nothing */
 385   if (!os_handle)
 386     return FALSE;
 387
 388   snd_pcm_close (os_handle);
 389   os_handle = NULL;
 390
 391   return TRUE;
 392 }
 393
 394
 395 BOOL PSoundChannelALSA::Write (const void *buf, PINDEX len)
 396 {
 397   long r = 0;
 398   char *buf2 = (char *) buf;
 399   int pos = 0, max_try = 0;
 400
 401   PWaitAndSignal m(device_mutex);
 402
 403   if (!isInitialised && !Setup() || !len || !os_handle)
 404     return FALSE;
 405
 406   do {
 407
 408
 409     /* the number of frames to read is the buffer length
 410        divided by the size of one frame */
 411     r = snd_pcm_writei (os_handle, (char *) &buf2 [pos], len / frame_bytes);
 412
 413     if (r > 0) {
 414
 415       pos += r * frame_bytes;
 416       len -= r * frame_bytes;
 417     }
 418     else {
 419
 420       if (r == -EPIPE) {    /* under-run */
 421
 422         r = snd_pcm_prepare (os_handle);
 423         if (r < 0)
 424           PTRACE (1, "ALSA\tCould not prepare device: " << snd_strerror (r));
 425
 426       } else if (r == -ESTRPIPE) {
 427
 428         while ((r = snd_pcm_resume (os_handle)) == -EAGAIN)
 429           sleep(1);       /* wait until the suspend flag is released */
 430
 431         if (r < 0)
 432           snd_pcm_prepare (os_handle);
 433       }
 434
 435       PTRACE (1, "ALSA\tCould not write "
 436               << max_try << " " << len << " " << r);
 437       max_try++;
 438     }
 439
 440   } while (len > 0 && max_try < 5);
 441
 442
 443   return TRUE;
 444 }
 445
 446
 447 BOOL PSoundChannelALSA::Read (void * buf, PINDEX len)
 448 {
 449   long r = 0;
 450
 451   char *buf2 = (char *) buf;
 452   int pos = 0, max_try = 0;
 453
 454   lastReadCount = 0;
 455
 456   PWaitAndSignal m(device_mutex);
 457
 458   if (!isInitialised && !Setup() || !len || !os_handle)
 459     return FALSE;
 460
 461   memset ((char *) buf, 0, len);
 462
 463   do {
 464
 465     /* the number of frames to read is the buffer length
 466        divided by the size of one frame */
 467     r = snd_pcm_readi (os_handle, (char *) &buf2 [pos], len / frame_bytes);
 468
 469     if (r > 0) {
 470
 471       pos += r * frame_bytes;
 472       len -= r * frame_bytes;
 473       lastReadCount += r * frame_bytes;
 474     }
 475     else {
 476
 477       if (r == -EPIPE) {    /* under-run */
 478
 479         snd_pcm_prepare (os_handle);
 480
 481       } else if (r == -ESTRPIPE) {
 482
 483         while ((r = snd_pcm_resume (os_handle)) == -EAGAIN)
 484           sleep(1);       /* wait until the suspend flag is released */
 485
 486         if (r < 0)
 487           snd_pcm_prepare (os_handle);
 488       }
 489
 490       PTRACE (1, "ALSA\tCould not read");
 491       max_try++;
 492     }
 493   } while (len > 0 && max_try < 5);
 494
 495
 496   if (len != 0) {
 497
 498     memset ((char *) &buf2 [pos], 0, len);
 499     lastReadCount += len;
 500
 501     PTRACE (1, "ALSA\tRead Error, filling with zeros");
 502   }
 503
 504   return TRUE;
 505 }
 506
 507
 508 BOOL PSoundChannelALSA::SetFormat (unsigned numChannels,
 509                                    unsigned sampleRate,
 510                                    unsigned bitsPerSample)
 511 {
 512   if (!os_handle)
 513     return SetErrorValues(NotOpen, EBADF);
 514
 515   /* check parameters */
 516   PAssert((bitsPerSample == 8) || (bitsPerSample == 16), PInvalidParameter);
 517   PAssert(numChannels >= 1 && numChannels <= 2, PInvalidParameter);
 518
 519   mNumChannels   = numChannels;
 520   mSampleRate    = sampleRate;
 521   mBitsPerSample = bitsPerSample;
 522
 523   /* mark this channel as uninitialised */
 524   isInitialised = FALSE;
 525
 526   return TRUE;
 527 }
 528
 529
 530 unsigned PSoundChannelALSA::GetChannels()   const
 531 {
 532   return mNumChannels;
 533 }
 534
 535
 536 unsigned PSoundChannelALSA::GetSampleRate() const
 537 {
 538   return mSampleRate;
 539 }
 540
 541
 542 unsigned PSoundChannelALSA::GetSampleSize() const
 543 {
 544   return mBitsPerSample;
 545 }
 546
 547
 548 BOOL PSoundChannelALSA::SetBuffers (PINDEX size, PINDEX count)
 549 {
 550   periods = count;
 551   period_size = size / (frame_bytes ? frame_bytes : 2);
 552
 553   return TRUE;
 554 }
 555
 556
 557 BOOL PSoundChannelALSA::GetBuffers(PINDEX & size, PINDEX & count)
 558 {
 559   size = period_size * (frame_bytes ? frame_bytes : 2);
 560   count = periods;
 561
 562   return FALSE;
 563 }
 564
 565
 566 BOOL PSoundChannelALSA::PlaySound(const PSound & sound, BOOL wait)
 567 {
 568   if (!os_handle)
 569     return SetErrorValues(NotOpen, EBADF);
 570
 571   if (!Write((const BYTE *)sound, sound.GetSize()))
 572     return FALSE;
 573
 574   if (wait)
 575     return WaitForPlayCompletion();
 576
 577   return TRUE;
 578 }
 579
 580
 581 BOOL PSoundChannelALSA::PlayFile(const PFilePath & filename, BOOL wait)
 582 {
 583   BYTE buffer [512];
 584
 585   if (!os_handle)
 586     return SetErrorValues(NotOpen, EBADF);
 587
 588   PFile file (filename, PFile::ReadOnly);
 589
 590   if (!file.IsOpen())
 591     return FALSE;
 592
 593   for (;;) {
 594
 595     if (!file.Read (buffer, 512))
 596       break;
 597
 598     PINDEX len = file.GetLastReadCount();
 599     if (len == 0)
 600       break;
 601     if (!Write(buffer, len))
 602       break;
 603   }
 604
 605   file.Close();
 606
 607   if (wait)
 608     return WaitForPlayCompletion();
 609
 610   return TRUE;
 611 }
 612
 613
 614 BOOL PSoundChannelALSA::HasPlayCompleted()
 615 {
 616   if (!os_handle)
 617     return SetErrorValues(NotOpen, EBADF);
 618
 619   return (snd_pcm_state (os_handle) != SND_PCM_STATE_RUNNING);
 620 }
 621
 622
 623 BOOL PSoundChannelALSA::WaitForPlayCompletion()
 624 {
 625   if (!os_handle)
 626     return SetErrorValues(NotOpen, EBADF);
 627
 628   snd_pcm_drain (os_handle);
 629
 630   return TRUE;
 631 }
 632
 633
 634 BOOL PSoundChannelALSA::RecordSound(PSound & sound)
 635 {
 636   return FALSE;
 637 }
 638
 639
 640 BOOL PSoundChannelALSA::RecordFile(const PFilePath & filename)
 641 {
 642   return FALSE;
 643 }
 644
 645
 646 BOOL PSoundChannelALSA::StartRecording()
 647 {
 648   return FALSE;
 649 }
 650
 651
 652 BOOL PSoundChannelALSA::IsRecordBufferFull()
 653 {
 654   return TRUE;
 655 }
 656
 657
 658 BOOL PSoundChannelALSA::AreAllRecordBuffersFull()
 659 {
 660   return TRUE;
 661 }
 662
 663
 664 BOOL PSoundChannelALSA::WaitForRecordBufferFull()
 665 {
 666   return TRUE;
 667 }
 668
 669
 670 BOOL PSoundChannelALSA::WaitForAllRecordBuffersFull()
 671 {
 672   return FALSE;
 673 }
 674
 675
 676 BOOL PSoundChannelALSA::Abort()
 677 {
 678   int r = 0;
 679
 680   if (!os_handle)
 681     return FALSE;
 682
 683   if ((r = snd_pcm_drain (os_handle)) < 0) {
 684
 685     PTRACE (1, "ALSA\tCannot abort" <<
 686             snd_strerror (r));
 687     return FALSE;
 688   }
 689   else
 690     return TRUE;
 691 }
 692
 693
 694
 695 BOOL PSoundChannelALSA::SetVolume (unsigned newVal)
 696 {
 697   unsigned i = 0;
 698
 699   return Volume (TRUE, newVal, i);
 700 }
 701
 702
 703 BOOL  PSoundChannelALSA::GetVolume(unsigned &devVol)
 704 {
 705   return Volume (FALSE, 0, devVol);
 706 }
 707
 708
 709 BOOL PSoundChannelALSA::IsOpen () const
 710 {
 711   return (os_handle != NULL);
 712 }
 713
 714
 715 BOOL PSoundChannelALSA::Volume (BOOL set, unsigned set_vol, unsigned &get_vol)
 716 {
 717   int err = 0;
 718   snd_mixer_t *handle;
 719   snd_mixer_elem_t *elem;
 720   snd_mixer_selem_id_t *sid;
 721
 722   const char *play_mix_name = (direction == Player) ? "PCM": "Mic";
 723   PString card_name;
 724
 725   long pmin = 0, pmax = 0;
 726   long int vol = 0;
 727
 728   if (!os_handle)
 729     return FALSE;
 730
 731   card_name = "hw:" + PString (card_nr);
 732
 733   //allocate simple id
 734   snd_mixer_selem_id_alloca (&sid);
 735
 736   //sets simple-mixer index and name
 737   snd_mixer_selem_id_set_index (sid, 0);
 738   snd_mixer_selem_id_set_name (sid, play_mix_name);
 739
 740   if ((err = snd_mixer_open (&handle, 0)) < 0) {
 741
 742     PTRACE (1, "alsa-control: mixer open error: " << snd_strerror (err));
 743     return FALSE;
 744   }
 745
 746
 747   if ((err = snd_mixer_attach (handle, card_name)) < 0) {
 748
 749     PTRACE (1, "alsa-control: mixer attach " << card_name << " error: "
 750             << snd_strerror(err));
 751     snd_mixer_close(handle);
 752     return FALSE;
 753   }
 754
 755
 756   if ((err = snd_mixer_selem_register (handle, NULL, NULL)) < 0) {
 757
 758     PTRACE (1, "alsa-control: mixer register error: " << snd_strerror(err));
 759     snd_mixer_close(handle);
 760     return FALSE;
 761   }
 762
 763
 764   err = snd_mixer_load(handle);
 765   if (err < 0) {
 766
 767     PTRACE (1, "alsa-control: mixer load error: " << snd_strerror(err));
 768     snd_mixer_close(handle);
 769     return FALSE;
 770   }
 771
 772   elem = snd_mixer_find_selem (handle, sid);
 773
 774   if (!elem) {
 775
 776     PTRACE (1, "alsa-control: unable to find simple control "
 777             << snd_mixer_selem_id_get_name(sid) << ","
 778             << snd_mixer_selem_id_get_index(sid));
 779     snd_mixer_close(handle);
 780     return FALSE;
 781   }
 782
 783   snd_mixer_selem_get_playback_volume_range (elem, &pmin, &pmax);
 784
 785   if (set) {
 786
 787     vol = (set_vol * (pmax?pmax:31)) / 100;
 788     snd_mixer_selem_set_playback_volume (elem,
 789                                          SND_MIXER_SCHN_FRONT_LEFT, vol);
 790     snd_mixer_selem_set_playback_volume (elem,
 791                                          SND_MIXER_SCHN_FRONT_RIGHT, vol);
 792
 793     PTRACE (4, "Set volume to " << vol);
 794   }
 795   else {
 796
 797     snd_mixer_selem_get_playback_volume (elem,
 798                                          SND_MIXER_SCHN_FRONT_LEFT, &vol);
 799     get_vol = (vol * 100) / (pmax?pmax:31);
 800     PTRACE (4, "Got volume " << vol);
 801   }
 802
 803   snd_mixer_close(handle);
 804
 805   return TRUE;
 806 }