blob: 8b9485f6773eaaa3999c8ac77041a20526c2c0ee [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
Eric Laurent81784c32012-11-19 14:55:58 -080030#include "AudioFlinger.h"
Eric Laurent81784c32012-11-19 14:55:58 -080031
Glenn Kastenda6ef132013-01-10 12:31:01 -080032#include <media/nbaio/Pipe.h>
33#include <media/nbaio/PipeReader.h>
Andy Hung89816052017-01-11 17:08:23 -080034#include <media/RecordBufferConverter.h>
Andy Hungab7ef302018-05-15 19:35:29 -070035#include <mediautils/ServiceUtilities.h>
Glenn Kastenc56f3422014-03-21 17:53:17 -070036#include <audio_utils/minifloat.h>
Glenn Kastenda6ef132013-01-10 12:31:01 -080037
Eric Laurent81784c32012-11-19 14:55:58 -080038// ----------------------------------------------------------------------------
39
40// Note: the following macro is used for extremely verbose logging message. In
41// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
42// 0; but one side effect of this is to turn all LOGV's as well. Some messages
43// are so verbose that we want to suppress them even when we have ALOG_ASSERT
44// turned on. Do not uncomment the #def below unless you really know what you
45// are doing and want to see all of the extremely verbose messages.
46//#define VERY_VERY_VERBOSE_LOGGING
47#ifdef VERY_VERY_VERBOSE_LOGGING
48#define ALOGVV ALOGV
49#else
50#define ALOGVV(a...) do { } while(0)
51#endif
52
53namespace android {
54
Ivan Lozano8cf3a072017-08-09 09:01:33 -070055using media::VolumeShaper;
Eric Laurent81784c32012-11-19 14:55:58 -080056// ----------------------------------------------------------------------------
57// TrackBase
58// ----------------------------------------------------------------------------
59
Glenn Kastenda6ef132013-01-10 12:31:01 -080060static volatile int32_t nextTrackId = 55;
61
Eric Laurent81784c32012-11-19 14:55:58 -080062// TrackBase constructor must be called with AudioFlinger::mLock held
63AudioFlinger::ThreadBase::TrackBase::TrackBase(
64 ThreadBase *thread,
65 const sp<Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -070066 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -080067 uint32_t sampleRate,
68 audio_format_t format,
69 audio_channel_mask_t channelMask,
70 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -070071 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -070072 size_t bufferSize,
Glenn Kastend848eb42016-03-08 13:42:11 -080073 audio_session_t sessionId,
Andy Hung1f12a8a2016-11-07 16:10:30 -080074 uid_t clientUid,
Glenn Kastend776ac62014-05-07 09:16:09 -070075 bool isOut,
Eric Laurent83b88082014-06-20 18:31:16 -070076 alloc_type alloc,
Eric Laurent20b9ef02016-12-05 11:03:16 -080077 track_type type,
78 audio_port_handle_t portId)
Eric Laurent81784c32012-11-19 14:55:58 -080079 : RefBase(),
80 mThread(thread),
81 mClient(client),
82 mCblk(NULL),
Andy Hung8fe68032017-06-05 16:17:51 -070083 // mBuffer, mBufferSize
Eric Laurent81784c32012-11-19 14:55:58 -080084 mState(IDLE),
Kevin Rocard1f564ac2018-03-29 13:53:10 -070085 mAttr(attr),
Eric Laurent81784c32012-11-19 14:55:58 -080086 mSampleRate(sampleRate),
87 mFormat(format),
88 mChannelMask(channelMask),
Andy Hunge5412692014-05-16 11:25:07 -070089 mChannelCount(isOut ?
90 audio_channel_count_from_out_mask(channelMask) :
91 audio_channel_count_from_in_mask(channelMask)),
Phil Burkfdb3c072016-02-09 10:47:02 -080092 mFrameSize(audio_has_proportional_frames(format) ?
Eric Laurent81784c32012-11-19 14:55:58 -080093 mChannelCount * audio_bytes_per_sample(format) : sizeof(int8_t)),
94 mFrameCount(frameCount),
Glenn Kastene3aa6592012-12-04 12:22:46 -080095 mSessionId(sessionId),
96 mIsOut(isOut),
Eric Laurentbfb1b832013-01-07 09:53:42 -080097 mId(android_atomic_inc(&nextTrackId)),
Eric Laurent83b88082014-06-20 18:31:16 -070098 mTerminated(false),
Eric Laurentaaa44472014-09-12 17:41:50 -070099 mType(type),
Eric Laurent20b9ef02016-12-05 11:03:16 -0800100 mThreadIoHandle(thread->id()),
Eric Laurent6acd1d42017-01-04 14:23:29 -0800101 mPortId(portId),
102 mIsInvalid(false)
Eric Laurent81784c32012-11-19 14:55:58 -0800103{
Marco Nelissendcb346b2015-09-09 10:47:29 -0700104 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Andy Hung4ef19fa2018-05-15 19:35:29 -0700105 if (!isAudioServerOrMediaServerUid(callingUid) || clientUid == AUDIO_UID_INVALID) {
Andy Hung1f12a8a2016-11-07 16:10:30 -0800106 ALOGW_IF(clientUid != AUDIO_UID_INVALID && clientUid != callingUid,
Marco Nelissendcb346b2015-09-09 10:47:29 -0700107 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, clientUid);
Andy Hung1f12a8a2016-11-07 16:10:30 -0800108 clientUid = callingUid;
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800109 }
110 // clientUid contains the uid of the app that is responsible for this track, so we can blame
111 // battery usage on it.
112 mUid = clientUid;
113
Eric Laurent81784c32012-11-19 14:55:58 -0800114 // ALOGD("Creating track with %d buffers @ %d bytes", bufferCount, bufferSize);
Andy Hung1883f692017-02-13 18:48:39 -0800115
Andy Hung8fe68032017-06-05 16:17:51 -0700116 size_t minBufferSize = buffer == NULL ? roundup(frameCount) : frameCount;
Andy Hung1883f692017-02-13 18:48:39 -0800117 // check overflow when computing bufferSize due to multiplication by mFrameSize.
Andy Hung8fe68032017-06-05 16:17:51 -0700118 if (minBufferSize < frameCount // roundup rounds down for values above UINT_MAX / 2
Andy Hung1883f692017-02-13 18:48:39 -0800119 || mFrameSize == 0 // format needs to be correct
Andy Hung8fe68032017-06-05 16:17:51 -0700120 || minBufferSize > SIZE_MAX / mFrameSize) {
Andy Hung1883f692017-02-13 18:48:39 -0800121 android_errorWriteLog(0x534e4554, "34749571");
122 return;
123 }
Andy Hung8fe68032017-06-05 16:17:51 -0700124 minBufferSize *= mFrameSize;
125
126 if (buffer == nullptr) {
127 bufferSize = minBufferSize; // allocated here.
128 } else if (minBufferSize > bufferSize) {
129 android_errorWriteLog(0x534e4554, "38340117");
130 return;
131 }
Andy Hung1883f692017-02-13 18:48:39 -0800132
Eric Laurent81784c32012-11-19 14:55:58 -0800133 size_t size = sizeof(audio_track_cblk_t);
Eric Laurent83b88082014-06-20 18:31:16 -0700134 if (buffer == NULL && alloc == ALLOC_CBLK) {
Andy Hung1883f692017-02-13 18:48:39 -0800135 // check overflow when computing allocation size for streaming tracks.
136 if (size > SIZE_MAX - bufferSize) {
137 android_errorWriteLog(0x534e4554, "34749571");
138 return;
139 }
Eric Laurent81784c32012-11-19 14:55:58 -0800140 size += bufferSize;
141 }
142
143 if (client != 0) {
144 mCblkMemory = client->heap()->allocate(size);
Glenn Kasten663c2242013-09-24 11:52:37 -0700145 if (mCblkMemory == 0 ||
146 (mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->pointer())) == NULL) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -0700147 ALOGE("not enough memory for AudioTrack size=%zu", size);
Eric Laurent81784c32012-11-19 14:55:58 -0800148 client->heap()->dump("AudioTrack");
Glenn Kasten663c2242013-09-24 11:52:37 -0700149 mCblkMemory.clear();
Eric Laurent81784c32012-11-19 14:55:58 -0800150 return;
151 }
152 } else {
Andy Hungafb31482017-02-13 18:50:48 -0800153 mCblk = (audio_track_cblk_t *) malloc(size);
154 if (mCblk == NULL) {
155 ALOGE("not enough memory for AudioTrack size=%zu", size);
156 return;
157 }
Eric Laurent81784c32012-11-19 14:55:58 -0800158 }
159
160 // construct the shared structure in-place.
161 if (mCblk != NULL) {
162 new(mCblk) audio_track_cblk_t();
Glenn Kastenc263ca02014-06-04 20:31:46 -0700163 switch (alloc) {
164 case ALLOC_READONLY: {
Glenn Kastend776ac62014-05-07 09:16:09 -0700165 const sp<MemoryDealer> roHeap(thread->readOnlyHeap());
166 if (roHeap == 0 ||
167 (mBufferMemory = roHeap->allocate(bufferSize)) == 0 ||
168 (mBuffer = mBufferMemory->pointer()) == NULL) {
169 ALOGE("not enough memory for read-only buffer size=%zu", bufferSize);
170 if (roHeap != 0) {
171 roHeap->dump("buffer");
172 }
173 mCblkMemory.clear();
174 mBufferMemory.clear();
175 return;
176 }
Eric Laurent81784c32012-11-19 14:55:58 -0800177 memset(mBuffer, 0, bufferSize);
Glenn Kastenc263ca02014-06-04 20:31:46 -0700178 } break;
179 case ALLOC_PIPE:
180 mBufferMemory = thread->pipeMemory();
181 // mBuffer is the virtual address as seen from current process (mediaserver),
182 // and should normally be coming from mBufferMemory->pointer().
183 // However in this case the TrackBase does not reference the buffer directly.
184 // It should references the buffer via the pipe.
185 // Therefore, to detect incorrect usage of the buffer, we set mBuffer to NULL.
186 mBuffer = NULL;
Andy Hung8fe68032017-06-05 16:17:51 -0700187 bufferSize = 0;
Glenn Kastenc263ca02014-06-04 20:31:46 -0700188 break;
189 case ALLOC_CBLK:
Glenn Kastend776ac62014-05-07 09:16:09 -0700190 // clear all buffers
Eric Laurent83b88082014-06-20 18:31:16 -0700191 if (buffer == NULL) {
Glenn Kastend776ac62014-05-07 09:16:09 -0700192 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);
193 memset(mBuffer, 0, bufferSize);
194 } else {
Eric Laurent83b88082014-06-20 18:31:16 -0700195 mBuffer = buffer;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800196#if 0
Glenn Kastend776ac62014-05-07 09:16:09 -0700197 mCblk->mFlags = CBLK_FORCEREADY; // FIXME hack, need to fix the track ready logic
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800198#endif
Glenn Kastend776ac62014-05-07 09:16:09 -0700199 }
Glenn Kastenc263ca02014-06-04 20:31:46 -0700200 break;
Eric Laurent83b88082014-06-20 18:31:16 -0700201 case ALLOC_LOCAL:
202 mBuffer = calloc(1, bufferSize);
203 break;
204 case ALLOC_NONE:
205 mBuffer = buffer;
206 break;
Andy Hung8fe68032017-06-05 16:17:51 -0700207 default:
208 LOG_ALWAYS_FATAL("invalid allocation type: %d", (int)alloc);
Eric Laurent81784c32012-11-19 14:55:58 -0800209 }
Andy Hung8fe68032017-06-05 16:17:51 -0700210 mBufferSize = bufferSize;
Glenn Kastenda6ef132013-01-10 12:31:01 -0800211
Glenn Kasten46909e72013-02-26 09:20:22 -0800212#ifdef TEE_SINK
Andy Hung8946a282018-04-19 20:04:56 -0700213 mTee.set(sampleRate, mChannelCount, format, NBAIO_Tee::TEE_FLAG_TRACK);
Glenn Kasten46909e72013-02-26 09:20:22 -0800214#endif
Glenn Kastenda6ef132013-01-10 12:31:01 -0800215
Eric Laurent81784c32012-11-19 14:55:58 -0800216 }
217}
218
Eric Laurent83b88082014-06-20 18:31:16 -0700219status_t AudioFlinger::ThreadBase::TrackBase::initCheck() const
220{
221 status_t status;
222 if (mType == TYPE_OUTPUT || mType == TYPE_PATCH) {
223 status = cblk() != NULL ? NO_ERROR : NO_MEMORY;
224 } else {
225 status = getCblk() != 0 ? NO_ERROR : NO_MEMORY;
226 }
227 return status;
228}
229
Eric Laurent81784c32012-11-19 14:55:58 -0800230AudioFlinger::ThreadBase::TrackBase::~TrackBase()
231{
Glenn Kastene3aa6592012-12-04 12:22:46 -0800232 // delete the proxy before deleting the shared memory it refers to, to avoid dangling reference
Eric Laurent5bba2f62016-03-18 11:14:14 -0700233 mServerProxy.clear();
Eric Laurent81784c32012-11-19 14:55:58 -0800234 if (mCblk != NULL) {
Andy Hungafb31482017-02-13 18:50:48 -0800235 mCblk->~audio_track_cblk_t(); // destroy our shared-structure.
Eric Laurent81784c32012-11-19 14:55:58 -0800236 if (mClient == 0) {
Andy Hungafb31482017-02-13 18:50:48 -0800237 free(mCblk);
Eric Laurent81784c32012-11-19 14:55:58 -0800238 }
239 }
240 mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to
241 if (mClient != 0) {
Eric Laurent021cf962014-05-13 10:18:14 -0700242 // Client destructor must run with AudioFlinger client mutex locked
243 Mutex::Autolock _l(mClient->audioFlinger()->mClientLock);
Eric Laurent81784c32012-11-19 14:55:58 -0800244 // If the client's reference count drops to zero, the associated destructor
245 // must run with AudioFlinger lock held. Thus the explicit clear() rather than
246 // relying on the automatic clear() at end of scope.
247 mClient.clear();
248 }
Eric Laurent3bcffa12014-06-12 18:38:45 -0700249 // flush the binder command buffer
250 IPCThreadState::self()->flushCommands();
Eric Laurent81784c32012-11-19 14:55:58 -0800251}
252
253// AudioBufferProvider interface
254// getNextBuffer() = 0;
Glenn Kastend79072e2016-01-06 08:41:20 -0800255// This implementation of releaseBuffer() is used by Track and RecordTrack
Eric Laurent81784c32012-11-19 14:55:58 -0800256void AudioFlinger::ThreadBase::TrackBase::releaseBuffer(AudioBufferProvider::Buffer* buffer)
257{
Glenn Kasten46909e72013-02-26 09:20:22 -0800258#ifdef TEE_SINK
Andy Hung8946a282018-04-19 20:04:56 -0700259 mTee.write(buffer->raw, buffer->frameCount);
Glenn Kasten46909e72013-02-26 09:20:22 -0800260#endif
Glenn Kastenda6ef132013-01-10 12:31:01 -0800261
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800262 ServerProxy::Buffer buf;
263 buf.mFrameCount = buffer->frameCount;
264 buf.mRaw = buffer->raw;
Eric Laurent81784c32012-11-19 14:55:58 -0800265 buffer->frameCount = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800266 buffer->raw = NULL;
267 mServerProxy->releaseBuffer(&buf);
Eric Laurent81784c32012-11-19 14:55:58 -0800268}
269
Eric Laurent81784c32012-11-19 14:55:58 -0800270status_t AudioFlinger::ThreadBase::TrackBase::setSyncEvent(const sp<SyncEvent>& event)
271{
272 mSyncEvents.add(event);
273 return NO_ERROR;
274}
275
276// ----------------------------------------------------------------------------
277// Playback
278// ----------------------------------------------------------------------------
279
280AudioFlinger::TrackHandle::TrackHandle(const sp<AudioFlinger::PlaybackThread::Track>& track)
281 : BnAudioTrack(),
282 mTrack(track)
283{
284}
285
286AudioFlinger::TrackHandle::~TrackHandle() {
287 // just stop the track on deletion, associated resources
288 // will be freed from the main thread once all pending buffers have
289 // been played. Unless it's not in the active track list, in which
290 // case we free everything now...
291 mTrack->destroy();
292}
293
294sp<IMemory> AudioFlinger::TrackHandle::getCblk() const {
295 return mTrack->getCblk();
296}
297
298status_t AudioFlinger::TrackHandle::start() {
299 return mTrack->start();
300}
301
302void AudioFlinger::TrackHandle::stop() {
303 mTrack->stop();
304}
305
306void AudioFlinger::TrackHandle::flush() {
307 mTrack->flush();
308}
309
Eric Laurent81784c32012-11-19 14:55:58 -0800310void AudioFlinger::TrackHandle::pause() {
311 mTrack->pause();
312}
313
314status_t AudioFlinger::TrackHandle::attachAuxEffect(int EffectId)
315{
316 return mTrack->attachAuxEffect(EffectId);
317}
318
Glenn Kasten3dcd00d2013-07-17 10:10:23 -0700319status_t AudioFlinger::TrackHandle::setParameters(const String8& keyValuePairs) {
320 return mTrack->setParameters(keyValuePairs);
321}
322
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800323VolumeShaper::Status AudioFlinger::TrackHandle::applyVolumeShaper(
324 const sp<VolumeShaper::Configuration>& configuration,
325 const sp<VolumeShaper::Operation>& operation) {
326 return mTrack->applyVolumeShaper(configuration, operation);
327}
328
329sp<VolumeShaper::State> AudioFlinger::TrackHandle::getVolumeShaperState(int id) {
330 return mTrack->getVolumeShaperState(id);
331}
332
Glenn Kasten53cec222013-08-29 09:01:02 -0700333status_t AudioFlinger::TrackHandle::getTimestamp(AudioTimestamp& timestamp)
334{
Glenn Kasten573d80a2013-08-26 09:36:23 -0700335 return mTrack->getTimestamp(timestamp);
Glenn Kasten53cec222013-08-29 09:01:02 -0700336}
337
Eric Laurent59fe0102013-09-27 18:48:26 -0700338
339void AudioFlinger::TrackHandle::signal()
340{
341 return mTrack->signal();
342}
343
Eric Laurent81784c32012-11-19 14:55:58 -0800344status_t AudioFlinger::TrackHandle::onTransact(
345 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
346{
347 return BnAudioTrack::onTransact(code, data, reply, flags);
348}
349
350// ----------------------------------------------------------------------------
351
352// Track constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
353AudioFlinger::PlaybackThread::Track::Track(
354 PlaybackThread *thread,
355 const sp<Client>& client,
356 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700357 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -0800358 uint32_t sampleRate,
359 audio_format_t format,
360 audio_channel_mask_t channelMask,
361 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700362 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700363 size_t bufferSize,
Eric Laurent81784c32012-11-19 14:55:58 -0800364 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -0800365 audio_session_t sessionId,
Andy Hung1f12a8a2016-11-07 16:10:30 -0800366 uid_t uid,
Eric Laurent05067782016-06-01 18:27:28 -0700367 audio_output_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800368 track_type type,
369 audio_port_handle_t portId)
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700370 : TrackBase(thread, client, attr, sampleRate, format, channelMask, frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700371 (sharedBuffer != 0) ? sharedBuffer->pointer() : buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700372 (sharedBuffer != 0) ? sharedBuffer->size() : bufferSize,
Eric Laurent05067782016-06-01 18:27:28 -0700373 sessionId, uid, true /*isOut*/,
Eric Laurent83b88082014-06-20 18:31:16 -0700374 (type == TYPE_PATCH) ? ( buffer == NULL ? ALLOC_LOCAL : ALLOC_NONE) : ALLOC_CBLK,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800375 type, portId),
Eric Laurent81784c32012-11-19 14:55:58 -0800376 mFillingUpStatus(FS_INVALID),
377 // mRetryCount initialized later when needed
378 mSharedBuffer(sharedBuffer),
379 mStreamType(streamType),
Andy Hung1bc088a2018-02-09 15:57:31 -0800380 mName(TRACK_NAME_FAILURE), // set to TRACK_NAME_PENDING on constructor success.
rago94a1ee82017-07-21 15:11:02 -0700381 mMainBuffer(thread->sinkBuffer()),
Eric Laurent81784c32012-11-19 14:55:58 -0800382 mAuxBuffer(NULL),
383 mAuxEffectId(0), mHasVolumeController(false),
384 mPresentationCompleteFrames(0),
Andy Hunge10393e2015-06-12 13:59:33 -0700385 mFrameMap(16 /* sink-frame-to-track-frame map memory */),
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700386 mVolumeHandler(new media::VolumeHandler(sampleRate)),
Andy Hunge10393e2015-06-12 13:59:33 -0700387 // mSinkTimestamp
Eric Laurent81784c32012-11-19 14:55:58 -0800388 mFastIndex(-1),
Glenn Kasten5736c352012-12-04 12:12:34 -0800389 mCachedVolume(1.0),
Kevin Rocard12381092018-04-11 09:19:59 -0700390 /* The track might not play immediately after being active, similarly as if its volume was 0.
391 * When the track starts playing, its volume will be computed. */
392 mFinalVolume(0.f),
Haynes Mathew George7844f672014-01-15 12:32:55 -0800393 mResumeToStopping(false),
Eric Laurent05067782016-06-01 18:27:28 -0700394 mFlushHwPending(false),
395 mFlags(flags)
Eric Laurent81784c32012-11-19 14:55:58 -0800396{
Eric Laurent83b88082014-06-20 18:31:16 -0700397 // client == 0 implies sharedBuffer == 0
398 ALOG_ASSERT(!(client == 0 && sharedBuffer != 0));
399
Eric Laurente93cc032016-05-05 10:15:10 -0700400 ALOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %zu", sharedBuffer->pointer(),
Eric Laurent83b88082014-06-20 18:31:16 -0700401 sharedBuffer->size());
402
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700403 if (mCblk == NULL) {
404 return;
Eric Laurent81784c32012-11-19 14:55:58 -0800405 }
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700406
407 if (sharedBuffer == 0) {
408 mAudioTrackServerProxy = new AudioTrackServerProxy(mCblk, mBuffer, frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700409 mFrameSize, !isExternalTrack(), sampleRate);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700410 } else {
411 mAudioTrackServerProxy = new StaticAudioTrackServerProxy(mCblk, mBuffer, frameCount,
412 mFrameSize);
413 }
414 mServerProxy = mAudioTrackServerProxy;
415
Andy Hung1bc088a2018-02-09 15:57:31 -0800416 if (!thread->isTrackAllowed_l(channelMask, format, sessionId, uid)) {
417 ALOGE("no more tracks available");
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700418 return;
419 }
420 // only allocate a fast track index if we were able to allocate a normal track name
Eric Laurent05067782016-06-01 18:27:28 -0700421 if (flags & AUDIO_OUTPUT_FLAG_FAST) {
Andy Hunga5427822015-09-11 16:15:35 -0700422 // FIXME: Not calling framesReadyIsCalledByMultipleThreads() exposes a potential
423 // race with setSyncEvent(). However, if we call it, we cannot properly start
424 // static fast tracks (SoundPool) immediately after stopping.
425 //mAudioTrackServerProxy->framesReadyIsCalledByMultipleThreads();
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700426 ALOG_ASSERT(thread->mFastTrackAvailMask != 0);
427 int i = __builtin_ctz(thread->mFastTrackAvailMask);
Glenn Kastendc2c50b2016-04-21 08:13:14 -0700428 ALOG_ASSERT(0 < i && i < (int)FastMixerState::sMaxFastTracks);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700429 // FIXME This is too eager. We allocate a fast track index before the
430 // fast track becomes active. Since fast tracks are a scarce resource,
431 // this means we are potentially denying other more important fast tracks from
432 // being created. It would be better to allocate the index dynamically.
433 mFastIndex = i;
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700434 thread->mFastTrackAvailMask &= ~(1 << i);
435 }
Andy Hung1bc088a2018-02-09 15:57:31 -0800436 mName = TRACK_NAME_PENDING;
Andy Hung8946a282018-04-19 20:04:56 -0700437
Andy Hung1c86ebe2018-05-29 20:29:08 -0700438 mServerLatencySupported = thread->type() == ThreadBase::MIXER
439 || thread->type() == ThreadBase::DUPLICATING;
Andy Hung8946a282018-04-19 20:04:56 -0700440#ifdef TEE_SINK
441 mTee.setId(std::string("_") + std::to_string(mThreadIoHandle)
442 + "_" + std::to_string(mId) +
443 + "_PEND_T");
444#endif
Eric Laurent81784c32012-11-19 14:55:58 -0800445}
446
447AudioFlinger::PlaybackThread::Track::~Track()
448{
449 ALOGV("PlaybackThread::Track destructor");
Glenn Kasten0c72b242013-09-11 09:14:16 -0700450
451 // The destructor would clear mSharedBuffer,
452 // but it will not push the decremented reference count,
453 // leaving the client's IMemory dangling indefinitely.
454 // This prevents that leak.
455 if (mSharedBuffer != 0) {
456 mSharedBuffer.clear();
Glenn Kasten0c72b242013-09-11 09:14:16 -0700457 }
Eric Laurent81784c32012-11-19 14:55:58 -0800458}
459
Glenn Kasten03003332013-08-06 15:40:54 -0700460status_t AudioFlinger::PlaybackThread::Track::initCheck() const
461{
462 status_t status = TrackBase::initCheck();
Andy Hung1bc088a2018-02-09 15:57:31 -0800463 if (status == NO_ERROR && mName == TRACK_NAME_FAILURE) {
Glenn Kasten03003332013-08-06 15:40:54 -0700464 status = NO_MEMORY;
465 }
466 return status;
467}
468
Eric Laurent81784c32012-11-19 14:55:58 -0800469void AudioFlinger::PlaybackThread::Track::destroy()
470{
471 // NOTE: destroyTrack_l() can remove a strong reference to this Track
472 // by removing it from mTracks vector, so there is a risk that this Tracks's
473 // destructor is called. As the destructor needs to lock mLock,
474 // we must acquire a strong reference on this Track before locking mLock
475 // here so that the destructor is called only when exiting this function.
476 // On the other hand, as long as Track::destroy() is only called by
477 // TrackHandle destructor, the TrackHandle still holds a strong ref on
478 // this Track with its member mTrack.
479 sp<Track> keep(this);
480 { // scope for mLock
Eric Laurentaaa44472014-09-12 17:41:50 -0700481 bool wasActive = false;
Eric Laurent81784c32012-11-19 14:55:58 -0800482 sp<ThreadBase> thread = mThread.promote();
483 if (thread != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -0800484 Mutex::Autolock _l(thread->mLock);
485 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Eric Laurentaaa44472014-09-12 17:41:50 -0700486 wasActive = playbackThread->destroyTrack_l(this);
487 }
488 if (isExternalTrack() && !wasActive) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700489 AudioSystem::releaseOutput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -0800490 }
491 }
492}
493
Andy Hungf6ab58d2018-05-25 12:50:39 -0700494void AudioFlinger::PlaybackThread::Track::appendDumpHeader(String8& result)
Eric Laurent81784c32012-11-19 14:55:58 -0800495{
Andy Hungf6ab58d2018-05-25 12:50:39 -0700496 result.appendFormat("T Name Active Client Session S Flags "
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700497 " Format Chn mask SRate "
498 "ST Usg CT "
499 " G db L dB R dB VS dB "
500 " Server FrmCnt FrmRdy F Underruns Flushed"
501 "%s\n",
502 isServerLatencySupported() ? " Latency" : "");
Eric Laurent81784c32012-11-19 14:55:58 -0800503}
504
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700505void AudioFlinger::PlaybackThread::Track::appendDump(String8& result, bool active)
Eric Laurent81784c32012-11-19 14:55:58 -0800506{
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700507 char trackType;
508 switch (mType) {
509 case TYPE_DEFAULT:
510 case TYPE_OUTPUT:
Andy Hungf6ab58d2018-05-25 12:50:39 -0700511 if (isStatic()) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700512 trackType = 'S'; // static
513 } else {
514 trackType = ' '; // normal
Eric Laurentbfb1b832013-01-07 09:53:42 -0800515 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700516 break;
517 case TYPE_PATCH:
518 trackType = 'P';
519 break;
520 default:
521 trackType = '?';
Eric Laurent81784c32012-11-19 14:55:58 -0800522 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700523
524 if (isFastTrack()) {
525 result.appendFormat("F%c %3d", trackType, mFastIndex);
Andy Hung1bc088a2018-02-09 15:57:31 -0800526 } else if (mName == TRACK_NAME_PENDING) {
527 result.appendFormat("%c pend", trackType);
528 } else if (mName == TRACK_NAME_FAILURE) {
529 result.appendFormat("%c fail", trackType);
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700530 } else {
Andy Hung1bc088a2018-02-09 15:57:31 -0800531 result.appendFormat("%c %4d", trackType, mName);
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700532 }
533
Eric Laurent81784c32012-11-19 14:55:58 -0800534 char nowInUnderrun;
535 switch (mObservedUnderruns.mBitFields.mMostRecent) {
536 case UNDERRUN_FULL:
537 nowInUnderrun = ' ';
538 break;
539 case UNDERRUN_PARTIAL:
540 nowInUnderrun = '<';
541 break;
542 case UNDERRUN_EMPTY:
543 nowInUnderrun = '*';
544 break;
545 default:
546 nowInUnderrun = '?';
547 break;
548 }
Andy Hungda540db2017-04-20 14:06:17 -0700549
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700550 char fillingStatus;
551 switch (mFillingUpStatus) {
552 case FS_INVALID:
553 fillingStatus = 'I';
554 break;
555 case FS_FILLING:
556 fillingStatus = 'f';
557 break;
558 case FS_FILLED:
559 fillingStatus = 'F';
560 break;
561 case FS_ACTIVE:
562 fillingStatus = 'A';
563 break;
564 default:
565 fillingStatus = '?';
566 break;
567 }
568
569 // clip framesReadySafe to max representation in dump
570 const size_t framesReadySafe =
571 std::min(mAudioTrackServerProxy->framesReadySafe(), (size_t)99999999);
572
573 // obtain volumes
574 const gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR();
575 const std::pair<float /* volume */, bool /* active */> vsVolume =
576 mVolumeHandler->getLastVolume();
577
578 // Our effective frame count is obtained by ServerProxy::getBufferSizeInFrames()
579 // as it may be reduced by the application.
580 const size_t bufferSizeInFrames = (size_t)mAudioTrackServerProxy->getBufferSizeInFrames();
581 // Check whether the buffer size has been modified by the app.
582 const char modifiedBufferChar = bufferSizeInFrames < mFrameCount
583 ? 'r' /* buffer reduced */: bufferSizeInFrames > mFrameCount
584 ? 'e' /* error */ : ' ' /* identical */;
585
586 result.appendFormat("%7s %6u %7u %2s 0x%03X "
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700587 "%08X %08X %6u "
588 "%2u %3x %2x "
589 "%5.2g %5.2g %5.2g %5.2g%c "
590 "%08X %6zu%c %6zu %c %9u%c %7u",
Marco Nelissenb2208842014-02-07 14:00:50 -0800591 active ? "yes" : "no",
Andy Hung4ef19fa2018-05-15 19:35:29 -0700592 (mClient == 0) ? getpid() : mClient->pid(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700593 mSessionId,
594 getTrackStateString(),
595 mCblk->mFlags,
596
Eric Laurent81784c32012-11-19 14:55:58 -0800597 mFormat,
598 mChannelMask,
Andy Hungcef2daa2018-06-01 15:31:49 -0700599 sampleRate(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700600
601 mStreamType,
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700602 mAttr.usage,
603 mAttr.content_type,
604
605 20.0 * log10(mFinalVolume),
Glenn Kastenc56f3422014-03-21 17:53:17 -0700606 20.0 * log10(float_from_gain(gain_minifloat_unpack_left(vlr))),
607 20.0 * log10(float_from_gain(gain_minifloat_unpack_right(vlr))),
Andy Hungda540db2017-04-20 14:06:17 -0700608 20.0 * log10(vsVolume.first), // VolumeShaper(s) total volume
609 vsVolume.second ? 'A' : ' ', // if any VolumeShapers active
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700610
Glenn Kastenf20e1d82013-07-12 09:45:18 -0700611 mCblk->mServer,
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700612 bufferSizeInFrames,
613 modifiedBufferChar,
614 framesReadySafe,
615 fillingStatus,
Glenn Kasten82aaf942013-07-17 16:05:07 -0700616 mAudioTrackServerProxy->getUnderrunFrames(),
Andy Hung2148bf02016-11-28 19:01:02 -0800617 nowInUnderrun,
Andy Hungf6ab58d2018-05-25 12:50:39 -0700618 (unsigned)mAudioTrackServerProxy->framesFlushed() % 10000000
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700619 );
Andy Hungcef2daa2018-06-01 15:31:49 -0700620
621 if (isServerLatencySupported()) {
622 double latencyMs;
623 bool fromTrack;
624 if (getTrackLatencyMs(&latencyMs, &fromTrack) == OK) {
625 // Show latency in msec, followed by 't' if from track timestamp (the most accurate)
626 // or 'k' if estimated from kernel because track frames haven't been presented yet.
627 result.appendFormat(" %7.2lf %c", latencyMs, fromTrack ? 't' : 'k');
Andy Hungf6ab58d2018-05-25 12:50:39 -0700628 } else {
Andy Hungcef2daa2018-06-01 15:31:49 -0700629 result.appendFormat("%10s", mCblk->mServer != 0 ? "unavail" : "new");
Andy Hungf6ab58d2018-05-25 12:50:39 -0700630 }
631 }
632 result.append("\n");
Eric Laurent81784c32012-11-19 14:55:58 -0800633}
634
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800635uint32_t AudioFlinger::PlaybackThread::Track::sampleRate() const {
636 return mAudioTrackServerProxy->getSampleRate();
637}
638
Eric Laurent81784c32012-11-19 14:55:58 -0800639// AudioBufferProvider interface
640status_t AudioFlinger::PlaybackThread::Track::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -0800641 AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -0800642{
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800643 ServerProxy::Buffer buf;
644 size_t desiredFrames = buffer->frameCount;
645 buf.mFrameCount = desiredFrames;
646 status_t status = mServerProxy->obtainBuffer(&buf);
647 buffer->frameCount = buf.mFrameCount;
648 buffer->raw = buf.mRaw;
Mikhail Naganova66d3892017-05-03 16:50:56 -0700649 if (buf.mFrameCount == 0 && !isStopping() && !isStopped() && !isPaused()) {
650 ALOGV("underrun, framesReady(%zu) < framesDesired(%zd), state: %d",
651 buf.mFrameCount, desiredFrames, mState);
Glenn Kasten82aaf942013-07-17 16:05:07 -0700652 mAudioTrackServerProxy->tallyUnderrunFrames(desiredFrames);
Phil Burk2812d9e2016-01-04 10:34:30 -0800653 } else {
654 mAudioTrackServerProxy->tallyUnderrunFrames(0);
Eric Laurent81784c32012-11-19 14:55:58 -0800655 }
Phil Burk2812d9e2016-01-04 10:34:30 -0800656
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800657 return status;
Eric Laurent81784c32012-11-19 14:55:58 -0800658}
659
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700660// releaseBuffer() is not overridden
661
662// ExtendedAudioBufferProvider interface
663
Andy Hung27876c02014-09-09 18:07:55 -0700664// framesReady() may return an approximation of the number of frames if called
665// from a different thread than the one calling Proxy->obtainBuffer() and
666// Proxy->releaseBuffer(). Also note there is no mutual exclusion in the
667// AudioTrackServerProxy so be especially careful calling with FastTracks.
Eric Laurent81784c32012-11-19 14:55:58 -0800668size_t AudioFlinger::PlaybackThread::Track::framesReady() const {
Andy Hung27876c02014-09-09 18:07:55 -0700669 if (mSharedBuffer != 0 && (isStopped() || isStopping())) {
670 // Static tracks return zero frames immediately upon stopping (for FastTracks).
671 // The remainder of the buffer is not drained.
672 return 0;
673 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800674 return mAudioTrackServerProxy->framesReady();
Eric Laurent81784c32012-11-19 14:55:58 -0800675}
676
Andy Hung818e7a32016-02-16 18:08:07 -0800677int64_t AudioFlinger::PlaybackThread::Track::framesReleased() const
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700678{
679 return mAudioTrackServerProxy->framesReleased();
680}
681
Andy Hung818e7a32016-02-16 18:08:07 -0800682void AudioFlinger::PlaybackThread::Track::onTimestamp(const ExtendedTimestamp &timestamp)
Andy Hung6ae58432016-02-16 18:32:24 -0800683{
684 // This call comes from a FastTrack and should be kept lockless.
685 // The server side frames are already translated to client frames.
Andy Hung818e7a32016-02-16 18:08:07 -0800686 mAudioTrackServerProxy->setTimestamp(timestamp);
Andy Hung6ae58432016-02-16 18:32:24 -0800687
Andy Hung818e7a32016-02-16 18:08:07 -0800688 // We do not set drained here, as FastTrack timestamp may not go to very last frame.
Andy Hungcef2daa2018-06-01 15:31:49 -0700689
690 // Compute latency.
691 // TODO: Consider whether the server latency may be passed in by FastMixer
692 // as a constant for all active FastTracks.
693 const double latencyMs = timestamp.getOutputServerLatencyMs(sampleRate());
694 mServerLatencyFromTrack.store(true);
695 mServerLatencyMs.store(latencyMs);
Andy Hung6ae58432016-02-16 18:32:24 -0800696}
697
Eric Laurent81784c32012-11-19 14:55:58 -0800698// Don't call for fast tracks; the framesReady() could result in priority inversion
699bool AudioFlinger::PlaybackThread::Track::isReady() const {
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -0800700 if (mFillingUpStatus != FS_FILLING || isStopped() || isPausing()) {
701 return true;
702 }
703
Eric Laurent16498512014-03-17 17:22:08 -0700704 if (isStopping()) {
705 if (framesReady() > 0) {
706 mFillingUpStatus = FS_FILLED;
707 }
Eric Laurent81784c32012-11-19 14:55:58 -0800708 return true;
709 }
710
Phil Burke8972b02016-03-04 11:29:57 -0800711 if (framesReady() >= mServerProxy->getBufferSizeInFrames() ||
Glenn Kasten96f60d82013-07-12 10:21:18 -0700712 (mCblk->mFlags & CBLK_FORCEREADY)) {
Eric Laurent81784c32012-11-19 14:55:58 -0800713 mFillingUpStatus = FS_FILLED;
Glenn Kasten96f60d82013-07-12 10:21:18 -0700714 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -0800715 return true;
716 }
717 return false;
718}
719
Glenn Kasten0f11b512014-01-31 16:18:54 -0800720status_t AudioFlinger::PlaybackThread::Track::start(AudioSystem::sync_event_t event __unused,
Glenn Kastend848eb42016-03-08 13:42:11 -0800721 audio_session_t triggerSession __unused)
Eric Laurent81784c32012-11-19 14:55:58 -0800722{
723 status_t status = NO_ERROR;
724 ALOGV("start(%d), calling pid %d session %d",
725 mName, IPCThreadState::self()->getCallingPid(), mSessionId);
726
727 sp<ThreadBase> thread = mThread.promote();
728 if (thread != 0) {
Eric Laurent813e2a72013-08-31 12:59:48 -0700729 if (isOffloaded()) {
730 Mutex::Autolock _laf(thread->mAudioFlinger->mLock);
731 Mutex::Autolock _lth(thread->mLock);
732 sp<EffectChain> ec = thread->getEffectChain_l(mSessionId);
Eric Laurent5baf2af2013-09-12 17:37:00 -0700733 if (thread->mAudioFlinger->isNonOffloadableGlobalEffectEnabled_l() ||
734 (ec != 0 && ec->isNonOffloadableEnabled())) {
Eric Laurent813e2a72013-08-31 12:59:48 -0700735 invalidate();
736 return PERMISSION_DENIED;
737 }
738 }
739 Mutex::Autolock _lth(thread->mLock);
Eric Laurent81784c32012-11-19 14:55:58 -0800740 track_state state = mState;
741 // here the track could be either new, or restarted
742 // in both cases "unstop" the track
Eric Laurentbfb1b832013-01-07 09:53:42 -0800743
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -0800744 // initial state-stopping. next state-pausing.
745 // What if resume is called ?
746
747 if (state == PAUSED || state == PAUSING) {
Eric Laurentbfb1b832013-01-07 09:53:42 -0800748 if (mResumeToStopping) {
749 // happened we need to resume to STOPPING_1
750 mState = TrackBase::STOPPING_1;
751 ALOGV("PAUSED => STOPPING_1 (%d) on thread %p", mName, this);
752 } else {
753 mState = TrackBase::RESUMING;
754 ALOGV("PAUSED => RESUMING (%d) on thread %p", mName, this);
755 }
Eric Laurent81784c32012-11-19 14:55:58 -0800756 } else {
757 mState = TrackBase::ACTIVE;
758 ALOGV("? => ACTIVE (%d) on thread %p", mName, this);
759 }
760
Andy Hunge10393e2015-06-12 13:59:33 -0700761 // states to reset position info for non-offloaded/direct tracks
762 if (!isOffloaded() && !isDirect()
763 && (state == IDLE || state == STOPPED || state == FLUSHED)) {
764 mFrameMap.reset();
765 }
Eric Laurentbfb1b832013-01-07 09:53:42 -0800766 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Haynes Mathew George240934b2015-03-11 18:25:50 -0700767 if (isFastTrack()) {
768 // refresh fast track underruns on start because that field is never cleared
769 // by the fast mixer; furthermore, the same track can be recycled, i.e. start
770 // after stop.
771 mObservedUnderruns = playbackThread->getFastTrackUnderruns(mFastIndex);
772 }
Eric Laurentbfb1b832013-01-07 09:53:42 -0800773 status = playbackThread->addTrack_l(this);
774 if (status == INVALID_OPERATION || status == PERMISSION_DENIED) {
Eric Laurent81784c32012-11-19 14:55:58 -0800775 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800776 // restore previous state if start was rejected by policy manager
777 if (status == PERMISSION_DENIED) {
778 mState = state;
779 }
780 }
Andy Hung1d3556d2018-03-29 16:30:14 -0700781
782 if (status == NO_ERROR || status == ALREADY_EXISTS) {
783 // for streaming tracks, remove the buffer read stop limit.
784 mAudioTrackServerProxy->start();
785 }
786
Eric Laurentbfb1b832013-01-07 09:53:42 -0800787 // track was already in the active list, not a problem
788 if (status == ALREADY_EXISTS) {
789 status = NO_ERROR;
Glenn Kasten12022ff2013-10-17 11:32:39 -0700790 } else {
791 // Acknowledge any pending flush(), so that subsequent new data isn't discarded.
792 // It is usually unsafe to access the server proxy from a binder thread.
793 // But in this case we know the mixer thread (whether normal mixer or fast mixer)
794 // isn't looking at this track yet: we still hold the normal mixer thread lock,
795 // and for fast tracks the track is not yet in the fast mixer thread's active set.
Andy Hunge6fb82a2015-09-09 14:39:02 -0700796 // For static tracks, this is used to acknowledge change in position or loop.
Eric Laurent564d1442015-09-09 12:26:52 -0700797 ServerProxy::Buffer buffer;
798 buffer.mFrameCount = 1;
799 (void) mAudioTrackServerProxy->obtainBuffer(&buffer, true /*ackFlush*/);
Eric Laurent81784c32012-11-19 14:55:58 -0800800 }
801 } else {
802 status = BAD_VALUE;
803 }
804 return status;
805}
806
807void AudioFlinger::PlaybackThread::Track::stop()
808{
809 ALOGV("stop(%d), calling pid %d", mName, IPCThreadState::self()->getCallingPid());
810 sp<ThreadBase> thread = mThread.promote();
811 if (thread != 0) {
812 Mutex::Autolock _l(thread->mLock);
813 track_state state = mState;
814 if (state == RESUMING || state == ACTIVE || state == PAUSING || state == PAUSED) {
815 // If the track is not active (PAUSED and buffers full), flush buffers
816 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
817 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
818 reset();
819 mState = STOPPED;
Eric Laurentab5cdba2014-06-09 17:22:27 -0700820 } else if (!isFastTrack() && !isOffloaded() && !isDirect()) {
Eric Laurent81784c32012-11-19 14:55:58 -0800821 mState = STOPPED;
822 } else {
Eric Laurentbfb1b832013-01-07 09:53:42 -0800823 // For fast tracks prepareTracks_l() will set state to STOPPING_2
824 // presentation is complete
825 // For an offloaded track this starts a drain and state will
826 // move to STOPPING_2 when drain completes and then STOPPED
Eric Laurent81784c32012-11-19 14:55:58 -0800827 mState = STOPPING_1;
Eric Laurente93cc032016-05-05 10:15:10 -0700828 if (isOffloaded()) {
829 mRetryCount = PlaybackThread::kMaxTrackStopRetriesOffload;
830 }
Eric Laurent81784c32012-11-19 14:55:58 -0800831 }
Eric Laurentb369caf2015-03-30 20:51:47 -0700832 playbackThread->broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800833 ALOGV("not stopping/stopped => stopping/stopped (%d) on thread %p", mName,
834 playbackThread);
835 }
Eric Laurent81784c32012-11-19 14:55:58 -0800836 }
837}
838
839void AudioFlinger::PlaybackThread::Track::pause()
840{
841 ALOGV("pause(%d), calling pid %d", mName, IPCThreadState::self()->getCallingPid());
842 sp<ThreadBase> thread = mThread.promote();
843 if (thread != 0) {
844 Mutex::Autolock _l(thread->mLock);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800845 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
846 switch (mState) {
847 case STOPPING_1:
848 case STOPPING_2:
849 if (!isOffloaded()) {
850 /* nothing to do if track is not offloaded */
851 break;
852 }
853
854 // Offloaded track was draining, we need to carry on draining when resumed
855 mResumeToStopping = true;
856 // fall through...
857 case ACTIVE:
858 case RESUMING:
Eric Laurent81784c32012-11-19 14:55:58 -0800859 mState = PAUSING;
860 ALOGV("ACTIVE/RESUMING => PAUSING (%d) on thread %p", mName, thread.get());
Eric Laurentede6c3b2013-09-19 14:37:46 -0700861 playbackThread->broadcast_l();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800862 break;
Eric Laurent81784c32012-11-19 14:55:58 -0800863
Eric Laurentbfb1b832013-01-07 09:53:42 -0800864 default:
865 break;
Eric Laurent81784c32012-11-19 14:55:58 -0800866 }
867 }
868}
869
870void AudioFlinger::PlaybackThread::Track::flush()
871{
872 ALOGV("flush(%d)", mName);
873 sp<ThreadBase> thread = mThread.promote();
874 if (thread != 0) {
875 Mutex::Autolock _l(thread->mLock);
Eric Laurent81784c32012-11-19 14:55:58 -0800876 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800877
Phil Burk4bb650b2016-09-09 12:11:17 -0700878 // Flush the ring buffer now if the track is not active in the PlaybackThread.
879 // Otherwise the flush would not be done until the track is resumed.
880 // Requires FastTrack removal be BLOCK_UNTIL_ACKED
881 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
882 (void)mServerProxy->flushBufferIfNeeded();
883 }
884
Eric Laurentbfb1b832013-01-07 09:53:42 -0800885 if (isOffloaded()) {
886 // If offloaded we allow flush during any state except terminated
887 // and keep the track active to avoid problems if user is seeking
888 // rapidly and underlying hardware has a significant delay handling
889 // a pause
890 if (isTerminated()) {
891 return;
892 }
893
894 ALOGV("flush: offload flush");
Eric Laurent81784c32012-11-19 14:55:58 -0800895 reset();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800896
897 if (mState == STOPPING_1 || mState == STOPPING_2) {
898 ALOGV("flushed in STOPPING_1 or 2 state, change state to ACTIVE");
899 mState = ACTIVE;
900 }
901
Haynes Mathew George7844f672014-01-15 12:32:55 -0800902 mFlushHwPending = true;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800903 mResumeToStopping = false;
904 } else {
905 if (mState != STOPPING_1 && mState != STOPPING_2 && mState != STOPPED &&
906 mState != PAUSED && mState != PAUSING && mState != IDLE && mState != FLUSHED) {
907 return;
908 }
909 // No point remaining in PAUSED state after a flush => go to
910 // FLUSHED state
911 mState = FLUSHED;
912 // do not reset the track if it is still in the process of being stopped or paused.
913 // this will be done by prepareTracks_l() when the track is stopped.
914 // prepareTracks_l() will see mState == FLUSHED, then
915 // remove from active track list, reset(), and trigger presentation complete
Eric Laurentd1f69b02014-12-15 14:33:13 -0800916 if (isDirect()) {
917 mFlushHwPending = true;
918 }
Eric Laurentbfb1b832013-01-07 09:53:42 -0800919 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
920 reset();
921 }
Eric Laurent81784c32012-11-19 14:55:58 -0800922 }
Eric Laurentbfb1b832013-01-07 09:53:42 -0800923 // Prevent flush being lost if the track is flushed and then resumed
924 // before mixer thread can run. This is important when offloading
925 // because the hardware buffer could hold a large amount of audio
Eric Laurentede6c3b2013-09-19 14:37:46 -0700926 playbackThread->broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800927 }
928}
929
Haynes Mathew George7844f672014-01-15 12:32:55 -0800930// must be called with thread lock held
931void AudioFlinger::PlaybackThread::Track::flushAck()
932{
Eric Laurentd1f69b02014-12-15 14:33:13 -0800933 if (!isOffloaded() && !isDirect())
Haynes Mathew George7844f672014-01-15 12:32:55 -0800934 return;
935
Phil Burk4bb650b2016-09-09 12:11:17 -0700936 // Clear the client ring buffer so that the app can prime the buffer while paused.
937 // Otherwise it might not get cleared until playback is resumed and obtainBuffer() is called.
938 mServerProxy->flushBufferIfNeeded();
939
Haynes Mathew George7844f672014-01-15 12:32:55 -0800940 mFlushHwPending = false;
941}
942
Eric Laurent81784c32012-11-19 14:55:58 -0800943void AudioFlinger::PlaybackThread::Track::reset()
944{
945 // Do not reset twice to avoid discarding data written just after a flush and before
946 // the audioflinger thread detects the track is stopped.
947 if (!mResetDone) {
Eric Laurent81784c32012-11-19 14:55:58 -0800948 // Force underrun condition to avoid false underrun callback until first data is
949 // written to buffer
Glenn Kasten96f60d82013-07-12 10:21:18 -0700950 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -0800951 mFillingUpStatus = FS_FILLING;
952 mResetDone = true;
953 if (mState == FLUSHED) {
954 mState = IDLE;
955 }
956 }
957}
958
Eric Laurentbfb1b832013-01-07 09:53:42 -0800959status_t AudioFlinger::PlaybackThread::Track::setParameters(const String8& keyValuePairs)
960{
961 sp<ThreadBase> thread = mThread.promote();
962 if (thread == 0) {
963 ALOGE("thread is dead");
964 return FAILED_TRANSACTION;
965 } else if ((thread->type() == ThreadBase::DIRECT) ||
966 (thread->type() == ThreadBase::OFFLOAD)) {
967 return thread->setParameters(keyValuePairs);
968 } else {
969 return PERMISSION_DENIED;
970 }
971}
972
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800973VolumeShaper::Status AudioFlinger::PlaybackThread::Track::applyVolumeShaper(
974 const sp<VolumeShaper::Configuration>& configuration,
975 const sp<VolumeShaper::Operation>& operation)
976{
Andy Hung10cbff12017-02-21 17:30:14 -0800977 sp<VolumeShaper::Configuration> newConfiguration;
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800978
Andy Hung10cbff12017-02-21 17:30:14 -0800979 if (isOffloadedOrDirect()) {
980 const VolumeShaper::Configuration::OptionFlag optionFlag
981 = configuration->getOptionFlags();
982 if ((optionFlag & VolumeShaper::Configuration::OPTION_FLAG_CLOCK_TIME) == 0) {
983 ALOGW("%s tracks do not support frame counted VolumeShaper,"
984 " using clock time instead", isOffloaded() ? "Offload" : "Direct");
985 newConfiguration = new VolumeShaper::Configuration(*configuration);
986 newConfiguration->setOptionFlags(
987 VolumeShaper::Configuration::OptionFlag(optionFlag
988 | VolumeShaper::Configuration::OPTION_FLAG_CLOCK_TIME));
989 }
990 }
991
992 VolumeShaper::Status status = mVolumeHandler->applyVolumeShaper(
993 (newConfiguration.get() != nullptr ? newConfiguration : configuration), operation);
994
995 if (isOffloadedOrDirect()) {
996 // Signal thread to fetch new volume.
997 sp<ThreadBase> thread = mThread.promote();
998 if (thread != 0) {
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700999 Mutex::Autolock _l(thread->mLock);
Andy Hung10cbff12017-02-21 17:30:14 -08001000 thread->broadcast_l();
1001 }
1002 }
1003 return status;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001004}
1005
1006sp<VolumeShaper::State> AudioFlinger::PlaybackThread::Track::getVolumeShaperState(int id)
1007{
1008 // Note: We don't check if Thread exists.
1009
1010 // mVolumeHandler is thread safe.
1011 return mVolumeHandler->getVolumeShaperState(id);
1012}
1013
Kevin Rocard12381092018-04-11 09:19:59 -07001014void AudioFlinger::PlaybackThread::Track::setFinalVolume(float volume)
1015{
1016 if (mFinalVolume != volume) { // Compare to an epsilon if too many meaningless updates
1017 mFinalVolume = volume;
1018 setMetadataHasChanged();
1019 }
1020}
1021
1022void AudioFlinger::PlaybackThread::Track::copyMetadataTo(MetadataInserter& backInserter) const
1023{
1024 *backInserter++ = {
1025 .usage = mAttr.usage,
1026 .content_type = mAttr.content_type,
1027 .gain = mFinalVolume,
1028 };
1029}
1030
Glenn Kasten573d80a2013-08-26 09:36:23 -07001031status_t AudioFlinger::PlaybackThread::Track::getTimestamp(AudioTimestamp& timestamp)
1032{
Andy Hung818e7a32016-02-16 18:08:07 -08001033 if (!isOffloaded() && !isDirect()) {
1034 return INVALID_OPERATION; // normal tracks handled through SSQ
Glenn Kastenfe346c72013-08-30 13:28:22 -07001035 }
Glenn Kasten573d80a2013-08-26 09:36:23 -07001036 sp<ThreadBase> thread = mThread.promote();
1037 if (thread == 0) {
Glenn Kastenfe346c72013-08-30 13:28:22 -07001038 return INVALID_OPERATION;
Glenn Kasten573d80a2013-08-26 09:36:23 -07001039 }
Phil Burk6140c792015-03-19 14:30:21 -07001040
Glenn Kasten573d80a2013-08-26 09:36:23 -07001041 Mutex::Autolock _l(thread->mLock);
1042 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Andy Hung818e7a32016-02-16 18:08:07 -08001043 return playbackThread->getTimestamp_l(timestamp);
Glenn Kasten573d80a2013-08-26 09:36:23 -07001044}
1045
Eric Laurent81784c32012-11-19 14:55:58 -08001046status_t AudioFlinger::PlaybackThread::Track::attachAuxEffect(int EffectId)
1047{
1048 status_t status = DEAD_OBJECT;
1049 sp<ThreadBase> thread = mThread.promote();
1050 if (thread != 0) {
1051 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1052 sp<AudioFlinger> af = mClient->audioFlinger();
1053
1054 Mutex::Autolock _l(af->mLock);
1055
1056 sp<PlaybackThread> srcThread = af->getEffectThread_l(AUDIO_SESSION_OUTPUT_MIX, EffectId);
1057
1058 if (EffectId != 0 && srcThread != 0 && playbackThread != srcThread.get()) {
1059 Mutex::Autolock _dl(playbackThread->mLock);
1060 Mutex::Autolock _sl(srcThread->mLock);
1061 sp<EffectChain> chain = srcThread->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
1062 if (chain == 0) {
1063 return INVALID_OPERATION;
1064 }
1065
1066 sp<EffectModule> effect = chain->getEffectFromId_l(EffectId);
1067 if (effect == 0) {
1068 return INVALID_OPERATION;
1069 }
1070 srcThread->removeEffect_l(effect);
Eric Laurent5baf2af2013-09-12 17:37:00 -07001071 status = playbackThread->addEffect_l(effect);
1072 if (status != NO_ERROR) {
1073 srcThread->addEffect_l(effect);
1074 return INVALID_OPERATION;
1075 }
Eric Laurent81784c32012-11-19 14:55:58 -08001076 // removeEffect_l() has stopped the effect if it was active so it must be restarted
1077 if (effect->state() == EffectModule::ACTIVE ||
1078 effect->state() == EffectModule::STOPPING) {
1079 effect->start();
1080 }
1081
1082 sp<EffectChain> dstChain = effect->chain().promote();
1083 if (dstChain == 0) {
1084 srcThread->addEffect_l(effect);
1085 return INVALID_OPERATION;
1086 }
1087 AudioSystem::unregisterEffect(effect->id());
1088 AudioSystem::registerEffect(&effect->desc(),
1089 srcThread->id(),
1090 dstChain->strategy(),
1091 AUDIO_SESSION_OUTPUT_MIX,
1092 effect->id());
Eric Laurentd72b7c02013-10-12 16:17:46 -07001093 AudioSystem::setEffectEnabled(effect->id(), effect->isEnabled());
Eric Laurent81784c32012-11-19 14:55:58 -08001094 }
1095 status = playbackThread->attachAuxEffect(this, EffectId);
1096 }
1097 return status;
1098}
1099
1100void AudioFlinger::PlaybackThread::Track::setAuxBuffer(int EffectId, int32_t *buffer)
1101{
1102 mAuxEffectId = EffectId;
1103 mAuxBuffer = buffer;
1104}
1105
Andy Hung818e7a32016-02-16 18:08:07 -08001106bool AudioFlinger::PlaybackThread::Track::presentationComplete(
1107 int64_t framesWritten, size_t audioHalFrames)
Eric Laurent81784c32012-11-19 14:55:58 -08001108{
Andy Hung818e7a32016-02-16 18:08:07 -08001109 // TODO: improve this based on FrameMap if it exists, to ensure full drain.
1110 // This assists in proper timestamp computation as well as wakelock management.
1111
Eric Laurent81784c32012-11-19 14:55:58 -08001112 // a track is considered presented when the total number of frames written to audio HAL
1113 // corresponds to the number of frames written when presentationComplete() is called for the
1114 // first time (mPresentationCompleteFrames == 0) plus the buffer filling status at that time.
Eric Laurentbfb1b832013-01-07 09:53:42 -08001115 // For an offloaded track the HAL+h/w delay is variable so a HAL drain() is used
1116 // to detect when all frames have been played. In this case framesWritten isn't
1117 // useful because it doesn't always reflect whether there is data in the h/w
1118 // buffers, particularly if a track has been paused and resumed during draining
Andy Hung818e7a32016-02-16 18:08:07 -08001119 ALOGV("presentationComplete() mPresentationCompleteFrames %lld framesWritten %lld",
1120 (long long)mPresentationCompleteFrames, (long long)framesWritten);
Eric Laurent81784c32012-11-19 14:55:58 -08001121 if (mPresentationCompleteFrames == 0) {
1122 mPresentationCompleteFrames = framesWritten + audioHalFrames;
Andy Hung818e7a32016-02-16 18:08:07 -08001123 ALOGV("presentationComplete() reset: mPresentationCompleteFrames %lld audioHalFrames %zu",
1124 (long long)mPresentationCompleteFrames, audioHalFrames);
Eric Laurent81784c32012-11-19 14:55:58 -08001125 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001126
Andy Hungc54b1ff2016-02-23 14:07:07 -08001127 bool complete;
1128 if (isOffloaded()) {
1129 complete = true;
1130 } else if (isDirect() || isFastTrack()) { // these do not go through linear map
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001131 complete = framesWritten >= (int64_t) mPresentationCompleteFrames;
Andy Hungc54b1ff2016-02-23 14:07:07 -08001132 } else { // Normal tracks, OutputTracks, and PatchTracks
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001133 complete = framesWritten >= (int64_t) mPresentationCompleteFrames
Andy Hungc54b1ff2016-02-23 14:07:07 -08001134 && mAudioTrackServerProxy->isDrained();
1135 }
1136
1137 if (complete) {
Eric Laurent81784c32012-11-19 14:55:58 -08001138 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001139 mAudioTrackServerProxy->setStreamEndDone();
Eric Laurent81784c32012-11-19 14:55:58 -08001140 return true;
1141 }
1142 return false;
1143}
1144
1145void AudioFlinger::PlaybackThread::Track::triggerEvents(AudioSystem::sync_event_t type)
1146{
Ivan Lozano5ec161b2017-12-06 10:00:28 -08001147 for (size_t i = 0; i < mSyncEvents.size();) {
Eric Laurent81784c32012-11-19 14:55:58 -08001148 if (mSyncEvents[i]->type() == type) {
1149 mSyncEvents[i]->trigger();
1150 mSyncEvents.removeAt(i);
Ivan Lozano5ec161b2017-12-06 10:00:28 -08001151 } else {
1152 ++i;
Eric Laurent81784c32012-11-19 14:55:58 -08001153 }
1154 }
1155}
1156
1157// implement VolumeBufferProvider interface
1158
Glenn Kastenc56f3422014-03-21 17:53:17 -07001159gain_minifloat_packed_t AudioFlinger::PlaybackThread::Track::getVolumeLR()
Eric Laurent81784c32012-11-19 14:55:58 -08001160{
1161 // called by FastMixer, so not allowed to take any locks, block, or do I/O including logs
1162 ALOG_ASSERT(isFastTrack() && (mCblk != NULL));
Glenn Kastenc56f3422014-03-21 17:53:17 -07001163 gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR();
1164 float vl = float_from_gain(gain_minifloat_unpack_left(vlr));
1165 float vr = float_from_gain(gain_minifloat_unpack_right(vlr));
Eric Laurent81784c32012-11-19 14:55:58 -08001166 // track volumes come from shared memory, so can't be trusted and must be clamped
Glenn Kastenc56f3422014-03-21 17:53:17 -07001167 if (vl > GAIN_FLOAT_UNITY) {
1168 vl = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08001169 }
Glenn Kastenc56f3422014-03-21 17:53:17 -07001170 if (vr > GAIN_FLOAT_UNITY) {
1171 vr = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08001172 }
1173 // now apply the cached master volume and stream type volume;
1174 // this is trusted but lacks any synchronization or barrier so may be stale
1175 float v = mCachedVolume;
1176 vl *= v;
1177 vr *= v;
Glenn Kastenc56f3422014-03-21 17:53:17 -07001178 // re-combine into packed minifloat
1179 vlr = gain_minifloat_pack(gain_from_float(vl), gain_from_float(vr));
Eric Laurent81784c32012-11-19 14:55:58 -08001180 // FIXME look at mute, pause, and stop flags
1181 return vlr;
1182}
1183
1184status_t AudioFlinger::PlaybackThread::Track::setSyncEvent(const sp<SyncEvent>& event)
1185{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001186 if (isTerminated() || mState == PAUSED ||
Eric Laurent81784c32012-11-19 14:55:58 -08001187 ((framesReady() == 0) && ((mSharedBuffer != 0) ||
1188 (mState == STOPPED)))) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001189 ALOGW("Track::setSyncEvent() in invalid state %d on session %d %s mode, framesReady %zu",
Eric Laurent81784c32012-11-19 14:55:58 -08001190 mState, mSessionId, (mSharedBuffer != 0) ? "static" : "stream", framesReady());
1191 event->cancel();
1192 return INVALID_OPERATION;
1193 }
1194 (void) TrackBase::setSyncEvent(event);
1195 return NO_ERROR;
1196}
1197
Glenn Kasten5736c352012-12-04 12:12:34 -08001198void AudioFlinger::PlaybackThread::Track::invalidate()
1199{
Eric Laurent6acd1d42017-01-04 14:23:29 -08001200 TrackBase::invalidate();
Eric Laurent4d231dc2016-03-11 18:38:23 -08001201 signalClientFlag(CBLK_INVALID);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001202}
1203
1204void AudioFlinger::PlaybackThread::Track::disable()
1205{
1206 signalClientFlag(CBLK_DISABLED);
1207}
1208
1209void AudioFlinger::PlaybackThread::Track::signalClientFlag(int32_t flag)
1210{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001211 // FIXME should use proxy, and needs work
1212 audio_track_cblk_t* cblk = mCblk;
Eric Laurent4d231dc2016-03-11 18:38:23 -08001213 android_atomic_or(flag, &cblk->mFlags);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001214 android_atomic_release_store(0x40000000, &cblk->mFutex);
1215 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE
Elliott Hughesee499292014-05-21 17:55:51 -07001216 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX);
Glenn Kasten5736c352012-12-04 12:12:34 -08001217}
1218
Eric Laurent59fe0102013-09-27 18:48:26 -07001219void AudioFlinger::PlaybackThread::Track::signal()
1220{
1221 sp<ThreadBase> thread = mThread.promote();
1222 if (thread != 0) {
1223 PlaybackThread *t = (PlaybackThread *)thread.get();
1224 Mutex::Autolock _l(t->mLock);
1225 t->broadcast_l();
1226 }
1227}
1228
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001229//To be called with thread lock held
1230bool AudioFlinger::PlaybackThread::Track::isResumePending() {
1231
1232 if (mState == RESUMING)
1233 return true;
1234 /* Resume is pending if track was stopping before pause was called */
1235 if (mState == STOPPING_1 &&
1236 mResumeToStopping)
1237 return true;
1238
1239 return false;
1240}
1241
1242//To be called with thread lock held
1243void AudioFlinger::PlaybackThread::Track::resumeAck() {
1244
1245
1246 if (mState == RESUMING)
1247 mState = ACTIVE;
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08001248
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001249 // Other possibility of pending resume is stopping_1 state
1250 // Do not update the state from stopping as this prevents
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08001251 // drain being called.
1252 if (mState == STOPPING_1) {
1253 mResumeToStopping = false;
1254 }
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001255}
Andy Hunge10393e2015-06-12 13:59:33 -07001256
1257//To be called with thread lock held
1258void AudioFlinger::PlaybackThread::Track::updateTrackFrameInfo(
Andy Hung818e7a32016-02-16 18:08:07 -08001259 int64_t trackFramesReleased, int64_t sinkFramesWritten,
Andy Hungcef2daa2018-06-01 15:31:49 -07001260 uint32_t halSampleRate, const ExtendedTimestamp &timeStamp) {
Andy Hung818e7a32016-02-16 18:08:07 -08001261 //update frame map
Andy Hunge10393e2015-06-12 13:59:33 -07001262 mFrameMap.push(trackFramesReleased, sinkFramesWritten);
Andy Hung818e7a32016-02-16 18:08:07 -08001263
1264 // adjust server times and set drained state.
1265 //
1266 // Our timestamps are only updated when the track is on the Thread active list.
1267 // We need to ensure that tracks are not removed before full drain.
1268 ExtendedTimestamp local = timeStamp;
Andy Hungcef2daa2018-06-01 15:31:49 -07001269 bool drained = true; // default assume drained, if no server info found
Andy Hung818e7a32016-02-16 18:08:07 -08001270 bool checked = false;
1271 for (int i = ExtendedTimestamp::LOCATION_MAX - 1;
1272 i >= ExtendedTimestamp::LOCATION_SERVER; --i) {
1273 // Lookup the track frame corresponding to the sink frame position.
1274 if (local.mTimeNs[i] > 0) {
1275 local.mPosition[i] = mFrameMap.findX(local.mPosition[i]);
1276 // check drain state from the latest stage in the pipeline.
Andy Hung6d7b1192016-05-07 22:59:48 -07001277 if (!checked && i <= ExtendedTimestamp::LOCATION_KERNEL) {
Andy Hungcef2daa2018-06-01 15:31:49 -07001278 drained = local.mPosition[i] >= mAudioTrackServerProxy->framesReleased();
Andy Hung818e7a32016-02-16 18:08:07 -08001279 checked = true;
1280 }
1281 }
Andy Hunge10393e2015-06-12 13:59:33 -07001282 }
Andy Hungcef2daa2018-06-01 15:31:49 -07001283
1284 mAudioTrackServerProxy->setDrained(drained);
Andy Hungea2b9c02016-02-12 17:06:53 -08001285 // Set correction for flushed frames that are not accounted for in released.
Andy Hungea2b9c02016-02-12 17:06:53 -08001286 local.mFlushed = mAudioTrackServerProxy->framesFlushed();
Andy Hung818e7a32016-02-16 18:08:07 -08001287 mServerProxy->setTimestamp(local);
Andy Hungcef2daa2018-06-01 15:31:49 -07001288
1289 // Compute latency info.
1290 const bool useTrackTimestamp = !drained;
1291 const double latencyMs = useTrackTimestamp
1292 ? local.getOutputServerLatencyMs(sampleRate())
1293 : timeStamp.getOutputServerLatencyMs(halSampleRate);
1294
1295 mServerLatencyFromTrack.store(useTrackTimestamp);
1296 mServerLatencyMs.store(latencyMs);
Andy Hunge10393e2015-06-12 13:59:33 -07001297}
1298
Eric Laurent81784c32012-11-19 14:55:58 -08001299// ----------------------------------------------------------------------------
1300
Eric Laurent81784c32012-11-19 14:55:58 -08001301AudioFlinger::PlaybackThread::OutputTrack::OutputTrack(
1302 PlaybackThread *playbackThread,
1303 DuplicatingThread *sourceThread,
1304 uint32_t sampleRate,
1305 audio_format_t format,
1306 audio_channel_mask_t channelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001307 size_t frameCount,
Andy Hung1f12a8a2016-11-07 16:10:30 -08001308 uid_t uid)
Eric Laurent223fd5c2014-11-11 13:43:36 -08001309 : Track(playbackThread, NULL, AUDIO_STREAM_PATCH,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001310 audio_attributes_t{} /* currently unused for output track */,
Eric Laurent223fd5c2014-11-11 13:43:36 -08001311 sampleRate, format, channelMask, frameCount,
Andy Hung8fe68032017-06-05 16:17:51 -07001312 nullptr /* buffer */, (size_t)0 /* bufferSize */, nullptr /* sharedBuffer */,
1313 AUDIO_SESSION_NONE, uid, AUDIO_OUTPUT_FLAG_NONE,
Glenn Kastend848eb42016-03-08 13:42:11 -08001314 TYPE_OUTPUT),
Eric Laurent5bba2f62016-03-18 11:14:14 -07001315 mActive(false), mSourceThread(sourceThread)
Eric Laurent81784c32012-11-19 14:55:58 -08001316{
1317
1318 if (mCblk != NULL) {
Eric Laurent81784c32012-11-19 14:55:58 -08001319 mOutBuffer.frameCount = 0;
1320 playbackThread->mTracks.add(this);
Glenn Kastene3aa6592012-12-04 12:22:46 -08001321 ALOGV("OutputTrack constructor mCblk %p, mBuffer %p, "
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001322 "frameCount %zu, mChannelMask 0x%08x",
Glenn Kastene3aa6592012-12-04 12:22:46 -08001323 mCblk, mBuffer,
Glenn Kasten74935e42013-12-19 08:56:45 -08001324 frameCount, mChannelMask);
Glenn Kastene3aa6592012-12-04 12:22:46 -08001325 // since client and server are in the same process,
1326 // the buffer has the same virtual address on both sides
Glenn Kasten529c61b2014-07-18 15:31:02 -07001327 mClientProxy = new AudioTrackClientProxy(mCblk, mBuffer, mFrameCount, mFrameSize,
1328 true /*clientInServer*/);
Glenn Kastenc56f3422014-03-21 17:53:17 -07001329 mClientProxy->setVolumeLR(GAIN_MINIFLOAT_PACKED_UNITY);
Eric Laurent8d2d4932013-04-25 12:56:18 -07001330 mClientProxy->setSendLevel(0.0);
1331 mClientProxy->setSampleRate(sampleRate);
Eric Laurent81784c32012-11-19 14:55:58 -08001332 } else {
1333 ALOGW("Error creating output track on thread %p", playbackThread);
1334 }
1335}
1336
1337AudioFlinger::PlaybackThread::OutputTrack::~OutputTrack()
1338{
1339 clearBufferQueue();
Glenn Kastene3aa6592012-12-04 12:22:46 -08001340 // superclass destructor will now delete the server proxy and shared memory both refer to
Eric Laurent81784c32012-11-19 14:55:58 -08001341}
1342
1343status_t AudioFlinger::PlaybackThread::OutputTrack::start(AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08001344 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08001345{
1346 status_t status = Track::start(event, triggerSession);
1347 if (status != NO_ERROR) {
1348 return status;
1349 }
1350
1351 mActive = true;
1352 mRetryCount = 127;
1353 return status;
1354}
1355
1356void AudioFlinger::PlaybackThread::OutputTrack::stop()
1357{
1358 Track::stop();
1359 clearBufferQueue();
1360 mOutBuffer.frameCount = 0;
1361 mActive = false;
1362}
1363
Andy Hung1c86ebe2018-05-29 20:29:08 -07001364ssize_t AudioFlinger::PlaybackThread::OutputTrack::write(void* data, uint32_t frames)
Eric Laurent81784c32012-11-19 14:55:58 -08001365{
1366 Buffer *pInBuffer;
1367 Buffer inBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -08001368 bool outputBufferFull = false;
1369 inBuffer.frameCount = frames;
Andy Hungc25b84a2015-01-14 19:04:10 -08001370 inBuffer.raw = data;
Eric Laurent81784c32012-11-19 14:55:58 -08001371
1372 uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs();
1373
1374 if (!mActive && frames != 0) {
Andy Hung5bedff62015-01-16 11:05:32 -08001375 (void) start();
Eric Laurent81784c32012-11-19 14:55:58 -08001376 }
1377
1378 while (waitTimeLeftMs) {
1379 // First write pending buffers, then new data
1380 if (mBufferQueue.size()) {
1381 pInBuffer = mBufferQueue.itemAt(0);
1382 } else {
1383 pInBuffer = &inBuffer;
1384 }
1385
1386 if (pInBuffer->frameCount == 0) {
1387 break;
1388 }
1389
1390 if (mOutBuffer.frameCount == 0) {
1391 mOutBuffer.frameCount = pInBuffer->frameCount;
1392 nsecs_t startTime = systemTime();
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001393 status_t status = obtainBuffer(&mOutBuffer, waitTimeLeftMs);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001394 if (status != NO_ERROR && status != NOT_ENOUGH_DATA) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001395 ALOGV("OutputTrack::write() %p thread %p no more output buffers; status %d", this,
1396 mThread.unsafe_get(), status);
Eric Laurent81784c32012-11-19 14:55:58 -08001397 outputBufferFull = true;
1398 break;
1399 }
1400 uint32_t waitTimeMs = (uint32_t)ns2ms(systemTime() - startTime);
1401 if (waitTimeLeftMs >= waitTimeMs) {
1402 waitTimeLeftMs -= waitTimeMs;
1403 } else {
1404 waitTimeLeftMs = 0;
1405 }
Eric Laurent4d231dc2016-03-11 18:38:23 -08001406 if (status == NOT_ENOUGH_DATA) {
1407 restartIfDisabled();
1408 continue;
1409 }
Eric Laurent81784c32012-11-19 14:55:58 -08001410 }
1411
1412 uint32_t outFrames = pInBuffer->frameCount > mOutBuffer.frameCount ? mOutBuffer.frameCount :
1413 pInBuffer->frameCount;
Andy Hungc25b84a2015-01-14 19:04:10 -08001414 memcpy(mOutBuffer.raw, pInBuffer->raw, outFrames * mFrameSize);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001415 Proxy::Buffer buf;
1416 buf.mFrameCount = outFrames;
1417 buf.mRaw = NULL;
1418 mClientProxy->releaseBuffer(&buf);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001419 restartIfDisabled();
Eric Laurent81784c32012-11-19 14:55:58 -08001420 pInBuffer->frameCount -= outFrames;
Andy Hungc25b84a2015-01-14 19:04:10 -08001421 pInBuffer->raw = (int8_t *)pInBuffer->raw + outFrames * mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08001422 mOutBuffer.frameCount -= outFrames;
Andy Hungc25b84a2015-01-14 19:04:10 -08001423 mOutBuffer.raw = (int8_t *)mOutBuffer.raw + outFrames * mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08001424
1425 if (pInBuffer->frameCount == 0) {
1426 if (mBufferQueue.size()) {
1427 mBufferQueue.removeAt(0);
Andy Hungc25b84a2015-01-14 19:04:10 -08001428 free(pInBuffer->mBuffer);
Yunlian Jiang8adc8082017-06-06 15:59:44 -07001429 if (pInBuffer != &inBuffer) {
1430 delete pInBuffer;
1431 }
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001432 ALOGV("OutputTrack::write() %p thread %p released overflow buffer %zu", this,
Eric Laurent81784c32012-11-19 14:55:58 -08001433 mThread.unsafe_get(), mBufferQueue.size());
1434 } else {
1435 break;
1436 }
1437 }
1438 }
1439
1440 // If we could not write all frames, allocate a buffer and queue it for next time.
1441 if (inBuffer.frameCount) {
1442 sp<ThreadBase> thread = mThread.promote();
1443 if (thread != 0 && !thread->standby()) {
1444 if (mBufferQueue.size() < kMaxOverFlowBuffers) {
1445 pInBuffer = new Buffer;
Andy Hungc25b84a2015-01-14 19:04:10 -08001446 pInBuffer->mBuffer = malloc(inBuffer.frameCount * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08001447 pInBuffer->frameCount = inBuffer.frameCount;
Andy Hungc25b84a2015-01-14 19:04:10 -08001448 pInBuffer->raw = pInBuffer->mBuffer;
1449 memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08001450 mBufferQueue.add(pInBuffer);
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001451 ALOGV("OutputTrack::write() %p thread %p adding overflow buffer %zu", this,
Eric Laurent81784c32012-11-19 14:55:58 -08001452 mThread.unsafe_get(), mBufferQueue.size());
Andy Hung1c86ebe2018-05-29 20:29:08 -07001453 // audio data is consumed (stored locally); set frameCount to 0.
1454 inBuffer.frameCount = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08001455 } else {
1456 ALOGW("OutputTrack::write() %p thread %p no more overflow buffers",
1457 mThread.unsafe_get(), this);
Andy Hung1c86ebe2018-05-29 20:29:08 -07001458 // TODO: return error for this.
Eric Laurent81784c32012-11-19 14:55:58 -08001459 }
1460 }
1461 }
1462
Andy Hungc25b84a2015-01-14 19:04:10 -08001463 // Calling write() with a 0 length buffer means that no more data will be written:
1464 // We rely on stop() to set the appropriate flags to allow the remaining frames to play out.
1465 if (frames == 0 && mBufferQueue.size() == 0 && mActive) {
1466 stop();
Eric Laurent81784c32012-11-19 14:55:58 -08001467 }
1468
Andy Hung1c86ebe2018-05-29 20:29:08 -07001469 return frames - inBuffer.frameCount; // number of frames consumed.
Eric Laurent81784c32012-11-19 14:55:58 -08001470}
1471
Kevin Rocard12381092018-04-11 09:19:59 -07001472void AudioFlinger::PlaybackThread::OutputTrack::copyMetadataTo(MetadataInserter& backInserter) const
1473{
1474 std::lock_guard<std::mutex> lock(mTrackMetadatasMutex);
1475 backInserter = std::copy(mTrackMetadatas.begin(), mTrackMetadatas.end(), backInserter);
1476}
1477
1478void AudioFlinger::PlaybackThread::OutputTrack::setMetadatas(const SourceMetadatas& metadatas) {
1479 {
1480 std::lock_guard<std::mutex> lock(mTrackMetadatasMutex);
1481 mTrackMetadatas = metadatas;
1482 }
1483 // No need to adjust metadata track volumes as OutputTrack volumes are always 0dBFS.
1484 setMetadataHasChanged();
1485}
1486
Eric Laurent81784c32012-11-19 14:55:58 -08001487status_t AudioFlinger::PlaybackThread::OutputTrack::obtainBuffer(
1488 AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs)
1489{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001490 ClientProxy::Buffer buf;
1491 buf.mFrameCount = buffer->frameCount;
1492 struct timespec timeout;
1493 timeout.tv_sec = waitTimeMs / 1000;
1494 timeout.tv_nsec = (int) (waitTimeMs % 1000) * 1000000;
1495 status_t status = mClientProxy->obtainBuffer(&buf, &timeout);
1496 buffer->frameCount = buf.mFrameCount;
1497 buffer->raw = buf.mRaw;
1498 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08001499}
1500
Eric Laurent81784c32012-11-19 14:55:58 -08001501void AudioFlinger::PlaybackThread::OutputTrack::clearBufferQueue()
1502{
1503 size_t size = mBufferQueue.size();
1504
1505 for (size_t i = 0; i < size; i++) {
1506 Buffer *pBuffer = mBufferQueue.itemAt(i);
Andy Hungc25b84a2015-01-14 19:04:10 -08001507 free(pBuffer->mBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08001508 delete pBuffer;
1509 }
1510 mBufferQueue.clear();
1511}
1512
Eric Laurent4d231dc2016-03-11 18:38:23 -08001513void AudioFlinger::PlaybackThread::OutputTrack::restartIfDisabled()
1514{
1515 int32_t flags = android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
1516 if (mActive && (flags & CBLK_DISABLED)) {
1517 start();
1518 }
1519}
Eric Laurent81784c32012-11-19 14:55:58 -08001520
Eric Laurent83b88082014-06-20 18:31:16 -07001521AudioFlinger::PlaybackThread::PatchTrack::PatchTrack(PlaybackThread *playbackThread,
Eric Laurent3bcf8592015-04-03 12:13:24 -07001522 audio_stream_type_t streamType,
Eric Laurent83b88082014-06-20 18:31:16 -07001523 uint32_t sampleRate,
1524 audio_channel_mask_t channelMask,
1525 audio_format_t format,
1526 size_t frameCount,
1527 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07001528 size_t bufferSize,
Eric Laurent05067782016-06-01 18:27:28 -07001529 audio_output_flags_t flags)
Eric Laurent3bcf8592015-04-03 12:13:24 -07001530 : Track(playbackThread, NULL, streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001531 audio_attributes_t{} /* currently unused for patch track */,
Eric Laurent223fd5c2014-11-11 13:43:36 -08001532 sampleRate, format, channelMask, frameCount,
Andy Hung8fe68032017-06-05 16:17:51 -07001533 buffer, bufferSize, nullptr /* sharedBuffer */,
Andy Hung4ef19fa2018-05-15 19:35:29 -07001534 AUDIO_SESSION_NONE, AID_AUDIOSERVER, flags, TYPE_PATCH),
Eric Laurent83b88082014-06-20 18:31:16 -07001535 mProxy(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, true, true))
1536{
1537 uint64_t mixBufferNs = ((uint64_t)2 * playbackThread->frameCount() * 1000000000) /
1538 playbackThread->sampleRate();
1539 mPeerTimeout.tv_sec = mixBufferNs / 1000000000;
1540 mPeerTimeout.tv_nsec = (int) (mixBufferNs % 1000000000);
1541
1542 ALOGV("PatchTrack %p sampleRate %d mPeerTimeout %d.%03d sec",
1543 this, sampleRate,
1544 (int)mPeerTimeout.tv_sec,
1545 (int)(mPeerTimeout.tv_nsec / 1000000));
1546}
1547
1548AudioFlinger::PlaybackThread::PatchTrack::~PatchTrack()
1549{
1550}
1551
Eric Laurent4d231dc2016-03-11 18:38:23 -08001552status_t AudioFlinger::PlaybackThread::PatchTrack::start(AudioSystem::sync_event_t event,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07001553 audio_session_t triggerSession)
Eric Laurent4d231dc2016-03-11 18:38:23 -08001554{
1555 status_t status = Track::start(event, triggerSession);
1556 if (status != NO_ERROR) {
1557 return status;
1558 }
1559 android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
1560 return status;
1561}
1562
Eric Laurent83b88082014-06-20 18:31:16 -07001563// AudioBufferProvider interface
1564status_t AudioFlinger::PlaybackThread::PatchTrack::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08001565 AudioBufferProvider::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07001566{
1567 ALOG_ASSERT(mPeerProxy != 0, "PatchTrack::getNextBuffer() called without peer proxy");
1568 Proxy::Buffer buf;
1569 buf.mFrameCount = buffer->frameCount;
1570 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout);
1571 ALOGV_IF(status != NO_ERROR, "PatchTrack() %p getNextBuffer status %d", this, status);
Eric Laurentc2730ba2014-07-20 15:47:07 -07001572 buffer->frameCount = buf.mFrameCount;
Eric Laurent83b88082014-06-20 18:31:16 -07001573 if (buf.mFrameCount == 0) {
1574 return WOULD_BLOCK;
1575 }
Glenn Kastend79072e2016-01-06 08:41:20 -08001576 status = Track::getNextBuffer(buffer);
Eric Laurent83b88082014-06-20 18:31:16 -07001577 return status;
1578}
1579
1580void AudioFlinger::PlaybackThread::PatchTrack::releaseBuffer(AudioBufferProvider::Buffer* buffer)
1581{
1582 ALOG_ASSERT(mPeerProxy != 0, "PatchTrack::releaseBuffer() called without peer proxy");
1583 Proxy::Buffer buf;
1584 buf.mFrameCount = buffer->frameCount;
1585 buf.mRaw = buffer->raw;
1586 mPeerProxy->releaseBuffer(&buf);
1587 TrackBase::releaseBuffer(buffer);
1588}
1589
1590status_t AudioFlinger::PlaybackThread::PatchTrack::obtainBuffer(Proxy::Buffer* buffer,
1591 const struct timespec *timeOut)
1592{
Eric Laurent4d231dc2016-03-11 18:38:23 -08001593 status_t status = NO_ERROR;
1594 static const int32_t kMaxTries = 5;
1595 int32_t tryCounter = kMaxTries;
Andy Hungf62e1a22018-05-08 18:32:11 -07001596 const size_t originalFrameCount = buffer->mFrameCount;
Eric Laurent4d231dc2016-03-11 18:38:23 -08001597 do {
1598 if (status == NOT_ENOUGH_DATA) {
1599 restartIfDisabled();
Andy Hungf62e1a22018-05-08 18:32:11 -07001600 buffer->mFrameCount = originalFrameCount; // cleared on error, must be restored.
Eric Laurent4d231dc2016-03-11 18:38:23 -08001601 }
1602 status = mProxy->obtainBuffer(buffer, timeOut);
1603 } while ((status == NOT_ENOUGH_DATA) && (tryCounter-- > 0));
1604 return status;
Eric Laurent83b88082014-06-20 18:31:16 -07001605}
1606
1607void AudioFlinger::PlaybackThread::PatchTrack::releaseBuffer(Proxy::Buffer* buffer)
1608{
1609 mProxy->releaseBuffer(buffer);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001610 restartIfDisabled();
1611 android_atomic_or(CBLK_FORCEREADY, &mCblk->mFlags);
1612}
1613
1614void AudioFlinger::PlaybackThread::PatchTrack::restartIfDisabled()
1615{
Eric Laurent83b88082014-06-20 18:31:16 -07001616 if (android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags) & CBLK_DISABLED) {
1617 ALOGW("PatchTrack::releaseBuffer() disabled due to previous underrun, restarting");
1618 start();
1619 }
Eric Laurent83b88082014-06-20 18:31:16 -07001620}
1621
Eric Laurent81784c32012-11-19 14:55:58 -08001622// ----------------------------------------------------------------------------
1623// Record
1624// ----------------------------------------------------------------------------
1625
1626AudioFlinger::RecordHandle::RecordHandle(
1627 const sp<AudioFlinger::RecordThread::RecordTrack>& recordTrack)
1628 : BnAudioRecord(),
1629 mRecordTrack(recordTrack)
1630{
1631}
1632
1633AudioFlinger::RecordHandle::~RecordHandle() {
1634 stop_nonvirtual();
1635 mRecordTrack->destroy();
1636}
1637
Ivan Lozanoff6900d2017-08-01 15:47:38 -07001638binder::Status AudioFlinger::RecordHandle::start(int /*AudioSystem::sync_event_t*/ event,
1639 int /*audio_session_t*/ triggerSession) {
Eric Laurent81784c32012-11-19 14:55:58 -08001640 ALOGV("RecordHandle::start()");
Ivan Lozanoff6900d2017-08-01 15:47:38 -07001641 return binder::Status::fromStatusT(
1642 mRecordTrack->start((AudioSystem::sync_event_t)event, (audio_session_t) triggerSession));
Eric Laurent81784c32012-11-19 14:55:58 -08001643}
1644
Ivan Lozanoff6900d2017-08-01 15:47:38 -07001645binder::Status AudioFlinger::RecordHandle::stop() {
Eric Laurent81784c32012-11-19 14:55:58 -08001646 stop_nonvirtual();
Ivan Lozanoff6900d2017-08-01 15:47:38 -07001647 return binder::Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -08001648}
1649
1650void AudioFlinger::RecordHandle::stop_nonvirtual() {
1651 ALOGV("RecordHandle::stop()");
1652 mRecordTrack->stop();
1653}
1654
jiabin653cc0a2018-01-17 17:54:10 -08001655binder::Status AudioFlinger::RecordHandle::getActiveMicrophones(
1656 std::vector<media::MicrophoneInfo>* activeMicrophones) {
1657 ALOGV("RecordHandle::getActiveMicrophones()");
1658 return binder::Status::fromStatusT(
1659 mRecordTrack->getActiveMicrophones(activeMicrophones));
1660}
1661
Eric Laurent81784c32012-11-19 14:55:58 -08001662// ----------------------------------------------------------------------------
1663
Glenn Kasten05997e22014-03-13 15:08:33 -07001664// RecordTrack constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
Eric Laurent81784c32012-11-19 14:55:58 -08001665AudioFlinger::RecordThread::RecordTrack::RecordTrack(
1666 RecordThread *thread,
1667 const sp<Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001668 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -08001669 uint32_t sampleRate,
1670 audio_format_t format,
1671 audio_channel_mask_t channelMask,
1672 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -07001673 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07001674 size_t bufferSize,
Glenn Kastend848eb42016-03-08 13:42:11 -08001675 audio_session_t sessionId,
Andy Hung1f12a8a2016-11-07 16:10:30 -08001676 uid_t uid,
Eric Laurent05067782016-06-01 18:27:28 -07001677 audio_input_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -08001678 track_type type,
1679 audio_port_handle_t portId)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001680 : TrackBase(thread, client, attr, sampleRate, format,
Andy Hung8fe68032017-06-05 16:17:51 -07001681 channelMask, frameCount, buffer, bufferSize, sessionId, uid, false /*isOut*/,
Eric Laurent83b88082014-06-20 18:31:16 -07001682 (type == TYPE_DEFAULT) ?
Eric Laurent05067782016-06-01 18:27:28 -07001683 ((flags & AUDIO_INPUT_FLAG_FAST) ? ALLOC_PIPE : ALLOC_CBLK) :
Eric Laurent83b88082014-06-20 18:31:16 -07001684 ((buffer == NULL) ? ALLOC_LOCAL : ALLOC_NONE),
Eric Laurent20b9ef02016-12-05 11:03:16 -08001685 type, portId),
Andy Hung97a893e2015-03-29 01:03:07 -07001686 mOverflow(false),
Andy Hung4c6afaf2015-06-12 18:23:35 -07001687 mFramesToDrop(0),
1688 mResamplerBufferProvider(NULL), // initialize in case of early constructor exit
Eric Laurent05067782016-06-01 18:27:28 -07001689 mRecordBufferConverter(NULL),
jiabin9378eb92018-05-02 15:26:35 -07001690 mFlags(flags),
1691 mSilenced(false)
Eric Laurent81784c32012-11-19 14:55:58 -08001692{
Glenn Kasten3ef14ef2014-03-13 15:08:51 -07001693 if (mCblk == NULL) {
1694 return;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001695 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001696
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07001697 if (!isDirect()) {
1698 mRecordBufferConverter = new RecordBufferConverter(
1699 thread->mChannelMask, thread->mFormat, thread->mSampleRate,
1700 channelMask, format, sampleRate);
1701 // Check if the RecordBufferConverter construction was successful.
1702 // If not, don't continue with construction.
1703 //
1704 // NOTE: It would be extremely rare that the record track cannot be created
1705 // for the current device, but a pending or future device change would make
1706 // the record track configuration valid.
1707 if (mRecordBufferConverter->initCheck() != NO_ERROR) {
1708 ALOGE("RecordTrack unable to create record buffer converter");
1709 return;
1710 }
Andy Hung97a893e2015-03-29 01:03:07 -07001711 }
1712
Andy Hung6ae58432016-02-16 18:32:24 -08001713 mServerProxy = new AudioRecordServerProxy(mCblk, mBuffer, frameCount,
Andy Hung3f0c9022016-01-15 17:49:46 -08001714 mFrameSize, !isExternalTrack());
Andy Hung3f0c9022016-01-15 17:49:46 -08001715
Andy Hung97a893e2015-03-29 01:03:07 -07001716 mResamplerBufferProvider = new ResamplerBufferProvider(this);
Glenn Kastenc263ca02014-06-04 20:31:46 -07001717
Eric Laurent05067782016-06-01 18:27:28 -07001718 if (flags & AUDIO_INPUT_FLAG_FAST) {
Glenn Kastenc263ca02014-06-04 20:31:46 -07001719 ALOG_ASSERT(thread->mFastTrackAvail);
1720 thread->mFastTrackAvail = false;
Andy Hung000adb52018-06-01 15:43:26 -07001721 } else {
1722 // TODO: only Normal Record has timestamps (Fast Record does not).
1723 mServerLatencySupported = true;
Glenn Kastenc263ca02014-06-04 20:31:46 -07001724 }
Andy Hung8946a282018-04-19 20:04:56 -07001725#ifdef TEE_SINK
1726 mTee.setId(std::string("_") + std::to_string(mThreadIoHandle)
1727 + "_" + std::to_string(mId)
1728 + "_R");
1729#endif
Eric Laurent81784c32012-11-19 14:55:58 -08001730}
1731
1732AudioFlinger::RecordThread::RecordTrack::~RecordTrack()
1733{
1734 ALOGV("%s", __func__);
Andy Hung97a893e2015-03-29 01:03:07 -07001735 delete mRecordBufferConverter;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001736 delete mResamplerBufferProvider;
Eric Laurent81784c32012-11-19 14:55:58 -08001737}
1738
Andy Hung97a893e2015-03-29 01:03:07 -07001739status_t AudioFlinger::RecordThread::RecordTrack::initCheck() const
1740{
1741 status_t status = TrackBase::initCheck();
1742 if (status == NO_ERROR && mServerProxy == 0) {
1743 status = BAD_VALUE;
1744 }
1745 return status;
1746}
1747
Eric Laurent81784c32012-11-19 14:55:58 -08001748// AudioBufferProvider interface
Glenn Kastend79072e2016-01-06 08:41:20 -08001749status_t AudioFlinger::RecordThread::RecordTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08001750{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001751 ServerProxy::Buffer buf;
1752 buf.mFrameCount = buffer->frameCount;
1753 status_t status = mServerProxy->obtainBuffer(&buf);
1754 buffer->frameCount = buf.mFrameCount;
1755 buffer->raw = buf.mRaw;
1756 if (buf.mFrameCount == 0) {
1757 // FIXME also wake futex so that overrun is noticed more quickly
Glenn Kasten96f60d82013-07-12 10:21:18 -07001758 (void) android_atomic_or(CBLK_OVERRUN, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08001759 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001760 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08001761}
1762
1763status_t AudioFlinger::RecordThread::RecordTrack::start(AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08001764 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08001765{
1766 sp<ThreadBase> thread = mThread.promote();
1767 if (thread != 0) {
1768 RecordThread *recordThread = (RecordThread *)thread.get();
1769 return recordThread->start(this, event, triggerSession);
1770 } else {
1771 return BAD_VALUE;
1772 }
1773}
1774
1775void AudioFlinger::RecordThread::RecordTrack::stop()
1776{
1777 sp<ThreadBase> thread = mThread.promote();
1778 if (thread != 0) {
1779 RecordThread *recordThread = (RecordThread *)thread.get();
Eric Laurent83b88082014-06-20 18:31:16 -07001780 if (recordThread->stop(this) && isExternalTrack()) {
Eric Laurentfee19762018-01-29 18:44:13 -08001781 AudioSystem::stopInput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -08001782 }
1783 }
1784}
1785
1786void AudioFlinger::RecordThread::RecordTrack::destroy()
1787{
1788 // see comments at AudioFlinger::PlaybackThread::Track::destroy()
1789 sp<RecordTrack> keep(this);
1790 {
Eric Laurentaaa44472014-09-12 17:41:50 -07001791 if (isExternalTrack()) {
1792 if (mState == ACTIVE || mState == RESUMING) {
Eric Laurentfee19762018-01-29 18:44:13 -08001793 AudioSystem::stopInput(mPortId);
Eric Laurentaaa44472014-09-12 17:41:50 -07001794 }
Eric Laurentfee19762018-01-29 18:44:13 -08001795 AudioSystem::releaseInput(mPortId);
Eric Laurentaaa44472014-09-12 17:41:50 -07001796 }
Eric Laurent81784c32012-11-19 14:55:58 -08001797 sp<ThreadBase> thread = mThread.promote();
1798 if (thread != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08001799 Mutex::Autolock _l(thread->mLock);
1800 RecordThread *recordThread = (RecordThread *) thread.get();
1801 recordThread->destroyTrack_l(this);
1802 }
1803 }
1804}
1805
Eric Laurent9a54bc22013-09-09 09:08:44 -07001806void AudioFlinger::RecordThread::RecordTrack::invalidate()
1807{
Eric Laurent6acd1d42017-01-04 14:23:29 -08001808 TrackBase::invalidate();
Eric Laurent9a54bc22013-09-09 09:08:44 -07001809 // FIXME should use proxy, and needs work
1810 audio_track_cblk_t* cblk = mCblk;
1811 android_atomic_or(CBLK_INVALID, &cblk->mFlags);
1812 android_atomic_release_store(0x40000000, &cblk->mFutex);
1813 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE
Elliott Hughesee499292014-05-21 17:55:51 -07001814 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX);
Eric Laurent9a54bc22013-09-09 09:08:44 -07001815}
1816
Eric Laurent81784c32012-11-19 14:55:58 -08001817
Andy Hung000adb52018-06-01 15:43:26 -07001818void AudioFlinger::RecordThread::RecordTrack::appendDumpHeader(String8& result)
Eric Laurent81784c32012-11-19 14:55:58 -08001819{
Kevin Rocard5f2136e2018-05-11 22:03:00 -07001820 result.appendFormat("Active Client Session S Flags "
1821 " Format Chn mask SRate Source "
1822 " Server FrmCnt FrmRdy Sil%s\n",
1823 isServerLatencySupported() ? " Latency" : "");
Eric Laurent81784c32012-11-19 14:55:58 -08001824}
1825
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001826void AudioFlinger::RecordThread::RecordTrack::appendDump(String8& result, bool active)
Eric Laurent81784c32012-11-19 14:55:58 -08001827{
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001828 result.appendFormat("%c%5s %6u %7u %2s 0x%03X "
Kevin Rocard5f2136e2018-05-11 22:03:00 -07001829 "%08X %08X %6u %6X "
Andy Hung000adb52018-06-01 15:43:26 -07001830 "%08X %6zu %6zu %3c",
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001831 isFastTrack() ? 'F' : ' ',
Marco Nelissenb2208842014-02-07 14:00:50 -08001832 active ? "yes" : "no",
Andy Hung4ef19fa2018-05-15 19:35:29 -07001833 (mClient == 0) ? getpid() : mClient->pid(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001834 mSessionId,
1835 getTrackStateString(),
1836 mCblk->mFlags,
1837
Eric Laurent81784c32012-11-19 14:55:58 -08001838 mFormat,
1839 mChannelMask,
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001840 mSampleRate,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07001841 mAttr.source,
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001842
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001843 mCblk->mServer,
Jean-Michel Trivi7d665ab2018-04-11 17:26:51 -07001844 mFrameCount,
Andy Hung000adb52018-06-01 15:43:26 -07001845 mServerProxy->framesReadySafe(),
Jean-Michel Trivi7d665ab2018-04-11 17:26:51 -07001846 isSilenced() ? 's' : 'n'
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001847 );
Andy Hung000adb52018-06-01 15:43:26 -07001848 if (isServerLatencySupported()) {
1849 double latencyMs;
1850 bool fromTrack;
1851 if (getTrackLatencyMs(&latencyMs, &fromTrack) == OK) {
1852 // Show latency in msec, followed by 't' if from track timestamp (the most accurate)
1853 // or 'k' if estimated from kernel (usually for debugging).
1854 result.appendFormat(" %7.2lf %c", latencyMs, fromTrack ? 't' : 'k');
1855 } else {
1856 result.appendFormat("%10s", mCblk->mServer != 0 ? "unavail" : "new");
1857 }
1858 }
1859 result.append("\n");
Eric Laurent81784c32012-11-19 14:55:58 -08001860}
1861
Glenn Kasten25f4aa82014-02-07 10:50:43 -08001862void AudioFlinger::RecordThread::RecordTrack::handleSyncStartEvent(const sp<SyncEvent>& event)
1863{
1864 if (event == mSyncStartEvent) {
1865 ssize_t framesToDrop = 0;
1866 sp<ThreadBase> threadBase = mThread.promote();
1867 if (threadBase != 0) {
1868 // TODO: use actual buffer filling status instead of 2 buffers when info is available
1869 // from audio HAL
1870 framesToDrop = threadBase->mFrameCount * 2;
1871 }
1872 mFramesToDrop = framesToDrop;
1873 }
1874}
1875
1876void AudioFlinger::RecordThread::RecordTrack::clearSyncStartEvent()
1877{
1878 if (mSyncStartEvent != 0) {
1879 mSyncStartEvent->cancel();
1880 mSyncStartEvent.clear();
1881 }
1882 mFramesToDrop = 0;
1883}
1884
Andy Hung3f0c9022016-01-15 17:49:46 -08001885void AudioFlinger::RecordThread::RecordTrack::updateTrackFrameInfo(
1886 int64_t trackFramesReleased, int64_t sourceFramesRead,
1887 uint32_t halSampleRate, const ExtendedTimestamp &timestamp)
1888{
1889 ExtendedTimestamp local = timestamp;
1890
1891 // Convert HAL frames to server-side track frames at track sample rate.
1892 // We use trackFramesReleased and sourceFramesRead as an anchor point.
1893 for (int i = ExtendedTimestamp::LOCATION_SERVER; i < ExtendedTimestamp::LOCATION_MAX; ++i) {
1894 if (local.mTimeNs[i] != 0) {
1895 const int64_t relativeServerFrames = local.mPosition[i] - sourceFramesRead;
1896 const int64_t relativeTrackFrames = relativeServerFrames
1897 * mSampleRate / halSampleRate; // TODO: potential computation overflow
1898 local.mPosition[i] = relativeTrackFrames + trackFramesReleased;
1899 }
1900 }
Andy Hung6ae58432016-02-16 18:32:24 -08001901 mServerProxy->setTimestamp(local);
Andy Hung000adb52018-06-01 15:43:26 -07001902
1903 // Compute latency info.
1904 const bool useTrackTimestamp = true; // use track unless debugging.
1905 const double latencyMs = - (useTrackTimestamp
1906 ? local.getOutputServerLatencyMs(sampleRate())
1907 : timestamp.getOutputServerLatencyMs(halSampleRate));
1908
1909 mServerLatencyFromTrack.store(useTrackTimestamp);
1910 mServerLatencyMs.store(latencyMs);
Andy Hung3f0c9022016-01-15 17:49:46 -08001911}
Eric Laurent83b88082014-06-20 18:31:16 -07001912
jiabin653cc0a2018-01-17 17:54:10 -08001913status_t AudioFlinger::RecordThread::RecordTrack::getActiveMicrophones(
1914 std::vector<media::MicrophoneInfo>* activeMicrophones)
1915{
1916 sp<ThreadBase> thread = mThread.promote();
1917 if (thread != 0) {
1918 RecordThread *recordThread = (RecordThread *)thread.get();
1919 return recordThread->getActiveMicrophones(activeMicrophones);
1920 } else {
1921 return BAD_VALUE;
1922 }
1923}
1924
Eric Laurent83b88082014-06-20 18:31:16 -07001925AudioFlinger::RecordThread::PatchRecord::PatchRecord(RecordThread *recordThread,
1926 uint32_t sampleRate,
1927 audio_channel_mask_t channelMask,
1928 audio_format_t format,
1929 size_t frameCount,
1930 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07001931 size_t bufferSize,
Eric Laurent05067782016-06-01 18:27:28 -07001932 audio_input_flags_t flags)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001933 : RecordTrack(recordThread, NULL,
1934 audio_attributes_t{} /* currently unused for patch track */,
1935 sampleRate, format, channelMask, frameCount,
Andy Hung4ef19fa2018-05-15 19:35:29 -07001936 buffer, bufferSize, AUDIO_SESSION_NONE, AID_AUDIOSERVER,
1937 flags, TYPE_PATCH),
Eric Laurent83b88082014-06-20 18:31:16 -07001938 mProxy(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, false, true))
1939{
1940 uint64_t mixBufferNs = ((uint64_t)2 * recordThread->frameCount() * 1000000000) /
1941 recordThread->sampleRate();
1942 mPeerTimeout.tv_sec = mixBufferNs / 1000000000;
1943 mPeerTimeout.tv_nsec = (int) (mixBufferNs % 1000000000);
1944
1945 ALOGV("PatchRecord %p sampleRate %d mPeerTimeout %d.%03d sec",
1946 this, sampleRate,
1947 (int)mPeerTimeout.tv_sec,
1948 (int)(mPeerTimeout.tv_nsec / 1000000));
1949}
1950
1951AudioFlinger::RecordThread::PatchRecord::~PatchRecord()
1952{
1953}
1954
1955// AudioBufferProvider interface
1956status_t AudioFlinger::RecordThread::PatchRecord::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08001957 AudioBufferProvider::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07001958{
1959 ALOG_ASSERT(mPeerProxy != 0, "PatchRecord::getNextBuffer() called without peer proxy");
1960 Proxy::Buffer buf;
1961 buf.mFrameCount = buffer->frameCount;
1962 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout);
1963 ALOGV_IF(status != NO_ERROR,
1964 "PatchRecord() %p mPeerProxy->obtainBuffer status %d", this, status);
Eric Laurentc2730ba2014-07-20 15:47:07 -07001965 buffer->frameCount = buf.mFrameCount;
Eric Laurent83b88082014-06-20 18:31:16 -07001966 if (buf.mFrameCount == 0) {
1967 return WOULD_BLOCK;
1968 }
Glenn Kastend79072e2016-01-06 08:41:20 -08001969 status = RecordTrack::getNextBuffer(buffer);
Eric Laurent83b88082014-06-20 18:31:16 -07001970 return status;
1971}
1972
1973void AudioFlinger::RecordThread::PatchRecord::releaseBuffer(AudioBufferProvider::Buffer* buffer)
1974{
1975 ALOG_ASSERT(mPeerProxy != 0, "PatchRecord::releaseBuffer() called without peer proxy");
1976 Proxy::Buffer buf;
1977 buf.mFrameCount = buffer->frameCount;
1978 buf.mRaw = buffer->raw;
1979 mPeerProxy->releaseBuffer(&buf);
1980 TrackBase::releaseBuffer(buffer);
1981}
1982
1983status_t AudioFlinger::RecordThread::PatchRecord::obtainBuffer(Proxy::Buffer* buffer,
1984 const struct timespec *timeOut)
1985{
1986 return mProxy->obtainBuffer(buffer, timeOut);
1987}
1988
1989void AudioFlinger::RecordThread::PatchRecord::releaseBuffer(Proxy::Buffer* buffer)
1990{
1991 mProxy->releaseBuffer(buffer);
1992}
1993
Eric Laurent6acd1d42017-01-04 14:23:29 -08001994
1995
1996AudioFlinger::MmapThread::MmapTrack::MmapTrack(ThreadBase *thread,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001997 const audio_attributes_t& attr,
Eric Laurent6acd1d42017-01-04 14:23:29 -08001998 uint32_t sampleRate,
1999 audio_format_t format,
2000 audio_channel_mask_t channelMask,
2001 audio_session_t sessionId,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002002 bool isOut,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002003 uid_t uid,
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002004 pid_t pid,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002005 audio_port_handle_t portId)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002006 : TrackBase(thread, NULL, attr, sampleRate, format,
Andy Hung8fe68032017-06-05 16:17:51 -07002007 channelMask, (size_t)0 /* frameCount */,
2008 nullptr /* buffer */, (size_t)0 /* bufferSize */,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002009 sessionId, uid, isOut,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002010 ALLOC_NONE,
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002011 TYPE_DEFAULT, portId),
Eric Laurent331679c2018-04-16 17:03:16 -07002012 mPid(pid), mSilenced(false), mSilencedNotified(false)
Eric Laurent6acd1d42017-01-04 14:23:29 -08002013{
2014}
2015
2016AudioFlinger::MmapThread::MmapTrack::~MmapTrack()
2017{
2018}
2019
2020status_t AudioFlinger::MmapThread::MmapTrack::initCheck() const
2021{
2022 return NO_ERROR;
2023}
2024
2025status_t AudioFlinger::MmapThread::MmapTrack::start(AudioSystem::sync_event_t event __unused,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002026 audio_session_t triggerSession __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08002027{
2028 return NO_ERROR;
2029}
2030
2031void AudioFlinger::MmapThread::MmapTrack::stop()
2032{
2033}
2034
2035// AudioBufferProvider interface
2036status_t AudioFlinger::MmapThread::MmapTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer)
2037{
2038 buffer->frameCount = 0;
2039 buffer->raw = nullptr;
2040 return INVALID_OPERATION;
2041}
2042
2043// ExtendedAudioBufferProvider interface
2044size_t AudioFlinger::MmapThread::MmapTrack::framesReady() const {
2045 return 0;
2046}
2047
2048int64_t AudioFlinger::MmapThread::MmapTrack::framesReleased() const
2049{
2050 return 0;
2051}
2052
2053void AudioFlinger::MmapThread::MmapTrack::onTimestamp(const ExtendedTimestamp &timestamp __unused)
2054{
2055}
2056
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002057void AudioFlinger::MmapThread::MmapTrack::appendDumpHeader(String8& result)
Eric Laurent6acd1d42017-01-04 14:23:29 -08002058{
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002059 result.appendFormat("Client Session Format Chn mask SRate Flags %s\n",
2060 isOut() ? "Usg CT": "Source");
Eric Laurent6acd1d42017-01-04 14:23:29 -08002061}
2062
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002063void AudioFlinger::MmapThread::MmapTrack::appendDump(String8& result, bool active __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08002064{
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002065 result.appendFormat("%6u %7u %08X %08X %6u 0x%03X ",
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002066 mPid,
2067 mSessionId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002068 mFormat,
2069 mChannelMask,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002070 mSampleRate,
2071 mAttr.flags);
2072 if (isOut()) {
2073 result.appendFormat("%3x %2x", mAttr.usage, mAttr.content_type);
2074 } else {
2075 result.appendFormat("%6x", mAttr.source);
2076 }
2077 result.append("\n");
Eric Laurent6acd1d42017-01-04 14:23:29 -08002078}
2079
Glenn Kasten63238ef2015-03-02 15:50:29 -08002080} // namespace android