merge in jb-release history after reset to jb-dev
diff --git a/media/libmediaplayerservice/MediaPlayerService.cpp b/media/libmediaplayerservice/MediaPlayerService.cpp
index 20d6d7a..4bf2d3f 100644
--- a/media/libmediaplayerservice/MediaPlayerService.cpp
+++ b/media/libmediaplayerservice/MediaPlayerService.cpp
@@ -1542,51 +1542,10 @@
}
}
- if (mRecycledTrack) {
- // check if the existing track can be reused as-is, or if a new track needs to be created.
-
- bool reuse = true;
- if ((mCallbackData == NULL && mCallback != NULL) ||
- (mCallbackData != NULL && mCallback == NULL)) {
- // recycled track uses callbacks but the caller wants to use writes, or vice versa
- ALOGV("can't chain callback and write");
- reuse = false;
- } else if ((mRecycledTrack->getSampleRate() != sampleRate) ||
- (mRecycledTrack->channelCount() != channelCount) ||
- (mRecycledTrack->frameCount() != frameCount)) {
- ALOGV("samplerate, channelcount or framecount differ");
- reuse = false;
- } if (flags != mFlags) {
- ALOGV("output flags differ");
- reuse = false;
- }
- if (reuse) {
- ALOGV("chaining to next output");
- close();
- mTrack = mRecycledTrack;
- mRecycledTrack = NULL;
- if (mCallbackData != NULL) {
- mCallbackData->setOutput(this);
- }
- return OK;
- }
-
- // if we're not going to reuse the track, unblock and flush it
- if (mCallbackData != NULL) {
- mCallbackData->setOutput(NULL);
- mCallbackData->endTrackSwitch();
- }
- mRecycledTrack->flush();
- delete mRecycledTrack;
- mRecycledTrack = NULL;
- delete mCallbackData;
- mCallbackData = NULL;
- close();
- }
-
AudioTrack *t;
+ CallbackData *newcbd = NULL;
if (mCallback != NULL) {
- mCallbackData = new CallbackData(this);
+ newcbd = new CallbackData(this);
t = new AudioTrack(
mStreamType,
sampleRate,
@@ -1595,7 +1554,7 @@
frameCount,
flags,
CallbackWrapper,
- mCallbackData,
+ newcbd,
0, // notification frames
mSessionId);
} else {
@@ -1615,9 +1574,59 @@
if ((t == 0) || (t->initCheck() != NO_ERROR)) {
ALOGE("Unable to create audio track");
delete t;
+ delete newcbd;
return NO_INIT;
}
+
+ if (mRecycledTrack) {
+ // check if the existing track can be reused as-is, or if a new track needs to be created.
+
+ bool reuse = true;
+ if ((mCallbackData == NULL && mCallback != NULL) ||
+ (mCallbackData != NULL && mCallback == NULL)) {
+ // recycled track uses callbacks but the caller wants to use writes, or vice versa
+ ALOGV("can't chain callback and write");
+ reuse = false;
+ } else if ((mRecycledTrack->getSampleRate() != sampleRate) ||
+ (mRecycledTrack->channelCount() != channelCount) ||
+ (mRecycledTrack->frameCount() != t->frameCount())) {
+ ALOGV("samplerate, channelcount or framecount differ: %d/%d Hz, %d/%d ch, %d/%d frames",
+ mRecycledTrack->getSampleRate(), sampleRate,
+ mRecycledTrack->channelCount(), channelCount,
+ mRecycledTrack->frameCount(), t->frameCount());
+ reuse = false;
+ } else if (flags != mFlags) {
+ ALOGV("output flags differ %08x/%08x", flags, mFlags);
+ reuse = false;
+ }
+ if (reuse) {
+ ALOGV("chaining to next output");
+ close();
+ mTrack = mRecycledTrack;
+ mRecycledTrack = NULL;
+ if (mCallbackData != NULL) {
+ mCallbackData->setOutput(this);
+ }
+ delete t;
+ delete newcbd;
+ return OK;
+ }
+
+ // if we're not going to reuse the track, unblock and flush it
+ if (mCallbackData != NULL) {
+ mCallbackData->setOutput(NULL);
+ mCallbackData->endTrackSwitch();
+ }
+ mRecycledTrack->flush();
+ delete mRecycledTrack;
+ mRecycledTrack = NULL;
+ delete mCallbackData;
+ mCallbackData = NULL;
+ close();
+ }
+
+ mCallbackData = newcbd;
ALOGV("setVolume");
t->setVolume(mLeftVolume, mRightVolume);
diff --git a/media/libstagefright/OMXCodec.cpp b/media/libstagefright/OMXCodec.cpp
index baabd37..7fb395e 100755
--- a/media/libstagefright/OMXCodec.cpp
+++ b/media/libstagefright/OMXCodec.cpp
@@ -3648,7 +3648,7 @@
}
status_t OMXCodec::stop() {
- CODEC_LOGI("stop mState=%d", mState);
+ CODEC_LOGV("stop mState=%d", mState);
Mutex::Autolock autoLock(mLock);
@@ -3748,10 +3748,9 @@
mLeftOverBuffer = NULL;
}
- CODEC_LOGI("stopping in state %d", mState);
mSource->stop();
- CODEC_LOGI("stopped in state %d", mState);
+ CODEC_LOGV("stopped in state %d", mState);
return OK;
}
diff --git a/services/audioflinger/Android.mk b/services/audioflinger/Android.mk
index ee843aa..f32d90f 100644
--- a/services/audioflinger/Android.mk
+++ b/services/audioflinger/Android.mk
@@ -95,4 +95,8 @@
# 47.5 seconds at 44.1 kHz, 8 megabytes
# LOCAL_CFLAGS += -DTEE_SINK_FRAMES=0x200000
+# uncomment to enable the audio watchdog
+LOCAL_SRC_FILES += AudioWatchdog.cpp
+LOCAL_CFLAGS += -DAUDIO_WATCHDOG
+
include $(BUILD_SHARED_LIBRARY)
diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp
index be59ca0..586a916 100644
--- a/services/audioflinger/AudioFlinger.cpp
+++ b/services/audioflinger/AudioFlinger.cpp
@@ -2300,6 +2300,19 @@
}
#endif
+#ifdef AUDIO_WATCHDOG
+ // create and start the watchdog
+ mAudioWatchdog = new AudioWatchdog();
+ mAudioWatchdog->setDump(&mAudioWatchdogDump);
+ mAudioWatchdog->run("AudioWatchdog", PRIORITY_URGENT_AUDIO);
+ tid = mAudioWatchdog->getTid();
+ err = requestPriority(getpid_cached, tid, 1);
+ if (err != 0) {
+ ALOGW("Policy SCHED_FIFO priority %d is unavailable for pid %d tid %d; error %d",
+ 1, getpid_cached, tid, err);
+ }
+#endif
+
} else {
mFastMixer = NULL;
}
@@ -2349,6 +2362,11 @@
}
delete mSoaker;
#endif
+ if (mAudioWatchdog != 0) {
+ mAudioWatchdog->requestExit();
+ mAudioWatchdog->requestExitAndWait();
+ mAudioWatchdog.clear();
+ }
}
delete mAudioMixer;
}
@@ -2670,6 +2688,9 @@
if (old == -1) {
__futex_syscall3(&mFastMixerFutex, FUTEX_WAKE_PRIVATE, 1);
}
+ if (mAudioWatchdog != 0) {
+ mAudioWatchdog->resume();
+ }
}
state->mCommand = FastMixerState::MIX_WRITE;
sq->end();
@@ -2746,6 +2767,9 @@
if (kUseFastMixer == FastMixer_Dynamic) {
mNormalSink = mOutputSink;
}
+ if (mAudioWatchdog != 0) {
+ mAudioWatchdog->pause();
+ }
} else {
sq->end(false /*didModify*/);
}
@@ -3234,6 +3258,7 @@
}
// Push the new FastMixer state if necessary
+ bool pauseAudioWatchdog = false;
if (didModify) {
state->mFastTracksGen++;
// if the fast mixer was active, but now there are no fast tracks, then put it in cold idle
@@ -3249,6 +3274,7 @@
// If we go into cold idle, need to wait for acknowledgement
// so that fast mixer stops doing I/O.
block = FastMixerStateQueue::BLOCK_UNTIL_ACKED;
+ pauseAudioWatchdog = true;
}
sq->end();
}
@@ -3256,6 +3282,9 @@
sq->end(didModify);
sq->push(block);
}
+ if (pauseAudioWatchdog && mAudioWatchdog != 0) {
+ mAudioWatchdog->pause();
+ }
// Now perform the deferred reset on fast tracks that have stopped
while (resetMask != 0) {
@@ -3576,6 +3605,12 @@
}
}
+ if (mAudioWatchdog != 0) {
+ // Make a non-atomic copy of audio watchdog dump so it won't change underneath us
+ AudioWatchdogDump wdCopy = mAudioWatchdogDump;
+ wdCopy.dump(fd);
+ }
+
return NO_ERROR;
}
diff --git a/services/audioflinger/AudioFlinger.h b/services/audioflinger/AudioFlinger.h
index 677d466..384306c 100644
--- a/services/audioflinger/AudioFlinger.h
+++ b/services/audioflinger/AudioFlinger.h
@@ -49,6 +49,7 @@
#include "ExtendedAudioBufferProvider.h"
#include "FastMixer.h"
#include "NBAIO.h"
+#include "AudioWatchdog.h"
#include <powermanager/IPowerManager.h>
@@ -1169,6 +1170,7 @@
#endif
// one-time initialization, no locks required
FastMixer* mFastMixer; // non-NULL if there is also a fast mixer
+ sp<AudioWatchdog> mAudioWatchdog; // non-0 if there is an audio watchdog thread
// contents are not guaranteed to be consistent, no locks required
FastMixerDumpState mFastMixerDumpState;
@@ -1176,6 +1178,7 @@
StateQueueObserverDump mStateQueueObserverDump;
StateQueueMutatorDump mStateQueueMutatorDump;
#endif
+ AudioWatchdogDump mAudioWatchdogDump;
// accessible only within the threadLoop(), no locks required
// mFastMixer->sq() // for mutating and pushing state
diff --git a/services/audioflinger/AudioWatchdog.cpp b/services/audioflinger/AudioWatchdog.cpp
new file mode 100644
index 0000000..8f328ee
--- /dev/null
+++ b/services/audioflinger/AudioWatchdog.cpp
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "AudioWatchdog"
+//#define LOG_NDEBUG 0
+
+#include <utils/Log.h>
+#include "AudioWatchdog.h"
+
+namespace android {
+
+void AudioWatchdogDump::dump(int fd)
+{
+ char buf[32];
+ if (mMostRecent != 0) {
+ // includes NUL terminator
+ ctime_r(&mMostRecent, buf);
+ } else {
+ strcpy(buf, "N/A\n");
+ }
+ fdprintf(fd, "Watchdog: underruns=%u, logs=%u, most recent underrun log at %s",
+ mUnderruns, mLogs, buf);
+}
+
+bool AudioWatchdog::threadLoop()
+{
+ {
+ AutoMutex _l(mMyLock);
+ if (mPaused) {
+ mMyCond.wait(mMyLock);
+ // ignore previous timestamp after resume()
+ mOldTsValid = false;
+ // force an immediate log on first underrun after resume()
+ mLogTs.tv_sec = MIN_TIME_BETWEEN_LOGS_SEC;
+ mLogTs.tv_nsec = 0;
+ // caller will check for exitPending()
+ return true;
+ }
+ }
+ struct timespec newTs;
+ int rc = clock_gettime(CLOCK_MONOTONIC, &newTs);
+ if (rc != 0) {
+ pause();
+ return false;
+ }
+ if (!mOldTsValid) {
+ mOldTs = newTs;
+ mOldTsValid = true;
+ return true;
+ }
+ time_t sec = newTs.tv_sec - mOldTs.tv_sec;
+ long nsec = newTs.tv_nsec - mOldTs.tv_nsec;
+ if (nsec < 0) {
+ --sec;
+ nsec += 1000000000;
+ }
+ mOldTs = newTs;
+ // cycleNs is same as sec*1e9 + nsec, but limited to about 4 seconds
+ uint32_t cycleNs = nsec;
+ if (sec > 0) {
+ if (sec < 4) {
+ cycleNs += sec * 1000000000;
+ } else {
+ cycleNs = 4000000000u;
+ }
+ }
+ mLogTs.tv_sec += sec;
+ if ((mLogTs.tv_nsec += nsec) >= 1000000000) {
+ mLogTs.tv_sec++;
+ mLogTs.tv_nsec -= 1000000000;
+ }
+ if (cycleNs > mMaxCycleNs) {
+ mDump->mUnderruns = ++mUnderruns;
+ if (mLogTs.tv_sec >= MIN_TIME_BETWEEN_LOGS_SEC) {
+ mDump->mLogs = ++mLogs;
+ mDump->mMostRecent = time(NULL);
+ ALOGW("Insufficient CPU for load: expected=%.1f actual=%.1f ms; underruns=%u logs=%u",
+ mPeriodNs * 1e-6, cycleNs * 1e-6, mUnderruns, mLogs);
+ mLogTs.tv_sec = 0;
+ mLogTs.tv_nsec = 0;
+ }
+ }
+ struct timespec req;
+ req.tv_sec = 0;
+ req.tv_nsec = mPeriodNs;
+ rc = nanosleep(&req, NULL);
+ if (!((rc == 0) || (rc == -1 && errno == EINTR))) {
+ pause();
+ return false;
+ }
+ return true;
+}
+
+void AudioWatchdog::requestExit()
+{
+ // must be in this order to avoid a race condition
+ Thread::requestExit();
+ resume();
+}
+
+void AudioWatchdog::pause()
+{
+ AutoMutex _l(mMyLock);
+ mPaused = true;
+}
+
+void AudioWatchdog::resume()
+{
+ AutoMutex _l(mMyLock);
+ if (mPaused) {
+ mPaused = false;
+ mMyCond.signal();
+ }
+}
+
+void AudioWatchdog::setDump(AudioWatchdogDump *dump)
+{
+ mDump = dump != NULL ? dump : &mDummyDump;
+}
+
+} // namespace android
diff --git a/services/audioflinger/AudioWatchdog.h b/services/audioflinger/AudioWatchdog.h
new file mode 100644
index 0000000..4657530
--- /dev/null
+++ b/services/audioflinger/AudioWatchdog.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// The watchdog thread runs periodically. It has two functions:
+// (a) verify that adequate CPU time is available, and log
+// as soon as possible when there appears to be a CPU shortage
+// (b) monitor the other threads [not yet implemented]
+
+#ifndef AUDIO_WATCHDOG_H
+#define AUDIO_WATCHDOG_H
+
+#include <time.h>
+#include <utils/Thread.h>
+
+namespace android {
+
+// Keeps a cache of AudioWatchdog statistics that can be logged by dumpsys.
+// The usual caveats about atomicity of information apply.
+struct AudioWatchdogDump {
+ AudioWatchdogDump() : mUnderruns(0), mLogs(0), mMostRecent(0) { }
+ /*virtual*/ ~AudioWatchdogDump() { }
+ uint32_t mUnderruns; // total number of underruns
+ uint32_t mLogs; // total number of log messages
+ time_t mMostRecent; // time of most recent log
+ void dump(int fd); // should only be called on a stable copy, not the original
+};
+
+class AudioWatchdog : public Thread {
+
+public:
+ AudioWatchdog(unsigned periodMs = 50) : Thread(false /*canCallJava*/), mPaused(false),
+ mPeriodNs(periodMs * 1000000), mMaxCycleNs(mPeriodNs * 2),
+ // mOldTs
+ // mLogTs initialized below
+ mOldTsValid(false), mUnderruns(0), mLogs(0), mDump(&mDummyDump)
+ {
+#define MIN_TIME_BETWEEN_LOGS_SEC 60
+ // force an immediate log on first underrun
+ mLogTs.tv_sec = MIN_TIME_BETWEEN_LOGS_SEC;
+ mLogTs.tv_nsec = 0;
+ }
+ virtual ~AudioWatchdog() { }
+
+ // Do not call Thread::requestExitAndWait() without first calling requestExit().
+ // Thread::requestExitAndWait() is not virtual, and the implementation doesn't do enough.
+ virtual void requestExit();
+
+ // FIXME merge API and implementation with AudioTrackThread
+ void pause(); // suspend thread from execution at next loop boundary
+ void resume(); // allow thread to execute, if not requested to exit
+
+ // Where to store the dump, or NULL to not update
+ void setDump(AudioWatchdogDump* dump);
+
+private:
+ virtual bool threadLoop();
+
+ Mutex mMyLock; // Thread::mLock is private
+ Condition mMyCond; // Thread::mThreadExitedCondition is private
+ bool mPaused; // whether thread is currently paused
+
+ uint32_t mPeriodNs; // nominal period
+ uint32_t mMaxCycleNs; // maximum allowed time of one cycle before declaring underrun
+ struct timespec mOldTs; // monotonic time when threadLoop last ran
+ struct timespec mLogTs; // time since last log
+ bool mOldTsValid; // whether mOldTs is valid
+ uint32_t mUnderruns; // total number of underruns
+ uint32_t mLogs; // total number of logs
+ AudioWatchdogDump* mDump; // where to store the dump, always non-NULL
+ AudioWatchdogDump mDummyDump; // default area for dump in case setDump() is not called
+};
+
+} // namespace android
+
+#endif // AUDIO_WATCHDOG_H