| /* |
| * 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. |
| */ |
| |
| // <IMPORTANT_WARNING> |
| // Design rules for threadLoop() are given in the comments at section "Fast mixer thread" of |
| // StateQueue.h. In particular, avoid library and system calls except at well-known points. |
| // The design rules are only for threadLoop(), and don't apply to FastMixerDumpState methods. |
| // </IMPORTANT_WARNING> |
| |
| #define LOG_TAG "FastMixer" |
| //#define LOG_NDEBUG 0 |
| |
| #define ATRACE_TAG ATRACE_TAG_AUDIO |
| |
| #include "Configuration.h" |
| #include <time.h> |
| #include <utils/Log.h> |
| #include <utils/Trace.h> |
| #include <system/audio.h> |
| #ifdef FAST_THREAD_STATISTICS |
| #include <audio_utils/Statistics.h> |
| #ifdef CPU_FREQUENCY_STATISTICS |
| #include <cpustats/ThreadCpuUsage.h> |
| #endif |
| #endif |
| #include <audio_utils/channels.h> |
| #include <audio_utils/format.h> |
| #include <audio_utils/mono_blend.h> |
| #include <cutils/bitops.h> |
| #include <media/AudioMixer.h> |
| #include "FastMixer.h" |
| #include "TypedLogger.h" |
| |
| namespace android { |
| |
| /*static*/ const FastMixerState FastMixer::sInitial; |
| |
| FastMixer::FastMixer(audio_io_handle_t parentIoHandle) |
| : FastThread("cycle_ms", "load_us"), |
| // mFastTrackNames |
| // mGenerations |
| mOutputSink(NULL), |
| mOutputSinkGen(0), |
| mMixer(NULL), |
| mSinkBuffer(NULL), |
| mSinkBufferSize(0), |
| mSinkChannelCount(FCC_2), |
| mMixerBuffer(NULL), |
| mMixerBufferSize(0), |
| mMixerBufferState(UNDEFINED), |
| mFormat(Format_Invalid), |
| mSampleRate(0), |
| mFastTracksGen(0), |
| mTotalNativeFramesWritten(0), |
| // timestamp |
| mNativeFramesWrittenButNotPresented(0), // the = 0 is to silence the compiler |
| mMasterMono(false), |
| mThreadIoHandle(parentIoHandle) |
| { |
| (void)mThreadIoHandle; // prevent unused warning, see C++17 [[maybe_unused]] |
| |
| // FIXME pass sInitial as parameter to base class constructor, and make it static local |
| mPrevious = &sInitial; |
| mCurrent = &sInitial; |
| |
| mDummyDumpState = &mDummyFastMixerDumpState; |
| // TODO: Add channel mask to NBAIO_Format. |
| // We assume that the channel mask must be a valid positional channel mask. |
| mSinkChannelMask = audio_channel_out_mask_from_count(mSinkChannelCount); |
| |
| unsigned i; |
| for (i = 0; i < FastMixerState::sMaxFastTracks; ++i) { |
| mGenerations[i] = 0; |
| } |
| #ifdef FAST_THREAD_STATISTICS |
| mOldLoad.tv_sec = 0; |
| mOldLoad.tv_nsec = 0; |
| #endif |
| } |
| |
| FastMixer::~FastMixer() |
| { |
| } |
| |
| FastMixerStateQueue* FastMixer::sq() |
| { |
| return &mSQ; |
| } |
| |
| const FastThreadState *FastMixer::poll() |
| { |
| return mSQ.poll(); |
| } |
| |
| void FastMixer::setNBLogWriter(NBLog::Writer *logWriter __unused) |
| { |
| } |
| |
| void FastMixer::onIdle() |
| { |
| mPreIdle = *(const FastMixerState *)mCurrent; |
| mCurrent = &mPreIdle; |
| } |
| |
| void FastMixer::onExit() |
| { |
| delete mMixer; |
| free(mMixerBuffer); |
| free(mSinkBuffer); |
| } |
| |
| bool FastMixer::isSubClassCommand(FastThreadState::Command command) |
| { |
| switch ((FastMixerState::Command) command) { |
| case FastMixerState::MIX: |
| case FastMixerState::WRITE: |
| case FastMixerState::MIX_WRITE: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| void FastMixer::updateMixerTrack(int index, Reason reason) { |
| const FastMixerState * const current = (const FastMixerState *) mCurrent; |
| const FastTrack * const fastTrack = ¤t->mFastTracks[index]; |
| |
| // check and update generation |
| if (reason == REASON_MODIFY && mGenerations[index] == fastTrack->mGeneration) { |
| return; // no change on an already configured track. |
| } |
| mGenerations[index] = fastTrack->mGeneration; |
| |
| // mMixer == nullptr on configuration failure (check done after generation update). |
| if (mMixer == nullptr) { |
| return; |
| } |
| |
| switch (reason) { |
| case REASON_REMOVE: |
| mMixer->destroy(index); |
| break; |
| case REASON_ADD: { |
| const status_t status = mMixer->create( |
| index, fastTrack->mChannelMask, fastTrack->mFormat, AUDIO_SESSION_OUTPUT_MIX); |
| LOG_ALWAYS_FATAL_IF(status != NO_ERROR, |
| "%s: cannot create fast track index" |
| " %d, mask %#x, format %#x in AudioMixer", |
| __func__, index, fastTrack->mChannelMask, fastTrack->mFormat); |
| } |
| [[fallthrough]]; // now fallthrough to update the newly created track. |
| case REASON_MODIFY: |
| mMixer->setBufferProvider(index, fastTrack->mBufferProvider); |
| |
| float vlf, vrf; |
| if (fastTrack->mVolumeProvider != nullptr) { |
| const gain_minifloat_packed_t vlr = fastTrack->mVolumeProvider->getVolumeLR(); |
| vlf = float_from_gain(gain_minifloat_unpack_left(vlr)); |
| vrf = float_from_gain(gain_minifloat_unpack_right(vlr)); |
| } else { |
| vlf = vrf = AudioMixer::UNITY_GAIN_FLOAT; |
| } |
| |
| // set volume to avoid ramp whenever the track is updated (or created). |
| // Note: this does not distinguish from starting fresh or |
| // resuming from a paused state. |
| mMixer->setParameter(index, AudioMixer::VOLUME, AudioMixer::VOLUME0, &vlf); |
| mMixer->setParameter(index, AudioMixer::VOLUME, AudioMixer::VOLUME1, &vrf); |
| |
| mMixer->setParameter(index, AudioMixer::RESAMPLE, AudioMixer::REMOVE, nullptr); |
| mMixer->setParameter(index, AudioMixer::TRACK, AudioMixer::MAIN_BUFFER, |
| (void *)mMixerBuffer); |
| mMixer->setParameter(index, AudioMixer::TRACK, AudioMixer::MIXER_FORMAT, |
| (void *)(uintptr_t)mMixerBufferFormat); |
| mMixer->setParameter(index, AudioMixer::TRACK, AudioMixer::FORMAT, |
| (void *)(uintptr_t)fastTrack->mFormat); |
| mMixer->setParameter(index, AudioMixer::TRACK, AudioMixer::CHANNEL_MASK, |
| (void *)(uintptr_t)fastTrack->mChannelMask); |
| mMixer->setParameter(index, AudioMixer::TRACK, AudioMixer::MIXER_CHANNEL_MASK, |
| (void *)(uintptr_t)mSinkChannelMask); |
| mMixer->setParameter(index, AudioMixer::TRACK, AudioMixer::HAPTIC_ENABLED, |
| (void *)(uintptr_t)fastTrack->mHapticPlaybackEnabled); |
| mMixer->setParameter(index, AudioMixer::TRACK, AudioMixer::HAPTIC_INTENSITY, |
| (void *)(uintptr_t)fastTrack->mHapticIntensity); |
| |
| mMixer->enable(index); |
| break; |
| default: |
| LOG_ALWAYS_FATAL("%s: invalid update reason %d", __func__, reason); |
| } |
| } |
| |
| void FastMixer::onStateChange() |
| { |
| const FastMixerState * const current = (const FastMixerState *) mCurrent; |
| const FastMixerState * const previous = (const FastMixerState *) mPrevious; |
| FastMixerDumpState * const dumpState = (FastMixerDumpState *) mDumpState; |
| const size_t frameCount = current->mFrameCount; |
| |
| // update boottime offset, in case it has changed |
| mTimestamp.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_BOOTTIME] = |
| mBoottimeOffset.load(); |
| |
| // handle state change here, but since we want to diff the state, |
| // we're prepared for previous == &sInitial the first time through |
| unsigned previousTrackMask; |
| |
| // check for change in output HAL configuration |
| NBAIO_Format previousFormat = mFormat; |
| if (current->mOutputSinkGen != mOutputSinkGen) { |
| mOutputSink = current->mOutputSink; |
| mOutputSinkGen = current->mOutputSinkGen; |
| mSinkChannelMask = current->mSinkChannelMask; |
| mBalance.setChannelMask(mSinkChannelMask); |
| if (mOutputSink == NULL) { |
| mFormat = Format_Invalid; |
| mSampleRate = 0; |
| mSinkChannelCount = 0; |
| mSinkChannelMask = AUDIO_CHANNEL_NONE; |
| mAudioChannelCount = 0; |
| } else { |
| mFormat = mOutputSink->format(); |
| mSampleRate = Format_sampleRate(mFormat); |
| mSinkChannelCount = Format_channelCount(mFormat); |
| LOG_ALWAYS_FATAL_IF(mSinkChannelCount > AudioMixer::MAX_NUM_CHANNELS); |
| |
| if (mSinkChannelMask == AUDIO_CHANNEL_NONE) { |
| mSinkChannelMask = audio_channel_out_mask_from_count(mSinkChannelCount); |
| } |
| mAudioChannelCount = mSinkChannelCount - audio_channel_count_from_out_mask( |
| mSinkChannelMask & AUDIO_CHANNEL_HAPTIC_ALL); |
| } |
| dumpState->mSampleRate = mSampleRate; |
| } |
| |
| if ((!Format_isEqual(mFormat, previousFormat)) || (frameCount != previous->mFrameCount)) { |
| // FIXME to avoid priority inversion, don't delete here |
| delete mMixer; |
| mMixer = NULL; |
| free(mMixerBuffer); |
| mMixerBuffer = NULL; |
| free(mSinkBuffer); |
| mSinkBuffer = NULL; |
| if (frameCount > 0 && mSampleRate > 0) { |
| // FIXME new may block for unbounded time at internal mutex of the heap |
| // implementation; it would be better to have normal mixer allocate for us |
| // to avoid blocking here and to prevent possible priority inversion |
| mMixer = new AudioMixer(frameCount, mSampleRate); |
| // FIXME See the other FIXME at FastMixer::setNBLogWriter() |
| NBLog::thread_params_t params; |
| params.frameCount = frameCount; |
| params.sampleRate = mSampleRate; |
| LOG_THREAD_PARAMS(params); |
| const size_t mixerFrameSize = mSinkChannelCount |
| * audio_bytes_per_sample(mMixerBufferFormat); |
| mMixerBufferSize = mixerFrameSize * frameCount; |
| (void)posix_memalign(&mMixerBuffer, 32, mMixerBufferSize); |
| const size_t sinkFrameSize = mSinkChannelCount |
| * audio_bytes_per_sample(mFormat.mFormat); |
| if (sinkFrameSize > mixerFrameSize) { // need a sink buffer |
| mSinkBufferSize = sinkFrameSize * frameCount; |
| (void)posix_memalign(&mSinkBuffer, 32, mSinkBufferSize); |
| } |
| mPeriodNs = (frameCount * 1000000000LL) / mSampleRate; // 1.00 |
| mUnderrunNs = (frameCount * 1750000000LL) / mSampleRate; // 1.75 |
| mOverrunNs = (frameCount * 500000000LL) / mSampleRate; // 0.50 |
| mForceNs = (frameCount * 950000000LL) / mSampleRate; // 0.95 |
| mWarmupNsMin = (frameCount * 750000000LL) / mSampleRate; // 0.75 |
| mWarmupNsMax = (frameCount * 1250000000LL) / mSampleRate; // 1.25 |
| } else { |
| mPeriodNs = 0; |
| mUnderrunNs = 0; |
| mOverrunNs = 0; |
| mForceNs = 0; |
| mWarmupNsMin = 0; |
| mWarmupNsMax = LONG_MAX; |
| } |
| mMixerBufferState = UNDEFINED; |
| // we need to reconfigure all active tracks |
| previousTrackMask = 0; |
| mFastTracksGen = current->mFastTracksGen - 1; |
| dumpState->mFrameCount = frameCount; |
| #ifdef TEE_SINK |
| mTee.set(mFormat, NBAIO_Tee::TEE_FLAG_OUTPUT_THREAD); |
| mTee.setId(std::string("_") + std::to_string(mThreadIoHandle) + "_F"); |
| #endif |
| } else { |
| previousTrackMask = previous->mTrackMask; |
| } |
| |
| // check for change in active track set |
| const unsigned currentTrackMask = current->mTrackMask; |
| dumpState->mTrackMask = currentTrackMask; |
| dumpState->mNumTracks = popcount(currentTrackMask); |
| if (current->mFastTracksGen != mFastTracksGen) { |
| |
| // process removed tracks first to avoid running out of track names |
| unsigned removedTracks = previousTrackMask & ~currentTrackMask; |
| while (removedTracks != 0) { |
| int i = __builtin_ctz(removedTracks); |
| removedTracks &= ~(1 << i); |
| updateMixerTrack(i, REASON_REMOVE); |
| // don't reset track dump state, since other side is ignoring it |
| } |
| |
| // now process added tracks |
| unsigned addedTracks = currentTrackMask & ~previousTrackMask; |
| while (addedTracks != 0) { |
| int i = __builtin_ctz(addedTracks); |
| addedTracks &= ~(1 << i); |
| updateMixerTrack(i, REASON_ADD); |
| } |
| |
| // finally process (potentially) modified tracks; these use the same slot |
| // but may have a different buffer provider or volume provider |
| unsigned modifiedTracks = currentTrackMask & previousTrackMask; |
| while (modifiedTracks != 0) { |
| int i = __builtin_ctz(modifiedTracks); |
| modifiedTracks &= ~(1 << i); |
| updateMixerTrack(i, REASON_MODIFY); |
| } |
| |
| mFastTracksGen = current->mFastTracksGen; |
| } |
| } |
| |
| void FastMixer::onWork() |
| { |
| // TODO: pass an ID parameter to indicate which time series we want to write to in NBLog.cpp |
| // Or: pass both of these into a single call with a boolean |
| const FastMixerState * const current = (const FastMixerState *) mCurrent; |
| FastMixerDumpState * const dumpState = (FastMixerDumpState *) mDumpState; |
| |
| if (mIsWarm) { |
| // Logging timestamps for FastMixer is currently disabled to make memory room for logging |
| // other statistics in FastMixer. |
| // To re-enable, delete the #ifdef FASTMIXER_LOG_HIST_TS lines (and the #endif lines). |
| #ifdef FASTMIXER_LOG_HIST_TS |
| LOG_HIST_TS(); |
| #endif |
| //ALOGD("Eric FastMixer::onWork() mIsWarm"); |
| } else { |
| dumpState->mTimestampVerifier.discontinuity( |
| dumpState->mTimestampVerifier.DISCONTINUITY_MODE_CONTINUOUS); |
| // See comment in if block. |
| #ifdef FASTMIXER_LOG_HIST_TS |
| LOG_AUDIO_STATE(); |
| #endif |
| } |
| const FastMixerState::Command command = mCommand; |
| const size_t frameCount = current->mFrameCount; |
| |
| if ((command & FastMixerState::MIX) && (mMixer != NULL) && mIsWarm) { |
| ALOG_ASSERT(mMixerBuffer != NULL); |
| |
| // AudioMixer::mState.enabledTracks is undefined if mState.hook == process__validate, |
| // so we keep a side copy of enabledTracks |
| bool anyEnabledTracks = false; |
| |
| // for each track, update volume and check for underrun |
| unsigned currentTrackMask = current->mTrackMask; |
| while (currentTrackMask != 0) { |
| int i = __builtin_ctz(currentTrackMask); |
| currentTrackMask &= ~(1 << i); |
| const FastTrack* fastTrack = ¤t->mFastTracks[i]; |
| |
| const int64_t trackFramesWrittenButNotPresented = |
| mNativeFramesWrittenButNotPresented; |
| const int64_t trackFramesWritten = fastTrack->mBufferProvider->framesReleased(); |
| ExtendedTimestamp perTrackTimestamp(mTimestamp); |
| |
| // Can't provide an ExtendedTimestamp before first frame presented. |
| // Also, timestamp may not go to very last frame on stop(). |
| if (trackFramesWritten >= trackFramesWrittenButNotPresented && |
| perTrackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] > 0) { |
| perTrackTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = |
| trackFramesWritten - trackFramesWrittenButNotPresented; |
| } else { |
| perTrackTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = 0; |
| perTrackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] = -1; |
| } |
| perTrackTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER] = trackFramesWritten; |
| fastTrack->mBufferProvider->onTimestamp(perTrackTimestamp); |
| |
| const int name = i; |
| if (fastTrack->mVolumeProvider != NULL) { |
| gain_minifloat_packed_t vlr = fastTrack->mVolumeProvider->getVolumeLR(); |
| float vlf = float_from_gain(gain_minifloat_unpack_left(vlr)); |
| float vrf = float_from_gain(gain_minifloat_unpack_right(vlr)); |
| |
| mMixer->setParameter(name, AudioMixer::RAMP_VOLUME, AudioMixer::VOLUME0, &vlf); |
| mMixer->setParameter(name, AudioMixer::RAMP_VOLUME, AudioMixer::VOLUME1, &vrf); |
| } |
| // FIXME The current implementation of framesReady() for fast tracks |
| // takes a tryLock, which can block |
| // up to 1 ms. If enough active tracks all blocked in sequence, this would result |
| // in the overall fast mix cycle being delayed. Should use a non-blocking FIFO. |
| size_t framesReady = fastTrack->mBufferProvider->framesReady(); |
| if (ATRACE_ENABLED()) { |
| // I wish we had formatted trace names |
| char traceName[16]; |
| strcpy(traceName, "fRdy"); |
| traceName[4] = i + (i < 10 ? '0' : 'A' - 10); |
| traceName[5] = '\0'; |
| ATRACE_INT(traceName, framesReady); |
| } |
| FastTrackDump *ftDump = &dumpState->mTracks[i]; |
| FastTrackUnderruns underruns = ftDump->mUnderruns; |
| if (framesReady < frameCount) { |
| if (framesReady == 0) { |
| underruns.mBitFields.mEmpty++; |
| underruns.mBitFields.mMostRecent = UNDERRUN_EMPTY; |
| mMixer->disable(name); |
| } else { |
| // allow mixing partial buffer |
| underruns.mBitFields.mPartial++; |
| underruns.mBitFields.mMostRecent = UNDERRUN_PARTIAL; |
| mMixer->enable(name); |
| anyEnabledTracks = true; |
| } |
| } else { |
| underruns.mBitFields.mFull++; |
| underruns.mBitFields.mMostRecent = UNDERRUN_FULL; |
| mMixer->enable(name); |
| anyEnabledTracks = true; |
| } |
| ftDump->mUnderruns = underruns; |
| ftDump->mFramesReady = framesReady; |
| ftDump->mFramesWritten = trackFramesWritten; |
| } |
| |
| if (anyEnabledTracks) { |
| // process() is CPU-bound |
| mMixer->process(); |
| mMixerBufferState = MIXED; |
| } else if (mMixerBufferState != ZEROED) { |
| mMixerBufferState = UNDEFINED; |
| } |
| |
| } else if (mMixerBufferState == MIXED) { |
| mMixerBufferState = UNDEFINED; |
| } |
| //bool didFullWrite = false; // dumpsys could display a count of partial writes |
| if ((command & FastMixerState::WRITE) && (mOutputSink != NULL) && (mMixerBuffer != NULL)) { |
| if (mMixerBufferState == UNDEFINED) { |
| memset(mMixerBuffer, 0, mMixerBufferSize); |
| mMixerBufferState = ZEROED; |
| } |
| |
| if (mMasterMono.load()) { // memory_order_seq_cst |
| mono_blend(mMixerBuffer, mMixerBufferFormat, Format_channelCount(mFormat), frameCount, |
| true /*limit*/); |
| } |
| |
| // Balance must take effect after mono conversion. |
| // mBalance detects zero balance within the class for speed (not needed here). |
| mBalance.setBalance(mMasterBalance.load()); |
| mBalance.process((float *)mMixerBuffer, frameCount); |
| |
| // prepare the buffer used to write to sink |
| void *buffer = mSinkBuffer != NULL ? mSinkBuffer : mMixerBuffer; |
| if (mFormat.mFormat != mMixerBufferFormat) { // sink format not the same as mixer format |
| memcpy_by_audio_format(buffer, mFormat.mFormat, mMixerBuffer, mMixerBufferFormat, |
| frameCount * Format_channelCount(mFormat)); |
| } |
| if (mSinkChannelMask & AUDIO_CHANNEL_HAPTIC_ALL) { |
| // When there are haptic channels, the sample data is partially interleaved. |
| // Make the sample data fully interleaved here. |
| adjust_channels_non_destructive(buffer, mAudioChannelCount, buffer, mSinkChannelCount, |
| audio_bytes_per_sample(mFormat.mFormat), |
| frameCount * audio_bytes_per_frame(mAudioChannelCount, mFormat.mFormat)); |
| } |
| // if non-NULL, then duplicate write() to this non-blocking sink |
| #ifdef TEE_SINK |
| mTee.write(buffer, frameCount); |
| #endif |
| // FIXME write() is non-blocking and lock-free for a properly implemented NBAIO sink, |
| // but this code should be modified to handle both non-blocking and blocking sinks |
| dumpState->mWriteSequence++; |
| ATRACE_BEGIN("write"); |
| ssize_t framesWritten = mOutputSink->write(buffer, frameCount); |
| ATRACE_END(); |
| dumpState->mWriteSequence++; |
| if (framesWritten >= 0) { |
| ALOG_ASSERT((size_t) framesWritten <= frameCount); |
| mTotalNativeFramesWritten += framesWritten; |
| dumpState->mFramesWritten = mTotalNativeFramesWritten; |
| //if ((size_t) framesWritten == frameCount) { |
| // didFullWrite = true; |
| //} |
| } else { |
| dumpState->mWriteErrors++; |
| } |
| mAttemptedWrite = true; |
| // FIXME count # of writes blocked excessively, CPU usage, etc. for dump |
| |
| if (mIsWarm) { |
| ExtendedTimestamp timestamp; // local |
| status_t status = mOutputSink->getTimestamp(timestamp); |
| if (status == NO_ERROR) { |
| dumpState->mTimestampVerifier.add( |
| timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL], |
| timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL], |
| mSampleRate); |
| const int64_t totalNativeFramesPresented = |
| timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]; |
| if (totalNativeFramesPresented <= mTotalNativeFramesWritten) { |
| mNativeFramesWrittenButNotPresented = |
| mTotalNativeFramesWritten - totalNativeFramesPresented; |
| mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = |
| timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]; |
| mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] = |
| timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]; |
| // We don't compensate for server - kernel time difference and |
| // only update latency if we have valid info. |
| const double latencyMs = |
| (double)mNativeFramesWrittenButNotPresented * 1000 / mSampleRate; |
| dumpState->mLatencyMs = latencyMs; |
| LOG_LATENCY(latencyMs); |
| } else { |
| // HAL reported that more frames were presented than were written |
| mNativeFramesWrittenButNotPresented = 0; |
| status = INVALID_OPERATION; |
| } |
| } else { |
| dumpState->mTimestampVerifier.error(); |
| } |
| if (status == NO_ERROR) { |
| mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] = |
| mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]; |
| } else { |
| // fetch server time if we can't get timestamp |
| mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] = |
| systemTime(SYSTEM_TIME_MONOTONIC); |
| // clear out kernel cached position as this may get rapidly stale |
| // if we never get a new valid timestamp |
| mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = 0; |
| mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] = -1; |
| } |
| } |
| } |
| } |
| |
| } // namespace android |