Lines Matching refs:track
140 // Offloaded output thread standby delay: allows track transition without going to standby
154 FastMixer_Dynamic, // initialize if needed, then use dynamically depending on track load,
177 // track buffer in shared memory. Zero on input means to use a default value. For fast tracks,
178 // AudioFlinger derives the default from HAL buffer size and 'fast track multiplier'.
1776 sp<Track> track = mTracks[i];
1777 if (track != 0) {
1778 bool active = mActiveTracks.indexOf(track) >= 0;
1782 track->dump(buffer, SIZE, active);
1792 " not in the track list\n");
1796 sp<Track> track = mActiveTracks[i].promote();
1797 if (track != 0 && mTracks.indexOf(track) < 0) {
1798 track->dump(buffer, SIZE, true);
1823 dprintf(fd, " Fast track availMask=%#x\n", mFastTrackAvailMask);
1872 sp<Track> track;
1903 // there are sufficient fast track slots available
1905 // FIXME test that MixerThread for this fast track has a capable output HAL
1910 // read the fast track multiplier property the first time it is needed
2044 track = new Track(this, client, streamType, sampleRate, format,
2048 lStatus = track != 0 ? track->initCheck() : (status_t) NO_MEMORY;
2051 // track must be cleared from the caller as the caller has the AF lock
2054 mTracks.add(track);
2059 track->setMainBuffer(chain->inBuffer());
2060 chain->setStrategy(AudioSystem::getStrategyForStream(track->streamType()));
2076 return track;
2143 status_t AudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track)
2147 if (mActiveTracks.indexOf(track) < 0) {
2148 // the track is newly added, make sure it fills up all its
2151 if (track->isExternalTrack()) {
2152 TrackBase::track_state state = track->mState;
2154 status = AudioSystem::startOutput(mId, track->streamType(),
2155 track->sessionId());
2157 // abort track was stopped/paused while we released the lock
2158 if (state != track->mState) {
2161 AudioSystem::stopOutput(mId, track->streamType(),
2162 track->sessionId());
2172 // to track the speaker usage
2178 if (track->isOffloaded()) {
2179 if (track->isStopping_1()) {
2180 track->mRetryCount = kMaxTrackStopRetriesOffload;
2182 track->mRetryCount = kMaxTrackStartupRetriesOffload;
2184 track->mFillingUpStatus = mStandby ? Track::FS_FILLING : Track::FS_FILLED;
2186 track->mRetryCount = kMaxTrackStartupRetries;
2187 track->mFillingUpStatus =
2188 track->sharedBuffer() != 0 ? Track::FS_FILLED : Track::FS_FILLING;
2191 track->mResetDone = false;
2192 track->mPresentationCompleteFrames = 0;
2193 mActiveTracks.add(track);
2194 mWakeLockUids.add(track->uid());
2196 mLatestActiveTrack = track;
2197 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
2199 ALOGV("addTrack_l() starting track on chain %p for session %d", chain.get(),
2200 track->sessionId());
2211 bool AudioFlinger::PlaybackThread::destroyTrack_l(const sp<Track>& track)
2213 track->terminate();
2215 bool trackActive = (mActiveTracks.indexOf(track) >= 0);
2216 track->mState = TrackBase::STOPPED;
2218 removeTrack_l(track);
2219 } else if (track->isFastTrack() || track->isOffloaded() || track->isDirect()) {
2220 track->mState = TrackBase::STOPPING_1;
2226 void AudioFlinger::PlaybackThread::removeTrack_l(const sp<Track>& track)
2228 track->triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
2229 mTracks.remove(track);
2230 deleteTrackName_l(track->name());
2231 // redundant as track is about to be destroyed, for dumpsys only
2232 track->mName = -1;
2233 if (track->isFastTrack()) {
2234 int index = track->mFastIndex;
2238 // redundant as track is about to be destroyed, for dumpsys only
2239 track->mFastIndex = -1;
2241 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
2552 sp<Track> track = mTracks[i];
2553 if (sessionId == track->sessionId() && !track->isInvalid()) {
2555 if (track->isFastTrack()) {
2573 sp<Track> track = mTracks[i];
2574 if (sessionId == track->sessionId() && !track->isInvalid()) {
2575 return AudioSystem::getStrategyForStream(track->streamType());
2624 sp<Track> track = mTracks[i];
2625 if (event->triggerSession() == track->sessionId()) {
2626 (void) track->setSyncEvent(event);
2645 const sp<Track>& track = tracksToRemove.itemAt(i);
2646 if (track->isExternalTrack()) {
2647 AudioSystem::stopOutput(mId, track->streamType(),
2648 track->sessionId());
2650 // to track the speaker usage
2653 if (track->isTerminated()) {
2654 AudioSystem::releaseOutput(mId, track->streamType(),
2655 track->sessionId());
2764 sp<Track> track = mTracks[i];
2765 track->invalidate();
2849 sp<Track> track = mTracks[i];
2850 if (session == track->sessionId()) {
2851 ALOGV("addEffectChain_l() track->setMainBuffer track %p buffer %p", track.get(),
2853 track->setMainBuffer(buffer);
2860 sp<Track> track = mActiveTracks[i].promote();
2861 if (track == 0) {
2864 if (session == track->sessionId()) {
2865 ALOGV("addEffectChain_l() activating track %p on session %d", track.get(), session);
2878 // after track specific effects and before output stage.
2911 sp<Track> track = mActiveTracks[i].promote();
2912 if (track == 0) {
2915 if (session == track->sessionId()) {
2916 ALOGV("removeEffectChain_l(): stopping track on chain %p for session Id: %d",
2924 sp<Track> track = mTracks[i];
2925 if (session == track->sessionId()) {
2926 track->setMainBuffer(reinterpret_cast<int16_t*>(mSinkBuffer));
2937 const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId)
2940 return attachAuxEffect_l(track, EffectId);
2944 const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId)
2949 track->setAuxBuffer(0, NULL);
2955 track->setAuxBuffer(EffectId, (int32_t *)effect->inBuffer());
2969 sp<Track> track = mTracks[i];
2970 if (track->auxEffectId() == effectId) {
2971 attachAuxEffect_l(track, 0);
2982 int64_t lastFramesWritten = -1; // track changes in timestamp server frames written
3032 // this to convert the sink timestamp to the track timestamp.
3041 // We keep track of the last valid kernel position in case we are in underrun
3070 // even after standby() is called. This is useful for the track frame
3246 // was read from audio track: process only updates effect state
3325 // (2) minimum buffer sized tracks (even if the track is full,
3371 // Finally let go of removed track(s), without the lock held
3411 const sp<Track>& track = tracksToRemove.itemAt(i);
3412 mActiveTracks.remove(track);
3413 mWakeLockUids.remove(track->uid());
3415 ALOGV("removeTracks_l removing track on session %d", track->sessionId());
3416 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
3418 ALOGV("stopping track on chain %p for session Id: %d", chain.get(),
3419 track->sessionId());
3422 if (track->isTerminated()) {
3423 removeTrack_l(track);
3575 void AudioFlinger::PlaybackThread::addPatchTrack(const sp<PatchTrack>& track)
3578 mTracks.add(track);
3581 void AudioFlinger::PlaybackThread::deletePatchTrack(const sp<PatchTrack>& track)
3584 destroyTrack_l(track);
3707 // create fast mixer and configure it initially with just one fast track for our submix
3788 // We'll use that extract the final state which contains one remaining fast track
4044 Track* const track = t.get();
4047 if (track->isFastTrack()) {
4049 // It's theoretically possible (though unlikely) for a fast track to be created
4051 // the track never becomes active so it's fast mixer slot is never touched.
4052 // The converse, of removing an (active) track and then creating a new track
4055 int j = track->mFastIndex;
4060 // Determine whether the track is currently in underrun condition,
4065 track->mObservedUnderruns.mBitFields.mFull) & UNDERRUN_MASK;
4067 track->mObservedUnderruns.mBitFields.mPartial) & UNDERRUN_MASK;
4069 track->mObservedUnderruns.mBitFields.mEmpty) & UNDERRUN_MASK;
4071 track->mObservedUnderruns = underruns;
4074 if (!(track->isStopping() || track->isPausing() || track->isStopped()) &&
4077 track->mAudioTrackServerProxy->tallyUnderrunFrames(recentUnderruns * mFrameCount);
4079 track->mAudioTrackServerProxy->tallyUnderrunFrames(0);
4085 switch (track->mState) {
4087 // track stays active in STOPPING_1 state until first underrun
4088 if (recentUnderruns > 0 || track->isTerminated()) {
4089 track->mState = TrackBase::STOPPING_2;
4094 track->setPaused();
4098 track->mState = TrackBase::ACTIVE;
4102 // track has provided at least some frames recently: reset retry count
4103 track->mRetryCount = kMaxTrackRetries;
4110 if (track->sharedBuffer() == 0) {
4117 if (--(track->mRetryCount) > 0) {
4120 // indicate to client process that the track was disabled because of underrun;
4122 track->disable();
4132 // Check for presentation complete if track is inactive
4133 // We have consumed all the buffers of this track.
4139 if (!(mStandby || track->presentationComplete(framesWritten, audioHALFrames))) {
4140 // track stays in active list until presentation is complete
4144 if (track->isStopping_2()) {
4145 track->mState = TrackBase::STOPPED;
4147 if (track->isStopped()) {
4148 // Can't reset directly, as fast mixer is still polling this track
4149 // track->reset();
4150 // So instead mark this track as needing to be reset after push with ack
4157 LOG_ALWAYS_FATAL("unexpected track state %d", track->mState);
4163 ExtendedAudioBufferProvider *eabp = track;
4164 VolumeProvider *vp = track;
4167 fastTrack->mChannelMask = track->mChannelMask;
4168 fastTrack->mFormat = track->mFormat;
4176 track->mCachedVolume = masterVolume * mStreamTypes[track->streamType()].volume;
4189 LOG_ALWAYS_FATAL("fast track %d should have been active; "
4191 j, track->mState, state->mTrackMask, recentUnderruns,
4192 track->sharedBuffer() != 0);
4194 tracksToRemove->add(track);
4196 track->mObservedUnderruns.mBitFields.mMostRecent = UNDERRUN_FULL;
4203 audio_track_cblk_t* cblk = track->cblk();
4205 // The first time a track is added we wait
4207 int name = track->name();
4211 // hence the test on (mMixerStatus == MIXER_TRACKS_READY) meaning the track was mixed
4214 const uint32_t sampleRate = track->mAudioTrackServerProxy->getSampleRate();
4215 AudioPlaybackRate playbackRate = track->mAudioTrackServerProxy->getPlaybackRate();
4222 desiredFrames += mAudioMixer->getUnreleasedFrames(track->name());
4225 if ((track->sharedBuffer() == 0) && !track->isStopped() && !track->isPausing() &&
4230 size_t framesReady = track->framesReady();
4235 int name = track->name();
4248 if ((framesReady >= minFrames) && track->isReady() &&
4249 !track->isPaused() && !track->isTerminated())
4251 ALOGVV("track %d s=%08x [OK] on thread %p", name, cblk->mServer, this);
4255 // track->mainBuffer() != mSinkBuffer or mMixerBuffer means
4256 // there is an effect chain connected to the track
4258 if (track->mainBuffer() != mSinkBuffer &&
4259 track->mainBuffer() != mMixerBuffer) {
4263 chain = getEffectChain_l(track->sessionId());
4264 // Delegate volume control to effect in track effect chain if needed
4268 ALOGW("prepareTracks_l(): track %d attached to effect but no chain found on "
4270 name, track->sessionId());
4276 if (track->mFillingUpStatus == Track::FS_FILLED) {
4278 track->mFillingUpStatus = Track::FS_ACTIVE;
4279 if (track->mState == TrackBase::RESUMING) {
4280 track->mState = TrackBase::ACTIVE;
4286 // If the track is stopped before the first frame was mixed,
4291 // compute volume for this track
4294 if (track->isPausing() || mStreamTypes[track->streamType()].mute) {
4297 if (track->isPausing()) {
4298 track->setPaused();
4303 float typeVolume = mStreamTypes[track->streamType()].volume;
4305 AudioTrackServerProxy *proxy = track->mAudioTrackServerProxy;
4309 // track volumes come from shared memory, so can't be trusted and must be clamped
4337 // Delegate volume control to effect in track effect chain if needed
4344 track->mHasVolumeController = true;
4348 if (track->mHasVolumeController) {
4351 track->mHasVolumeController = false;
4355 mAudioMixer->setBufferProvider(name, track);
4364 AudioMixer::FORMAT, (void *)track->format());
4368 AudioMixer::CHANNEL_MASK, (void *)(uintptr_t)track->channelMask());
4373 // limit track sample rate to 2 x output sample rate, which changes at re-configuration
4375 uint32_t reqSampleRate = track->mAudioTrackServerProxy->getSampleRate();
4387 AudioPlaybackRate playbackRate = track->mAudioTrackServerProxy->getPlaybackRate();
4395 * Select the appropriate output buffer for the track.
4407 && (track->mainBuffer() == mSinkBuffer
4408 || track->mainBuffer() == mMixerBuffer)) {
4417 // TODO: override track->mainBuffer()?
4427 AudioMixer::MAIN_BUFFER, (void *)track->mainBuffer());
4432 AudioMixer::AUX_BUFFER, (void *)track->auxBuffer());
4435 track->mRetryCount = kMaxTrackRetries;
4437 // If one track is ready, set the mixer ready if:
4439 // - no other track is not ready
4445 if (framesReady < desiredFrames && !track->isStopped() && !track->isPaused()) {
4446 ALOGV("track(%p) underrun, framesReady(%zu) < framesDesired(%zd)",
4447 track, framesReady, desiredFrames);
4448 track->mAudioTrackServerProxy->tallyUnderrunFrames(desiredFrames);
4450 track->mAudioTrackServerProxy->tallyUnderrunFrames(0);
4453 // clear effect chain input buffer if an active track underruns to avoid sending
4455 chain = getEffectChain_l(track->sessionId());
4460 ALOGVV("track %d s=%08x [NOT READY] on thread %p", name, cblk->mServer, this);
4461 if ((track->sharedBuffer() != 0) || track->isTerminated() ||
4462 track->isStopped() || track->isPaused()) {
4463 // We have consumed all the buffers of this track.
4469 if (mStandby || track->presentationComplete(framesWritten, audioHALFrames)) {
4470 if (track->isStopped()) {
4471 track->reset();
4473 tracksToRemove->add(track);
4476 // No buffers for this track. Give it a few chances to
4478 if (--(track->mRetryCount) <= 0) {
4480 tracksToRemove->add(track);
4481 // indicate to client process that the track was disabled because of underrun;
4483 track->disable();
4484 // If one track is not ready, mark the mixer also not ready if:
4486 // - no other track is ready
4538 Track* track = t.get();
4539 ALOG_ASSERT(track->isFastTrack() && track->isStopped());
4540 track->reset();
4557 // and track effects will accumulate into it
4610 ALOGV("remove track (%d) and delete from mixer", name);
4647 // do not accept frame count changes if tracks are open as the track buffer
4649 // if frame count is changed after track creation
4801 void AudioFlinger::DirectOutputThread::processVolume_l(Track *track, bool lastTrack)
4805 if (mMasterMute || mStreamTypes[track->streamType()].mute) {
4808 float typeVolume = mStreamTypes[track->streamType()].volume;
4810 AudioTrackServerProxy *proxy = track->mAudioTrackServerProxy;
4833 // Delegate volume control to effect in track effect chain if needed
4835 // there is one, the track is connected to it
4879 // The track died recently
4885 ALOGW("An invalidated track shouldn't be in active list");
4890 Track* const track = t.get();
4892 audio_track_cblk_t* cblk = track->cblk();
4894 // Only consider last track started for volume and mixer state control.
4895 // In theory an older track could underrun and restart after the new one starts
4899 bool last = l.get() == track;
4901 if (track->isPausing()) {
4902 track->setPaused();
4907 tracksToRemove->add(track);
4908 } else if (track->isFlushPending()) {
4909 track->flushAck();
4913 } else if (track->isResumePending()) {
4914 track->resumeAck();
4924 // The first time a track is added we wait
4928 // hence the test on (track->mRetryCount > 1).
4929 // If retryCount<=1 then track is about to underrun and be removed.
4932 if ((track->sharedBuffer() == 0) && !track->isStopping_1() && !track->isPausing()
4933 && (track->mRetryCount > 1) && audio_has_proportional_frames(mFormat)) {
4939 if ((track->framesReady() >= minFrames) && track->isReady() && !track->isPaused() &&
4940 !track->isStopping_2() && !track->isStopped())
4942 ALOGVV("track %d s=%08x [OK]", track->name(), cblk->mServer);
4944 if (track->mFillingUpStatus == Track::FS_FILLED) {
4945 track->mFillingUpStatus = Track::FS_ACTIVE;
4951 track->resumeAck();
4955 // compute volume for this track
4956 processVolume_l(track, last);
4960 if (track != previousTrack.get()) {
4961 // Flush any data still being written from last track
4963 // Invalidate previous track to force a seek when resuming.
4967 mPreviousTrack = track;
4970 track->mRetryCount = kMaxTrackRetriesDirect;
4979 // clear effect chain input buffer if the last active track started underruns
4984 if (track->isStopping_1()) {
4985 track->mState = TrackBase::STOPPING_2;
4991 if ((track->sharedBuffer() != 0) || track->isStopped() ||
4992 track->isStopping_2() || track->isPaused()) {
4993 // We have consumed all the buffers of this track.
5004 track->presentationComplete(framesWritten, audioHALFrames)) {
5005 if (track->isStopping_2()) {
5006 track->mState = TrackBase::STOPPED;
5008 if (track->isStopped()) {
5009 track->reset();
5011 tracksToRemove->add(track);
5014 // No buffers for this track. Give it a few chances to
5016 // Only consider last track started for mixer state control
5017 if (--(track->mRetryCount) <= 0) {
5018 ALOGV("BUFFER TIMEOUT: remove(%d) from active list", track->name());
5019 tracksToRemove->add(track);
5020 // indicate to client process that the track was disabled because of underrun;
5022 track->disable();
5026 track->framesReady(), minFrames, mFormat);
5037 // if an active track did not command a flush, check for pending flush on stopped tracks
5048 // If a flush is pending and a track is active but the HW is not paused, force a HW pause
5190 // do not accept frame count changes if tracks are open as the track buffer
5192 // if frame count is changed after track creation
5406 // If a flush is pending or track was paused, just discard buffered data
5434 // The track died recently
5438 Track* const track = t.get();
5440 audio_track_cblk_t* cblk = track->cblk();
5442 // Only consider last track started for volume and mixer state control.
5443 // In theory an older track could underrun and restart after the new one starts
5447 bool last = l.get() == track;
5449 if (track->isInvalid()) {
5450 ALOGW("An invalidated track shouldn't be in active list");
5451 tracksToRemove->add(track);
5455 if (track->mState == TrackBase::IDLE) {
5456 ALOGW("An idle track shouldn't be in active list");
5460 if (track->isPausing()) {
5461 track->setPaused();
5469 // BUG - this will be wrong if a different track is made active,
5472 // track is resumed
5477 tracksToRemove->add(track);
5478 } else if (track->isFlushPending()) {
5479 if (track->isStopping_1()) {
5480 track->mRetryCount = kMaxTrackStopRetriesOffload;
5482 track->mRetryCount = kMaxTrackRetriesOffload;
5484 track->flushAck();
5488 } else if (track->isResumePending()){
5489 track->resumeAck();
5508 // Do not handle new data in this iteration even if track->framesReady()
5511 } else if (track->framesReady() && track->isReady() &&
5512 !track->isPaused() && !track->isTerminated() && !track->isStopping_2()) {
5513 ALOGVV("OffloadThread: track %d s=%08x [OK]", track->name(), cblk->mServer);
5514 if (track->mFillingUpStatus == Track::FS_FILLED) {
5515 track->mFillingUpStatus = Track::FS_ACTIVE;
5525 if (track != previousTrack.get()) {
5526 // Flush any data still being written from last track
5529 // Last track was paused so we also need to flush saved
5530 // mixbuffer state and invalidate track so that it will
5539 // comes from a different source. Also invalidate previous track to force a
5541 if (previousTrack->sessionId() != track->sessionId()) {
5546 mPreviousTrack = track;
5548 if (track->isStopping_1()) {
5549 track->mRetryCount = kMaxTrackStopRetriesOffload;
5551 track->mRetryCount = kMaxTrackRetriesOffload;
5557 ALOGVV("OffloadThread: track %d s=%08x [NOT READY]", track->name(), cblk->mServer);
5558 if (track->isStopping_1()) {
5559 if (--(track->mRetryCount) <= 0) {
5561 // wait for all current track's data to drain before we say
5562 // that the track is stopped.
5567 track->mState = TrackBase::STOPPING_2; // so presentation completes after
5587 ALOGV("stopping1 underrun retries left %d", track->mRetryCount);
5590 } else if (track->isStopping_2()) {
5593 track->mState = TrackBase::STOPPED;
5598 track->presentationComplete(framesWritten, audioHALFrames);
5599 track->reset();
5600 tracksToRemove->add(track);
5603 // No buffers for this track. Give it a few chances to
5605 if (--(track->mRetryCount) <= 0) {
5621 track->mRetryCount = kMaxTrackRetriesOffload;
5624 track->name());
5625 tracksToRemove->add(track);
5626 // indicate to client process that the track was disabled because of underrun;
5628 track->disable();
5635 // compute volume for this track
5636 processVolume_l(track, last);
5640 // If a flush is pending and a track is active but the HW is not paused, force a HW pause
5815 ALOGV("addOutputTrack() track %p, on thread %p", outputTrack.get(), thread);
5858 ALOGW("DuplicatingThread::outputsReady() could not promote thread on output track %p",
5865 ALOGV("DuplicatingThread output track %p on thread %p Not Ready", outputTracks[i].get(),
6089 // reference to the (first and only) active fast track
6092 // reference to a fast track which is about to be removed
6115 // if no active track(s), then standby and release wakelock
6252 // block until acked if removing a fast track
6269 // now run the fast track destructor with thread mutex unlocked
6323 // Use this to track timestamp information
6351 // loop over each active track
6378 // if the record track isn't draining fast enough.
6441 // FIXME should lastWarning per track?
6473 sp<RecordTrack> track = mTracks[i];
6474 track->invalidate();
6539 sp<RecordTrack> track;
6574 // there are sufficient fast track slots available
6603 // compute track buffer size in frames, and suggest the notification frame count
6605 // fast track: frame count is exactly the pipe depth
6610 // not fast track: max notification period is resampled equivalent of one HAL buffer time
6642 track = new RecordTrack(this, client, sampleRate,
6646 lStatus = track->initCheck();
6649 // track must be cleared from the caller as the caller has the AF lock
6652 mTracks.add(track);
6672 return track;
6691 // Sync event can be cancelled by the trigger session if the track is not in a
6707 ALOGV("active record track PAUSING -> ACTIVE");
6710 ALOGV("active record track state %d", recordTrack->mState);
6716 // adding the track to mActiveTracks after returning from AudioSystem::startInput(),
6736 // This is what makes a new client discard all buffered data. If the track's mRsmpInFront
6737 // was initialized to some value closer to the thread's mRsmpInFront, then the track could
6782 // note that threadLoop may still be processing the track at this point [without lock]
6818 sp<RecordTrack> track = mTracks[i];
6819 if (eventSession == track->sessionId()) {
6820 (void) track->setSyncEvent(event);
6831 void AudioFlinger::RecordThread::destroyTrack_l(const sp<RecordTrack>& track)
6833 track->terminate();
6834 track->mState = TrackBase::STOPPED;
6836 if (mActiveTracks.indexOf(track) < 0) {
6837 removeTrack_l(track);
6841 void AudioFlinger::RecordThread::removeTrack_l(const sp<RecordTrack>& track)
6843 mTracks.remove(track);
6845 if (track->isFastTrack()) {
6868 dprintf(fd, " Fast track available: %s\n", mFastTrackAvail ? "yes" : "no");
6893 sp<RecordTrack> track = mTracks[i];
6894 if (track != 0) {
6895 bool active = mActiveTracks.indexOf(track) >= 0;
6899 track->dump(buffer, SIZE, active);
6909 " not in the track list\n");
6913 sp<RecordTrack> track = mActiveTracks[i];
6914 if (mTracks.indexOf(track) < 0) {
6915 track->dump(buffer, SIZE, true);
7090 // resampler accumulates, but we only have one source track
7313 // do not accept frame count changes if tracks are open as the track buffer
7315 // if frame count is changed after track creation
7346 sp<RecordTrack> track = mTracks[i];
7347 setEffectSuspended_l(FX_IID_AEC, suspend, track->sessionId());
7348 setEffectSuspended_l(FX_IID_NS, suspend, track->sessionId());
7448 // A larger value should allow more old data to be read after a track calls start(),
7509 sp<RecordThread::RecordTrack> track = mTracks[j];
7510 audio_session_t sessionId = track->sessionId();
7588 sp<RecordTrack> track = mTracks[i];
7589 setEffectSuspended_l(FX_IID_AEC, suspend, track->sessionId());
7590 setEffectSuspended_l(FX_IID_NS, suspend, track->sessionId());