AudioHardwareALSA.cpp

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