// static
void *TimedEventQueue::ThreadWrapper(void *me) {
#ifdef ANDROID_SIMULATOR
// The simulator runs everything as one process, so any
// Binder calls happen on this thread instead of a thread
// in another process. We therefore need to make sure that
// this thread can do calls into interpreted code.
// On the device this is not an issue because the remote
// thread will already be set up correctly for this.
JavaVM *vm;
int numvms;
JNI_GetCreatedJavaVMs(&vm, 1, &numvms);
JNIEnv *env;
vm->AttachCurrentThread(&env, NULL);
#endif
androidSetThreadPriority(0, ANDROID_PRIORITY_FOREGROUND);
static_cast<TimedEventQueue *>(me)->threadEntry();
#ifdef ANDROID_SIMULATOR
vm->DetachCurrentThread();
#endif
return NULL;
}
// static
void *TimedEventQueue::ThreadWrapper(void *me) {
androidSetThreadPriority(0, ANDROID_PRIORITY_FOREGROUND);
static_cast<TimedEventQueue *>(me)->threadEntry();
return NULL;
}
status_t AudioRecord::start(AudioSystem::sync_event_t event, audio_session_t triggerSession)
{
ALOGV("start, sync event %d trigger session %d", event, triggerSession);
AutoMutex lock(mLock);
if (mActive) {
return NO_ERROR;
}
// discard data in buffer
const uint32_t framesFlushed = mProxy->flush();
mFramesReadServerOffset -= mFramesRead + framesFlushed;
mFramesRead = 0;
mProxy->clearTimestamp(); // timestamp is invalid until next server push
// reset current position as seen by client to 0
mProxy->setEpoch(mProxy->getEpoch() - mProxy->getPosition());
// force refresh of remaining frames by processAudioBuffer() as last
// read before stop could be partial.
mRefreshRemaining = true;
mNewPosition = mProxy->getPosition() + mUpdatePeriod;
int32_t flags = android_atomic_acquire_load(&mCblk->mFlags);
// we reactivate markers (mMarkerPosition != 0) as the position is reset to 0.
// This is legacy behavior. This is not done in stop() to avoid a race condition
// where the last marker event is issued twice.
mMarkerReached = false;
mActive = true;
status_t status = NO_ERROR;
if (!(flags & CBLK_INVALID)) {
status = mAudioRecord->start(event, triggerSession);
if (status == DEAD_OBJECT) {
flags |= CBLK_INVALID;
}
}
if (flags & CBLK_INVALID) {
status = restoreRecord_l("start");
}
if (status != NO_ERROR) {
mActive = false;
ALOGE("start() status %d", status);
} else {
sp<AudioRecordThread> t = mAudioRecordThread;
if (t != 0) {
t->resume();
} else {
mPreviousPriority = getpriority(PRIO_PROCESS, 0);
get_sched_policy(0, &mPreviousSchedulingGroup);
androidSetThreadPriority(0, ANDROID_PRIORITY_AUDIO);
}
}
return status;
}
status_t AudioRecord::start(AudioSystem::sync_event_t event, int triggerSession)
{
ALOGV("start, sync event %d trigger session %d", event, triggerSession);
AutoMutex lock(mLock);
if (mActive) {
return NO_ERROR;
}
// reset current position as seen by client to 0
mProxy->setEpoch(mProxy->getEpoch() - mProxy->getPosition());
// force refresh of remaining frames by processAudioBuffer() as last
// read before stop could be partial.
mRefreshRemaining = true;
mNewPosition = mProxy->getPosition() + mUpdatePeriod;
int32_t flags = android_atomic_acquire_load(&mCblk->mFlags);
status_t status = NO_ERROR;
if (!(flags & CBLK_INVALID)) {
ALOGV("mAudioRecord->start()");
status = mAudioRecord->start(event, triggerSession);
if (status == DEAD_OBJECT) {
flags |= CBLK_INVALID;
}
}
if (flags & CBLK_INVALID) {
status = restoreRecord_l("start");
}
if (status != NO_ERROR) {
ALOGE("start() status %d", status);
} else {
mActive = true;
sp<AudioRecordThread> t = mAudioRecordThread;
if (t != 0) {
t->resume();
} else {
mPreviousPriority = getpriority(PRIO_PROCESS, 0);
get_sched_policy(0, &mPreviousSchedulingGroup);
androidSetThreadPriority(0, ANDROID_PRIORITY_AUDIO);
}
}
return status;
}
void TunnelPlayer::extractorThreadEntry() {
pthread_mutex_lock(&extractor_mutex);
pid_t tid = gettid();
androidSetThreadPriority(tid, ANDROID_PRIORITY_AUDIO);
prctl(PR_SET_NAME, (unsigned long)"LPA DecodeThread", 0, 0, 0);
ALOGV("extractorThreadEntry wait for signal \n");
if (!mStarted) {
pthread_cond_wait(&extractor_cv, &extractor_mutex);
}
ALOGV("extractorThreadEntry ready to work \n");
pthread_mutex_unlock(&extractor_mutex);
if (killExtractorThread) {
return;
}
void* local_buf = malloc(MEM_BUFFER_SIZE);
int bytesWritten = 0;
while (!killExtractorThread) {
if (mReachedEOS || mPaused || !mIsAudioRouted) {
pthread_mutex_lock(&extractor_mutex);
pthread_cond_wait(&extractor_cv, &extractor_mutex);
pthread_mutex_unlock(&extractor_mutex);
continue;
}
if (!mIsA2DPEnabled) {
ALOGV("FillBuffer: MemBuffer size %d", MEM_BUFFER_SIZE);
ALOGV("Fillbuffer started");
bytesWritten = fillBuffer(local_buf, MEM_BUFFER_SIZE);
ALOGV("FillBuffer completed bytesToWrite %d", bytesWritten);
if(!killExtractorThread) {
mAudioSink->write(local_buf, bytesWritten);
}
}
}
free(local_buf);
//TODO: Call fillbuffer with different size and write to mAudioSink()
}
static void *uevent_loop(void *param)
{
int len = 0;
static char udata[PAGE_SIZE];
hwc_context_t * ctx = reinterpret_cast<hwc_context_t *>(param);
char thread_name[64] = HWC_UEVENT_THREAD_NAME;
prctl(PR_SET_NAME, (unsigned long) &thread_name, 0, 0, 0);
androidSetThreadPriority(0, HAL_PRIORITY_URGENT_DISPLAY);
if(!uevent_init()) {
ALOGE("%s: failed to init uevent ",__FUNCTION__);
return NULL;
}
while(1) {
len = uevent_next_event(udata, (int)sizeof(udata) - 2);
handle_uevent(ctx, udata, len);
}
return NULL;
}
static void *vsync_loop(void *param)
{
const char* vsync_timestamp_fb0 = "/sys/class/graphics/fb0/vsync_event";
const char* vsync_timestamp_fb1 = "/sys/class/graphics/fb1/vsync_event";
int dpy = HWC_DISPLAY_PRIMARY;
hwc_context_t * ctx = reinterpret_cast<hwc_context_t *>(param);
char thread_name[64] = HWC_VSYNC_THREAD_NAME;
prctl(PR_SET_NAME, (unsigned long) &thread_name, 0, 0, 0);
androidSetThreadPriority(0, HAL_PRIORITY_URGENT_DISPLAY +
android::PRIORITY_MORE_FAVORABLE);
android_set_rt_ioprio(0, 1);
const int MAX_DATA = 64;
static char vdata[MAX_DATA];
uint64_t cur_timestamp=0;
ssize_t len = -1;
int fd_timestamp = -1;
int ret = 0;
bool fb1_vsync = false;
bool logvsync = false;
char property[PROPERTY_VALUE_MAX];
if(property_get("debug.hwc.fakevsync", property, NULL) > 0) {
if(atoi(property) == 1)
ctx->vstate.fakevsync = true;
}
if(property_get("debug.hwc.logvsync", property, 0) > 0) {
if(atoi(property) == 1)
logvsync = true;
}
/* Currently read vsync timestamp from drivers
e.g. VSYNC=41800875994
*/
fd_timestamp = open(vsync_timestamp_fb0, O_RDONLY);
if (fd_timestamp < 0) {
// Make sure fb device is opened before starting this thread so this
// never happens.
ALOGE ("FATAL:%s:not able to open file:%s, %s", __FUNCTION__,
(fb1_vsync) ? vsync_timestamp_fb1 : vsync_timestamp_fb0,
strerror(errno));
ctx->vstate.fakevsync = true;
}
do {
if (LIKELY(!ctx->vstate.fakevsync)) {
len = pread(fd_timestamp, vdata, MAX_DATA, 0);
if (len < 0) {
// If the read was just interrupted - it is not a fatal error
// In either case, just continue.
if (errno != EAGAIN &&
errno != EINTR &&
errno != EBUSY) {
ALOGE ("FATAL:%s:not able to read file:%s, %s",
__FUNCTION__,
vsync_timestamp_fb0, strerror(errno));
}
continue;
}
// extract timestamp
const char *str = vdata;
if (!strncmp(str, "VSYNC=", strlen("VSYNC="))) {
cur_timestamp = strtoull(str + strlen("VSYNC="), NULL, 0);
}
} else {
usleep(16666);
cur_timestamp = systemTime();
}
// send timestamp to HAL
if(ctx->vstate.enable) {
ALOGD_IF (logvsync, "%s: timestamp %llu sent to HWC for %s",
__FUNCTION__, cur_timestamp, "fb0");
ctx->proc->vsync(ctx->proc, dpy, cur_timestamp);
}
} while (true);
if(fd_timestamp >= 0)
close (fd_timestamp);
return NULL;
}
void TunnelPlayer::extractorThreadEntry() {
mLock.lock();
uint32_t BufferSizeToUse = MEM_BUFFER_SIZE;
pid_t tid = gettid();
androidSetThreadPriority(tid, mHasVideo ? ANDROID_PRIORITY_NORMAL :
ANDROID_PRIORITY_AUDIO);
prctl(PR_SET_NAME, (unsigned long)"Extractor Thread", 0, 0, 0);
ALOGV("extractorThreadEntry wait for signal \n");
if (!mStarted && !mKillExtractorThread) {
mExtractorCv.wait(mLock);
}
ALOGV("extractorThreadEntry ready to work \n");
mLock.unlock();
if (mKillExtractorThread) {
return;
}
if(mSource != NULL) {
sp<MetaData> format = mSource->getFormat();
const char *mime;
bool success = format->findCString(kKeyMIMEType, &mime);
}
void* local_buf = malloc(BufferSizeToUse);
int *lptr = ((int*)local_buf);
int bytesWritten = 0;
bool lSeeking = false;
bool lPaused = false;
while (!mKillExtractorThread) {
if (mReachedEOS || mPaused || !mIsAudioRouted) {
ALOGV("Going to sleep before write since "
"mReachedEOS %d, mPaused %d, mIsAudioRouted %d",
mReachedEOS, mPaused, mIsAudioRouted);
mExtractorMutex.lock();
mExtractorCv.wait(mExtractorMutex);
mExtractorMutex.unlock();
ALOGV("Woke up from sleep before write since "
"mReachedEOS %d, mPaused %d, mIsAudioRouted %d",
mReachedEOS, mPaused, mIsAudioRouted);
continue;
}
ALOGV("FillBuffer: MemBuffer size %d", BufferSizeToUse);
ALOGV("Fillbuffer started");
bytesWritten = fillBuffer(local_buf, BufferSizeToUse);
ALOGV("FillBuffer completed bytesToWrite %d", bytesWritten);
if(!mKillExtractorThread) {
mLock.lock();
lPaused = mPaused;
mLock.unlock();
if(lPaused == true) {
//write only if player is not in paused state. Sleep on lock
// resume is called
ALOGV("Going to sleep in decodethreadiwrite since sink is paused");
mExtractorMutex.lock();
mExtractorCv.wait(mExtractorMutex);
ALOGV("Going to unlock n decodethreadwrite since sink "
"resumed mPaused %d, mIsAudioRouted %d, mReachedEOS %d",
mPaused, mIsAudioRouted, mReachedEOS);
mExtractorMutex.unlock();
}
mLock.lock();
lSeeking = mSeeking||mInternalSeeking;
mLock.unlock();
if(lSeeking == false && (mKillExtractorThread == false)){
//if we are seeking, ignore write, otherwise write
ALOGV("Fillbuffer before seek flag %d", mSeeking);
int lWrittenBytes = mAudioSink->write(local_buf, bytesWritten);
ALOGV("Fillbuffer after write, written bytes %d and seek flag %d", lWrittenBytes, mSeeking);
if(lWrittenBytes > 0) {
//send EOS only if write was successful, if is_buffer_available
// is flushed out (which returns 0 do not SEND EOS
ALOGV("Fillbuffer after write and seek flag %d", mSeeking);
mLock.lock();
lSeeking = mSeeking||mInternalSeeking;
mLock.unlock();
//ignore posting zero length buffer is seeking is set
if(mReachedEOS && bytesWritten && !lSeeking && (mKillExtractorThread == false)) {
ALOGV("Fillbuffer after write sent EOS flag %d", lSeeking);
mAudioSink->write(local_buf, 0);
} else {
ALOGV("Not sending EOS buffer sent since seeking %d, "
"kill %d and mReachedEOS %d", \
lSeeking, mKillExtractorThread, mReachedEOS);
}
} else {
ALOGV("write exited because of flush %d", mSeeking);
}
} else {
ALOGV("Fillbuffer ignored since we seeked after fillBuffer was set %d", mSeeking);
}
}
}
free(local_buf);
//TODO: Call fillbuffer with different size and write to mAudioSink()
}
~AutoPrioritySaver() {
androidSetThreadPriority(mTID, mPrevPriority);
}
AutoPrioritySaver()
: mTID(androidGetTid()),
mPrevPriority(androidGetThreadPriority(mTID)) {
androidSetThreadPriority(mTID, ANDROID_PRIORITY_NORMAL);
}
status_t ExtendedWriter::threadFunc() {
mEstimatedDurationUs = 0;
mEstimatedSizeBytes = 0;
bool stoppedPrematurely = true;
int64_t previousPausedDurationUs = 0;
int64_t maxTimestampUs = 0;
status_t err = OK;
pid_t tid = gettid();
androidSetThreadPriority(tid, ANDROID_PRIORITY_AUDIO);
prctl(PR_SET_NAME, (unsigned long)"ExtendedWriter", 0, 0, 0);
while (!mDone) {
MediaBuffer *buffer;
err = mSource->read(&buffer);
if (err != OK) {
break;
}
if (mPaused) {
buffer->release();
buffer = NULL;
continue;
}
mEstimatedSizeBytes += buffer->range_length();
if (exceedsFileSizeLimit()) {
buffer->release();
buffer = NULL;
notify(MEDIA_RECORDER_EVENT_INFO, MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED, 0);
break;
}
int64_t timestampUs;
CHECK(buffer->meta_data()->findInt64(kKeyTime, ×tampUs));
if (timestampUs > mEstimatedDurationUs) {
mEstimatedDurationUs = timestampUs;
}
if (mResumed) {
previousPausedDurationUs += (timestampUs - maxTimestampUs - 20000);
mResumed = false;
}
timestampUs -= previousPausedDurationUs;
ALOGV("time stamp: %lld, previous paused duration: %lld",
timestampUs, previousPausedDurationUs);
if (timestampUs > maxTimestampUs) {
maxTimestampUs = timestampUs;
}
if (exceedsFileDurationLimit()) {
buffer->release();
buffer = NULL;
notify(MEDIA_RECORDER_EVENT_INFO, MEDIA_RECORDER_INFO_MAX_DURATION_REACHED, 0);
break;
}
ssize_t n = fwrite(
(const uint8_t *)buffer->data() + buffer->range_offset(),
1,
buffer->range_length(),
mFile);
mOffset += n;
if (n < (ssize_t)buffer->range_length()) {
buffer->release();
buffer = NULL;
break;
}
// XXX: How to tell it is stopped prematurely?
if (stoppedPrematurely) {
stoppedPrematurely = false;
}
buffer->release();
buffer = NULL;
}
if (stoppedPrematurely) {
notify(MEDIA_RECORDER_EVENT_INFO, MEDIA_RECORDER_TRACK_INFO_COMPLETION_STATUS, UNKNOWN_ERROR);
}
if ( mFormat == AUDIO_FORMAT_QCELP ) {
writeQCPHeader( );
}
else if ( mFormat == AUDIO_FORMAT_EVRC ) {
writeEVRCHeader( );
}
fflush(mFile);
fclose(mFile);
mFile = NULL;
mReachedEOS = true;
if (err == ERROR_END_OF_STREAM || (err == -ETIMEDOUT)) {
return OK;
}
return err;
}
static void* a2dp_thread(void *d)
{
struct bluetooth_data* data = (struct bluetooth_data*)d;
a2dp_command_t command = A2DP_CMD_NONE;
int err = 0;
DBG("a2dp_thread started");
prctl(PR_SET_NAME, (int)"a2dp_thread", 0, 0, 0);
androidSetThreadPriority(0, ANDROID_PRIORITY_AUDIO);
pthread_mutex_lock(&data->mutex);
data->started = 1;
pthread_cond_signal(&data->thread_start);
while (1)
{
while (1) {
pthread_cond_wait(&data->thread_wait, &data->mutex);
/* Initialization needed */
if (data->state == A2DP_STATE_NONE &&
data->command != A2DP_CMD_QUIT) {
err = bluetooth_init(data);
}
/* New state command signaled */
if (command != data->command) {
command = data->command;
break;
}
}
switch (command) {
case A2DP_CMD_CONFIGURE:
if (data->state != A2DP_STATE_INITIALIZED)
break;
err = bluetooth_configure(data);
break;
case A2DP_CMD_START:
if (data->state != A2DP_STATE_CONFIGURED)
break;
err = bluetooth_start(data);
break;
case A2DP_CMD_STOP:
if (data->state != A2DP_STATE_STARTED)
break;
err = bluetooth_stop(data);
break;
case A2DP_CMD_QUIT:
bluetooth_close(data);
sbc_finish(&data->sbc);
a2dp_free(data);
goto done;
case A2DP_CMD_INIT:
/* already called bluetooth_init() */
default:
break;
}
// reset last command in case of error to allow
// re-execution of the same command
if (err < 0) {
command = A2DP_CMD_NONE;
}
}
done:
pthread_mutex_unlock(&data->mutex);
DBG("a2dp_thread finished");
return NULL;
}
status_t AudioRecord::set(
audio_source_t inputSource,
uint32_t sampleRate,
audio_format_t format,
audio_channel_mask_t channelMask,
int frameCountInt,
callback_t cbf,
void* user,
int notificationFrames,
bool threadCanCallJava,
int sessionId,
transfer_type transferType,
audio_input_flags_t flags)
{
ALOGV("sampleRate %u, channelMask %#x, format %d", sampleRate, channelMask, format);
ALOGV("inputSource %d", inputSource);
switch (transferType) {
case TRANSFER_DEFAULT:
if (cbf == NULL || threadCanCallJava) {
transferType = TRANSFER_SYNC;
} else {
transferType = TRANSFER_CALLBACK;
}
break;
case TRANSFER_CALLBACK:
if (cbf == NULL) {
ALOGE("Transfer type TRANSFER_CALLBACK but cbf == NULL");
return BAD_VALUE;
}
break;
case TRANSFER_OBTAIN:
case TRANSFER_SYNC:
break;
default:
ALOGE("Invalid transfer type %d", transferType);
return BAD_VALUE;
}
mTransfer = transferType;
// FIXME "int" here is legacy and will be replaced by size_t later
if (frameCountInt < 0) {
ALOGE("Invalid frame count %d", frameCountInt);
return BAD_VALUE;
}
size_t frameCount = frameCountInt;
ALOGV("set(): sampleRate %u, channelMask %#x, frameCount %u", sampleRate, channelMask,
frameCount);
AutoMutex lock(mLock);
if (mAudioRecord != 0) {
ALOGE("Track already in use");
return INVALID_OPERATION;
}
if (inputSource == AUDIO_SOURCE_DEFAULT) {
inputSource = AUDIO_SOURCE_MIC;
}
mInputSource = inputSource;
if (sampleRate == 0) {
ALOGE("Invalid sample rate %u", sampleRate);
return BAD_VALUE;
}
mSampleRate = sampleRate;
// these below should probably come from the audioFlinger too...
if (format == AUDIO_FORMAT_DEFAULT) {
format = AUDIO_FORMAT_PCM_16_BIT;
}
// validate parameters
if (!audio_is_valid_format(format)) {
ALOGE("Invalid format %d", format);
return BAD_VALUE;
}
#if defined(QCOM_HARDWARE) && !defined(QCOM_DIRECTTRACK)
if (format != AUDIO_FORMAT_PCM_16_BIT &&
!audio_is_compress_voip_format(format) &&
!audio_is_compress_capture_format(format)) {
#else
#ifndef QCOM_DIRECTTRACK
// Temporary restriction: AudioFlinger currently supports 16-bit PCM only
if (format != AUDIO_FORMAT_PCM_16_BIT) {
#endif
#endif
#ifndef QCOM_DIRECTTRACK
ALOGE("Format %d is not supported", format);
return BAD_VALUE;
}
#endif
mFormat = format;
if (!audio_is_input_channel(channelMask)) {
ALOGE("Invalid channel mask %#x", channelMask);
return BAD_VALUE;
}
mChannelMask = channelMask;
uint32_t channelCount = popcount(channelMask);
mChannelCount = channelCount;
#ifdef QCOM_DIRECTTRACK
mFrameSize = frameSize();
size_t inputBuffSizeInBytes = -1;
status_t status = AudioSystem::getInputBufferSize(sampleRate, format, channelMask, &inputBuffSizeInBytes);
if (status != NO_ERROR) {
ALOGE("AudioSystem could not query the input buffer size; status %d", status);
return NO_INIT;
}
if (inputBuffSizeInBytes == 0) {
ALOGE("Unsupported configuration: sampleRate %u, format %d, channelMask %#x",
sampleRate, format, channelMask);
return BAD_VALUE;
}
int minFrameCount = (inputBuffSizeInBytes * 2)/mFrameSize;
#else
// Assumes audio_is_linear_pcm(format), else sizeof(uint8_t)
#ifdef QCOM_HARDWARE
if (audio_is_linear_pcm(format))
mFrameSize = channelCount * audio_bytes_per_sample(format);
else
mFrameSize = sizeof(uint8_t);
#else
mFrameSize = channelCount * audio_bytes_per_sample(format);
#endif
// validate framecount
size_t minFrameCount = 0;
status_t status = AudioRecord::getMinFrameCount(&minFrameCount,
sampleRate, format, channelMask);
if (status != NO_ERROR) {
ALOGE("getMinFrameCount() failed; status %d", status);
return status;
}
#endif
ALOGV("AudioRecord::set() minFrameCount = %d", minFrameCount);
if (frameCount == 0) {
frameCount = minFrameCount;
} else if (frameCount < minFrameCount) {
ALOGE("frameCount %u < minFrameCount %u", frameCount, minFrameCount);
return BAD_VALUE;
}
mFrameCount = frameCount;
mNotificationFramesReq = notificationFrames;
mNotificationFramesAct = 0;
if (sessionId == 0 ) {
mSessionId = AudioSystem::newAudioSessionId();
} else {
mSessionId = sessionId;
}
ALOGV("set(): mSessionId %d", mSessionId);
mFlags = flags;
// create the IAudioRecord
status = openRecord_l(0 /*epoch*/);
if (status) {
return status;
}
if (cbf != NULL) {
mAudioRecordThread = new AudioRecordThread(*this, threadCanCallJava);
mAudioRecordThread->run("AudioRecord", ANDROID_PRIORITY_AUDIO);
}
mStatus = NO_ERROR;
// Update buffer size in case it has been limited by AudioFlinger during track creation
mFrameCount = mCblk->frameCount_;
mActive = false;
mCbf = cbf;
mRefreshRemaining = true;
mUserData = user;
// TODO: add audio hardware input latency here
mLatency = (1000*mFrameCount) / sampleRate;
mMarkerPosition = 0;
mMarkerReached = false;
mNewPosition = 0;
mUpdatePeriod = 0;
AudioSystem::acquireAudioSessionId(mSessionId);
mSequence = 1;
mObservedSequence = mSequence;
mInOverrun = false;
return NO_ERROR;
}
#ifdef QCOM_DIRECTTRACK
audio_source_t AudioRecord::inputSource() const
{
return mInputSource;
}
#endif
// -------------------------------------------------------------------------
status_t AudioRecord::start(AudioSystem::sync_event_t event, int triggerSession)
{
ALOGV("start, sync event %d trigger session %d", event, triggerSession);
AutoMutex lock(mLock);
if (mActive) {
return NO_ERROR;
}
// reset current position as seen by client to 0
mProxy->setEpoch(mProxy->getEpoch() - mProxy->getPosition());
mNewPosition = mProxy->getPosition() + mUpdatePeriod;
int32_t flags = android_atomic_acquire_load(&mCblk->mFlags);
status_t status = NO_ERROR;
if (!(flags & CBLK_INVALID)) {
ALOGV("mAudioRecord->start()");
status = mAudioRecord->start(event, triggerSession);
if (status == DEAD_OBJECT) {
flags |= CBLK_INVALID;
}
}
if (flags & CBLK_INVALID) {
status = restoreRecord_l("start");
}
if (status != NO_ERROR) {
ALOGE("start() status %d", status);
} else {
mActive = true;
sp<AudioRecordThread> t = mAudioRecordThread;
if (t != 0) {
t->resume();
} else {
mPreviousPriority = getpriority(PRIO_PROCESS, 0);
get_sched_policy(0, &mPreviousSchedulingGroup);
androidSetThreadPriority(0, ANDROID_PRIORITY_AUDIO);
}
}
return status;
}