AudioHardwareALSA.cpp

   1 /* AudioHardwareALSA.cpp
   2  **
   3  ** Copyright 2008-2009 Wind River Systems
   4  **
   5  ** Licensed under the Apache License, Version 2.0 (the "License");
   6  ** you may not use this file except in compliance with the License.
   7  ** You may obtain a copy of the License at
   8  **
   9  **     http://www.apache.org/licenses/LICENSE-2.0
  10  **
  11  ** Unless required by applicable law or agreed to in writing, software
  12  ** distributed under the License is distributed on an "AS IS" BASIS,
  13  ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  ** See the License for the specific language governing permissions and
  15  ** limitations under the License.
  16  */
  17
  18 #include <errno.h>
  19 #include <stdarg.h>
  20 #include <stdint.h>
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <fcntl.h>
  24 #include <stdlib.h>
  25 #include <unistd.h>
  26
  27 #define LOG_TAG "AudioHardwareALSA"
  28 #include <utils/Log.h>
  29 #include <utils/String8.h>
  30
  31 #include <cutils/properties.h>
  32 #include <media/AudioRecord.h>
  33 #include <hardware_legacy/power.h>
  34
  35 #include <alsa/asoundlib.h>
  36 #include "AudioHardwareALSA.h"
  37
  38 #ifndef ALSA_DEFAULT_SAMPLE_RATE
  39 #define ALSA_DEFAULT_SAMPLE_RATE 44100 // in Hz
  40 #endif
  41
  42 #define SND_MIXER_VOL_RANGE_MIN  (0)
  43 #define SND_MIXER_VOL_RANGE_MAX  (100)
  44
  45 #define ALSA_NAME_MAX 128
  46
  47 #define ALSA_STRCAT(x,y) \
  48     if (strlen(x) + strlen(y) < ALSA_NAME_MAX) \
  49         strcat(x, y);
  50
  51 extern "C"
  52 {
  53     extern int ffs(int i);
  54
  55     //
  56     // Make sure this prototype is consistent with what's in
  57     // external/libasound/alsa-lib-1.0.16/src/pcm/pcm_null.c!
  58     //
  59     extern int snd_pcm_null_open(snd_pcm_t **pcmp,
  60                                  const char *name,
  61                                  snd_pcm_stream_t stream,
  62                                  int mode);
  63
  64     //
  65     // Function for dlsym() to look up for creating a new AudioHardwareInterface.
  66     //
  67     android::AudioHardwareInterface *createAudioHardware(void) {
  68         return new android::AudioHardwareALSA();
  69     }
  70 }         // extern "C"
  71
  72 namespace android
  73 {
  74
  75 typedef AudioSystem::audio_routes audio_routes;
  76
  77 #define ROUTE_ALL            AudioSystem::ROUTE_ALL
  78 #define ROUTE_EARPIECE       AudioSystem::ROUTE_EARPIECE
  79 #define ROUTE_SPEAKER        AudioSystem::ROUTE_SPEAKER
  80 #define ROUTE_BLUETOOTH_SCO  AudioSystem::ROUTE_BLUETOOTH_SCO
  81 #define ROUTE_HEADSET        AudioSystem::ROUTE_HEADSET
  82 #define ROUTE_BLUETOOTH_A2DP AudioSystem::ROUTE_BLUETOOTH_A2DP
  83
  84 // ----------------------------------------------------------------------------
  85
  86 static const int DEFAULT_SAMPLE_RATE = ALSA_DEFAULT_SAMPLE_RATE;
  87
  88 static const char _nullALSADeviceName[] = "NULL_Device";
  89
  90 static void ALSAErrorHandler(const char *file,
  91                              int line,
  92                              const char *function,
  93                              int err,
  94                              const char *fmt,
  95                              ...)
  96 {
  97     char buf[BUFSIZ];
  98     va_list arg;
  99     int l;
 100
 101     va_start(arg, fmt);
 102     l = snprintf(buf, BUFSIZ, "%s:%i:(%s) ", file, line, function);
 103     vsnprintf(buf + l, BUFSIZ - l, fmt, arg);
 104     buf[BUFSIZ-1] = '\0';
 105     LOG(LOG_ERROR, "ALSALib", buf);
 106     va_end(arg);
 107 }
 108
 109 // ----------------------------------------------------------------------------
 110
 111 /* The following table(s) need to match in order of the route bits
 112  */
 113 static const char *deviceSuffix[] = {
 114     /* ROUTE_EARPIECE       */ "_Earpiece",
 115     /* ROUTE_SPEAKER        */ "_Speaker",
 116     /* ROUTE_BLUETOOTH_SCO  */ "_Bluetooth",
 117     /* ROUTE_HEADSET        */ "_Headset",
 118     /* ROUTE_BLUETOOTH_A2DP */ "_Bluetooth-A2DP",
 119 };
 120
 121 static const int deviceSuffixLen = (sizeof(deviceSuffix) / sizeof(char *));
 122
 123 struct mixer_info_t;
 124
 125 struct alsa_properties_t
 126 {
 127     const audio_routes  routes;
 128     const char         *propName;
 129     const char         *propDefault;
 130     mixer_info_t       *mInfo;
 131 };
 132
 133 static alsa_properties_t masterPlaybackProp = {
 134     ROUTE_ALL, "alsa.mixer.playback.master", "PCM", NULL
 135 };
 136
 137 static alsa_properties_t masterCaptureProp = {
 138     ROUTE_ALL, "alsa.mixer.capture.master", "Capture", NULL
 139 };
 140
 141 static alsa_properties_t
 142 mixerMasterProp[SND_PCM_STREAM_LAST+1] = {
 143     { ROUTE_ALL, "alsa.mixer.playback.master",  "PCM",     NULL},
 144     { ROUTE_ALL, "alsa.mixer.capture.master",   "Capture", NULL}
 145 };
 146
 147 static alsa_properties_t
 148 mixerProp[][SND_PCM_STREAM_LAST+1] = {
 149     {
 150         {ROUTE_EARPIECE,       "alsa.mixer.playback.earpiece",       "Earpiece", NULL},
 151         {ROUTE_EARPIECE,       "alsa.mixer.capture.earpiece",        "Capture",  NULL}
 152     },
 153     {
 154         {ROUTE_SPEAKER,        "alsa.mixer.playback.speaker",        "Speaker", NULL},
 155         {ROUTE_SPEAKER,        "alsa.mixer.capture.speaker",         "",        NULL}
 156     },
 157     {
 158         {ROUTE_BLUETOOTH_SCO,  "alsa.mixer.playback.bluetooth.sco",  "Bluetooth",         NULL},
 159         {ROUTE_BLUETOOTH_SCO,  "alsa.mixer.capture.bluetooth.sco",   "Bluetooth Capture", NULL}
 160     },
 161     {
 162         {ROUTE_HEADSET,        "alsa.mixer.playback.headset",        "Headphone", NULL},
 163         {ROUTE_HEADSET,        "alsa.mixer.capture.headset",         "Capture",   NULL}
 164     },
 165     {
 166         {ROUTE_BLUETOOTH_A2DP, "alsa.mixer.playback.bluetooth.a2dp", "Bluetooth A2DP",         NULL},
 167         {ROUTE_BLUETOOTH_A2DP, "alsa.mixer.capture.bluetooth.a2dp",  "Bluetooth A2DP Capture", NULL}
 168     },
 169     {
 170         {static_cast<audio_routes>(0), NULL, NULL, NULL},
 171         {static_cast<audio_routes>(0), NULL, NULL, NULL}
 172     }
 173 };
 174
 175 // ----------------------------------------------------------------------------
 176
 177 AudioHardwareALSA::AudioHardwareALSA() :
 178     mOutput(0),
 179     mInput(0)
 180 {
 181     snd_lib_error_set_handler(&ALSAErrorHandler);
 182     mMixer = new ALSAMixer;
 183 }
 184
 185 AudioHardwareALSA::~AudioHardwareALSA()
 186 {
 187     if (mOutput) delete mOutput;
 188     if (mInput) delete mInput;
 189     if (mMixer) delete mMixer;
 190 }
 191
 192 status_t AudioHardwareALSA::initCheck()
 193 {
 194     if (mMixer && mMixer->isValid())
 195         return NO_ERROR;
 196     else
 197         return NO_INIT;
 198 }
 199
 200 status_t AudioHardwareALSA::standby()
 201 {
 202     if (mOutput)
 203         return mOutput->standby();
 204
 205     return NO_ERROR;
 206 }
 207
 208 status_t AudioHardwareALSA::setVoiceVolume(float volume)
 209 {
 210     // The voice volume is used by the VOICE_CALL audio stream.
 211     if (mMixer)
 212         return mMixer->setVolume(ROUTE_EARPIECE, volume);
 213     else
 214         return INVALID_OPERATION;
 215 }
 216
 217 status_t AudioHardwareALSA::setMasterVolume(float volume)
 218 {
 219     if (mMixer)
 220         return mMixer->setMasterVolume(volume);
 221     else
 222         return INVALID_OPERATION;
 223 }
 224
 225 AudioStreamOut *
 226 AudioHardwareALSA::openOutputStream(int format,
 227                                     int channelCount,
 228                                     uint32_t sampleRate,
 229                                     status_t *status)
 230 {
 231     AutoMutex lock(mLock);
 232
 233     // only one output stream allowed
 234     if (mOutput) {
 235         *status = ALREADY_EXISTS;
 236         return 0;
 237     }
 238
 239     AudioStreamOutALSA *out = new AudioStreamOutALSA(this);
 240
 241     *status = out->set(format, channelCount, sampleRate);
 242
 243     if (*status == NO_ERROR) {
 244         mOutput = out;
 245         // Some information is expected to be available immediately after
 246         // the device is open.
 247         uint32_t routes = mRoutes[mMode];
 248         mOutput->setDevice(mMode, routes);
 249     }
 250     else {
 251         delete out;
 252     }
 253
 254     return mOutput;
 255 }
 256
 257 AudioStreamIn *
 258 AudioHardwareALSA::openInputStream(int      format,
 259                                    int      channelCount,
 260                                    uint32_t sampleRate,
 261                                    status_t *status,
 262                                    AudioSystem::audio_in_acoustics acoustics)
 263 {
 264     AutoMutex lock(mLock);
 265
 266     // only one input stream allowed
 267     if (mInput) {
 268         *status = ALREADY_EXISTS;
 269         return 0;
 270     }
 271
 272     AudioStreamInALSA *in = new AudioStreamInALSA(this);
 273
 274     *status = in->set(format, channelCount, sampleRate);
 275     if (*status == NO_ERROR) {
 276         mInput = in;
 277         // Some information is expected to be available immediately after
 278         // the device is open.
 279         uint32_t routes = mRoutes[mMode];
 280         mInput->setDevice(mMode, routes);    return mInput;
 281     }
 282     else {
 283         delete in;
 284     }
 285     return mInput;
 286 }
 287
 288 status_t AudioHardwareALSA::doRouting()
 289 {
 290     uint32_t routes;
 291
 292     AutoMutex lock(mLock);
 293
 294     if (mOutput) {
 295         routes = mRoutes[mMode];
 296         return mOutput->setDevice(mMode, routes);
 297     }
 298     return NO_INIT;
 299 }
 300
 301 status_t AudioHardwareALSA::setMicMute(bool state)
 302 {
 303     if (mMixer)
 304         return mMixer->setCaptureMuteState(ROUTE_EARPIECE, state);
 305
 306     return NO_INIT;
 307 }
 308
 309 status_t AudioHardwareALSA::getMicMute(bool *state)
 310 {
 311     if (mMixer)
 312         return mMixer->getCaptureMuteState(ROUTE_EARPIECE, state);
 313
 314     return NO_ERROR;
 315 }
 316
 317 status_t AudioHardwareALSA::dump(int fd, const Vector<String16>& args)
 318 {
 319     return NO_ERROR;
 320 }
 321
 322 // ----------------------------------------------------------------------------
 323
 324 ALSAStreamOps::ALSAStreamOps() :
 325     mHandle(0),
 326     mHardwareParams(0),
 327     mSoftwareParams(0),
 328     mMode(-1),
 329     mDevice(0)
 330 {
 331     if (snd_pcm_hw_params_malloc(&mHardwareParams) < 0) {
 332         LOG_ALWAYS_FATAL("Failed to allocate ALSA hardware parameters!");
 333     }
 334
 335     if (snd_pcm_sw_params_malloc(&mSoftwareParams) < 0) {
 336         LOG_ALWAYS_FATAL("Failed to allocate ALSA software parameters!");
 337     }
 338 }
 339
 340 ALSAStreamOps::~ALSAStreamOps()
 341 {
 342     AutoMutex lock(mLock);
 343
 344     close();
 345
 346     if (mHardwareParams)
 347         snd_pcm_hw_params_free(mHardwareParams);
 348
 349     if (mSoftwareParams)
 350         snd_pcm_sw_params_free(mSoftwareParams);
 351 }
 352
 353 status_t ALSAStreamOps::set(int      format,
 354                             int      channels,
 355                             uint32_t rate)
 356 {
 357     if (channels != 0)
 358         mDefaults->channels = channels;
 359
 360     if (rate != 0)
 361         mDefaults->sampleRate = rate;
 362
 363     switch(format) {
 364       // format == 0
 365         case AudioSystem::DEFAULT:
 366             break;
 367
 368         case AudioSystem::PCM_16_BIT:
 369             mDefaults->format = SND_PCM_FORMAT_S16_LE;
 370             break;
 371
 372         case AudioSystem::PCM_8_BIT:
 373             mDefaults->format = SND_PCM_FORMAT_S8;
 374             break;
 375
 376         default:
 377             LOGE("Unknown PCM format %i. Forcing default", format);
 378             break;
 379     }
 380
 381     return NO_ERROR;
 382 }
 383
 384 uint32_t ALSAStreamOps::sampleRate() const
 385 {
 386     unsigned int rate;
 387     int err;
 388
 389     if (! mHandle)
 390         return NO_INIT;
 391
 392     return snd_pcm_hw_params_get_rate(mHardwareParams, &rate, 0) < 0
 393         ? 0 : static_cast<uint32_t>(rate);
 394 }
 395
 396 status_t ALSAStreamOps::sampleRate(uint32_t rate)
 397 {
 398     const char *stream;
 399     unsigned int requestedRate;
 400     int err;
 401
 402     if (!mHandle)
 403         return NO_INIT;
 404
 405     stream = streamName();
 406     requestedRate = rate;
 407     err = snd_pcm_hw_params_set_rate_near(mHandle,
 408                                           mHardwareParams,
 409                                           &requestedRate,
 410                                           0);
 411
 412     if (err < 0) {
 413         LOGE("Unable to set %s sample rate to %u: %s",
 414             stream, rate, snd_strerror(err));
 415         return BAD_VALUE;
 416     }
 417     if (requestedRate != rate) {
 418         // Some devices have a fixed sample rate, and can not be changed.
 419         // This may cause resampling problems; i.e. PCM playback will be too
 420         // slow or fast.
 421         LOGW("Requested rate (%u HZ) does not match actual rate (%u HZ)",
 422             rate, requestedRate);
 423     }
 424     else {
 425         LOGD("Set %s sample rate to %u HZ", stream, requestedRate);
 426     }
 427     return NO_ERROR;
 428 }
 429
 430 //
 431 // Return the number of bytes (not frames)
 432 //
 433 size_t ALSAStreamOps::bufferSize() const
 434 {
 435     int err;
 436
 437     if (!mHandle)
 438         return -1;
 439
 440     snd_pcm_uframes_t bufferSize = 0;
 441     snd_pcm_uframes_t periodSize = 0;
 442
 443     err = snd_pcm_get_params(mHandle, &bufferSize, &periodSize);
 444
 445     if (err < 0)
 446         return -1;
 447
 448     return static_cast<size_t>(snd_pcm_frames_to_bytes(mHandle, bufferSize));
 449 }
 450
 451 int ALSAStreamOps::format() const
 452 {
 453     snd_pcm_format_t ALSAFormat;
 454     int pcmFormatBitWidth;
 455     int audioSystemFormat;
 456
 457     if (!mHandle)
 458         return -1;
 459
 460     if (snd_pcm_hw_params_get_format(mHardwareParams, &ALSAFormat) < 0) {
 461         return -1;
 462     }
 463
 464     pcmFormatBitWidth = snd_pcm_format_physical_width(ALSAFormat);
 465     audioSystemFormat = AudioSystem::DEFAULT;
 466     switch(pcmFormatBitWidth) {
 467         case 8:
 468             audioSystemFormat = AudioSystem::PCM_8_BIT;
 469             break;
 470
 471         case 16:
 472             audioSystemFormat = AudioSystem::PCM_16_BIT;
 473             break;
 474
 475         default:
 476             LOG_FATAL("Unknown AudioSystem bit width %i!", pcmFormatBitWidth);
 477     }
 478
 479     return audioSystemFormat;
 480 }
 481
 482 int ALSAStreamOps::channelCount() const
 483 {
 484     unsigned int val;
 485     int err;
 486
 487     if (!mHandle)
 488         return -1;
 489
 490     err = snd_pcm_hw_params_get_channels(mHardwareParams, &val);
 491     if (err < 0) {
 492         LOGE("Unable to get device channel count: %s",
 493             snd_strerror(err));
 494         return -1;
 495     }
 496
 497     return val;
 498 }
 499
 500 status_t ALSAStreamOps::channelCount(int channels) {
 501     int err;
 502
 503     if (!mHandle)
 504         return NO_INIT;
 505
 506     err = snd_pcm_hw_params_set_channels(mHandle, mHardwareParams, channels);
 507     if (err < 0) {
 508         LOGE("Unable to set channel count to %i: %s",
 509             channels, snd_strerror(err));
 510         return BAD_VALUE;
 511     }
 512
 513     LOGD("Using %i %s for %s.",
 514         channels, channels == 1 ? "channel" : "channels", streamName());
 515
 516     return NO_ERROR;
 517 }
 518
 519 status_t ALSAStreamOps::open(int mode, uint32_t device)
 520 {
 521     const char *stream = streamName();
 522     const char *devName = deviceName(mode, device);
 523
 524     int         err;
 525
 526     for(;;) {
 527         // The PCM stream is opened in blocking mode, per ALSA defaults.  The
 528         // AudioFlinger seems to assume blocking mode too, so asynchronous mode
 529         // should not be used.
 530         err = snd_pcm_open(&mHandle, devName, mDefaults->direction, 0);
 531         if (err == 0) break;
 532
 533         // See if there is a less specific name we can try.
 534         // Note: We are changing the contents of a const char * here.
 535         char *tail = strrchr(devName, '_');
 536         if (! tail) break;
 537         *tail = 0;
 538     }
 539
 540     if (err < 0) {
 541         // None of the Android defined audio devices exist. Open a generic one.
 542         devName = "hw:00,0";
 543         err = snd_pcm_open(&mHandle, devName, mDefaults->direction, 0);
 544         if (err < 0) {
 545             // Last resort is the NULL device (i.e. the bit bucket).
 546             devName = _nullALSADeviceName;
 547             err = snd_pcm_open(&mHandle, devName, mDefaults->direction, 0);
 548         }
 549     }
 550
 551     mMode   = mode;
 552     mDevice = device;
 553
 554     LOGI("Initialized ALSA %s device %s", stream, devName);
 555     return err;
 556 }
 557
 558 void ALSAStreamOps::close()
 559 {
 560     snd_pcm_t *handle = mHandle;
 561     mHandle = NULL;
 562
 563     if (handle) {
 564         snd_pcm_close(handle);
 565         mMode   = -1;
 566         mDevice = 0;
 567     }
 568 }
 569
 570 status_t ALSAStreamOps::setSoftwareParams()
 571 {
 572     if (!mHandle)
 573         return NO_INIT;
 574
 575     int err;
 576
 577     // Get the current software parameters
 578     err = snd_pcm_sw_params_current(mHandle, mSoftwareParams);
 579     if (err < 0) {
 580         LOGE("Unable to get software parameters: %s", snd_strerror(err));
 581         return NO_INIT;
 582     }
 583
 584     snd_pcm_uframes_t bufferSize = 0;
 585     snd_pcm_uframes_t periodSize = 0;
 586     snd_pcm_uframes_t startThreshold;
 587
 588     // Configure ALSA to start the transfer when the buffer is almost full.
 589     snd_pcm_get_params(mHandle, &bufferSize, &periodSize);
 590
 591     if (mDefaults->direction == SND_PCM_STREAM_PLAYBACK) {
 592         // For playback, configure ALSA to start the transfer when the
 593         // buffer is almost full.
 594         startThreshold = (bufferSize / periodSize) * periodSize;
 595     }
 596     else {
 597         // For recording, configure ALSA to start the transfer on the
 598         // first frame.
 599         startThreshold = 1;
 600     }
 601
 602     err = snd_pcm_sw_params_set_start_threshold(mHandle,
 603         mSoftwareParams,
 604         startThreshold);
 605     if (err < 0) {
 606         LOGE("Unable to set start threshold to %lu frames: %s",
 607             startThreshold, snd_strerror(err));
 608         return NO_INIT;
 609     }
 610
 611     // Stop the transfer when the buffer is full.
 612     err = snd_pcm_sw_params_set_stop_threshold(mHandle,
 613                                                mSoftwareParams,
 614                                                bufferSize);
 615     if (err < 0) {
 616         LOGE("Unable to set stop threshold to %lu frames: %s",
 617             bufferSize, snd_strerror(err));
 618         return NO_INIT;
 619     }
 620
 621     // Allow the transfer to start when at least periodSize samples can be
 622     // processed.
 623     err = snd_pcm_sw_params_set_avail_min(mHandle,
 624                                           mSoftwareParams,
 625                                           periodSize);
 626     if (err < 0) {
 627         LOGE("Unable to configure available minimum to %lu: %s",
 628             periodSize, snd_strerror(err));
 629         return NO_INIT;
 630     }
 631
 632     // Commit the software parameters back to the device.
 633     err = snd_pcm_sw_params(mHandle, mSoftwareParams);
 634     if (err < 0) {
 635         LOGE("Unable to configure software parameters: %s",
 636             snd_strerror(err));
 637         return NO_INIT;
 638     }
 639
 640     return NO_ERROR;
 641 }
 642
 643 status_t ALSAStreamOps::setPCMFormat(snd_pcm_format_t format)
 644 {
 645     const char *formatDesc;
 646     const char *formatName;
 647     bool validFormat;
 648     int err;
 649
 650     // snd_pcm_format_description() and snd_pcm_format_name() do not perform
 651     // proper bounds checking.
 652     validFormat = (static_cast<int>(format) > SND_PCM_FORMAT_UNKNOWN) &&
 653         (static_cast<int>(format) <= SND_PCM_FORMAT_LAST);
 654     formatDesc = validFormat ?
 655         snd_pcm_format_description(format) : "Invalid Format";
 656     formatName = validFormat ?
 657         snd_pcm_format_name(format) : "UNKNOWN";
 658
 659     err = snd_pcm_hw_params_set_format(mHandle, mHardwareParams, format);
 660     if (err < 0) {
 661         LOGE("Unable to configure PCM format %s (%s): %s",
 662             formatName, formatDesc, snd_strerror(err));
 663         return NO_INIT;
 664     }
 665
 666     LOGD("Set %s PCM format to %s (%s)", streamName(), formatName, formatDesc);
 667     return NO_ERROR;
 668 }
 669
 670 status_t ALSAStreamOps::setHardwareResample(bool resample)
 671 {
 672     int err;
 673
 674     err = snd_pcm_hw_params_set_rate_resample(mHandle,
 675                                               mHardwareParams,
 676                                               static_cast<int>(resample));
 677     if (err < 0) {
 678         LOGE("Unable to %s hardware resampling: %s",
 679             resample ? "enable" : "disable",
 680             snd_strerror(err));
 681         return NO_INIT;
 682     }
 683     return NO_ERROR;
 684 }
 685
 686 const char *ALSAStreamOps::streamName()
 687 {
 688     // Don't use snd_pcm_stream(mHandle), as the PCM stream may not be
 689     // opened yet.  In such case, snd_pcm_stream() will abort().
 690     return snd_pcm_stream_name(mDefaults->direction);
 691 }
 692
 693 //
 694 // Set playback or capture PCM device.  It's possible to support audio output
 695 // or input from multiple devices by using the ALSA plugins, but this is
 696 // not supported for simplicity.
 697 //
 698 // The AudioHardwareALSA API does not allow one to set the input routing.
 699 //
 700 // If the "routes" value does not map to a valid device, the default playback
 701 // device is used.
 702 //
 703 status_t ALSAStreamOps::setDevice(int mode, uint32_t device)
 704 {
 705     // Close off previously opened device.
 706     // It would be nice to determine if the underlying device actually
 707     // changes, but we might be manipulating mixer settings (see asound.conf).
 708     //
 709     close();
 710
 711     const char *stream = streamName();
 712
 713     status_t    status = open (mode, device);
 714     int     err;
 715
 716     if (status != NO_ERROR)
 717         return status;
 718
 719     err = snd_pcm_hw_params_any(mHandle, mHardwareParams);
 720     if (err < 0) {
 721         LOGE("Unable to configure hardware: %s", snd_strerror(err));
 722         return NO_INIT;
 723     }
 724
 725     status = setPCMFormat(mDefaults->format);
 726
 727     // Set the interleaved read and write format.
 728     err = snd_pcm_hw_params_set_access(mHandle, mHardwareParams,
 729                                        SND_PCM_ACCESS_RW_INTERLEAVED);
 730     if (err < 0) {
 731         LOGE("Unable to configure PCM read/write format: %s",
 732             snd_strerror(err));
 733         return NO_INIT;
 734     }
 735
 736     //
 737     // Some devices do not have the default two channels.  Force an error to
 738     // prevent AudioMixer from crashing and taking the whole system down.
 739     //
 740     // Note that some devices will return an -EINVAL if the channel count
 741     // is queried before it has been set.  i.e. calling channelCount()
 742     // before channelCount(channels) may return -EINVAL.
 743     //
 744     status = channelCount(mDefaults->channels);
 745     if (status != NO_ERROR)
 746         return status;
 747
 748     // Don't check for failure; some devices do not support the default
 749     // sample rate.
 750     sampleRate(mDefaults->sampleRate);
 751
 752     // Disable hardware resampling.
 753     status = setHardwareResample(false);
 754     if (status != NO_ERROR)
 755         return status;
 756
 757     snd_pcm_uframes_t bufferSize = mDefaults->bufferSize;
 758     unsigned int latency = mDefaults->latency;
 759
 760     // Make sure we have at least the size we originally wanted
 761     err = snd_pcm_hw_params_set_buffer_size(mHandle, mHardwareParams, bufferSize);
 762     if (err < 0) {
 763         LOGE("Unable to set buffer size to %d:  %s",
 764              (int)bufferSize, snd_strerror(err));
 765         return NO_INIT;
 766     }
 767
 768     // Setup buffers for latency
 769     err = snd_pcm_hw_params_set_buffer_time_near (mHandle, mHardwareParams,
 770                                                   &latency, NULL);
 771     if (err < 0) {
 772         /* That didn't work, set the period instead */
 773         unsigned int periodTime = latency / 4;
 774         err = snd_pcm_hw_params_set_period_time_near (mHandle, mHardwareParams,
 775                                                       &periodTime, NULL);
 776         if (err < 0) {
 777             LOGE("Unable to set the period time for latency: %s", snd_strerror(err));
 778             return NO_INIT;
 779         }
 780         snd_pcm_uframes_t periodSize;
 781         err = snd_pcm_hw_params_get_period_size (mHardwareParams, &periodSize, NULL);
 782         if (err < 0) {
 783             LOGE("Unable to get the period size for latency: %s", snd_strerror(err));
 784             return NO_INIT;
 785         }
 786         bufferSize = periodSize * 4;
 787         if (bufferSize < mDefaults->bufferSize)
 788             bufferSize = mDefaults->bufferSize;
 789         err = snd_pcm_hw_params_set_buffer_size_near (mHandle, mHardwareParams, &bufferSize);
 790         if (err < 0) {
 791             LOGE("Unable to set the buffer size for latency: %s", snd_strerror(err));
 792             return NO_INIT;
 793         }
 794     } else {
 795         // OK, we got buffer time near what we expect. See what that did for bufferSize.
 796         err = snd_pcm_hw_params_get_buffer_size (mHardwareParams, &bufferSize);
 797         if (err < 0) {
 798             LOGE("Unable to get the buffer size for latency: %s", snd_strerror(err));
 799             return NO_INIT;
 800         }
 801         // Does set_buffer_time_near change the passed value? It should.
 802         err = snd_pcm_hw_params_get_buffer_time (mHardwareParams, &latency, NULL);
 803         if (err < 0) {
 804             LOGE("Unable to get the buffer time for latency: %s", snd_strerror(err));
 805             return NO_INIT;
 806         }
 807         unsigned int periodTime = latency / 4;
 808         err = snd_pcm_hw_params_set_period_time_near (mHandle, mHardwareParams,
 809                                                       &periodTime, NULL);
 810         if (err < 0) {
 811             LOGE("Unable to set the period time for latency: %s", snd_strerror(err));
 812             return NO_INIT;
 813         }
 814     }
 815
 816     LOGD("Buffer size: %d", (int)bufferSize);
 817     LOGD("Latency: %d", (int)latency);
 818
 819     mDefaults->bufferSize = bufferSize;
 820     mDefaults->latency = latency;
 821
 822     // Commit the hardware parameters back to the device.
 823     err = snd_pcm_hw_params(mHandle, mHardwareParams);
 824     if (err < 0) {
 825         LOGE("Unable to set hardware parameters: %s", snd_strerror(err));
 826         return NO_INIT;
 827     }
 828
 829     status = setSoftwareParams();
 830
 831     return status;
 832 }
 833
 834 const char *ALSAStreamOps::deviceName(int mode, uint32_t device)
 835 {
 836     static char devString[ALSA_NAME_MAX];
 837     int dev;
 838     int hasDevExt = 0;
 839
 840     strcpy (devString, mDefaults->devicePrefix);
 841
 842     for (dev=0; device; dev++)
 843         if (device & (1 << dev)) {
 844             /* Don't go past the end of our list */
 845             if (dev >= deviceSuffixLen)
 846                 break;
 847             ALSA_STRCAT (devString, deviceSuffix[dev]);
 848             device &= ~(1 << dev);
 849             hasDevExt = 1;
 850         }
 851
 852     if (hasDevExt)
 853         switch (mode) {
 854             case AudioSystem::MODE_NORMAL:
 855                 ALSA_STRCAT (devString, "_normal");
 856                 break;
 857             case AudioSystem::MODE_RINGTONE:
 858                 ALSA_STRCAT (devString, "_ringtone");
 859                 break;
 860             case AudioSystem::MODE_IN_CALL:
 861                 ALSA_STRCAT (devString, "_incall");
 862                 break;
 863         };
 864
 865     return devString;
 866 }
 867
 868 // ----------------------------------------------------------------------------
 869
 870 AudioStreamOutALSA::AudioStreamOutALSA(AudioHardwareALSA *parent) :
 871     mParent(parent),
 872     mPowerLock(false)
 873 {
 874     static StreamDefaults _defaults = {
 875         devicePrefix   : "AndroidPlayback",
 876         direction      : SND_PCM_STREAM_PLAYBACK,
 877         format         : SND_PCM_FORMAT_S16_LE,   // AudioSystem::PCM_16_BIT
 878         channels       : 2,
 879         sampleRate     : DEFAULT_SAMPLE_RATE,
 880         latency        : 250000,                  // Desired Delay in usec
 881         bufferSize     : 16384,                   // Desired Number of samples
 882         };
 883
 884     setStreamDefaults(&_defaults);
 885 }
 886
 887 AudioStreamOutALSA::~AudioStreamOutALSA()
 888 {
 889     standby();
 890     mParent->mOutput = NULL;
 891 }
 892
 893 int AudioStreamOutALSA::channelCount() const
 894 {
 895     int c = ALSAStreamOps::channelCount();
 896
 897     // AudioMixer will seg fault if it doesn't have two channels.
 898     LOGW_IF(c != 2,
 899         "AudioMixer expects two channels, but only %i found!", c);
 900     return c;
 901 }
 902
 903 status_t AudioStreamOutALSA::setVolume(float volume)
 904 {
 905     if (! mParent->mMixer || ! mDevice)
 906         return NO_INIT;
 907
 908     return mParent->mMixer->setVolume (mDevice, volume);
 909 }
 910
 911 ssize_t AudioStreamOutALSA::write(const void *buffer, size_t bytes)
 912 {
 913     snd_pcm_sframes_t n;
 914     status_t          err;
 915
 916     AutoMutex lock(mLock);
 917
 918     if (isStandby())
 919         return 0;
 920
 921     if (!mPowerLock) {
 922         acquire_wake_lock (PARTIAL_WAKE_LOCK, "AudioLock");
 923         ALSAStreamOps::setDevice(mMode, mDevice);
 924         mPowerLock = true;
 925     }
 926
 927     n = snd_pcm_writei(mHandle,
 928                        buffer,
 929                        snd_pcm_bytes_to_frames(mHandle, bytes));
 930     if (n < 0 && mHandle) {
 931         // snd_pcm_recover() will return 0 if successful in recovering from
 932         // an error, or -errno if the error was unrecoverable.
 933         n = snd_pcm_recover(mHandle, n, 0);
 934     }
 935
 936     return static_cast<ssize_t>(n);
 937 }
 938
 939 status_t AudioStreamOutALSA::dump(int fd, const Vector<String16>& args)
 940 {
 941     return NO_ERROR;
 942 }
 943
 944 status_t AudioStreamOutALSA::setDevice(int mode, uint32_t newDevice)
 945 {
 946     AutoMutex lock(mLock);
 947
 948     return ALSAStreamOps::setDevice(mode, newDevice);
 949 }
 950
 951 status_t AudioStreamOutALSA::standby()
 952 {
 953     AutoMutex lock(mLock);
 954
 955     if (mHandle)
 956         snd_pcm_drain (mHandle);
 957
 958     if (mPowerLock) {
 959         release_wake_lock ("AudioLock");
 960         mPowerLock = false;
 961     }
 962
 963     return NO_ERROR;
 964 }
 965
 966 bool AudioStreamOutALSA::isStandby()
 967 {
 968     return (!mHandle);
 969 }
 970
 971 #define USEC_TO_MSEC(x) ((x + 999) / 1000)
 972
 973 uint32_t AudioStreamOutALSA::latency() const
 974 {
 975     // Android wants latency in milliseconds.
 976     return USEC_TO_MSEC (mDefaults->latency);
 977 }
 978
 979 // ----------------------------------------------------------------------------
 980
 981 AudioStreamInALSA::AudioStreamInALSA(AudioHardwareALSA *parent) :
 982     mParent(parent)
 983 {
 984     static StreamDefaults _defaults = {
 985         devicePrefix   : "AndroidRecord",
 986         direction      : SND_PCM_STREAM_CAPTURE,
 987         format         : SND_PCM_FORMAT_S16_LE,   // AudioSystem::PCM_16_BIT
 988         channels       : 1,
 989         sampleRate     : AudioRecord::DEFAULT_SAMPLE_RATE,
 990         latency        : 250000,                  // Desired Delay in usec
 991         bufferSize     : 16384,                   // Desired Number of samples
 992         };
 993
 994     setStreamDefaults(&_defaults);
 995 }
 996
 997 AudioStreamInALSA::~AudioStreamInALSA()
 998 {
 999     mParent->mInput = NULL;
1000 }
1001
1002 status_t AudioStreamInALSA::setGain(float gain)
1003 {
1004     if (mParent->mMixer)
1005         return mParent->mMixer->setMasterGain (gain);
1006     else
1007         return NO_INIT;
1008 }
1009
1010 ssize_t AudioStreamInALSA::read(void *buffer, ssize_t bytes)
1011 {
1012     snd_pcm_sframes_t n;
1013     status_t          err;
1014
1015     AutoMutex lock(mLock);
1016
1017     n = snd_pcm_readi(mHandle,
1018                       buffer,
1019                       snd_pcm_bytes_to_frames(mHandle, bytes));
1020     if (n < 0 && mHandle) {
1021         n = snd_pcm_recover(mHandle, n, 0);
1022     }
1023
1024     return static_cast<ssize_t>(n);
1025 }
1026
1027 status_t AudioStreamInALSA::dump(int fd, const Vector<String16>& args)
1028 {
1029     return NO_ERROR;
1030 }
1031
1032 status_t AudioStreamInALSA::setDevice(int mode, uint32_t newDevice)
1033 {
1034     AutoMutex lock(mLock);
1035
1036     return ALSAStreamOps::setDevice(mode, newDevice);
1037 }
1038
1039 status_t AudioStreamInALSA::standby()
1040 {
1041     AutoMutex lock(mLock);
1042
1043     return NO_ERROR;
1044 }
1045
1046 // ----------------------------------------------------------------------------
1047
1048 struct mixer_info_t
1049 {
1050     mixer_info_t() :
1051         elem(0),
1052         min(SND_MIXER_VOL_RANGE_MIN),
1053         max(SND_MIXER_VOL_RANGE_MAX),
1054         mute(false)
1055     {
1056     }
1057
1058     snd_mixer_elem_t *elem;
1059     long              min;
1060     long              max;
1061     long              volume;
1062     bool              mute;
1063     char              name[ALSA_NAME_MAX];
1064 };
1065
1066 static int initMixer (snd_mixer_t **mixer, const char *name)
1067 {
1068     int err;
1069
1070     if ((err = snd_mixer_open(mixer, 0)) < 0) {
1071         LOGE("Unable to open mixer: %s", snd_strerror(err));
1072         return err;
1073     }
1074
1075     if ((err = snd_mixer_attach(*mixer, name)) < 0) {
1076         LOGE("Unable to attach mixer to device %s: %s",
1077             name, snd_strerror(err));
1078
1079         if ((err = snd_mixer_attach(*mixer, "hw:00")) < 0) {
1080             LOGE("Unable to attach mixer to device default: %s",
1081                 snd_strerror(err));
1082
1083             snd_mixer_close (*mixer);
1084             *mixer = NULL;
1085             return err;
1086         }
1087     }
1088
1089     if ((err = snd_mixer_selem_register(*mixer, NULL, NULL)) < 0) {
1090         LOGE("Unable to register mixer elements: %s", snd_strerror(err));
1091         snd_mixer_close (*mixer);
1092         *mixer = NULL;
1093         return err;
1094     }
1095
1096     // Get the mixer controls from the kernel
1097     if ((err = snd_mixer_load(*mixer)) < 0) {
1098         LOGE("Unable to load mixer elements: %s", snd_strerror(err));
1099         snd_mixer_close (*mixer);
1100         *mixer = NULL;
1101         return err;
1102     }
1103
1104     return 0;
1105 }
1106
1107 typedef int (*hasVolume_t)(snd_mixer_elem_t*);
1108
1109 static const hasVolume_t hasVolume[] = {
1110     snd_mixer_selem_has_playback_volume,
1111     snd_mixer_selem_has_capture_volume
1112 };
1113
1114 typedef int (*getVolumeRange_t)(snd_mixer_elem_t*, long int*, long int*);
1115
1116 static const getVolumeRange_t getVolumeRange[] = {
1117     snd_mixer_selem_get_playback_volume_range,
1118     snd_mixer_selem_get_capture_volume_range
1119 };
1120
1121 typedef int (*setVolume_t)(snd_mixer_elem_t*, long int);
1122
1123 static const setVolume_t setVol[] = {
1124     snd_mixer_selem_set_playback_volume_all,
1125     snd_mixer_selem_set_capture_volume_all
1126 };
1127
1128 ALSAMixer::ALSAMixer()
1129 {
1130     int err;
1131
1132     initMixer (&mMixer[SND_PCM_STREAM_PLAYBACK], "AndroidPlayback");
1133     initMixer (&mMixer[SND_PCM_STREAM_CAPTURE], "AndroidRecord");
1134
1135     snd_mixer_selem_id_t *sid;
1136     snd_mixer_selem_id_alloca(&sid);
1137
1138     for (int i = 0; i <= SND_PCM_STREAM_LAST; i++) {
1139
1140         mixer_info_t *info = mixerMasterProp[i].mInfo = new mixer_info_t;
1141
1142         property_get (mixerMasterProp[i].propName,
1143                       info->name,
1144                       mixerMasterProp[i].propDefault);
1145
1146         for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]);
1147              elem;
1148              elem = snd_mixer_elem_next(elem)) {
1149
1150             if (!snd_mixer_selem_is_active(elem))
1151                 continue;
1152
1153             snd_mixer_selem_get_id(elem, sid);
1154
1155             // Find PCM playback volume control element.
1156             const char *elementName = snd_mixer_selem_id_get_name(sid);
1157
1158             if (hasVolume[i] (elem))
1159                 LOGD ("Mixer: element name: '%s'", elementName);
1160
1161             if (info->elem == NULL &&
1162                 strcmp(elementName, info->name) == 0 &&
1163                 hasVolume[i] (elem)) {
1164
1165                 info->elem = elem;
1166                 getVolumeRange[i] (elem, &info->min, &info->max);
1167                 info->volume = info->max;
1168                 setVol[i] (elem, info->volume);
1169                 if (i == SND_PCM_STREAM_PLAYBACK &&
1170                     snd_mixer_selem_has_playback_switch (elem))
1171                     snd_mixer_selem_set_playback_switch_all (elem, 1);
1172                 break;
1173             }
1174         }
1175
1176         LOGD ("Mixer: master '%s' %s.", info->name, info->elem ? "found" : "not found");
1177
1178         for (int j = 0; mixerProp[j][i].routes; j++) {
1179
1180             mixer_info_t *info = mixerProp[j][i].mInfo = new mixer_info_t;
1181
1182             property_get (mixerProp[j][i].propName,
1183                           info->name,
1184                           mixerProp[j][i].propDefault);
1185
1186             for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]);
1187                  elem;
1188                  elem = snd_mixer_elem_next(elem)) {
1189
1190                 if (!snd_mixer_selem_is_active(elem))
1191                     continue;
1192
1193                 snd_mixer_selem_get_id(elem, sid);
1194
1195                 // Find PCM playback volume control element.
1196                 const char *elementName = snd_mixer_selem_id_get_name(sid);
1197
1198                if (info->elem == NULL &&
1199                     strcmp(elementName, info->name) == 0 &&
1200                     hasVolume[i] (elem)) {
1201
1202                     info->elem = elem;
1203                     getVolumeRange[i] (elem, &info->min, &info->max);
1204                     info->volume = info->max;
1205                     setVol[i] (elem, info->volume);
1206                     if (i == SND_PCM_STREAM_PLAYBACK &&
1207                         snd_mixer_selem_has_playback_switch (elem))
1208                         snd_mixer_selem_set_playback_switch_all (elem, 1);
1209                     break;
1210                 }
1211             }
1212             LOGD ("Mixer: route '%s' %s.", info->name, info->elem ? "found" : "not found");
1213         }
1214     }
1215     LOGD("mixer initialized.");
1216 }
1217
1218 ALSAMixer::~ALSAMixer()
1219 {
1220     for (int i = 0; i <= SND_PCM_STREAM_LAST; i++) {
1221         if (mMixer[i]) snd_mixer_close (mMixer[i]);
1222         if (mixerMasterProp[i].mInfo) {
1223             delete mixerMasterProp[i].mInfo;
1224             mixerMasterProp[i].mInfo = NULL;
1225         }
1226         for (int j = 0; mixerProp[j][i].routes; j++) {
1227             if (mixerProp[j][i].mInfo) {
1228                 delete mixerProp[j][i].mInfo;
1229                 mixerProp[j][i].mInfo = NULL;
1230             }
1231         }
1232     }
1233     LOGD("mixer destroyed.");
1234 }
1235
1236 status_t ALSAMixer::setMasterVolume(float volume)
1237 {
1238     mixer_info_t *info = mixerMasterProp[SND_PCM_STREAM_PLAYBACK].mInfo;
1239     if (!info || !info->elem) return INVALID_OPERATION;
1240
1241     long minVol = info->min;
1242     long maxVol = info->max;
1243
1244     // Make sure volume is between bounds.
1245     long vol = minVol + volume * (maxVol - minVol);
1246     if (vol > maxVol) vol = maxVol;
1247     if (vol < minVol) vol = minVol;
1248
1249     info->volume = vol;
1250     snd_mixer_selem_set_playback_volume_all (info->elem, vol);
1251
1252     return NO_ERROR;
1253 }
1254
1255 status_t ALSAMixer::setMasterGain(float gain)
1256 {
1257     mixer_info_t *info = mixerMasterProp[SND_PCM_STREAM_CAPTURE].mInfo;
1258     if (!info || !info->elem) return INVALID_OPERATION;
1259
1260     long minVol = info->min;
1261     long maxVol = info->max;
1262
1263     // Make sure volume is between bounds.
1264     long vol = minVol + gain * (maxVol - minVol);
1265     if (vol > maxVol) vol = maxVol;
1266     if (vol < minVol) vol = minVol;
1267
1268     info->volume = vol;
1269     snd_mixer_selem_set_capture_volume_all (info->elem, vol);
1270
1271     return NO_ERROR;
1272 }
1273
1274 status_t ALSAMixer::setVolume(uint32_t device, float volume)
1275 {
1276     for (int j = 0; mixerProp[j][SND_PCM_STREAM_PLAYBACK].routes; j++)
1277         if (mixerProp[j][SND_PCM_STREAM_PLAYBACK].routes & device) {
1278
1279             mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_PLAYBACK].mInfo;
1280             if (!info || !info->elem) return INVALID_OPERATION;
1281
1282             long minVol = info->min;
1283             long maxVol = info->max;
1284
1285             // Make sure volume is between bounds.
1286             long vol = minVol + volume * (maxVol - minVol);
1287             if (vol > maxVol) vol = maxVol;
1288             if (vol < minVol) vol = minVol;
1289
1290             info->volume = vol;
1291             snd_mixer_selem_set_playback_volume_all (info->elem, vol);
1292         }
1293
1294     return NO_ERROR;
1295 }
1296
1297 status_t ALSAMixer::setGain(uint32_t device, float gain)
1298 {
1299     for (int j = 0; mixerProp[j][SND_PCM_STREAM_CAPTURE].routes; j++)
1300         if (mixerProp[j][SND_PCM_STREAM_CAPTURE].routes & device) {
1301
1302             mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_CAPTURE].mInfo;
1303             if (!info || !info->elem) return INVALID_OPERATION;
1304
1305             long minVol = info->min;
1306             long maxVol = info->max;
1307
1308             // Make sure volume is between bounds.
1309             long vol = minVol + gain * (maxVol - minVol);
1310             if (vol > maxVol) vol = maxVol;
1311             if (vol < minVol) vol = minVol;
1312
1313             info->volume = vol;
1314             snd_mixer_selem_set_capture_volume_all (info->elem, vol);
1315         }
1316
1317     return NO_ERROR;
1318 }
1319
1320 status_t ALSAMixer::setCaptureMuteState(uint32_t device, bool state)
1321 {
1322     for (int j = 0; mixerProp[j][SND_PCM_STREAM_CAPTURE].routes; j++)
1323         if (mixerProp[j][SND_PCM_STREAM_CAPTURE].routes & device) {
1324
1325             mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_CAPTURE].mInfo;
1326             if (!info || !info->elem) return INVALID_OPERATION;
1327
1328             if (snd_mixer_selem_has_capture_switch (info->elem)) {
1329
1330                 int err = snd_mixer_selem_set_capture_switch_all (info->elem, static_cast<int>(!state));
1331                 if (err < 0) {
1332                     LOGE("Unable to %s capture mixer switch %s",
1333                         state ? "enable" : "disable", info->name);
1334                     return INVALID_OPERATION;
1335                 }
1336             }
1337
1338             info->mute = state;
1339         }
1340
1341     return NO_ERROR;
1342 }
1343
1344 status_t ALSAMixer::getCaptureMuteState(uint32_t device, bool *state)
1345 {
1346     if (! state) return BAD_VALUE;
1347
1348     for (int j = 0; mixerProp[j][SND_PCM_STREAM_CAPTURE].routes; j++)
1349         if (mixerProp[j][SND_PCM_STREAM_CAPTURE].routes & device) {
1350
1351             mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_CAPTURE].mInfo;
1352             if (!info || !info->elem) return INVALID_OPERATION;
1353
1354             *state = info->mute;
1355             return NO_ERROR;
1356         }
1357
1358     return BAD_VALUE;
1359 }
1360
1361 status_t ALSAMixer::setPlaybackMuteState(uint32_t device, bool state)
1362 {
1363     for (int j = 0; mixerProp[j][SND_PCM_STREAM_PLAYBACK].routes; j++)
1364         if (mixerProp[j][SND_PCM_STREAM_PLAYBACK].routes & device) {
1365
1366             mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_PLAYBACK].mInfo;
1367             if (!info || !info->elem) return INVALID_OPERATION;
1368
1369             if (snd_mixer_selem_has_playback_switch (info->elem)) {
1370
1371                 int err = snd_mixer_selem_set_playback_switch_all (info->elem, static_cast<int>(!state));
1372                 if (err < 0) {
1373                     LOGE("Unable to %s playback mixer switch %s",
1374                         state ? "enable" : "disable", info->name);
1375                     return INVALID_OPERATION;
1376                 }
1377             }
1378
1379             info->mute = state;
1380         }
1381
1382     return NO_ERROR;
1383 }
1384
1385 status_t ALSAMixer::getPlaybackMuteState(uint32_t device, bool *state)
1386 {
1387     if (! state) return BAD_VALUE;
1388
1389     for (int j = 0; mixerProp[j][SND_PCM_STREAM_PLAYBACK].routes; j++)
1390         if (mixerProp[j][SND_PCM_STREAM_PLAYBACK].routes & device) {
1391
1392             mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_PLAYBACK].mInfo;
1393             if (!info || !info->elem) return INVALID_OPERATION;
1394
1395             *state = info->mute;
1396             return NO_ERROR;
1397         }
1398
1399     return BAD_VALUE;
1400 }
1401
1402 // ----------------------------------------------------------------------------
1403
1404 };        // namespace android