Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge change 26349 into eclair

Browse Source 
* changes:
  Fix issue 2116700: Ringer screwy while connected over Bluetooth.
This commit is contained in:
Android (Google) Code Review
2009-09-22 12:20:38 -04:00
parent f53c186524 f69a3f8dc5
commit 56b2086021
1 changed files with 106 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

203
libs/audioflinger/AudioFlinger.cpp
View File

@@ -1227,44 +1227,46 @@ bool AudioFlinger::MixerThread::threadLoop()
enabledTracks = prepareTracks_l(activeTracks, &tracksToRemove); enabledTracks = prepareTracks_l(activeTracks, &tracksToRemove);
} }
if (LIKELY(enabledTracks)) {
// output audio to hardware // mix buffers...
if (mSuspended) { mAudioMixer->process(curBuf);
usleep(kMaxBufferRecoveryInUsecs); sleepTime = 0;
standbyTime = systemTime() + kStandbyTimeInNsecs;
} else { } else {
if (LIKELY(enabledTracks)) { sleepTime += kBufferRecoveryInUsecs;
// mix buffers... if (sleepTime > kMaxBufferRecoveryInUsecs) {
mAudioMixer->process(curBuf); sleepTime = kMaxBufferRecoveryInUsecs;
}
// There was nothing to mix this round, which means all
// active tracks were late. Sleep a little bit to give
// them another chance. If we're too late, write 0s to audio
// hardware to avoid underrun.
if (mBytesWritten != 0 && sleepTime >= kMaxBufferRecoveryInUsecs) {
memset (curBuf, 0, mixBufferSize);
sleepTime = 0; sleepTime = 0;
standbyTime = systemTime() + kStandbyTimeInNsecs;
} else {
sleepTime += kBufferRecoveryInUsecs;
// There was nothing to mix this round, which means all
// active tracks were late. Sleep a little bit to give
// them another chance. If we're too late, write 0s to audio
// hardware to avoid underrun.
if (mBytesWritten == 0 || sleepTime < kMaxBufferRecoveryInUsecs) {
usleep(kBufferRecoveryInUsecs);
} else {
memset (curBuf, 0, mixBufferSize);
sleepTime = 0;
}
} }
// sleepTime == 0 means PCM data were written to mMixBuffer[] }
if (sleepTime == 0) {
mLastWriteTime = systemTime(); if (mSuspended) {
mInWrite = true; sleepTime = kMaxBufferRecoveryInUsecs;
int bytesWritten = (int)mOutput->write(curBuf, mixBufferSize); }
if (bytesWritten > 0) mBytesWritten += bytesWritten; // sleepTime == 0 means we must write to audio hardware
mNumWrites++; if (sleepTime == 0) {
mInWrite = false; mLastWriteTime = systemTime();
mStandby = false; mInWrite = true;
nsecs_t delta = systemTime() - mLastWriteTime; LOGV("mOutput->write() thread %p frames %d", this, mFrameCount);
if (delta > maxPeriod) { int bytesWritten = (int)mOutput->write(curBuf, mixBufferSize);
LOGW("write blocked for %llu msecs", ns2ms(delta)); if (bytesWritten > 0) mBytesWritten += bytesWritten;
mNumDelayedWrites++; mNumWrites++;
} mInWrite = false;
mStandby = false;
nsecs_t delta = systemTime() - mLastWriteTime;
if (delta > maxPeriod) {
LOGW("write blocked for %llu msecs, thread %p", ns2ms(delta), this);
mNumDelayedWrites++;
} }
} else {
usleep(sleepTime);
} }
// finally let go of all our tracks, without the lock held // finally let go of all our tracks, without the lock held
@@ -1718,50 +1720,55 @@ bool AudioFlinger::DirectOutputThread::threadLoop()
} }
} }
// output audio to hardware if (activeTrack != 0) {
if (mSuspended) { AudioBufferProvider::Buffer buffer;
usleep(kMaxBufferRecoveryInUsecs); size_t frameCount = mFrameCount;
curBuf = (int8_t *)mMixBuffer;
// output audio to hardware
while(frameCount) {
buffer.frameCount = frameCount;
activeTrack->getNextBuffer(&buffer);
if (UNLIKELY(buffer.raw == 0)) {
memset(curBuf, 0, frameCount * mFrameSize);
break;
}
memcpy(curBuf, buffer.raw, buffer.frameCount * mFrameSize);
frameCount -= buffer.frameCount;
curBuf += buffer.frameCount * mFrameSize;
activeTrack->releaseBuffer(&buffer);
}
sleepTime = 0;
standbyTime = systemTime() + kStandbyTimeInNsecs;
} else { } else {
if (activeTrack != 0) { sleepTime += kBufferRecoveryInUsecs;
AudioBufferProvider::Buffer buffer; if (sleepTime > kMaxBufferRecoveryInUsecs) {
size_t frameCount = mFrameCount; sleepTime = kMaxBufferRecoveryInUsecs;
curBuf = (int8_t *)mMixBuffer; }
// output audio to hardware // There was nothing to mix this round, which means all
while(frameCount) { // active tracks were late. Sleep a little bit to give
buffer.frameCount = frameCount; // them another chance. If we're too late, write 0s to audio
activeTrack->getNextBuffer(&buffer); // hardware to avoid underrun.
if (UNLIKELY(buffer.raw == 0)) { if (mBytesWritten != 0 && sleepTime >= kMaxBufferRecoveryInUsecs &&
memset(curBuf, 0, frameCount * mFrameSize); AudioSystem::isLinearPCM(mFormat)) {
break; memset (mMixBuffer, 0, mFrameCount * mFrameSize);
}
memcpy(curBuf, buffer.raw, buffer.frameCount * mFrameSize);
frameCount -= buffer.frameCount;
curBuf += buffer.frameCount * mFrameSize;
activeTrack->releaseBuffer(&buffer);
}
sleepTime = 0; sleepTime = 0;
standbyTime = systemTime() + kStandbyTimeInNsecs;
} else {
sleepTime += kBufferRecoveryInUsecs;
if (mBytesWritten == 0 || !AudioSystem::isLinearPCM(mFormat) ||
sleepTime < kMaxBufferRecoveryInUsecs) {
usleep(kBufferRecoveryInUsecs);
} else {
memset (mMixBuffer, 0, mFrameCount * mFrameSize);
sleepTime = 0;
}
} }
}
// sleepTime == 0 means PCM data were written to mMixBuffer[] if (mSuspended) {
if (sleepTime == 0) { sleepTime = kMaxBufferRecoveryInUsecs;
mLastWriteTime = systemTime(); }
mInWrite = true; // sleepTime == 0 means we must write to audio hardware
int bytesWritten = (int)mOutput->write(mMixBuffer, mixBufferSize); if (sleepTime == 0) {
if (bytesWritten) mBytesWritten += bytesWritten; mLastWriteTime = systemTime();
mNumWrites++; mInWrite = true;
mInWrite = false; int bytesWritten = (int)mOutput->write(mMixBuffer, mixBufferSize);
mStandby = false; if (bytesWritten) mBytesWritten += bytesWritten;
} mNumWrites++;
mInWrite = false;
mStandby = false;
} else {
usleep(sleepTime);
} }
// finally let go of removed track, without the lock held // finally let go of removed track, without the lock held
@@ -1913,38 +1920,40 @@ bool AudioFlinger::DuplicatingThread::threadLoop()
} }
enabledTracks = prepareTracks_l(activeTracks, &tracksToRemove); enabledTracks = prepareTracks_l(activeTracks, &tracksToRemove);
} }
bool mustSleep = true;
if (LIKELY(enabledTracks)) { if (LIKELY(enabledTracks)) {
// mix buffers... // mix buffers...
mAudioMixer->process(curBuf); mAudioMixer->process(curBuf);
if (!mSuspended) { sleepTime = 0;
for (size_t i = 0; i < outputTracks.size(); i++) { standbyTime = systemTime() + kStandbyTimeInNsecs;
outputTracks[i]->write(curBuf, mFrameCount);
mustSleep = false;
}
mStandby = false;
mBytesWritten += mixBufferSize;
}
} else { } else {
// flush remaining overflow buffers in output tracks sleepTime += kBufferRecoveryInUsecs;
for (size_t i = 0; i < outputTracks.size(); i++) { if (sleepTime > kMaxBufferRecoveryInUsecs) {
if (outputTracks[i]->isActive()) { sleepTime = kMaxBufferRecoveryInUsecs;
outputTracks[i]->write(curBuf, 0); }
standbyTime = systemTime() + kStandbyTimeInNsecs; // There was nothing to mix this round, which means all
mustSleep = false; // active tracks were late. Sleep a little bit to give
} // them another chance. If we're too late, write 0s to audio
// hardware to avoid underrun.
if (mBytesWritten != 0 && sleepTime >= kMaxBufferRecoveryInUsecs) {
memset (curBuf, 0, mixBufferSize);
sleepTime = 0;
} }
} }
if (mustSleep) {
// LOGV("threadLoop() sleeping %d", sleepTime); if (mSuspended) {
usleep(sleepTime); sleepTime = kMaxBufferRecoveryInUsecs;
if (sleepTime < kMaxBufferRecoveryInUsecs) { }
sleepTime += kBufferRecoveryInUsecs; // sleepTime == 0 means we must write to audio hardware
if (sleepTime == 0) {
for (size_t i = 0; i < outputTracks.size(); i++) {
outputTracks[i]->write(curBuf, mFrameCount);
} }
mStandby = false;
mBytesWritten += mixBufferSize;
} else { } else {
sleepTime = kBufferRecoveryInUsecs; usleep(sleepTime);
} }
// finally let go of all our tracks, without the lock held // finally let go of all our tracks, without the lock held