blob: 1566b1fb3fb8f9c2f5ee8d1fb247f591a1e95eac [file] [log] [blame]
Eric Laurent81784c32012-11-19 14:55:58 -08001/*
2**
3** Copyright 2012, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9** http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18
19#define LOG_TAG "AudioFlinger"
20//#define LOG_NDEBUG 0
21
Glenn Kasten153b9fe2013-07-15 11:23:36 -070022#include "Configuration.h"
Glenn Kastenad8510a2015-02-17 16:24:07 -080023#include <linux/futex.h>
Eric Laurent81784c32012-11-19 14:55:58 -080024#include <math.h>
Elliott Hughesee499292014-05-21 17:55:51 -070025#include <sys/syscall.h>
Eric Laurent81784c32012-11-19 14:55:58 -080026#include <utils/Log.h>
27
28#include <private/media/AudioTrackShared.h>
29
30#include <common_time/cc_helper.h>
31#include <common_time/local_clock.h>
32
33#include "AudioMixer.h"
34#include "AudioFlinger.h"
35#include "ServiceUtilities.h"
36
Glenn Kastenda6ef132013-01-10 12:31:01 -080037#include <media/nbaio/Pipe.h>
38#include <media/nbaio/PipeReader.h>
Glenn Kastenc56f3422014-03-21 17:53:17 -070039#include <audio_utils/minifloat.h>
Glenn Kastenda6ef132013-01-10 12:31:01 -080040
Eric Laurent81784c32012-11-19 14:55:58 -080041// ----------------------------------------------------------------------------
42
43// Note: the following macro is used for extremely verbose logging message. In
44// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
45// 0; but one side effect of this is to turn all LOGV's as well. Some messages
46// are so verbose that we want to suppress them even when we have ALOG_ASSERT
47// turned on. Do not uncomment the #def below unless you really know what you
48// are doing and want to see all of the extremely verbose messages.
49//#define VERY_VERY_VERBOSE_LOGGING
50#ifdef VERY_VERY_VERBOSE_LOGGING
51#define ALOGVV ALOGV
52#else
53#define ALOGVV(a...) do { } while(0)
54#endif
55
56namespace android {
57
58// ----------------------------------------------------------------------------
59// TrackBase
60// ----------------------------------------------------------------------------
61
Glenn Kastenda6ef132013-01-10 12:31:01 -080062static volatile int32_t nextTrackId = 55;
63
Eric Laurent81784c32012-11-19 14:55:58 -080064// TrackBase constructor must be called with AudioFlinger::mLock held
65AudioFlinger::ThreadBase::TrackBase::TrackBase(
66 ThreadBase *thread,
67 const sp<Client>& client,
68 uint32_t sampleRate,
69 audio_format_t format,
70 audio_channel_mask_t channelMask,
71 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -070072 void *buffer,
Glenn Kastene3aa6592012-12-04 12:22:46 -080073 int sessionId,
Marco Nelissen462fd2f2013-01-14 14:12:05 -080074 int clientUid,
Glenn Kasten755b0a62014-05-13 11:30:28 -070075 IAudioFlinger::track_flags_t flags,
Glenn Kastend776ac62014-05-07 09:16:09 -070076 bool isOut,
Eric Laurent83b88082014-06-20 18:31:16 -070077 alloc_type alloc,
78 track_type type)
Eric Laurent81784c32012-11-19 14:55:58 -080079 : RefBase(),
80 mThread(thread),
81 mClient(client),
82 mCblk(NULL),
83 // mBuffer
Eric Laurent81784c32012-11-19 14:55:58 -080084 mState(IDLE),
85 mSampleRate(sampleRate),
86 mFormat(format),
87 mChannelMask(channelMask),
Andy Hunge5412692014-05-16 11:25:07 -070088 mChannelCount(isOut ?
89 audio_channel_count_from_out_mask(channelMask) :
90 audio_channel_count_from_in_mask(channelMask)),
Eric Laurent81784c32012-11-19 14:55:58 -080091 mFrameSize(audio_is_linear_pcm(format) ?
92 mChannelCount * audio_bytes_per_sample(format) : sizeof(int8_t)),
93 mFrameCount(frameCount),
Glenn Kastene3aa6592012-12-04 12:22:46 -080094 mSessionId(sessionId),
Glenn Kasten755b0a62014-05-13 11:30:28 -070095 mFlags(flags),
Glenn Kastene3aa6592012-12-04 12:22:46 -080096 mIsOut(isOut),
Glenn Kastenda6ef132013-01-10 12:31:01 -080097 mServerProxy(NULL),
Eric Laurentbfb1b832013-01-07 09:53:42 -080098 mId(android_atomic_inc(&nextTrackId)),
Eric Laurent83b88082014-06-20 18:31:16 -070099 mTerminated(false),
Eric Laurentaaa44472014-09-12 17:41:50 -0700100 mType(type),
101 mThreadIoHandle(thread->id())
Eric Laurent81784c32012-11-19 14:55:58 -0800102{
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800103 // if the caller is us, trust the specified uid
104 if (IPCThreadState::self()->getCallingPid() != getpid_cached || clientUid == -1) {
105 int newclientUid = IPCThreadState::self()->getCallingUid();
106 if (clientUid != -1 && clientUid != newclientUid) {
107 ALOGW("uid %d tried to pass itself off as %d", newclientUid, clientUid);
108 }
109 clientUid = newclientUid;
110 }
111 // clientUid contains the uid of the app that is responsible for this track, so we can blame
112 // battery usage on it.
113 mUid = clientUid;
114
Eric Laurent81784c32012-11-19 14:55:58 -0800115 // ALOGD("Creating track with %d buffers @ %d bytes", bufferCount, bufferSize);
116 size_t size = sizeof(audio_track_cblk_t);
Eric Laurent83b88082014-06-20 18:31:16 -0700117 size_t bufferSize = (buffer == NULL ? roundup(frameCount) : frameCount) * mFrameSize;
118 if (buffer == NULL && alloc == ALLOC_CBLK) {
Eric Laurent81784c32012-11-19 14:55:58 -0800119 size += bufferSize;
120 }
121
122 if (client != 0) {
123 mCblkMemory = client->heap()->allocate(size);
Glenn Kasten663c2242013-09-24 11:52:37 -0700124 if (mCblkMemory == 0 ||
125 (mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->pointer())) == NULL) {
Eric Laurent81784c32012-11-19 14:55:58 -0800126 ALOGE("not enough memory for AudioTrack size=%u", size);
127 client->heap()->dump("AudioTrack");
Glenn Kasten663c2242013-09-24 11:52:37 -0700128 mCblkMemory.clear();
Eric Laurent81784c32012-11-19 14:55:58 -0800129 return;
130 }
131 } else {
Glenn Kastene3aa6592012-12-04 12:22:46 -0800132 // this syntax avoids calling the audio_track_cblk_t constructor twice
133 mCblk = (audio_track_cblk_t *) new uint8_t[size];
Eric Laurent81784c32012-11-19 14:55:58 -0800134 // assume mCblk != NULL
135 }
136
137 // construct the shared structure in-place.
138 if (mCblk != NULL) {
139 new(mCblk) audio_track_cblk_t();
Glenn Kastenc263ca02014-06-04 20:31:46 -0700140 switch (alloc) {
141 case ALLOC_READONLY: {
Glenn Kastend776ac62014-05-07 09:16:09 -0700142 const sp<MemoryDealer> roHeap(thread->readOnlyHeap());
143 if (roHeap == 0 ||
144 (mBufferMemory = roHeap->allocate(bufferSize)) == 0 ||
145 (mBuffer = mBufferMemory->pointer()) == NULL) {
146 ALOGE("not enough memory for read-only buffer size=%zu", bufferSize);
147 if (roHeap != 0) {
148 roHeap->dump("buffer");
149 }
150 mCblkMemory.clear();
151 mBufferMemory.clear();
152 return;
153 }
Eric Laurent81784c32012-11-19 14:55:58 -0800154 memset(mBuffer, 0, bufferSize);
Glenn Kastenc263ca02014-06-04 20:31:46 -0700155 } break;
156 case ALLOC_PIPE:
157 mBufferMemory = thread->pipeMemory();
158 // mBuffer is the virtual address as seen from current process (mediaserver),
159 // and should normally be coming from mBufferMemory->pointer().
160 // However in this case the TrackBase does not reference the buffer directly.
161 // It should references the buffer via the pipe.
162 // Therefore, to detect incorrect usage of the buffer, we set mBuffer to NULL.
163 mBuffer = NULL;
164 break;
165 case ALLOC_CBLK:
Glenn Kastend776ac62014-05-07 09:16:09 -0700166 // clear all buffers
Eric Laurent83b88082014-06-20 18:31:16 -0700167 if (buffer == NULL) {
Glenn Kastend776ac62014-05-07 09:16:09 -0700168 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);
169 memset(mBuffer, 0, bufferSize);
170 } else {
Eric Laurent83b88082014-06-20 18:31:16 -0700171 mBuffer = buffer;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800172#if 0
Glenn Kastend776ac62014-05-07 09:16:09 -0700173 mCblk->mFlags = CBLK_FORCEREADY; // FIXME hack, need to fix the track ready logic
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800174#endif
Glenn Kastend776ac62014-05-07 09:16:09 -0700175 }
Glenn Kastenc263ca02014-06-04 20:31:46 -0700176 break;
Eric Laurent83b88082014-06-20 18:31:16 -0700177 case ALLOC_LOCAL:
178 mBuffer = calloc(1, bufferSize);
179 break;
180 case ALLOC_NONE:
181 mBuffer = buffer;
182 break;
Eric Laurent81784c32012-11-19 14:55:58 -0800183 }
Glenn Kastenda6ef132013-01-10 12:31:01 -0800184
Glenn Kasten46909e72013-02-26 09:20:22 -0800185#ifdef TEE_SINK
Glenn Kastenda6ef132013-01-10 12:31:01 -0800186 if (mTeeSinkTrackEnabled) {
Glenn Kasten329f6512014-08-28 16:23:16 -0700187 NBAIO_Format pipeFormat = Format_from_SR_C(mSampleRate, mChannelCount, mFormat);
Glenn Kasten6e0d67d2014-01-31 09:41:08 -0800188 if (Format_isValid(pipeFormat)) {
Glenn Kasten46909e72013-02-26 09:20:22 -0800189 Pipe *pipe = new Pipe(mTeeSinkTrackFrames, pipeFormat);
190 size_t numCounterOffers = 0;
191 const NBAIO_Format offers[1] = {pipeFormat};
192 ssize_t index = pipe->negotiate(offers, 1, NULL, numCounterOffers);
193 ALOG_ASSERT(index == 0);
194 PipeReader *pipeReader = new PipeReader(*pipe);
195 numCounterOffers = 0;
196 index = pipeReader->negotiate(offers, 1, NULL, numCounterOffers);
197 ALOG_ASSERT(index == 0);
198 mTeeSink = pipe;
199 mTeeSource = pipeReader;
200 }
Glenn Kastenda6ef132013-01-10 12:31:01 -0800201 }
Glenn Kasten46909e72013-02-26 09:20:22 -0800202#endif
Glenn Kastenda6ef132013-01-10 12:31:01 -0800203
Eric Laurent81784c32012-11-19 14:55:58 -0800204 }
205}
206
Eric Laurent83b88082014-06-20 18:31:16 -0700207status_t AudioFlinger::ThreadBase::TrackBase::initCheck() const
208{
209 status_t status;
210 if (mType == TYPE_OUTPUT || mType == TYPE_PATCH) {
211 status = cblk() != NULL ? NO_ERROR : NO_MEMORY;
212 } else {
213 status = getCblk() != 0 ? NO_ERROR : NO_MEMORY;
214 }
215 return status;
216}
217
Eric Laurent81784c32012-11-19 14:55:58 -0800218AudioFlinger::ThreadBase::TrackBase::~TrackBase()
219{
Glenn Kasten46909e72013-02-26 09:20:22 -0800220#ifdef TEE_SINK
Glenn Kastenda6ef132013-01-10 12:31:01 -0800221 dumpTee(-1, mTeeSource, mId);
Glenn Kasten46909e72013-02-26 09:20:22 -0800222#endif
Glenn Kastene3aa6592012-12-04 12:22:46 -0800223 // delete the proxy before deleting the shared memory it refers to, to avoid dangling reference
224 delete mServerProxy;
Eric Laurent81784c32012-11-19 14:55:58 -0800225 if (mCblk != NULL) {
226 if (mClient == 0) {
227 delete mCblk;
228 } else {
229 mCblk->~audio_track_cblk_t(); // destroy our shared-structure.
230 }
231 }
232 mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to
233 if (mClient != 0) {
Eric Laurent021cf962014-05-13 10:18:14 -0700234 // Client destructor must run with AudioFlinger client mutex locked
235 Mutex::Autolock _l(mClient->audioFlinger()->mClientLock);
Eric Laurent81784c32012-11-19 14:55:58 -0800236 // If the client's reference count drops to zero, the associated destructor
237 // must run with AudioFlinger lock held. Thus the explicit clear() rather than
238 // relying on the automatic clear() at end of scope.
239 mClient.clear();
240 }
Eric Laurent3bcffa12014-06-12 18:38:45 -0700241 // flush the binder command buffer
242 IPCThreadState::self()->flushCommands();
Eric Laurent81784c32012-11-19 14:55:58 -0800243}
244
245// AudioBufferProvider interface
246// getNextBuffer() = 0;
247// This implementation of releaseBuffer() is used by Track and RecordTrack, but not TimedTrack
248void AudioFlinger::ThreadBase::TrackBase::releaseBuffer(AudioBufferProvider::Buffer* buffer)
249{
Glenn Kasten46909e72013-02-26 09:20:22 -0800250#ifdef TEE_SINK
Glenn Kastenda6ef132013-01-10 12:31:01 -0800251 if (mTeeSink != 0) {
252 (void) mTeeSink->write(buffer->raw, buffer->frameCount);
253 }
Glenn Kasten46909e72013-02-26 09:20:22 -0800254#endif
Glenn Kastenda6ef132013-01-10 12:31:01 -0800255
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800256 ServerProxy::Buffer buf;
257 buf.mFrameCount = buffer->frameCount;
258 buf.mRaw = buffer->raw;
Eric Laurent81784c32012-11-19 14:55:58 -0800259 buffer->frameCount = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800260 buffer->raw = NULL;
261 mServerProxy->releaseBuffer(&buf);
Eric Laurent81784c32012-11-19 14:55:58 -0800262}
263
Eric Laurent81784c32012-11-19 14:55:58 -0800264status_t AudioFlinger::ThreadBase::TrackBase::setSyncEvent(const sp<SyncEvent>& event)
265{
266 mSyncEvents.add(event);
267 return NO_ERROR;
268}
269
270// ----------------------------------------------------------------------------
271// Playback
272// ----------------------------------------------------------------------------
273
274AudioFlinger::TrackHandle::TrackHandle(const sp<AudioFlinger::PlaybackThread::Track>& track)
275 : BnAudioTrack(),
276 mTrack(track)
277{
278}
279
280AudioFlinger::TrackHandle::~TrackHandle() {
281 // just stop the track on deletion, associated resources
282 // will be freed from the main thread once all pending buffers have
283 // been played. Unless it's not in the active track list, in which
284 // case we free everything now...
285 mTrack->destroy();
286}
287
288sp<IMemory> AudioFlinger::TrackHandle::getCblk() const {
289 return mTrack->getCblk();
290}
291
292status_t AudioFlinger::TrackHandle::start() {
293 return mTrack->start();
294}
295
296void AudioFlinger::TrackHandle::stop() {
297 mTrack->stop();
298}
299
300void AudioFlinger::TrackHandle::flush() {
301 mTrack->flush();
302}
303
Eric Laurent81784c32012-11-19 14:55:58 -0800304void AudioFlinger::TrackHandle::pause() {
305 mTrack->pause();
306}
307
308status_t AudioFlinger::TrackHandle::attachAuxEffect(int EffectId)
309{
310 return mTrack->attachAuxEffect(EffectId);
311}
312
313status_t AudioFlinger::TrackHandle::allocateTimedBuffer(size_t size,
314 sp<IMemory>* buffer) {
315 if (!mTrack->isTimedTrack())
316 return INVALID_OPERATION;
317
318 PlaybackThread::TimedTrack* tt =
319 reinterpret_cast<PlaybackThread::TimedTrack*>(mTrack.get());
320 return tt->allocateTimedBuffer(size, buffer);
321}
322
323status_t AudioFlinger::TrackHandle::queueTimedBuffer(const sp<IMemory>& buffer,
324 int64_t pts) {
325 if (!mTrack->isTimedTrack())
326 return INVALID_OPERATION;
327
Glenn Kasten663c2242013-09-24 11:52:37 -0700328 if (buffer == 0 || buffer->pointer() == NULL) {
329 ALOGE("queueTimedBuffer() buffer is 0 or has NULL pointer()");
330 return BAD_VALUE;
331 }
332
Eric Laurent81784c32012-11-19 14:55:58 -0800333 PlaybackThread::TimedTrack* tt =
334 reinterpret_cast<PlaybackThread::TimedTrack*>(mTrack.get());
335 return tt->queueTimedBuffer(buffer, pts);
336}
337
338status_t AudioFlinger::TrackHandle::setMediaTimeTransform(
339 const LinearTransform& xform, int target) {
340
341 if (!mTrack->isTimedTrack())
342 return INVALID_OPERATION;
343
344 PlaybackThread::TimedTrack* tt =
345 reinterpret_cast<PlaybackThread::TimedTrack*>(mTrack.get());
346 return tt->setMediaTimeTransform(
347 xform, static_cast<TimedAudioTrack::TargetTimeline>(target));
348}
349
Glenn Kasten3dcd00d2013-07-17 10:10:23 -0700350status_t AudioFlinger::TrackHandle::setParameters(const String8& keyValuePairs) {
351 return mTrack->setParameters(keyValuePairs);
352}
353
Glenn Kasten53cec222013-08-29 09:01:02 -0700354status_t AudioFlinger::TrackHandle::getTimestamp(AudioTimestamp& timestamp)
355{
Glenn Kasten573d80a2013-08-26 09:36:23 -0700356 return mTrack->getTimestamp(timestamp);
Glenn Kasten53cec222013-08-29 09:01:02 -0700357}
358
Eric Laurent59fe0102013-09-27 18:48:26 -0700359
360void AudioFlinger::TrackHandle::signal()
361{
362 return mTrack->signal();
363}
364
Eric Laurent81784c32012-11-19 14:55:58 -0800365status_t AudioFlinger::TrackHandle::onTransact(
366 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
367{
368 return BnAudioTrack::onTransact(code, data, reply, flags);
369}
370
371// ----------------------------------------------------------------------------
372
373// Track constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
374AudioFlinger::PlaybackThread::Track::Track(
375 PlaybackThread *thread,
376 const sp<Client>& client,
377 audio_stream_type_t streamType,
378 uint32_t sampleRate,
379 audio_format_t format,
380 audio_channel_mask_t channelMask,
381 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700382 void *buffer,
Eric Laurent81784c32012-11-19 14:55:58 -0800383 const sp<IMemory>& sharedBuffer,
384 int sessionId,
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800385 int uid,
Eric Laurent83b88082014-06-20 18:31:16 -0700386 IAudioFlinger::track_flags_t flags,
387 track_type type)
388 : TrackBase(thread, client, sampleRate, format, channelMask, frameCount,
389 (sharedBuffer != 0) ? sharedBuffer->pointer() : buffer,
390 sessionId, uid, flags, true /*isOut*/,
391 (type == TYPE_PATCH) ? ( buffer == NULL ? ALLOC_LOCAL : ALLOC_NONE) : ALLOC_CBLK,
392 type),
Eric Laurent81784c32012-11-19 14:55:58 -0800393 mFillingUpStatus(FS_INVALID),
394 // mRetryCount initialized later when needed
395 mSharedBuffer(sharedBuffer),
396 mStreamType(streamType),
397 mName(-1), // see note below
398 mMainBuffer(thread->mixBuffer()),
399 mAuxBuffer(NULL),
400 mAuxEffectId(0), mHasVolumeController(false),
401 mPresentationCompleteFrames(0),
Eric Laurent81784c32012-11-19 14:55:58 -0800402 mFastIndex(-1),
Glenn Kasten5736c352012-12-04 12:12:34 -0800403 mCachedVolume(1.0),
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800404 mIsInvalid(false),
Eric Laurentbfb1b832013-01-07 09:53:42 -0800405 mAudioTrackServerProxy(NULL),
Haynes Mathew George7844f672014-01-15 12:32:55 -0800406 mResumeToStopping(false),
Glenn Kastenced6e742014-06-09 17:12:32 -0700407 mFlushHwPending(false),
Phil Burk6140c792015-03-19 14:30:21 -0700408 mPreviousTimestampValid(false)
Eric Laurent81784c32012-11-19 14:55:58 -0800409{
Eric Laurent83b88082014-06-20 18:31:16 -0700410 // client == 0 implies sharedBuffer == 0
411 ALOG_ASSERT(!(client == 0 && sharedBuffer != 0));
412
413 ALOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %d", sharedBuffer->pointer(),
414 sharedBuffer->size());
415
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700416 if (mCblk == NULL) {
417 return;
Eric Laurent81784c32012-11-19 14:55:58 -0800418 }
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700419
420 if (sharedBuffer == 0) {
421 mAudioTrackServerProxy = new AudioTrackServerProxy(mCblk, mBuffer, frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700422 mFrameSize, !isExternalTrack(), sampleRate);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700423 } else {
424 mAudioTrackServerProxy = new StaticAudioTrackServerProxy(mCblk, mBuffer, frameCount,
425 mFrameSize);
426 }
427 mServerProxy = mAudioTrackServerProxy;
428
Glenn Kastenc263ca02014-06-04 20:31:46 -0700429 mName = thread->getTrackName_l(channelMask, format, sessionId);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700430 if (mName < 0) {
431 ALOGE("no more track names available");
432 return;
433 }
434 // only allocate a fast track index if we were able to allocate a normal track name
435 if (flags & IAudioFlinger::TRACK_FAST) {
436 mAudioTrackServerProxy->framesReadyIsCalledByMultipleThreads();
437 ALOG_ASSERT(thread->mFastTrackAvailMask != 0);
438 int i = __builtin_ctz(thread->mFastTrackAvailMask);
439 ALOG_ASSERT(0 < i && i < (int)FastMixerState::kMaxFastTracks);
440 // FIXME This is too eager. We allocate a fast track index before the
441 // fast track becomes active. Since fast tracks are a scarce resource,
442 // this means we are potentially denying other more important fast tracks from
443 // being created. It would be better to allocate the index dynamically.
444 mFastIndex = i;
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700445 thread->mFastTrackAvailMask &= ~(1 << i);
446 }
Eric Laurent81784c32012-11-19 14:55:58 -0800447}
448
449AudioFlinger::PlaybackThread::Track::~Track()
450{
451 ALOGV("PlaybackThread::Track destructor");
Glenn Kasten0c72b242013-09-11 09:14:16 -0700452
453 // The destructor would clear mSharedBuffer,
454 // but it will not push the decremented reference count,
455 // leaving the client's IMemory dangling indefinitely.
456 // This prevents that leak.
457 if (mSharedBuffer != 0) {
458 mSharedBuffer.clear();
Glenn Kasten0c72b242013-09-11 09:14:16 -0700459 }
Eric Laurent81784c32012-11-19 14:55:58 -0800460}
461
Glenn Kasten03003332013-08-06 15:40:54 -0700462status_t AudioFlinger::PlaybackThread::Track::initCheck() const
463{
464 status_t status = TrackBase::initCheck();
465 if (status == NO_ERROR && mName < 0) {
466 status = NO_MEMORY;
467 }
468 return status;
469}
470
Eric Laurent81784c32012-11-19 14:55:58 -0800471void AudioFlinger::PlaybackThread::Track::destroy()
472{
473 // NOTE: destroyTrack_l() can remove a strong reference to this Track
474 // by removing it from mTracks vector, so there is a risk that this Tracks's
475 // destructor is called. As the destructor needs to lock mLock,
476 // we must acquire a strong reference on this Track before locking mLock
477 // here so that the destructor is called only when exiting this function.
478 // On the other hand, as long as Track::destroy() is only called by
479 // TrackHandle destructor, the TrackHandle still holds a strong ref on
480 // this Track with its member mTrack.
481 sp<Track> keep(this);
482 { // scope for mLock
Eric Laurentaaa44472014-09-12 17:41:50 -0700483 bool wasActive = false;
Eric Laurent81784c32012-11-19 14:55:58 -0800484 sp<ThreadBase> thread = mThread.promote();
485 if (thread != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -0800486 Mutex::Autolock _l(thread->mLock);
487 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Eric Laurentaaa44472014-09-12 17:41:50 -0700488 wasActive = playbackThread->destroyTrack_l(this);
489 }
490 if (isExternalTrack() && !wasActive) {
Eric Laurente83b55d2014-11-14 10:06:21 -0800491 AudioSystem::releaseOutput(mThreadIoHandle, mStreamType, (audio_session_t)mSessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800492 }
493 }
494}
495
496/*static*/ void AudioFlinger::PlaybackThread::Track::appendDumpHeader(String8& result)
497{
Marco Nelissenb2208842014-02-07 14:00:50 -0800498 result.append(" Name Active Client Type Fmt Chn mask Session fCount S F SRate "
Glenn Kasten82aaf942013-07-17 16:05:07 -0700499 "L dB R dB Server Main buf Aux Buf Flags UndFrmCnt\n");
Eric Laurent81784c32012-11-19 14:55:58 -0800500}
501
Marco Nelissenb2208842014-02-07 14:00:50 -0800502void AudioFlinger::PlaybackThread::Track::dump(char* buffer, size_t size, bool active)
Eric Laurent81784c32012-11-19 14:55:58 -0800503{
Glenn Kastenc56f3422014-03-21 17:53:17 -0700504 gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR();
Eric Laurent81784c32012-11-19 14:55:58 -0800505 if (isFastTrack()) {
Marco Nelissenb2208842014-02-07 14:00:50 -0800506 sprintf(buffer, " F %2d", mFastIndex);
507 } else if (mName >= AudioMixer::TRACK0) {
508 sprintf(buffer, " %4d", mName - AudioMixer::TRACK0);
Eric Laurent81784c32012-11-19 14:55:58 -0800509 } else {
Marco Nelissenb2208842014-02-07 14:00:50 -0800510 sprintf(buffer, " none");
Eric Laurent81784c32012-11-19 14:55:58 -0800511 }
512 track_state state = mState;
513 char stateChar;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800514 if (isTerminated()) {
Eric Laurent81784c32012-11-19 14:55:58 -0800515 stateChar = 'T';
Eric Laurentbfb1b832013-01-07 09:53:42 -0800516 } else {
517 switch (state) {
518 case IDLE:
519 stateChar = 'I';
520 break;
521 case STOPPING_1:
522 stateChar = 's';
523 break;
524 case STOPPING_2:
525 stateChar = '5';
526 break;
527 case STOPPED:
528 stateChar = 'S';
529 break;
530 case RESUMING:
531 stateChar = 'R';
532 break;
533 case ACTIVE:
534 stateChar = 'A';
535 break;
536 case PAUSING:
537 stateChar = 'p';
538 break;
539 case PAUSED:
540 stateChar = 'P';
541 break;
542 case FLUSHED:
543 stateChar = 'F';
544 break;
545 default:
546 stateChar = '?';
547 break;
548 }
Eric Laurent81784c32012-11-19 14:55:58 -0800549 }
550 char nowInUnderrun;
551 switch (mObservedUnderruns.mBitFields.mMostRecent) {
552 case UNDERRUN_FULL:
553 nowInUnderrun = ' ';
554 break;
555 case UNDERRUN_PARTIAL:
556 nowInUnderrun = '<';
557 break;
558 case UNDERRUN_EMPTY:
559 nowInUnderrun = '*';
560 break;
561 default:
562 nowInUnderrun = '?';
563 break;
564 }
Narayan Kamath1d6fa7a2014-02-11 13:47:53 +0000565 snprintf(&buffer[8], size-8, " %6s %6u %4u %08X %08X %7u %6zu %1c %1d %5u %5.2g %5.2g "
Kévin PETIT377b2ec2014-02-03 12:35:36 +0000566 "%08X %p %p 0x%03X %9u%c\n",
Marco Nelissenb2208842014-02-07 14:00:50 -0800567 active ? "yes" : "no",
Eric Laurent81784c32012-11-19 14:55:58 -0800568 (mClient == 0) ? getpid_cached : mClient->pid(),
569 mStreamType,
570 mFormat,
571 mChannelMask,
572 mSessionId,
Eric Laurent81784c32012-11-19 14:55:58 -0800573 mFrameCount,
574 stateChar,
Eric Laurent81784c32012-11-19 14:55:58 -0800575 mFillingUpStatus,
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800576 mAudioTrackServerProxy->getSampleRate(),
Glenn Kastenc56f3422014-03-21 17:53:17 -0700577 20.0 * log10(float_from_gain(gain_minifloat_unpack_left(vlr))),
578 20.0 * log10(float_from_gain(gain_minifloat_unpack_right(vlr))),
Glenn Kastenf20e1d82013-07-12 09:45:18 -0700579 mCblk->mServer,
Kévin PETIT377b2ec2014-02-03 12:35:36 +0000580 mMainBuffer,
581 mAuxBuffer,
Glenn Kasten96f60d82013-07-12 10:21:18 -0700582 mCblk->mFlags,
Glenn Kasten82aaf942013-07-17 16:05:07 -0700583 mAudioTrackServerProxy->getUnderrunFrames(),
Eric Laurent81784c32012-11-19 14:55:58 -0800584 nowInUnderrun);
585}
586
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800587uint32_t AudioFlinger::PlaybackThread::Track::sampleRate() const {
588 return mAudioTrackServerProxy->getSampleRate();
589}
590
Eric Laurent81784c32012-11-19 14:55:58 -0800591// AudioBufferProvider interface
592status_t AudioFlinger::PlaybackThread::Track::getNextBuffer(
Glenn Kasten0f11b512014-01-31 16:18:54 -0800593 AudioBufferProvider::Buffer* buffer, int64_t pts __unused)
Eric Laurent81784c32012-11-19 14:55:58 -0800594{
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800595 ServerProxy::Buffer buf;
596 size_t desiredFrames = buffer->frameCount;
597 buf.mFrameCount = desiredFrames;
598 status_t status = mServerProxy->obtainBuffer(&buf);
599 buffer->frameCount = buf.mFrameCount;
600 buffer->raw = buf.mRaw;
601 if (buf.mFrameCount == 0) {
Glenn Kasten82aaf942013-07-17 16:05:07 -0700602 mAudioTrackServerProxy->tallyUnderrunFrames(desiredFrames);
Eric Laurent81784c32012-11-19 14:55:58 -0800603 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800604 return status;
Eric Laurent81784c32012-11-19 14:55:58 -0800605}
606
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700607// releaseBuffer() is not overridden
608
609// ExtendedAudioBufferProvider interface
610
Andy Hung27876c02014-09-09 18:07:55 -0700611// framesReady() may return an approximation of the number of frames if called
612// from a different thread than the one calling Proxy->obtainBuffer() and
613// Proxy->releaseBuffer(). Also note there is no mutual exclusion in the
614// AudioTrackServerProxy so be especially careful calling with FastTracks.
Eric Laurent81784c32012-11-19 14:55:58 -0800615size_t AudioFlinger::PlaybackThread::Track::framesReady() const {
Andy Hung27876c02014-09-09 18:07:55 -0700616 if (mSharedBuffer != 0 && (isStopped() || isStopping())) {
617 // Static tracks return zero frames immediately upon stopping (for FastTracks).
618 // The remainder of the buffer is not drained.
619 return 0;
620 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800621 return mAudioTrackServerProxy->framesReady();
Eric Laurent81784c32012-11-19 14:55:58 -0800622}
623
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700624size_t AudioFlinger::PlaybackThread::Track::framesReleased() const
625{
626 return mAudioTrackServerProxy->framesReleased();
627}
628
Eric Laurent81784c32012-11-19 14:55:58 -0800629// Don't call for fast tracks; the framesReady() could result in priority inversion
630bool AudioFlinger::PlaybackThread::Track::isReady() const {
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -0800631 if (mFillingUpStatus != FS_FILLING || isStopped() || isPausing()) {
632 return true;
633 }
634
Eric Laurent16498512014-03-17 17:22:08 -0700635 if (isStopping()) {
636 if (framesReady() > 0) {
637 mFillingUpStatus = FS_FILLED;
638 }
Eric Laurent81784c32012-11-19 14:55:58 -0800639 return true;
640 }
641
642 if (framesReady() >= mFrameCount ||
Glenn Kasten96f60d82013-07-12 10:21:18 -0700643 (mCblk->mFlags & CBLK_FORCEREADY)) {
Eric Laurent81784c32012-11-19 14:55:58 -0800644 mFillingUpStatus = FS_FILLED;
Glenn Kasten96f60d82013-07-12 10:21:18 -0700645 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -0800646 return true;
647 }
648 return false;
649}
650
Glenn Kasten0f11b512014-01-31 16:18:54 -0800651status_t AudioFlinger::PlaybackThread::Track::start(AudioSystem::sync_event_t event __unused,
652 int triggerSession __unused)
Eric Laurent81784c32012-11-19 14:55:58 -0800653{
654 status_t status = NO_ERROR;
655 ALOGV("start(%d), calling pid %d session %d",
656 mName, IPCThreadState::self()->getCallingPid(), mSessionId);
657
658 sp<ThreadBase> thread = mThread.promote();
659 if (thread != 0) {
Eric Laurent813e2a72013-08-31 12:59:48 -0700660 if (isOffloaded()) {
661 Mutex::Autolock _laf(thread->mAudioFlinger->mLock);
662 Mutex::Autolock _lth(thread->mLock);
663 sp<EffectChain> ec = thread->getEffectChain_l(mSessionId);
Eric Laurent5baf2af2013-09-12 17:37:00 -0700664 if (thread->mAudioFlinger->isNonOffloadableGlobalEffectEnabled_l() ||
665 (ec != 0 && ec->isNonOffloadableEnabled())) {
Eric Laurent813e2a72013-08-31 12:59:48 -0700666 invalidate();
667 return PERMISSION_DENIED;
668 }
669 }
670 Mutex::Autolock _lth(thread->mLock);
Eric Laurent81784c32012-11-19 14:55:58 -0800671 track_state state = mState;
672 // here the track could be either new, or restarted
673 // in both cases "unstop" the track
Eric Laurentbfb1b832013-01-07 09:53:42 -0800674
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -0800675 // initial state-stopping. next state-pausing.
676 // What if resume is called ?
677
678 if (state == PAUSED || state == PAUSING) {
Eric Laurentbfb1b832013-01-07 09:53:42 -0800679 if (mResumeToStopping) {
680 // happened we need to resume to STOPPING_1
681 mState = TrackBase::STOPPING_1;
682 ALOGV("PAUSED => STOPPING_1 (%d) on thread %p", mName, this);
683 } else {
684 mState = TrackBase::RESUMING;
685 ALOGV("PAUSED => RESUMING (%d) on thread %p", mName, this);
686 }
Eric Laurent81784c32012-11-19 14:55:58 -0800687 } else {
688 mState = TrackBase::ACTIVE;
689 ALOGV("? => ACTIVE (%d) on thread %p", mName, this);
690 }
691
Eric Laurentbfb1b832013-01-07 09:53:42 -0800692 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Haynes Mathew George240934b2015-03-11 18:25:50 -0700693 if (isFastTrack()) {
694 // refresh fast track underruns on start because that field is never cleared
695 // by the fast mixer; furthermore, the same track can be recycled, i.e. start
696 // after stop.
697 mObservedUnderruns = playbackThread->getFastTrackUnderruns(mFastIndex);
698 }
Eric Laurentbfb1b832013-01-07 09:53:42 -0800699 status = playbackThread->addTrack_l(this);
700 if (status == INVALID_OPERATION || status == PERMISSION_DENIED) {
Eric Laurent81784c32012-11-19 14:55:58 -0800701 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800702 // restore previous state if start was rejected by policy manager
703 if (status == PERMISSION_DENIED) {
704 mState = state;
705 }
706 }
707 // track was already in the active list, not a problem
708 if (status == ALREADY_EXISTS) {
709 status = NO_ERROR;
Glenn Kasten12022ff2013-10-17 11:32:39 -0700710 } else {
711 // Acknowledge any pending flush(), so that subsequent new data isn't discarded.
712 // It is usually unsafe to access the server proxy from a binder thread.
713 // But in this case we know the mixer thread (whether normal mixer or fast mixer)
714 // isn't looking at this track yet: we still hold the normal mixer thread lock,
715 // and for fast tracks the track is not yet in the fast mixer thread's active set.
716 ServerProxy::Buffer buffer;
717 buffer.mFrameCount = 1;
Glenn Kasten2e422c42013-10-18 13:00:29 -0700718 (void) mAudioTrackServerProxy->obtainBuffer(&buffer, true /*ackFlush*/);
Eric Laurent81784c32012-11-19 14:55:58 -0800719 }
720 } else {
721 status = BAD_VALUE;
722 }
723 return status;
724}
725
726void AudioFlinger::PlaybackThread::Track::stop()
727{
728 ALOGV("stop(%d), calling pid %d", mName, IPCThreadState::self()->getCallingPid());
729 sp<ThreadBase> thread = mThread.promote();
730 if (thread != 0) {
731 Mutex::Autolock _l(thread->mLock);
732 track_state state = mState;
733 if (state == RESUMING || state == ACTIVE || state == PAUSING || state == PAUSED) {
734 // If the track is not active (PAUSED and buffers full), flush buffers
735 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
736 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
737 reset();
738 mState = STOPPED;
Eric Laurentab5cdba2014-06-09 17:22:27 -0700739 } else if (!isFastTrack() && !isOffloaded() && !isDirect()) {
Eric Laurent81784c32012-11-19 14:55:58 -0800740 mState = STOPPED;
741 } else {
Eric Laurentbfb1b832013-01-07 09:53:42 -0800742 // For fast tracks prepareTracks_l() will set state to STOPPING_2
743 // presentation is complete
744 // For an offloaded track this starts a drain and state will
745 // move to STOPPING_2 when drain completes and then STOPPED
Eric Laurent81784c32012-11-19 14:55:58 -0800746 mState = STOPPING_1;
747 }
Eric Laurentb369caf2015-03-30 20:51:47 -0700748 playbackThread->broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800749 ALOGV("not stopping/stopped => stopping/stopped (%d) on thread %p", mName,
750 playbackThread);
751 }
Eric Laurent81784c32012-11-19 14:55:58 -0800752 }
753}
754
755void AudioFlinger::PlaybackThread::Track::pause()
756{
757 ALOGV("pause(%d), calling pid %d", mName, IPCThreadState::self()->getCallingPid());
758 sp<ThreadBase> thread = mThread.promote();
759 if (thread != 0) {
760 Mutex::Autolock _l(thread->mLock);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800761 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
762 switch (mState) {
763 case STOPPING_1:
764 case STOPPING_2:
765 if (!isOffloaded()) {
766 /* nothing to do if track is not offloaded */
767 break;
768 }
769
770 // Offloaded track was draining, we need to carry on draining when resumed
771 mResumeToStopping = true;
772 // fall through...
773 case ACTIVE:
774 case RESUMING:
Eric Laurent81784c32012-11-19 14:55:58 -0800775 mState = PAUSING;
776 ALOGV("ACTIVE/RESUMING => PAUSING (%d) on thread %p", mName, thread.get());
Eric Laurentede6c3b2013-09-19 14:37:46 -0700777 playbackThread->broadcast_l();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800778 break;
Eric Laurent81784c32012-11-19 14:55:58 -0800779
Eric Laurentbfb1b832013-01-07 09:53:42 -0800780 default:
781 break;
Eric Laurent81784c32012-11-19 14:55:58 -0800782 }
783 }
784}
785
786void AudioFlinger::PlaybackThread::Track::flush()
787{
788 ALOGV("flush(%d)", mName);
789 sp<ThreadBase> thread = mThread.promote();
790 if (thread != 0) {
791 Mutex::Autolock _l(thread->mLock);
Eric Laurent81784c32012-11-19 14:55:58 -0800792 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800793
794 if (isOffloaded()) {
795 // If offloaded we allow flush during any state except terminated
796 // and keep the track active to avoid problems if user is seeking
797 // rapidly and underlying hardware has a significant delay handling
798 // a pause
799 if (isTerminated()) {
800 return;
801 }
802
803 ALOGV("flush: offload flush");
Eric Laurent81784c32012-11-19 14:55:58 -0800804 reset();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800805
806 if (mState == STOPPING_1 || mState == STOPPING_2) {
807 ALOGV("flushed in STOPPING_1 or 2 state, change state to ACTIVE");
808 mState = ACTIVE;
809 }
810
811 if (mState == ACTIVE) {
812 ALOGV("flush called in active state, resetting buffer time out retry count");
813 mRetryCount = PlaybackThread::kMaxTrackRetriesOffload;
814 }
815
Haynes Mathew George7844f672014-01-15 12:32:55 -0800816 mFlushHwPending = true;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800817 mResumeToStopping = false;
818 } else {
819 if (mState != STOPPING_1 && mState != STOPPING_2 && mState != STOPPED &&
820 mState != PAUSED && mState != PAUSING && mState != IDLE && mState != FLUSHED) {
821 return;
822 }
823 // No point remaining in PAUSED state after a flush => go to
824 // FLUSHED state
825 mState = FLUSHED;
826 // do not reset the track if it is still in the process of being stopped or paused.
827 // this will be done by prepareTracks_l() when the track is stopped.
828 // prepareTracks_l() will see mState == FLUSHED, then
829 // remove from active track list, reset(), and trigger presentation complete
Eric Laurentd1f69b02014-12-15 14:33:13 -0800830 if (isDirect()) {
831 mFlushHwPending = true;
832 }
Eric Laurentbfb1b832013-01-07 09:53:42 -0800833 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
834 reset();
835 }
Eric Laurent81784c32012-11-19 14:55:58 -0800836 }
Eric Laurentbfb1b832013-01-07 09:53:42 -0800837 // Prevent flush being lost if the track is flushed and then resumed
838 // before mixer thread can run. This is important when offloading
839 // because the hardware buffer could hold a large amount of audio
Eric Laurentede6c3b2013-09-19 14:37:46 -0700840 playbackThread->broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800841 }
842}
843
Haynes Mathew George7844f672014-01-15 12:32:55 -0800844// must be called with thread lock held
845void AudioFlinger::PlaybackThread::Track::flushAck()
846{
Eric Laurentd1f69b02014-12-15 14:33:13 -0800847 if (!isOffloaded() && !isDirect())
Haynes Mathew George7844f672014-01-15 12:32:55 -0800848 return;
849
850 mFlushHwPending = false;
851}
852
Eric Laurent81784c32012-11-19 14:55:58 -0800853void AudioFlinger::PlaybackThread::Track::reset()
854{
855 // Do not reset twice to avoid discarding data written just after a flush and before
856 // the audioflinger thread detects the track is stopped.
857 if (!mResetDone) {
Eric Laurent81784c32012-11-19 14:55:58 -0800858 // Force underrun condition to avoid false underrun callback until first data is
859 // written to buffer
Glenn Kasten96f60d82013-07-12 10:21:18 -0700860 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -0800861 mFillingUpStatus = FS_FILLING;
862 mResetDone = true;
863 if (mState == FLUSHED) {
864 mState = IDLE;
865 }
Phil Burk6140c792015-03-19 14:30:21 -0700866 mPreviousTimestampValid = false;
Eric Laurent81784c32012-11-19 14:55:58 -0800867 }
868}
869
Eric Laurentbfb1b832013-01-07 09:53:42 -0800870status_t AudioFlinger::PlaybackThread::Track::setParameters(const String8& keyValuePairs)
871{
872 sp<ThreadBase> thread = mThread.promote();
873 if (thread == 0) {
874 ALOGE("thread is dead");
875 return FAILED_TRANSACTION;
876 } else if ((thread->type() == ThreadBase::DIRECT) ||
877 (thread->type() == ThreadBase::OFFLOAD)) {
878 return thread->setParameters(keyValuePairs);
879 } else {
880 return PERMISSION_DENIED;
881 }
882}
883
Glenn Kasten573d80a2013-08-26 09:36:23 -0700884status_t AudioFlinger::PlaybackThread::Track::getTimestamp(AudioTimestamp& timestamp)
885{
Glenn Kastenfe346c72013-08-30 13:28:22 -0700886 // Client should implement this using SSQ; the unpresented frame count in latch is irrelevant
887 if (isFastTrack()) {
Phil Burk6140c792015-03-19 14:30:21 -0700888 // FIXME no lock held to set mPreviousTimestampValid = false
Glenn Kastenfe346c72013-08-30 13:28:22 -0700889 return INVALID_OPERATION;
890 }
Glenn Kasten573d80a2013-08-26 09:36:23 -0700891 sp<ThreadBase> thread = mThread.promote();
892 if (thread == 0) {
Phil Burk6140c792015-03-19 14:30:21 -0700893 // FIXME no lock held to set mPreviousTimestampValid = false
Glenn Kastenfe346c72013-08-30 13:28:22 -0700894 return INVALID_OPERATION;
Glenn Kasten573d80a2013-08-26 09:36:23 -0700895 }
Phil Burk6140c792015-03-19 14:30:21 -0700896
Glenn Kasten573d80a2013-08-26 09:36:23 -0700897 Mutex::Autolock _l(thread->mLock);
898 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Phil Burk6140c792015-03-19 14:30:21 -0700899
900 status_t result = INVALID_OPERATION;
Eric Laurentab5cdba2014-06-09 17:22:27 -0700901 if (!isOffloaded() && !isDirect()) {
Eric Laurentaccc1472013-09-20 09:36:34 -0700902 if (!playbackThread->mLatchQValid) {
Phil Burk6140c792015-03-19 14:30:21 -0700903 mPreviousTimestampValid = false;
Eric Laurentaccc1472013-09-20 09:36:34 -0700904 return INVALID_OPERATION;
905 }
906 uint32_t unpresentedFrames =
907 ((int64_t) playbackThread->mLatchQ.mUnpresentedFrames * mSampleRate) /
908 playbackThread->mSampleRate;
Glenn Kasten4c053ea2014-09-28 14:41:07 -0700909 // FIXME Since we're using a raw pointer as the key, it is theoretically possible
910 // for a brand new track to share the same address as a recently destroyed
911 // track, and thus for us to get the frames released of the wrong track.
912 // It is unlikely that we would be able to call getTimestamp() so quickly
913 // right after creating a new track. Nevertheless, the index here should
914 // be changed to something that is unique. Or use a completely different strategy.
915 ssize_t i = playbackThread->mLatchQ.mFramesReleased.indexOfKey(this);
916 uint32_t framesWritten = i >= 0 ?
917 playbackThread->mLatchQ.mFramesReleased[i] :
918 mAudioTrackServerProxy->framesReleased();
Eric Laurentaccc1472013-09-20 09:36:34 -0700919 if (framesWritten < unpresentedFrames) {
Phil Burk6140c792015-03-19 14:30:21 -0700920 mPreviousTimestampValid = false;
921 // return invalid result
922 } else {
923 timestamp.mPosition = framesWritten - unpresentedFrames;
924 timestamp.mTime = playbackThread->mLatchQ.mTimestamp.mTime;
925 result = NO_ERROR;
Eric Laurentaccc1472013-09-20 09:36:34 -0700926 }
Phil Burk6140c792015-03-19 14:30:21 -0700927 } else { // offloaded or direct
928 result = playbackThread->getTimestamp_l(timestamp);
Glenn Kastenbd096fd2013-08-23 13:53:56 -0700929 }
Eric Laurentaccc1472013-09-20 09:36:34 -0700930
Phil Burk6140c792015-03-19 14:30:21 -0700931 // Prevent retrograde motion in timestamp.
932 if (result == NO_ERROR) {
933 if (mPreviousTimestampValid) {
934 if (timestamp.mTime.tv_sec < mPreviousTimestamp.mTime.tv_sec ||
935 (timestamp.mTime.tv_sec == mPreviousTimestamp.mTime.tv_sec &&
936 timestamp.mTime.tv_nsec < mPreviousTimestamp.mTime.tv_nsec)) {
937 ALOGW("WARNING - retrograde timestamp time");
938 // FIXME Consider blocking this from propagating upwards.
939 }
940
941 // Looking at signed delta will work even when the timestamps
942 // are wrapping around.
943 int32_t deltaPosition = static_cast<int32_t>(timestamp.mPosition
944 - mPreviousTimestamp.mPosition);
945 // position can bobble slightly as an artifact; this hides the bobble
946 static const int32_t MINIMUM_POSITION_DELTA = 8;
947 if (deltaPosition < 0) {
948#define TIME_TO_NANOS(time) ((uint64_t)time.tv_sec * 1000000000 + time.tv_nsec)
949 ALOGW("WARNING - retrograde timestamp position corrected,"
950 " %d = %u - %u, (at %llu, %llu nanos)",
951 deltaPosition,
952 timestamp.mPosition,
953 mPreviousTimestamp.mPosition,
954 TIME_TO_NANOS(timestamp.mTime),
955 TIME_TO_NANOS(mPreviousTimestamp.mTime));
956#undef TIME_TO_NANOS
957 }
958 if (deltaPosition < MINIMUM_POSITION_DELTA) {
959 // Current timestamp is bad. Use last valid timestamp.
960 timestamp = mPreviousTimestamp;
961 }
962 }
963 mPreviousTimestamp = timestamp;
964 mPreviousTimestampValid = true;
965 }
966 return result;
Glenn Kasten573d80a2013-08-26 09:36:23 -0700967}
968
Eric Laurent81784c32012-11-19 14:55:58 -0800969status_t AudioFlinger::PlaybackThread::Track::attachAuxEffect(int EffectId)
970{
971 status_t status = DEAD_OBJECT;
972 sp<ThreadBase> thread = mThread.promote();
973 if (thread != 0) {
974 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
975 sp<AudioFlinger> af = mClient->audioFlinger();
976
977 Mutex::Autolock _l(af->mLock);
978
979 sp<PlaybackThread> srcThread = af->getEffectThread_l(AUDIO_SESSION_OUTPUT_MIX, EffectId);
980
981 if (EffectId != 0 && srcThread != 0 && playbackThread != srcThread.get()) {
982 Mutex::Autolock _dl(playbackThread->mLock);
983 Mutex::Autolock _sl(srcThread->mLock);
984 sp<EffectChain> chain = srcThread->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
985 if (chain == 0) {
986 return INVALID_OPERATION;
987 }
988
989 sp<EffectModule> effect = chain->getEffectFromId_l(EffectId);
990 if (effect == 0) {
991 return INVALID_OPERATION;
992 }
993 srcThread->removeEffect_l(effect);
Eric Laurent5baf2af2013-09-12 17:37:00 -0700994 status = playbackThread->addEffect_l(effect);
995 if (status != NO_ERROR) {
996 srcThread->addEffect_l(effect);
997 return INVALID_OPERATION;
998 }
Eric Laurent81784c32012-11-19 14:55:58 -0800999 // removeEffect_l() has stopped the effect if it was active so it must be restarted
1000 if (effect->state() == EffectModule::ACTIVE ||
1001 effect->state() == EffectModule::STOPPING) {
1002 effect->start();
1003 }
1004
1005 sp<EffectChain> dstChain = effect->chain().promote();
1006 if (dstChain == 0) {
1007 srcThread->addEffect_l(effect);
1008 return INVALID_OPERATION;
1009 }
1010 AudioSystem::unregisterEffect(effect->id());
1011 AudioSystem::registerEffect(&effect->desc(),
1012 srcThread->id(),
1013 dstChain->strategy(),
1014 AUDIO_SESSION_OUTPUT_MIX,
1015 effect->id());
Eric Laurentd72b7c02013-10-12 16:17:46 -07001016 AudioSystem::setEffectEnabled(effect->id(), effect->isEnabled());
Eric Laurent81784c32012-11-19 14:55:58 -08001017 }
1018 status = playbackThread->attachAuxEffect(this, EffectId);
1019 }
1020 return status;
1021}
1022
1023void AudioFlinger::PlaybackThread::Track::setAuxBuffer(int EffectId, int32_t *buffer)
1024{
1025 mAuxEffectId = EffectId;
1026 mAuxBuffer = buffer;
1027}
1028
1029bool AudioFlinger::PlaybackThread::Track::presentationComplete(size_t framesWritten,
1030 size_t audioHalFrames)
1031{
1032 // a track is considered presented when the total number of frames written to audio HAL
1033 // corresponds to the number of frames written when presentationComplete() is called for the
1034 // first time (mPresentationCompleteFrames == 0) plus the buffer filling status at that time.
Eric Laurentbfb1b832013-01-07 09:53:42 -08001035 // For an offloaded track the HAL+h/w delay is variable so a HAL drain() is used
1036 // to detect when all frames have been played. In this case framesWritten isn't
1037 // useful because it doesn't always reflect whether there is data in the h/w
1038 // buffers, particularly if a track has been paused and resumed during draining
1039 ALOGV("presentationComplete() mPresentationCompleteFrames %d framesWritten %d",
1040 mPresentationCompleteFrames, framesWritten);
Eric Laurent81784c32012-11-19 14:55:58 -08001041 if (mPresentationCompleteFrames == 0) {
1042 mPresentationCompleteFrames = framesWritten + audioHalFrames;
1043 ALOGV("presentationComplete() reset: mPresentationCompleteFrames %d audioHalFrames %d",
1044 mPresentationCompleteFrames, audioHalFrames);
1045 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001046
1047 if (framesWritten >= mPresentationCompleteFrames || isOffloaded()) {
Eric Laurent81784c32012-11-19 14:55:58 -08001048 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001049 mAudioTrackServerProxy->setStreamEndDone();
Eric Laurent81784c32012-11-19 14:55:58 -08001050 return true;
1051 }
1052 return false;
1053}
1054
1055void AudioFlinger::PlaybackThread::Track::triggerEvents(AudioSystem::sync_event_t type)
1056{
Mark Salyzyn3ab368e2014-04-15 14:55:53 -07001057 for (size_t i = 0; i < mSyncEvents.size(); i++) {
Eric Laurent81784c32012-11-19 14:55:58 -08001058 if (mSyncEvents[i]->type() == type) {
1059 mSyncEvents[i]->trigger();
1060 mSyncEvents.removeAt(i);
1061 i--;
1062 }
1063 }
1064}
1065
1066// implement VolumeBufferProvider interface
1067
Glenn Kastenc56f3422014-03-21 17:53:17 -07001068gain_minifloat_packed_t AudioFlinger::PlaybackThread::Track::getVolumeLR()
Eric Laurent81784c32012-11-19 14:55:58 -08001069{
1070 // called by FastMixer, so not allowed to take any locks, block, or do I/O including logs
1071 ALOG_ASSERT(isFastTrack() && (mCblk != NULL));
Glenn Kastenc56f3422014-03-21 17:53:17 -07001072 gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR();
1073 float vl = float_from_gain(gain_minifloat_unpack_left(vlr));
1074 float vr = float_from_gain(gain_minifloat_unpack_right(vlr));
Eric Laurent81784c32012-11-19 14:55:58 -08001075 // track volumes come from shared memory, so can't be trusted and must be clamped
Glenn Kastenc56f3422014-03-21 17:53:17 -07001076 if (vl > GAIN_FLOAT_UNITY) {
1077 vl = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08001078 }
Glenn Kastenc56f3422014-03-21 17:53:17 -07001079 if (vr > GAIN_FLOAT_UNITY) {
1080 vr = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08001081 }
1082 // now apply the cached master volume and stream type volume;
1083 // this is trusted but lacks any synchronization or barrier so may be stale
1084 float v = mCachedVolume;
1085 vl *= v;
1086 vr *= v;
Glenn Kastenc56f3422014-03-21 17:53:17 -07001087 // re-combine into packed minifloat
1088 vlr = gain_minifloat_pack(gain_from_float(vl), gain_from_float(vr));
Eric Laurent81784c32012-11-19 14:55:58 -08001089 // FIXME look at mute, pause, and stop flags
1090 return vlr;
1091}
1092
1093status_t AudioFlinger::PlaybackThread::Track::setSyncEvent(const sp<SyncEvent>& event)
1094{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001095 if (isTerminated() || mState == PAUSED ||
Eric Laurent81784c32012-11-19 14:55:58 -08001096 ((framesReady() == 0) && ((mSharedBuffer != 0) ||
1097 (mState == STOPPED)))) {
1098 ALOGW("Track::setSyncEvent() in invalid state %d on session %d %s mode, framesReady %d ",
1099 mState, mSessionId, (mSharedBuffer != 0) ? "static" : "stream", framesReady());
1100 event->cancel();
1101 return INVALID_OPERATION;
1102 }
1103 (void) TrackBase::setSyncEvent(event);
1104 return NO_ERROR;
1105}
1106
Glenn Kasten5736c352012-12-04 12:12:34 -08001107void AudioFlinger::PlaybackThread::Track::invalidate()
1108{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001109 // FIXME should use proxy, and needs work
1110 audio_track_cblk_t* cblk = mCblk;
Glenn Kasten96f60d82013-07-12 10:21:18 -07001111 android_atomic_or(CBLK_INVALID, &cblk->mFlags);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001112 android_atomic_release_store(0x40000000, &cblk->mFutex);
1113 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE
Elliott Hughesee499292014-05-21 17:55:51 -07001114 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX);
Glenn Kasten5736c352012-12-04 12:12:34 -08001115 mIsInvalid = true;
1116}
1117
Eric Laurent59fe0102013-09-27 18:48:26 -07001118void AudioFlinger::PlaybackThread::Track::signal()
1119{
1120 sp<ThreadBase> thread = mThread.promote();
1121 if (thread != 0) {
1122 PlaybackThread *t = (PlaybackThread *)thread.get();
1123 Mutex::Autolock _l(t->mLock);
1124 t->broadcast_l();
1125 }
1126}
1127
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001128//To be called with thread lock held
1129bool AudioFlinger::PlaybackThread::Track::isResumePending() {
1130
1131 if (mState == RESUMING)
1132 return true;
1133 /* Resume is pending if track was stopping before pause was called */
1134 if (mState == STOPPING_1 &&
1135 mResumeToStopping)
1136 return true;
1137
1138 return false;
1139}
1140
1141//To be called with thread lock held
1142void AudioFlinger::PlaybackThread::Track::resumeAck() {
1143
1144
1145 if (mState == RESUMING)
1146 mState = ACTIVE;
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08001147
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001148 // Other possibility of pending resume is stopping_1 state
1149 // Do not update the state from stopping as this prevents
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08001150 // drain being called.
1151 if (mState == STOPPING_1) {
1152 mResumeToStopping = false;
1153 }
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001154}
Eric Laurent81784c32012-11-19 14:55:58 -08001155// ----------------------------------------------------------------------------
1156
1157sp<AudioFlinger::PlaybackThread::TimedTrack>
1158AudioFlinger::PlaybackThread::TimedTrack::create(
1159 PlaybackThread *thread,
1160 const sp<Client>& client,
1161 audio_stream_type_t streamType,
1162 uint32_t sampleRate,
1163 audio_format_t format,
1164 audio_channel_mask_t channelMask,
1165 size_t frameCount,
1166 const sp<IMemory>& sharedBuffer,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001167 int sessionId,
Glenn Kasten4944acb2013-08-19 08:39:20 -07001168 int uid)
1169{
Eric Laurent81784c32012-11-19 14:55:58 -08001170 if (!client->reserveTimedTrack())
1171 return 0;
1172
1173 return new TimedTrack(
1174 thread, client, streamType, sampleRate, format, channelMask, frameCount,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001175 sharedBuffer, sessionId, uid);
Eric Laurent81784c32012-11-19 14:55:58 -08001176}
1177
1178AudioFlinger::PlaybackThread::TimedTrack::TimedTrack(
1179 PlaybackThread *thread,
1180 const sp<Client>& client,
1181 audio_stream_type_t streamType,
1182 uint32_t sampleRate,
1183 audio_format_t format,
1184 audio_channel_mask_t channelMask,
1185 size_t frameCount,
1186 const sp<IMemory>& sharedBuffer,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001187 int sessionId,
1188 int uid)
Eric Laurent81784c32012-11-19 14:55:58 -08001189 : Track(thread, client, streamType, sampleRate, format, channelMask,
Eric Laurent83b88082014-06-20 18:31:16 -07001190 frameCount, (sharedBuffer != 0) ? sharedBuffer->pointer() : NULL, sharedBuffer,
1191 sessionId, uid, IAudioFlinger::TRACK_TIMED, TYPE_TIMED),
Eric Laurent81784c32012-11-19 14:55:58 -08001192 mQueueHeadInFlight(false),
1193 mTrimQueueHeadOnRelease(false),
1194 mFramesPendingInQueue(0),
1195 mTimedSilenceBuffer(NULL),
1196 mTimedSilenceBufferSize(0),
1197 mTimedAudioOutputOnTime(false),
1198 mMediaTimeTransformValid(false)
1199{
1200 LocalClock lc;
1201 mLocalTimeFreq = lc.getLocalFreq();
1202
1203 mLocalTimeToSampleTransform.a_zero = 0;
1204 mLocalTimeToSampleTransform.b_zero = 0;
1205 mLocalTimeToSampleTransform.a_to_b_numer = sampleRate;
1206 mLocalTimeToSampleTransform.a_to_b_denom = mLocalTimeFreq;
1207 LinearTransform::reduce(&mLocalTimeToSampleTransform.a_to_b_numer,
1208 &mLocalTimeToSampleTransform.a_to_b_denom);
1209
1210 mMediaTimeToSampleTransform.a_zero = 0;
1211 mMediaTimeToSampleTransform.b_zero = 0;
1212 mMediaTimeToSampleTransform.a_to_b_numer = sampleRate;
1213 mMediaTimeToSampleTransform.a_to_b_denom = 1000000;
1214 LinearTransform::reduce(&mMediaTimeToSampleTransform.a_to_b_numer,
1215 &mMediaTimeToSampleTransform.a_to_b_denom);
1216}
1217
1218AudioFlinger::PlaybackThread::TimedTrack::~TimedTrack() {
1219 mClient->releaseTimedTrack();
1220 delete [] mTimedSilenceBuffer;
1221}
1222
1223status_t AudioFlinger::PlaybackThread::TimedTrack::allocateTimedBuffer(
1224 size_t size, sp<IMemory>* buffer) {
1225
1226 Mutex::Autolock _l(mTimedBufferQueueLock);
1227
1228 trimTimedBufferQueue_l();
1229
1230 // lazily initialize the shared memory heap for timed buffers
1231 if (mTimedMemoryDealer == NULL) {
1232 const int kTimedBufferHeapSize = 512 << 10;
1233
1234 mTimedMemoryDealer = new MemoryDealer(kTimedBufferHeapSize,
1235 "AudioFlingerTimed");
Glenn Kasten6e2ebe92013-08-13 09:14:51 -07001236 if (mTimedMemoryDealer == NULL) {
Eric Laurent81784c32012-11-19 14:55:58 -08001237 return NO_MEMORY;
Glenn Kasten6e2ebe92013-08-13 09:14:51 -07001238 }
Eric Laurent81784c32012-11-19 14:55:58 -08001239 }
1240
1241 sp<IMemory> newBuffer = mTimedMemoryDealer->allocate(size);
Glenn Kasten663c2242013-09-24 11:52:37 -07001242 if (newBuffer == 0 || newBuffer->pointer() == NULL) {
Glenn Kasten30ff92c2013-11-20 11:57:08 -08001243 return NO_MEMORY;
Eric Laurent81784c32012-11-19 14:55:58 -08001244 }
1245
1246 *buffer = newBuffer;
1247 return NO_ERROR;
1248}
1249
1250// caller must hold mTimedBufferQueueLock
1251void AudioFlinger::PlaybackThread::TimedTrack::trimTimedBufferQueue_l() {
1252 int64_t mediaTimeNow;
1253 {
1254 Mutex::Autolock mttLock(mMediaTimeTransformLock);
1255 if (!mMediaTimeTransformValid)
1256 return;
1257
1258 int64_t targetTimeNow;
1259 status_t res = (mMediaTimeTransformTarget == TimedAudioTrack::COMMON_TIME)
1260 ? mCCHelper.getCommonTime(&targetTimeNow)
1261 : mCCHelper.getLocalTime(&targetTimeNow);
1262
1263 if (OK != res)
1264 return;
1265
1266 if (!mMediaTimeTransform.doReverseTransform(targetTimeNow,
1267 &mediaTimeNow)) {
1268 return;
1269 }
1270 }
1271
1272 size_t trimEnd;
1273 for (trimEnd = 0; trimEnd < mTimedBufferQueue.size(); trimEnd++) {
1274 int64_t bufEnd;
1275
1276 if ((trimEnd + 1) < mTimedBufferQueue.size()) {
1277 // We have a next buffer. Just use its PTS as the PTS of the frame
1278 // following the last frame in this buffer. If the stream is sparse
1279 // (ie, there are deliberate gaps left in the stream which should be
1280 // filled with silence by the TimedAudioTrack), then this can result
1281 // in one extra buffer being left un-trimmed when it could have
1282 // been. In general, this is not typical, and we would rather
1283 // optimized away the TS calculation below for the more common case
1284 // where PTSes are contiguous.
1285 bufEnd = mTimedBufferQueue[trimEnd + 1].pts();
1286 } else {
1287 // We have no next buffer. Compute the PTS of the frame following
1288 // the last frame in this buffer by computing the duration of of
1289 // this frame in media time units and adding it to the PTS of the
1290 // buffer.
1291 int64_t frameCount = mTimedBufferQueue[trimEnd].buffer()->size()
1292 / mFrameSize;
1293
1294 if (!mMediaTimeToSampleTransform.doReverseTransform(frameCount,
1295 &bufEnd)) {
1296 ALOGE("Failed to convert frame count of %lld to media time"
1297 " duration" " (scale factor %d/%u) in %s",
1298 frameCount,
1299 mMediaTimeToSampleTransform.a_to_b_numer,
1300 mMediaTimeToSampleTransform.a_to_b_denom,
1301 __PRETTY_FUNCTION__);
1302 break;
1303 }
1304 bufEnd += mTimedBufferQueue[trimEnd].pts();
1305 }
1306
1307 if (bufEnd > mediaTimeNow)
1308 break;
1309
1310 // Is the buffer we want to use in the middle of a mix operation right
1311 // now? If so, don't actually trim it. Just wait for the releaseBuffer
1312 // from the mixer which should be coming back shortly.
1313 if (!trimEnd && mQueueHeadInFlight) {
1314 mTrimQueueHeadOnRelease = true;
1315 }
1316 }
1317
1318 size_t trimStart = mTrimQueueHeadOnRelease ? 1 : 0;
1319 if (trimStart < trimEnd) {
1320 // Update the bookkeeping for framesReady()
1321 for (size_t i = trimStart; i < trimEnd; ++i) {
1322 updateFramesPendingAfterTrim_l(mTimedBufferQueue[i], "trim");
1323 }
1324
1325 // Now actually remove the buffers from the queue.
1326 mTimedBufferQueue.removeItemsAt(trimStart, trimEnd);
1327 }
1328}
1329
1330void AudioFlinger::PlaybackThread::TimedTrack::trimTimedBufferQueueHead_l(
1331 const char* logTag) {
1332 ALOG_ASSERT(mTimedBufferQueue.size() > 0,
1333 "%s called (reason \"%s\"), but timed buffer queue has no"
1334 " elements to trim.", __FUNCTION__, logTag);
1335
1336 updateFramesPendingAfterTrim_l(mTimedBufferQueue[0], logTag);
1337 mTimedBufferQueue.removeAt(0);
1338}
1339
1340void AudioFlinger::PlaybackThread::TimedTrack::updateFramesPendingAfterTrim_l(
1341 const TimedBuffer& buf,
Glenn Kasten0f11b512014-01-31 16:18:54 -08001342 const char* logTag __unused) {
Eric Laurent81784c32012-11-19 14:55:58 -08001343 uint32_t bufBytes = buf.buffer()->size();
1344 uint32_t consumedAlready = buf.position();
1345
1346 ALOG_ASSERT(consumedAlready <= bufBytes,
1347 "Bad bookkeeping while updating frames pending. Timed buffer is"
1348 " only %u bytes long, but claims to have consumed %u"
1349 " bytes. (update reason: \"%s\")",
1350 bufBytes, consumedAlready, logTag);
1351
1352 uint32_t bufFrames = (bufBytes - consumedAlready) / mFrameSize;
1353 ALOG_ASSERT(mFramesPendingInQueue >= bufFrames,
1354 "Bad bookkeeping while updating frames pending. Should have at"
1355 " least %u queued frames, but we think we have only %u. (update"
1356 " reason: \"%s\")",
1357 bufFrames, mFramesPendingInQueue, logTag);
1358
1359 mFramesPendingInQueue -= bufFrames;
1360}
1361
1362status_t AudioFlinger::PlaybackThread::TimedTrack::queueTimedBuffer(
1363 const sp<IMemory>& buffer, int64_t pts) {
1364
1365 {
1366 Mutex::Autolock mttLock(mMediaTimeTransformLock);
1367 if (!mMediaTimeTransformValid)
1368 return INVALID_OPERATION;
1369 }
1370
1371 Mutex::Autolock _l(mTimedBufferQueueLock);
1372
1373 uint32_t bufFrames = buffer->size() / mFrameSize;
1374 mFramesPendingInQueue += bufFrames;
1375 mTimedBufferQueue.add(TimedBuffer(buffer, pts));
1376
1377 return NO_ERROR;
1378}
1379
1380status_t AudioFlinger::PlaybackThread::TimedTrack::setMediaTimeTransform(
1381 const LinearTransform& xform, TimedAudioTrack::TargetTimeline target) {
1382
1383 ALOGVV("setMediaTimeTransform az=%lld bz=%lld n=%d d=%u tgt=%d",
1384 xform.a_zero, xform.b_zero, xform.a_to_b_numer, xform.a_to_b_denom,
1385 target);
1386
1387 if (!(target == TimedAudioTrack::LOCAL_TIME ||
1388 target == TimedAudioTrack::COMMON_TIME)) {
1389 return BAD_VALUE;
1390 }
1391
1392 Mutex::Autolock lock(mMediaTimeTransformLock);
1393 mMediaTimeTransform = xform;
1394 mMediaTimeTransformTarget = target;
1395 mMediaTimeTransformValid = true;
1396
1397 return NO_ERROR;
1398}
1399
1400#define min(a, b) ((a) < (b) ? (a) : (b))
1401
1402// implementation of getNextBuffer for tracks whose buffers have timestamps
1403status_t AudioFlinger::PlaybackThread::TimedTrack::getNextBuffer(
1404 AudioBufferProvider::Buffer* buffer, int64_t pts)
1405{
1406 if (pts == AudioBufferProvider::kInvalidPTS) {
1407 buffer->raw = NULL;
1408 buffer->frameCount = 0;
1409 mTimedAudioOutputOnTime = false;
1410 return INVALID_OPERATION;
1411 }
1412
1413 Mutex::Autolock _l(mTimedBufferQueueLock);
1414
1415 ALOG_ASSERT(!mQueueHeadInFlight,
1416 "getNextBuffer called without releaseBuffer!");
1417
1418 while (true) {
1419
1420 // if we have no timed buffers, then fail
1421 if (mTimedBufferQueue.isEmpty()) {
1422 buffer->raw = NULL;
1423 buffer->frameCount = 0;
1424 return NOT_ENOUGH_DATA;
1425 }
1426
1427 TimedBuffer& head = mTimedBufferQueue.editItemAt(0);
1428
1429 // calculate the PTS of the head of the timed buffer queue expressed in
1430 // local time
1431 int64_t headLocalPTS;
1432 {
1433 Mutex::Autolock mttLock(mMediaTimeTransformLock);
1434
1435 ALOG_ASSERT(mMediaTimeTransformValid, "media time transform invalid");
1436
1437 if (mMediaTimeTransform.a_to_b_denom == 0) {
1438 // the transform represents a pause, so yield silence
1439 timedYieldSilence_l(buffer->frameCount, buffer);
1440 return NO_ERROR;
1441 }
1442
1443 int64_t transformedPTS;
1444 if (!mMediaTimeTransform.doForwardTransform(head.pts(),
1445 &transformedPTS)) {
1446 // the transform failed. this shouldn't happen, but if it does
1447 // then just drop this buffer
1448 ALOGW("timedGetNextBuffer transform failed");
1449 buffer->raw = NULL;
1450 buffer->frameCount = 0;
1451 trimTimedBufferQueueHead_l("getNextBuffer; no transform");
1452 return NO_ERROR;
1453 }
1454
1455 if (mMediaTimeTransformTarget == TimedAudioTrack::COMMON_TIME) {
1456 if (OK != mCCHelper.commonTimeToLocalTime(transformedPTS,
1457 &headLocalPTS)) {
1458 buffer->raw = NULL;
1459 buffer->frameCount = 0;
1460 return INVALID_OPERATION;
1461 }
1462 } else {
1463 headLocalPTS = transformedPTS;
1464 }
1465 }
1466
Glenn Kasten9fdcb0a2013-06-26 16:11:36 -07001467 uint32_t sr = sampleRate();
1468
Eric Laurent81784c32012-11-19 14:55:58 -08001469 // adjust the head buffer's PTS to reflect the portion of the head buffer
1470 // that has already been consumed
1471 int64_t effectivePTS = headLocalPTS +
Glenn Kasten9fdcb0a2013-06-26 16:11:36 -07001472 ((head.position() / mFrameSize) * mLocalTimeFreq / sr);
Eric Laurent81784c32012-11-19 14:55:58 -08001473
1474 // Calculate the delta in samples between the head of the input buffer
1475 // queue and the start of the next output buffer that will be written.
1476 // If the transformation fails because of over or underflow, it means
1477 // that the sample's position in the output stream is so far out of
1478 // whack that it should just be dropped.
1479 int64_t sampleDelta;
1480 if (llabs(effectivePTS - pts) >= (static_cast<int64_t>(1) << 31)) {
1481 ALOGV("*** head buffer is too far from PTS: dropped buffer");
1482 trimTimedBufferQueueHead_l("getNextBuffer, buf pts too far from"
1483 " mix");
1484 continue;
1485 }
1486 if (!mLocalTimeToSampleTransform.doForwardTransform(
1487 (effectivePTS - pts) << 32, &sampleDelta)) {
1488 ALOGV("*** too late during sample rate transform: dropped buffer");
1489 trimTimedBufferQueueHead_l("getNextBuffer, bad local to sample");
1490 continue;
1491 }
1492
1493 ALOGVV("*** getNextBuffer head.pts=%lld head.pos=%d pts=%lld"
1494 " sampleDelta=[%d.%08x]",
1495 head.pts(), head.position(), pts,
1496 static_cast<int32_t>((sampleDelta >= 0 ? 0 : 1)
1497 + (sampleDelta >> 32)),
1498 static_cast<uint32_t>(sampleDelta & 0xFFFFFFFF));
1499
1500 // if the delta between the ideal placement for the next input sample and
1501 // the current output position is within this threshold, then we will
1502 // concatenate the next input samples to the previous output
1503 const int64_t kSampleContinuityThreshold =
Glenn Kasten9fdcb0a2013-06-26 16:11:36 -07001504 (static_cast<int64_t>(sr) << 32) / 250;
Eric Laurent81784c32012-11-19 14:55:58 -08001505
1506 // if this is the first buffer of audio that we're emitting from this track
1507 // then it should be almost exactly on time.
1508 const int64_t kSampleStartupThreshold = 1LL << 32;
1509
1510 if ((mTimedAudioOutputOnTime && llabs(sampleDelta) <= kSampleContinuityThreshold) ||
1511 (!mTimedAudioOutputOnTime && llabs(sampleDelta) <= kSampleStartupThreshold)) {
1512 // the next input is close enough to being on time, so concatenate it
1513 // with the last output
1514 timedYieldSamples_l(buffer);
1515
1516 ALOGVV("*** on time: head.pos=%d frameCount=%u",
1517 head.position(), buffer->frameCount);
1518 return NO_ERROR;
1519 }
1520
1521 // Looks like our output is not on time. Reset our on timed status.
1522 // Next time we mix samples from our input queue, then should be within
1523 // the StartupThreshold.
1524 mTimedAudioOutputOnTime = false;
1525 if (sampleDelta > 0) {
1526 // the gap between the current output position and the proper start of
1527 // the next input sample is too big, so fill it with silence
1528 uint32_t framesUntilNextInput = (sampleDelta + 0x80000000) >> 32;
1529
1530 timedYieldSilence_l(framesUntilNextInput, buffer);
1531 ALOGV("*** silence: frameCount=%u", buffer->frameCount);
1532 return NO_ERROR;
1533 } else {
1534 // the next input sample is late
1535 uint32_t lateFrames = static_cast<uint32_t>(-((sampleDelta + 0x80000000) >> 32));
1536 size_t onTimeSamplePosition =
1537 head.position() + lateFrames * mFrameSize;
1538
1539 if (onTimeSamplePosition > head.buffer()->size()) {
1540 // all the remaining samples in the head are too late, so
1541 // drop it and move on
1542 ALOGV("*** too late: dropped buffer");
1543 trimTimedBufferQueueHead_l("getNextBuffer, dropped late buffer");
1544 continue;
1545 } else {
1546 // skip over the late samples
1547 head.setPosition(onTimeSamplePosition);
1548
1549 // yield the available samples
1550 timedYieldSamples_l(buffer);
1551
1552 ALOGV("*** late: head.pos=%d frameCount=%u", head.position(), buffer->frameCount);
1553 return NO_ERROR;
1554 }
1555 }
1556 }
1557}
1558
1559// Yield samples from the timed buffer queue head up to the given output
1560// buffer's capacity.
1561//
1562// Caller must hold mTimedBufferQueueLock
1563void AudioFlinger::PlaybackThread::TimedTrack::timedYieldSamples_l(
1564 AudioBufferProvider::Buffer* buffer) {
1565
1566 const TimedBuffer& head = mTimedBufferQueue[0];
1567
1568 buffer->raw = (static_cast<uint8_t*>(head.buffer()->pointer()) +
1569 head.position());
1570
1571 uint32_t framesLeftInHead = ((head.buffer()->size() - head.position()) /
1572 mFrameSize);
1573 size_t framesRequested = buffer->frameCount;
1574 buffer->frameCount = min(framesLeftInHead, framesRequested);
1575
1576 mQueueHeadInFlight = true;
1577 mTimedAudioOutputOnTime = true;
1578}
1579
1580// Yield samples of silence up to the given output buffer's capacity
1581//
1582// Caller must hold mTimedBufferQueueLock
1583void AudioFlinger::PlaybackThread::TimedTrack::timedYieldSilence_l(
1584 uint32_t numFrames, AudioBufferProvider::Buffer* buffer) {
1585
1586 // lazily allocate a buffer filled with silence
1587 if (mTimedSilenceBufferSize < numFrames * mFrameSize) {
1588 delete [] mTimedSilenceBuffer;
1589 mTimedSilenceBufferSize = numFrames * mFrameSize;
1590 mTimedSilenceBuffer = new uint8_t[mTimedSilenceBufferSize];
1591 memset(mTimedSilenceBuffer, 0, mTimedSilenceBufferSize);
1592 }
1593
1594 buffer->raw = mTimedSilenceBuffer;
1595 size_t framesRequested = buffer->frameCount;
1596 buffer->frameCount = min(numFrames, framesRequested);
1597
1598 mTimedAudioOutputOnTime = false;
1599}
1600
1601// AudioBufferProvider interface
1602void AudioFlinger::PlaybackThread::TimedTrack::releaseBuffer(
1603 AudioBufferProvider::Buffer* buffer) {
1604
1605 Mutex::Autolock _l(mTimedBufferQueueLock);
1606
1607 // If the buffer which was just released is part of the buffer at the head
1608 // of the queue, be sure to update the amt of the buffer which has been
1609 // consumed. If the buffer being returned is not part of the head of the
1610 // queue, its either because the buffer is part of the silence buffer, or
1611 // because the head of the timed queue was trimmed after the mixer called
1612 // getNextBuffer but before the mixer called releaseBuffer.
1613 if (buffer->raw == mTimedSilenceBuffer) {
1614 ALOG_ASSERT(!mQueueHeadInFlight,
1615 "Queue head in flight during release of silence buffer!");
1616 goto done;
1617 }
1618
1619 ALOG_ASSERT(mQueueHeadInFlight,
1620 "TimedTrack::releaseBuffer of non-silence buffer, but no queue"
1621 " head in flight.");
1622
1623 if (mTimedBufferQueue.size()) {
1624 TimedBuffer& head = mTimedBufferQueue.editItemAt(0);
1625
1626 void* start = head.buffer()->pointer();
1627 void* end = reinterpret_cast<void*>(
1628 reinterpret_cast<uint8_t*>(head.buffer()->pointer())
1629 + head.buffer()->size());
1630
1631 ALOG_ASSERT((buffer->raw >= start) && (buffer->raw < end),
1632 "released buffer not within the head of the timed buffer"
1633 " queue; qHead = [%p, %p], released buffer = %p",
1634 start, end, buffer->raw);
1635
1636 head.setPosition(head.position() +
1637 (buffer->frameCount * mFrameSize));
1638 mQueueHeadInFlight = false;
1639
1640 ALOG_ASSERT(mFramesPendingInQueue >= buffer->frameCount,
1641 "Bad bookkeeping during releaseBuffer! Should have at"
1642 " least %u queued frames, but we think we have only %u",
1643 buffer->frameCount, mFramesPendingInQueue);
1644
1645 mFramesPendingInQueue -= buffer->frameCount;
1646
1647 if ((static_cast<size_t>(head.position()) >= head.buffer()->size())
1648 || mTrimQueueHeadOnRelease) {
1649 trimTimedBufferQueueHead_l("releaseBuffer");
1650 mTrimQueueHeadOnRelease = false;
1651 }
1652 } else {
Glenn Kastenadad3d72014-02-21 14:51:43 -08001653 LOG_ALWAYS_FATAL("TimedTrack::releaseBuffer of non-silence buffer with no"
Eric Laurent81784c32012-11-19 14:55:58 -08001654 " buffers in the timed buffer queue");
1655 }
1656
1657done:
1658 buffer->raw = 0;
1659 buffer->frameCount = 0;
1660}
1661
1662size_t AudioFlinger::PlaybackThread::TimedTrack::framesReady() const {
1663 Mutex::Autolock _l(mTimedBufferQueueLock);
1664 return mFramesPendingInQueue;
1665}
1666
1667AudioFlinger::PlaybackThread::TimedTrack::TimedBuffer::TimedBuffer()
1668 : mPTS(0), mPosition(0) {}
1669
1670AudioFlinger::PlaybackThread::TimedTrack::TimedBuffer::TimedBuffer(
1671 const sp<IMemory>& buffer, int64_t pts)
1672 : mBuffer(buffer), mPTS(pts), mPosition(0) {}
1673
1674
1675// ----------------------------------------------------------------------------
1676
1677AudioFlinger::PlaybackThread::OutputTrack::OutputTrack(
1678 PlaybackThread *playbackThread,
1679 DuplicatingThread *sourceThread,
1680 uint32_t sampleRate,
1681 audio_format_t format,
1682 audio_channel_mask_t channelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001683 size_t frameCount,
1684 int uid)
Eric Laurent223fd5c2014-11-11 13:43:36 -08001685 : Track(playbackThread, NULL, AUDIO_STREAM_PATCH,
1686 sampleRate, format, channelMask, frameCount,
1687 NULL, 0, 0, uid, IAudioFlinger::TRACK_DEFAULT, TYPE_OUTPUT),
Glenn Kastene3aa6592012-12-04 12:22:46 -08001688 mActive(false), mSourceThread(sourceThread), mClientProxy(NULL)
Eric Laurent81784c32012-11-19 14:55:58 -08001689{
1690
1691 if (mCblk != NULL) {
Eric Laurent81784c32012-11-19 14:55:58 -08001692 mOutBuffer.frameCount = 0;
1693 playbackThread->mTracks.add(this);
Glenn Kastene3aa6592012-12-04 12:22:46 -08001694 ALOGV("OutputTrack constructor mCblk %p, mBuffer %p, "
Glenn Kasten74935e42013-12-19 08:56:45 -08001695 "frameCount %u, mChannelMask 0x%08x",
Glenn Kastene3aa6592012-12-04 12:22:46 -08001696 mCblk, mBuffer,
Glenn Kasten74935e42013-12-19 08:56:45 -08001697 frameCount, mChannelMask);
Glenn Kastene3aa6592012-12-04 12:22:46 -08001698 // since client and server are in the same process,
1699 // the buffer has the same virtual address on both sides
Glenn Kasten529c61b2014-07-18 15:31:02 -07001700 mClientProxy = new AudioTrackClientProxy(mCblk, mBuffer, mFrameCount, mFrameSize,
1701 true /*clientInServer*/);
Glenn Kastenc56f3422014-03-21 17:53:17 -07001702 mClientProxy->setVolumeLR(GAIN_MINIFLOAT_PACKED_UNITY);
Eric Laurent8d2d4932013-04-25 12:56:18 -07001703 mClientProxy->setSendLevel(0.0);
1704 mClientProxy->setSampleRate(sampleRate);
Eric Laurent81784c32012-11-19 14:55:58 -08001705 } else {
1706 ALOGW("Error creating output track on thread %p", playbackThread);
1707 }
1708}
1709
1710AudioFlinger::PlaybackThread::OutputTrack::~OutputTrack()
1711{
1712 clearBufferQueue();
Glenn Kastene3aa6592012-12-04 12:22:46 -08001713 delete mClientProxy;
1714 // superclass destructor will now delete the server proxy and shared memory both refer to
Eric Laurent81784c32012-11-19 14:55:58 -08001715}
1716
1717status_t AudioFlinger::PlaybackThread::OutputTrack::start(AudioSystem::sync_event_t event,
1718 int triggerSession)
1719{
1720 status_t status = Track::start(event, triggerSession);
1721 if (status != NO_ERROR) {
1722 return status;
1723 }
1724
1725 mActive = true;
1726 mRetryCount = 127;
1727 return status;
1728}
1729
1730void AudioFlinger::PlaybackThread::OutputTrack::stop()
1731{
1732 Track::stop();
1733 clearBufferQueue();
1734 mOutBuffer.frameCount = 0;
1735 mActive = false;
1736}
1737
Andy Hungc25b84a2015-01-14 19:04:10 -08001738bool AudioFlinger::PlaybackThread::OutputTrack::write(void* data, uint32_t frames)
Eric Laurent81784c32012-11-19 14:55:58 -08001739{
1740 Buffer *pInBuffer;
1741 Buffer inBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -08001742 bool outputBufferFull = false;
1743 inBuffer.frameCount = frames;
Andy Hungc25b84a2015-01-14 19:04:10 -08001744 inBuffer.raw = data;
Eric Laurent81784c32012-11-19 14:55:58 -08001745
1746 uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs();
1747
1748 if (!mActive && frames != 0) {
Andy Hung5bedff62015-01-16 11:05:32 -08001749 (void) start();
Eric Laurent81784c32012-11-19 14:55:58 -08001750 }
1751
1752 while (waitTimeLeftMs) {
1753 // First write pending buffers, then new data
1754 if (mBufferQueue.size()) {
1755 pInBuffer = mBufferQueue.itemAt(0);
1756 } else {
1757 pInBuffer = &inBuffer;
1758 }
1759
1760 if (pInBuffer->frameCount == 0) {
1761 break;
1762 }
1763
1764 if (mOutBuffer.frameCount == 0) {
1765 mOutBuffer.frameCount = pInBuffer->frameCount;
1766 nsecs_t startTime = systemTime();
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001767 status_t status = obtainBuffer(&mOutBuffer, waitTimeLeftMs);
1768 if (status != NO_ERROR) {
1769 ALOGV("OutputTrack::write() %p thread %p no more output buffers; status %d", this,
1770 mThread.unsafe_get(), status);
Eric Laurent81784c32012-11-19 14:55:58 -08001771 outputBufferFull = true;
1772 break;
1773 }
1774 uint32_t waitTimeMs = (uint32_t)ns2ms(systemTime() - startTime);
1775 if (waitTimeLeftMs >= waitTimeMs) {
1776 waitTimeLeftMs -= waitTimeMs;
1777 } else {
1778 waitTimeLeftMs = 0;
1779 }
1780 }
1781
1782 uint32_t outFrames = pInBuffer->frameCount > mOutBuffer.frameCount ? mOutBuffer.frameCount :
1783 pInBuffer->frameCount;
Andy Hungc25b84a2015-01-14 19:04:10 -08001784 memcpy(mOutBuffer.raw, pInBuffer->raw, outFrames * mFrameSize);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001785 Proxy::Buffer buf;
1786 buf.mFrameCount = outFrames;
1787 buf.mRaw = NULL;
1788 mClientProxy->releaseBuffer(&buf);
Eric Laurent81784c32012-11-19 14:55:58 -08001789 pInBuffer->frameCount -= outFrames;
Andy Hungc25b84a2015-01-14 19:04:10 -08001790 pInBuffer->raw = (int8_t *)pInBuffer->raw + outFrames * mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08001791 mOutBuffer.frameCount -= outFrames;
Andy Hungc25b84a2015-01-14 19:04:10 -08001792 mOutBuffer.raw = (int8_t *)mOutBuffer.raw + outFrames * mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08001793
1794 if (pInBuffer->frameCount == 0) {
1795 if (mBufferQueue.size()) {
1796 mBufferQueue.removeAt(0);
Andy Hungc25b84a2015-01-14 19:04:10 -08001797 free(pInBuffer->mBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08001798 delete pInBuffer;
1799 ALOGV("OutputTrack::write() %p thread %p released overflow buffer %d", this,
1800 mThread.unsafe_get(), mBufferQueue.size());
1801 } else {
1802 break;
1803 }
1804 }
1805 }
1806
1807 // If we could not write all frames, allocate a buffer and queue it for next time.
1808 if (inBuffer.frameCount) {
1809 sp<ThreadBase> thread = mThread.promote();
1810 if (thread != 0 && !thread->standby()) {
1811 if (mBufferQueue.size() < kMaxOverFlowBuffers) {
1812 pInBuffer = new Buffer;
Andy Hungc25b84a2015-01-14 19:04:10 -08001813 pInBuffer->mBuffer = malloc(inBuffer.frameCount * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08001814 pInBuffer->frameCount = inBuffer.frameCount;
Andy Hungc25b84a2015-01-14 19:04:10 -08001815 pInBuffer->raw = pInBuffer->mBuffer;
1816 memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08001817 mBufferQueue.add(pInBuffer);
1818 ALOGV("OutputTrack::write() %p thread %p adding overflow buffer %d", this,
1819 mThread.unsafe_get(), mBufferQueue.size());
1820 } else {
1821 ALOGW("OutputTrack::write() %p thread %p no more overflow buffers",
1822 mThread.unsafe_get(), this);
1823 }
1824 }
1825 }
1826
Andy Hungc25b84a2015-01-14 19:04:10 -08001827 // Calling write() with a 0 length buffer means that no more data will be written:
1828 // We rely on stop() to set the appropriate flags to allow the remaining frames to play out.
1829 if (frames == 0 && mBufferQueue.size() == 0 && mActive) {
1830 stop();
Eric Laurent81784c32012-11-19 14:55:58 -08001831 }
1832
1833 return outputBufferFull;
1834}
1835
1836status_t AudioFlinger::PlaybackThread::OutputTrack::obtainBuffer(
1837 AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs)
1838{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001839 ClientProxy::Buffer buf;
1840 buf.mFrameCount = buffer->frameCount;
1841 struct timespec timeout;
1842 timeout.tv_sec = waitTimeMs / 1000;
1843 timeout.tv_nsec = (int) (waitTimeMs % 1000) * 1000000;
1844 status_t status = mClientProxy->obtainBuffer(&buf, &timeout);
1845 buffer->frameCount = buf.mFrameCount;
1846 buffer->raw = buf.mRaw;
1847 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08001848}
1849
Eric Laurent81784c32012-11-19 14:55:58 -08001850void AudioFlinger::PlaybackThread::OutputTrack::clearBufferQueue()
1851{
1852 size_t size = mBufferQueue.size();
1853
1854 for (size_t i = 0; i < size; i++) {
1855 Buffer *pBuffer = mBufferQueue.itemAt(i);
Andy Hungc25b84a2015-01-14 19:04:10 -08001856 free(pBuffer->mBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08001857 delete pBuffer;
1858 }
1859 mBufferQueue.clear();
1860}
1861
1862
Eric Laurent83b88082014-06-20 18:31:16 -07001863AudioFlinger::PlaybackThread::PatchTrack::PatchTrack(PlaybackThread *playbackThread,
Eric Laurent3bcf8592015-04-03 12:13:24 -07001864 audio_stream_type_t streamType,
Eric Laurent83b88082014-06-20 18:31:16 -07001865 uint32_t sampleRate,
1866 audio_channel_mask_t channelMask,
1867 audio_format_t format,
1868 size_t frameCount,
1869 void *buffer,
1870 IAudioFlinger::track_flags_t flags)
Eric Laurent3bcf8592015-04-03 12:13:24 -07001871 : Track(playbackThread, NULL, streamType,
Eric Laurent223fd5c2014-11-11 13:43:36 -08001872 sampleRate, format, channelMask, frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -07001873 buffer, 0, 0, getuid(), flags, TYPE_PATCH),
1874 mProxy(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, true, true))
1875{
1876 uint64_t mixBufferNs = ((uint64_t)2 * playbackThread->frameCount() * 1000000000) /
1877 playbackThread->sampleRate();
1878 mPeerTimeout.tv_sec = mixBufferNs / 1000000000;
1879 mPeerTimeout.tv_nsec = (int) (mixBufferNs % 1000000000);
1880
1881 ALOGV("PatchTrack %p sampleRate %d mPeerTimeout %d.%03d sec",
1882 this, sampleRate,
1883 (int)mPeerTimeout.tv_sec,
1884 (int)(mPeerTimeout.tv_nsec / 1000000));
1885}
1886
1887AudioFlinger::PlaybackThread::PatchTrack::~PatchTrack()
1888{
1889}
1890
1891// AudioBufferProvider interface
1892status_t AudioFlinger::PlaybackThread::PatchTrack::getNextBuffer(
1893 AudioBufferProvider::Buffer* buffer, int64_t pts)
1894{
1895 ALOG_ASSERT(mPeerProxy != 0, "PatchTrack::getNextBuffer() called without peer proxy");
1896 Proxy::Buffer buf;
1897 buf.mFrameCount = buffer->frameCount;
1898 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout);
1899 ALOGV_IF(status != NO_ERROR, "PatchTrack() %p getNextBuffer status %d", this, status);
Eric Laurentc2730ba2014-07-20 15:47:07 -07001900 buffer->frameCount = buf.mFrameCount;
Eric Laurent83b88082014-06-20 18:31:16 -07001901 if (buf.mFrameCount == 0) {
1902 return WOULD_BLOCK;
1903 }
Eric Laurent83b88082014-06-20 18:31:16 -07001904 status = Track::getNextBuffer(buffer, pts);
1905 return status;
1906}
1907
1908void AudioFlinger::PlaybackThread::PatchTrack::releaseBuffer(AudioBufferProvider::Buffer* buffer)
1909{
1910 ALOG_ASSERT(mPeerProxy != 0, "PatchTrack::releaseBuffer() called without peer proxy");
1911 Proxy::Buffer buf;
1912 buf.mFrameCount = buffer->frameCount;
1913 buf.mRaw = buffer->raw;
1914 mPeerProxy->releaseBuffer(&buf);
1915 TrackBase::releaseBuffer(buffer);
1916}
1917
1918status_t AudioFlinger::PlaybackThread::PatchTrack::obtainBuffer(Proxy::Buffer* buffer,
1919 const struct timespec *timeOut)
1920{
1921 return mProxy->obtainBuffer(buffer, timeOut);
1922}
1923
1924void AudioFlinger::PlaybackThread::PatchTrack::releaseBuffer(Proxy::Buffer* buffer)
1925{
1926 mProxy->releaseBuffer(buffer);
1927 if (android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags) & CBLK_DISABLED) {
1928 ALOGW("PatchTrack::releaseBuffer() disabled due to previous underrun, restarting");
1929 start();
1930 }
1931 android_atomic_or(CBLK_FORCEREADY, &mCblk->mFlags);
1932}
1933
Eric Laurent81784c32012-11-19 14:55:58 -08001934// ----------------------------------------------------------------------------
1935// Record
1936// ----------------------------------------------------------------------------
1937
1938AudioFlinger::RecordHandle::RecordHandle(
1939 const sp<AudioFlinger::RecordThread::RecordTrack>& recordTrack)
1940 : BnAudioRecord(),
1941 mRecordTrack(recordTrack)
1942{
1943}
1944
1945AudioFlinger::RecordHandle::~RecordHandle() {
1946 stop_nonvirtual();
1947 mRecordTrack->destroy();
1948}
1949
Eric Laurent81784c32012-11-19 14:55:58 -08001950status_t AudioFlinger::RecordHandle::start(int /*AudioSystem::sync_event_t*/ event,
1951 int triggerSession) {
1952 ALOGV("RecordHandle::start()");
1953 return mRecordTrack->start((AudioSystem::sync_event_t)event, triggerSession);
1954}
1955
1956void AudioFlinger::RecordHandle::stop() {
1957 stop_nonvirtual();
1958}
1959
1960void AudioFlinger::RecordHandle::stop_nonvirtual() {
1961 ALOGV("RecordHandle::stop()");
1962 mRecordTrack->stop();
1963}
1964
1965status_t AudioFlinger::RecordHandle::onTransact(
1966 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
1967{
1968 return BnAudioRecord::onTransact(code, data, reply, flags);
1969}
1970
1971// ----------------------------------------------------------------------------
1972
Glenn Kasten05997e22014-03-13 15:08:33 -07001973// RecordTrack constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
Eric Laurent81784c32012-11-19 14:55:58 -08001974AudioFlinger::RecordThread::RecordTrack::RecordTrack(
1975 RecordThread *thread,
1976 const sp<Client>& client,
1977 uint32_t sampleRate,
1978 audio_format_t format,
1979 audio_channel_mask_t channelMask,
1980 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -07001981 void *buffer,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001982 int sessionId,
Glenn Kastend776ac62014-05-07 09:16:09 -07001983 int uid,
Eric Laurent83b88082014-06-20 18:31:16 -07001984 IAudioFlinger::track_flags_t flags,
1985 track_type type)
Eric Laurent81784c32012-11-19 14:55:58 -08001986 : TrackBase(thread, client, sampleRate, format,
Eric Laurent83b88082014-06-20 18:31:16 -07001987 channelMask, frameCount, buffer, sessionId, uid,
Glenn Kasten755b0a62014-05-13 11:30:28 -07001988 flags, false /*isOut*/,
Eric Laurent83b88082014-06-20 18:31:16 -07001989 (type == TYPE_DEFAULT) ?
1990 ((flags & IAudioFlinger::TRACK_FAST) ? ALLOC_PIPE : ALLOC_CBLK) :
1991 ((buffer == NULL) ? ALLOC_LOCAL : ALLOC_NONE),
1992 type),
Andy Hung97a893e2015-03-29 01:03:07 -07001993 mOverflow(false),
Andy Hung73c02e42015-03-29 01:13:58 -07001994 mFramesToDrop(0)
Eric Laurent81784c32012-11-19 14:55:58 -08001995{
Glenn Kasten3ef14ef2014-03-13 15:08:51 -07001996 if (mCblk == NULL) {
1997 return;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001998 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001999
Andy Hung97a893e2015-03-29 01:03:07 -07002000 mRecordBufferConverter = new RecordBufferConverter(
2001 thread->mChannelMask, thread->mFormat, thread->mSampleRate,
2002 channelMask, format, sampleRate);
2003 // Check if the RecordBufferConverter construction was successful.
2004 // If not, don't continue with construction.
2005 //
2006 // NOTE: It would be extremely rare that the record track cannot be created
2007 // for the current device, but a pending or future device change would make
2008 // the record track configuration valid.
2009 if (mRecordBufferConverter->initCheck() != NO_ERROR) {
2010 ALOGE("RecordTrack unable to create record buffer converter");
2011 return;
2012 }
2013
Eric Laurent83b88082014-06-20 18:31:16 -07002014 mServerProxy = new AudioRecordServerProxy(mCblk, mBuffer, frameCount,
2015 mFrameSize, !isExternalTrack());
Andy Hung97a893e2015-03-29 01:03:07 -07002016 mResamplerBufferProvider = new ResamplerBufferProvider(this);
Glenn Kastenc263ca02014-06-04 20:31:46 -07002017
2018 if (flags & IAudioFlinger::TRACK_FAST) {
2019 ALOG_ASSERT(thread->mFastTrackAvail);
2020 thread->mFastTrackAvail = false;
2021 }
Eric Laurent81784c32012-11-19 14:55:58 -08002022}
2023
2024AudioFlinger::RecordThread::RecordTrack::~RecordTrack()
2025{
2026 ALOGV("%s", __func__);
Andy Hung97a893e2015-03-29 01:03:07 -07002027 delete mRecordBufferConverter;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002028 delete mResamplerBufferProvider;
Eric Laurent81784c32012-11-19 14:55:58 -08002029}
2030
Andy Hung97a893e2015-03-29 01:03:07 -07002031status_t AudioFlinger::RecordThread::RecordTrack::initCheck() const
2032{
2033 status_t status = TrackBase::initCheck();
2034 if (status == NO_ERROR && mServerProxy == 0) {
2035 status = BAD_VALUE;
2036 }
2037 return status;
2038}
2039
Eric Laurent81784c32012-11-19 14:55:58 -08002040// AudioBufferProvider interface
2041status_t AudioFlinger::RecordThread::RecordTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer,
Glenn Kasten0f11b512014-01-31 16:18:54 -08002042 int64_t pts __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08002043{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002044 ServerProxy::Buffer buf;
2045 buf.mFrameCount = buffer->frameCount;
2046 status_t status = mServerProxy->obtainBuffer(&buf);
2047 buffer->frameCount = buf.mFrameCount;
2048 buffer->raw = buf.mRaw;
2049 if (buf.mFrameCount == 0) {
2050 // FIXME also wake futex so that overrun is noticed more quickly
Glenn Kasten96f60d82013-07-12 10:21:18 -07002051 (void) android_atomic_or(CBLK_OVERRUN, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08002052 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002053 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08002054}
2055
2056status_t AudioFlinger::RecordThread::RecordTrack::start(AudioSystem::sync_event_t event,
2057 int triggerSession)
2058{
2059 sp<ThreadBase> thread = mThread.promote();
2060 if (thread != 0) {
2061 RecordThread *recordThread = (RecordThread *)thread.get();
2062 return recordThread->start(this, event, triggerSession);
2063 } else {
2064 return BAD_VALUE;
2065 }
2066}
2067
2068void AudioFlinger::RecordThread::RecordTrack::stop()
2069{
2070 sp<ThreadBase> thread = mThread.promote();
2071 if (thread != 0) {
2072 RecordThread *recordThread = (RecordThread *)thread.get();
Eric Laurent83b88082014-06-20 18:31:16 -07002073 if (recordThread->stop(this) && isExternalTrack()) {
Eric Laurentaaa44472014-09-12 17:41:50 -07002074 AudioSystem::stopInput(mThreadIoHandle, (audio_session_t)mSessionId);
Eric Laurent81784c32012-11-19 14:55:58 -08002075 }
2076 }
2077}
2078
2079void AudioFlinger::RecordThread::RecordTrack::destroy()
2080{
2081 // see comments at AudioFlinger::PlaybackThread::Track::destroy()
2082 sp<RecordTrack> keep(this);
2083 {
Eric Laurentaaa44472014-09-12 17:41:50 -07002084 if (isExternalTrack()) {
2085 if (mState == ACTIVE || mState == RESUMING) {
2086 AudioSystem::stopInput(mThreadIoHandle, (audio_session_t)mSessionId);
2087 }
2088 AudioSystem::releaseInput(mThreadIoHandle, (audio_session_t)mSessionId);
2089 }
Eric Laurent81784c32012-11-19 14:55:58 -08002090 sp<ThreadBase> thread = mThread.promote();
2091 if (thread != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08002092 Mutex::Autolock _l(thread->mLock);
2093 RecordThread *recordThread = (RecordThread *) thread.get();
2094 recordThread->destroyTrack_l(this);
2095 }
2096 }
2097}
2098
Eric Laurent9a54bc22013-09-09 09:08:44 -07002099void AudioFlinger::RecordThread::RecordTrack::invalidate()
2100{
2101 // FIXME should use proxy, and needs work
2102 audio_track_cblk_t* cblk = mCblk;
2103 android_atomic_or(CBLK_INVALID, &cblk->mFlags);
2104 android_atomic_release_store(0x40000000, &cblk->mFutex);
2105 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE
Elliott Hughesee499292014-05-21 17:55:51 -07002106 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX);
Eric Laurent9a54bc22013-09-09 09:08:44 -07002107}
2108
Eric Laurent81784c32012-11-19 14:55:58 -08002109
2110/*static*/ void AudioFlinger::RecordThread::RecordTrack::appendDumpHeader(String8& result)
2111{
Glenn Kasten6e6704c2014-07-03 10:20:00 -07002112 result.append(" Active Client Fmt Chn mask Session S Server fCount SRate\n");
Eric Laurent81784c32012-11-19 14:55:58 -08002113}
2114
Marco Nelissenb2208842014-02-07 14:00:50 -08002115void AudioFlinger::RecordThread::RecordTrack::dump(char* buffer, size_t size, bool active)
Eric Laurent81784c32012-11-19 14:55:58 -08002116{
Glenn Kasten6e6704c2014-07-03 10:20:00 -07002117 snprintf(buffer, size, " %6s %6u %3u %08X %7u %1d %08X %6zu %5u\n",
Marco Nelissenb2208842014-02-07 14:00:50 -08002118 active ? "yes" : "no",
Eric Laurent81784c32012-11-19 14:55:58 -08002119 (mClient == 0) ? getpid_cached : mClient->pid(),
2120 mFormat,
2121 mChannelMask,
2122 mSessionId,
Eric Laurent81784c32012-11-19 14:55:58 -08002123 mState,
Glenn Kastenf20e1d82013-07-12 09:45:18 -07002124 mCblk->mServer,
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002125 mFrameCount,
Glenn Kasten6e6704c2014-07-03 10:20:00 -07002126 mSampleRate);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002127
Eric Laurent81784c32012-11-19 14:55:58 -08002128}
2129
Glenn Kasten25f4aa82014-02-07 10:50:43 -08002130void AudioFlinger::RecordThread::RecordTrack::handleSyncStartEvent(const sp<SyncEvent>& event)
2131{
2132 if (event == mSyncStartEvent) {
2133 ssize_t framesToDrop = 0;
2134 sp<ThreadBase> threadBase = mThread.promote();
2135 if (threadBase != 0) {
2136 // TODO: use actual buffer filling status instead of 2 buffers when info is available
2137 // from audio HAL
2138 framesToDrop = threadBase->mFrameCount * 2;
2139 }
2140 mFramesToDrop = framesToDrop;
2141 }
2142}
2143
2144void AudioFlinger::RecordThread::RecordTrack::clearSyncStartEvent()
2145{
2146 if (mSyncStartEvent != 0) {
2147 mSyncStartEvent->cancel();
2148 mSyncStartEvent.clear();
2149 }
2150 mFramesToDrop = 0;
2151}
2152
Eric Laurent83b88082014-06-20 18:31:16 -07002153
2154AudioFlinger::RecordThread::PatchRecord::PatchRecord(RecordThread *recordThread,
2155 uint32_t sampleRate,
2156 audio_channel_mask_t channelMask,
2157 audio_format_t format,
2158 size_t frameCount,
2159 void *buffer,
2160 IAudioFlinger::track_flags_t flags)
2161 : RecordTrack(recordThread, NULL, sampleRate, format, channelMask, frameCount,
2162 buffer, 0, getuid(), flags, TYPE_PATCH),
2163 mProxy(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, false, true))
2164{
2165 uint64_t mixBufferNs = ((uint64_t)2 * recordThread->frameCount() * 1000000000) /
2166 recordThread->sampleRate();
2167 mPeerTimeout.tv_sec = mixBufferNs / 1000000000;
2168 mPeerTimeout.tv_nsec = (int) (mixBufferNs % 1000000000);
2169
2170 ALOGV("PatchRecord %p sampleRate %d mPeerTimeout %d.%03d sec",
2171 this, sampleRate,
2172 (int)mPeerTimeout.tv_sec,
2173 (int)(mPeerTimeout.tv_nsec / 1000000));
2174}
2175
2176AudioFlinger::RecordThread::PatchRecord::~PatchRecord()
2177{
2178}
2179
2180// AudioBufferProvider interface
2181status_t AudioFlinger::RecordThread::PatchRecord::getNextBuffer(
2182 AudioBufferProvider::Buffer* buffer, int64_t pts)
2183{
2184 ALOG_ASSERT(mPeerProxy != 0, "PatchRecord::getNextBuffer() called without peer proxy");
2185 Proxy::Buffer buf;
2186 buf.mFrameCount = buffer->frameCount;
2187 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout);
2188 ALOGV_IF(status != NO_ERROR,
2189 "PatchRecord() %p mPeerProxy->obtainBuffer status %d", this, status);
Eric Laurentc2730ba2014-07-20 15:47:07 -07002190 buffer->frameCount = buf.mFrameCount;
Eric Laurent83b88082014-06-20 18:31:16 -07002191 if (buf.mFrameCount == 0) {
2192 return WOULD_BLOCK;
2193 }
Eric Laurent83b88082014-06-20 18:31:16 -07002194 status = RecordTrack::getNextBuffer(buffer, pts);
2195 return status;
2196}
2197
2198void AudioFlinger::RecordThread::PatchRecord::releaseBuffer(AudioBufferProvider::Buffer* buffer)
2199{
2200 ALOG_ASSERT(mPeerProxy != 0, "PatchRecord::releaseBuffer() called without peer proxy");
2201 Proxy::Buffer buf;
2202 buf.mFrameCount = buffer->frameCount;
2203 buf.mRaw = buffer->raw;
2204 mPeerProxy->releaseBuffer(&buf);
2205 TrackBase::releaseBuffer(buffer);
2206}
2207
2208status_t AudioFlinger::RecordThread::PatchRecord::obtainBuffer(Proxy::Buffer* buffer,
2209 const struct timespec *timeOut)
2210{
2211 return mProxy->obtainBuffer(buffer, timeOut);
2212}
2213
2214void AudioFlinger::RecordThread::PatchRecord::releaseBuffer(Proxy::Buffer* buffer)
2215{
2216 mProxy->releaseBuffer(buffer);
2217}
2218
Glenn Kasten63238ef2015-03-02 15:50:29 -08002219} // namespace android