audio/A2dpAudioInterface.cpp

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <math.h>
  18
  19 //#define LOG_NDEBUG 0
  20 #define LOG_TAG "A2dpAudioInterface"
  21 #include <utils/Log.h>
  22 #include <utils/String8.h>
  23 #include <utils/Timers.h>
  24
  25 #include "A2dpAudioInterface.h"
  26 #include "audio/liba2dp.h"
  27 #include <hardware_legacy/power.h>
  28
  29
  30 namespace android_audio_legacy {
  31
  32 static const char *sA2dpWakeLock = "A2dpOutputStream";
  33 #define MAX_WRITE_RETRIES  5
  34
  35 // ----------------------------------------------------------------------------
  36
  37 //AudioHardwareInterface* A2dpAudioInterface::createA2dpInterface()
  38 //{
  39 //    AudioHardwareInterface* hw = 0;
  40 //
  41 //    hw = AudioHardwareInterface::create();
  42 //    ALOGD("new A2dpAudioInterface(hw: %p)", hw);
  43 //    hw = new A2dpAudioInterface(hw);
  44 //    return hw;
  45 //}
  46
  47 A2dpAudioInterface::A2dpAudioInterface(AudioHardwareInterface* hw) :
  48     mOutput(0), mHardwareInterface(hw), mBluetoothEnabled(true), mSuspended(false)
  49 {
  50 }
  51
  52 A2dpAudioInterface::~A2dpAudioInterface()
  53 {
  54     closeOutputStream((AudioStreamOut *)mOutput);
  55     delete mHardwareInterface;
  56 }
  57
  58 status_t A2dpAudioInterface::initCheck()
  59 {
  60     if (mHardwareInterface == 0) return NO_INIT;
  61     return mHardwareInterface->initCheck();
  62 }
  63
  64 AudioStreamOut* A2dpAudioInterface::openOutputStream(
  65         uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate, status_t *status)
  66 {
  67     if (!audio_is_a2dp_out_device(devices)) {
  68         ALOGV("A2dpAudioInterface::openOutputStream() open HW device: %x", devices);
  69         return mHardwareInterface->openOutputStream(devices, format, channels, sampleRate, status);
  70     }
  71
  72     status_t err = 0;
  73
  74     // only one output stream allowed
  75     if (mOutput) {
  76         if (status)
  77             *status = -1;
  78         return NULL;
  79     }
  80
  81     // create new output stream
  82     A2dpAudioStreamOut* out = new A2dpAudioStreamOut();
  83     if ((err = out->set(devices, format, channels, sampleRate)) == NO_ERROR) {
  84         mOutput = out;
  85         mOutput->setBluetoothEnabled(mBluetoothEnabled);
  86         mOutput->setSuspended(mSuspended);
  87     } else {
  88         delete out;
  89     }
  90
  91     if (status)
  92         *status = err;
  93     return mOutput;
  94 }
  95
  96 void A2dpAudioInterface::closeOutputStream(AudioStreamOut* out) {
  97     if (mOutput == 0 || mOutput != out) {
  98         mHardwareInterface->closeOutputStream(out);
  99     }
 100     else {
 101         delete mOutput;
 102         mOutput = 0;
 103     }
 104 }
 105
 106
 107 AudioStreamIn* A2dpAudioInterface::openInputStream(
 108         uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate, status_t *status,
 109         AudioSystem::audio_in_acoustics acoustics)
 110 {
 111     return mHardwareInterface->openInputStream(devices, format, channels, sampleRate, status, acoustics);
 112 }
 113
 114 void A2dpAudioInterface::closeInputStream(AudioStreamIn* in)
 115 {
 116     return mHardwareInterface->closeInputStream(in);
 117 }
 118
 119 status_t A2dpAudioInterface::setMode(int mode)
 120 {
 121     return mHardwareInterface->setMode(mode);
 122 }
 123
 124 status_t A2dpAudioInterface::setMicMute(bool state)
 125 {
 126     return mHardwareInterface->setMicMute(state);
 127 }
 128
 129 status_t A2dpAudioInterface::getMicMute(bool* state)
 130 {
 131     return mHardwareInterface->getMicMute(state);
 132 }
 133
 134 status_t A2dpAudioInterface::setParameters(const String8& keyValuePairs)
 135 {
 136     AudioParameter param = AudioParameter(keyValuePairs);
 137     String8 value;
 138     String8 key;
 139     status_t status = NO_ERROR;
 140
 141     ALOGV("setParameters() %s", keyValuePairs.string());
 142
 143     key = "bluetooth_enabled";
 144     if (param.get(key, value) == NO_ERROR) {
 145         mBluetoothEnabled = (value == "true");
 146         if (mOutput) {
 147             mOutput->setBluetoothEnabled(mBluetoothEnabled);
 148         }
 149         param.remove(key);
 150     }
 151     key = String8("A2dpSuspended");
 152     if (param.get(key, value) == NO_ERROR) {
 153         mSuspended = (value == "true");
 154         if (mOutput) {
 155             mOutput->setSuspended(mSuspended);
 156         }
 157         param.remove(key);
 158     }
 159
 160     if (param.size()) {
 161         status_t hwStatus = mHardwareInterface->setParameters(param.toString());
 162         if (status == NO_ERROR) {
 163             status = hwStatus;
 164         }
 165     }
 166
 167     return status;
 168 }
 169
 170 String8 A2dpAudioInterface::getParameters(const String8& keys)
 171 {
 172     AudioParameter param = AudioParameter(keys);
 173     AudioParameter a2dpParam = AudioParameter();
 174     String8 value;
 175     String8 key;
 176
 177     key = "bluetooth_enabled";
 178     if (param.get(key, value) == NO_ERROR) {
 179         value = mBluetoothEnabled ? "true" : "false";
 180         a2dpParam.add(key, value);
 181         param.remove(key);
 182     }
 183     key = "A2dpSuspended";
 184     if (param.get(key, value) == NO_ERROR) {
 185         value = mSuspended ? "true" : "false";
 186         a2dpParam.add(key, value);
 187         param.remove(key);
 188     }
 189
 190     String8 keyValuePairs  = a2dpParam.toString();
 191
 192     if (param.size()) {
 193         if (keyValuePairs != "") {
 194             keyValuePairs += ";";
 195         }
 196         keyValuePairs += mHardwareInterface->getParameters(param.toString());
 197     }
 198
 199     ALOGV("getParameters() %s", keyValuePairs.string());
 200     return keyValuePairs;
 201 }
 202
 203 size_t A2dpAudioInterface::getInputBufferSize(uint32_t sampleRate, int format, int channelCount)
 204 {
 205     return mHardwareInterface->getInputBufferSize(sampleRate, format, channelCount);
 206 }
 207
 208 status_t A2dpAudioInterface::setVoiceVolume(float v)
 209 {
 210     return mHardwareInterface->setVoiceVolume(v);
 211 }
 212
 213 status_t A2dpAudioInterface::setMasterVolume(float v)
 214 {
 215     return mHardwareInterface->setMasterVolume(v);
 216 }
 217
 218 status_t A2dpAudioInterface::dump(int fd, const Vector<String16>& args)
 219 {
 220     return mHardwareInterface->dumpState(fd, args);
 221 }
 222
 223 // ----------------------------------------------------------------------------
 224
 225 A2dpAudioInterface::A2dpAudioStreamOut::A2dpAudioStreamOut() :
 226     mFd(-1), mStandby(true), mStartCount(0), mRetryCount(0), mData(NULL),
 227     // assume BT enabled to start, this is safe because its only the
 228     // enabled->disabled transition we are worried about
 229     mBluetoothEnabled(true), mDevice(0), mClosing(false), mSuspended(false)
 230 {
 231     // use any address by default
 232     strcpy(mA2dpAddress, "00:00:00:00:00:00");
 233     init();
 234 }
 235
 236 status_t A2dpAudioInterface::A2dpAudioStreamOut::set(
 237         uint32_t device, int *pFormat, uint32_t *pChannels, uint32_t *pRate)
 238 {
 239     int lFormat = pFormat ? *pFormat : 0;
 240     uint32_t lChannels = pChannels ? *pChannels : 0;
 241     uint32_t lRate = pRate ? *pRate : 0;
 242
 243     ALOGD("A2dpAudioStreamOut::set %x, %d, %d, %d\n", device, lFormat, lChannels, lRate);
 244
 245     // fix up defaults
 246     if (lFormat == 0) lFormat = format();
 247     if (lChannels == 0) lChannels = channels();
 248     if (lRate == 0) lRate = sampleRate();
 249
 250     // check values
 251     if ((lFormat != format()) ||
 252             (lChannels != channels()) ||
 253             (lRate != sampleRate())){
 254         if (pFormat) *pFormat = format();
 255         if (pChannels) *pChannels = channels();
 256         if (pRate) *pRate = sampleRate();
 257         return BAD_VALUE;
 258     }
 259
 260     if (pFormat) *pFormat = lFormat;
 261     if (pChannels) *pChannels = lChannels;
 262     if (pRate) *pRate = lRate;
 263
 264     mDevice = device;
 265     mBufferDurationUs = ((bufferSize() * 1000 )/ frameSize() / sampleRate()) * 1000;
 266     return NO_ERROR;
 267 }
 268
 269 A2dpAudioInterface::A2dpAudioStreamOut::~A2dpAudioStreamOut()
 270 {
 271     ALOGV("A2dpAudioStreamOut destructor");
 272     close();
 273     ALOGV("A2dpAudioStreamOut destructor returning from close()");
 274 }
 275
 276 ssize_t A2dpAudioInterface::A2dpAudioStreamOut::write(const void* buffer, size_t bytes)
 277 {
 278     status_t status = -1;
 279     {
 280         Mutex::Autolock lock(mLock);
 281
 282         size_t remaining = bytes;
 283
 284         if (!mBluetoothEnabled || mClosing || mSuspended) {
 285             ALOGV("A2dpAudioStreamOut::write(), but bluetooth disabled \
 286                    mBluetoothEnabled %d, mClosing %d, mSuspended %d",
 287                     mBluetoothEnabled, mClosing, mSuspended);
 288             goto Error;
 289         }
 290
 291         if (mStandby) {
 292             acquire_wake_lock (PARTIAL_WAKE_LOCK, sA2dpWakeLock);
 293             mStandby = false;
 294             mLastWriteTime = systemTime();
 295         }
 296
 297         status = init();
 298         if (status < 0)
 299             goto Error;
 300
 301         int retries = MAX_WRITE_RETRIES;
 302         while (remaining > 0 && retries) {
 303             status = a2dp_write(mData, buffer, remaining);
 304             if (status < 0) {
 305                 ALOGE("a2dp_write failed err: %d\n", status);
 306                 goto Error;
 307             }
 308             if (status == 0) {
 309                 retries--;
 310             }
 311             remaining -= status;
 312             buffer = (char *)buffer + status;
 313         }
 314
 315         // if A2DP sink runs abnormally fast, sleep a little so that audioflinger mixer thread
 316         // does no spin and starve other threads.
 317         // NOTE: It is likely that the A2DP headset is being disconnected
 318         nsecs_t now = systemTime();
 319         if ((uint32_t)ns2us(now - mLastWriteTime) < (mBufferDurationUs >> 2)) {
 320             ALOGV("A2DP sink runs too fast");
 321             usleep(mBufferDurationUs - (uint32_t)ns2us(now - mLastWriteTime));
 322         }
 323         mLastWriteTime = now;
 324         return bytes;
 325
 326     }
 327 Error:
 328
 329     standby();
 330
 331     // Simulate audio output timing in case of error
 332     usleep(mBufferDurationUs);
 333
 334     return status;
 335 }
 336
 337 status_t A2dpAudioInterface::A2dpAudioStreamOut::init()
 338 {
 339     if (!mData) {
 340         status_t status = a2dp_init(44100, 2, &mData);
 341         if (status < 0) {
 342             ALOGE("a2dp_init failed err: %d\n", status);
 343             mData = NULL;
 344             return status;
 345         }
 346         a2dp_set_sink(mData, mA2dpAddress);
 347     }
 348
 349     return 0;
 350 }
 351
 352 status_t A2dpAudioInterface::A2dpAudioStreamOut::standby()
 353 {
 354     Mutex::Autolock lock(mLock);
 355     return standby_l();
 356 }
 357
 358 status_t A2dpAudioInterface::A2dpAudioStreamOut::standby_l()
 359 {
 360     int result = NO_ERROR;
 361
 362     if (!mStandby) {
 363         ALOGV_IF(mClosing || !mBluetoothEnabled, "Standby skip stop: closing %d enabled %d",
 364                 mClosing, mBluetoothEnabled);
 365         if (!mClosing && mBluetoothEnabled) {
 366             result = a2dp_stop(mData);
 367         }
 368         release_wake_lock(sA2dpWakeLock);
 369         mStandby = true;
 370     }
 371
 372     return result;
 373 }
 374
 375 status_t A2dpAudioInterface::A2dpAudioStreamOut::setParameters(const String8& keyValuePairs)
 376 {
 377     AudioParameter param = AudioParameter(keyValuePairs);
 378     String8 value;
 379     String8 key = String8("a2dp_sink_address");
 380     status_t status = NO_ERROR;
 381     int device;
 382     ALOGV("A2dpAudioStreamOut::setParameters() %s", keyValuePairs.string());
 383
 384     if (param.get(key, value) == NO_ERROR) {
 385         if (value.length() != strlen("00:00:00:00:00:00")) {
 386             status = BAD_VALUE;
 387         } else {
 388             setAddress(value.string());
 389         }
 390         param.remove(key);
 391     }
 392     key = String8("closing");
 393     if (param.get(key, value) == NO_ERROR) {
 394         mClosing = (value == "true");
 395         if (mClosing) {
 396             standby();
 397         }
 398         param.remove(key);
 399     }
 400     key = AudioParameter::keyRouting;
 401     if (param.getInt(key, device) == NO_ERROR) {
 402         if (audio_is_a2dp_out_device(device)) {
 403             mDevice = device;
 404             status = NO_ERROR;
 405         } else {
 406             status = BAD_VALUE;
 407         }
 408         param.remove(key);
 409     }
 410
 411     if (param.size()) {
 412         status = BAD_VALUE;
 413     }
 414     return status;
 415 }
 416
 417 String8 A2dpAudioInterface::A2dpAudioStreamOut::getParameters(const String8& keys)
 418 {
 419     AudioParameter param = AudioParameter(keys);
 420     String8 value;
 421     String8 key = String8("a2dp_sink_address");
 422
 423     if (param.get(key, value) == NO_ERROR) {
 424         value = mA2dpAddress;
 425         param.add(key, value);
 426     }
 427     key = AudioParameter::keyRouting;
 428     if (param.get(key, value) == NO_ERROR) {
 429         param.addInt(key, (int)mDevice);
 430     }
 431
 432     ALOGV("A2dpAudioStreamOut::getParameters() %s", param.toString().string());
 433     return param.toString();
 434 }
 435
 436 status_t A2dpAudioInterface::A2dpAudioStreamOut::setAddress(const char* address)
 437 {
 438     Mutex::Autolock lock(mLock);
 439
 440     if (strlen(address) != strlen("00:00:00:00:00:00"))
 441         return -EINVAL;
 442
 443     strcpy(mA2dpAddress, address);
 444     if (mData)
 445         a2dp_set_sink(mData, mA2dpAddress);
 446
 447     return NO_ERROR;
 448 }
 449
 450 status_t A2dpAudioInterface::A2dpAudioStreamOut::setBluetoothEnabled(bool enabled)
 451 {
 452     ALOGD("setBluetoothEnabled %d", enabled);
 453
 454     Mutex::Autolock lock(mLock);
 455
 456     mBluetoothEnabled = enabled;
 457     if (!enabled) {
 458         return close_l();
 459     }
 460     return NO_ERROR;
 461 }
 462
 463 status_t A2dpAudioInterface::A2dpAudioStreamOut::setSuspended(bool onOff)
 464 {
 465     ALOGV("setSuspended %d", onOff);
 466     mSuspended = onOff;
 467     standby();
 468     return NO_ERROR;
 469 }
 470
 471 status_t A2dpAudioInterface::A2dpAudioStreamOut::close()
 472 {
 473     Mutex::Autolock lock(mLock);
 474     ALOGV("A2dpAudioStreamOut::close() calling close_l()");
 475     return close_l();
 476 }
 477
 478 status_t A2dpAudioInterface::A2dpAudioStreamOut::close_l()
 479 {
 480     standby_l();
 481     if (mData) {
 482         ALOGV("A2dpAudioStreamOut::close_l() calling a2dp_cleanup(mData)");
 483         a2dp_cleanup(mData);
 484         mData = NULL;
 485     }
 486     return NO_ERROR;
 487 }
 488
 489 status_t A2dpAudioInterface::A2dpAudioStreamOut::dump(int fd, const Vector<String16>& args)
 490 {
 491     return NO_ERROR;
 492 }
 493
 494 status_t A2dpAudioInterface::A2dpAudioStreamOut::getRenderPosition(uint32_t *driverFrames)
 495 {
 496     //TODO: enable when supported by driver
 497     return INVALID_OPERATION;
 498 }
 499
 500 }; // namespace android