blob: 37c3a2d8b82fd56a7edf9709f4d591a297d6c211 [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// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -070059#undef LOG_TAG
60#define LOG_TAG "AF::TrackBase"
Eric Laurent81784c32012-11-19 14:55:58 -080061
Glenn Kastenda6ef132013-01-10 12:31:01 -080062static volatile int32_t nextTrackId = 55;
63
Eric Laurent81784c32012-11-19 14:55:58 -080064// TrackBase constructor must be called with AudioFlinger::mLock held
65AudioFlinger::ThreadBase::TrackBase::TrackBase(
66 ThreadBase *thread,
67 const sp<Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -070068 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -080069 uint32_t sampleRate,
70 audio_format_t format,
71 audio_channel_mask_t channelMask,
72 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -070073 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -070074 size_t bufferSize,
Glenn Kastend848eb42016-03-08 13:42:11 -080075 audio_session_t sessionId,
Andy Hung1f12a8a2016-11-07 16:10:30 -080076 uid_t clientUid,
Glenn Kastend776ac62014-05-07 09:16:09 -070077 bool isOut,
Eric Laurent83b88082014-06-20 18:31:16 -070078 alloc_type alloc,
Eric Laurent20b9ef02016-12-05 11:03:16 -080079 track_type type,
80 audio_port_handle_t portId)
Eric Laurent81784c32012-11-19 14:55:58 -080081 : RefBase(),
82 mThread(thread),
83 mClient(client),
84 mCblk(NULL),
Andy Hung8fe68032017-06-05 16:17:51 -070085 // mBuffer, mBufferSize
Eric Laurent81784c32012-11-19 14:55:58 -080086 mState(IDLE),
Kevin Rocard1f564ac2018-03-29 13:53:10 -070087 mAttr(attr),
Eric Laurent81784c32012-11-19 14:55:58 -080088 mSampleRate(sampleRate),
89 mFormat(format),
90 mChannelMask(channelMask),
Andy Hunge5412692014-05-16 11:25:07 -070091 mChannelCount(isOut ?
92 audio_channel_count_from_out_mask(channelMask) :
93 audio_channel_count_from_in_mask(channelMask)),
Phil Burkfdb3c072016-02-09 10:47:02 -080094 mFrameSize(audio_has_proportional_frames(format) ?
Eric Laurent81784c32012-11-19 14:55:58 -080095 mChannelCount * audio_bytes_per_sample(format) : sizeof(int8_t)),
96 mFrameCount(frameCount),
Glenn Kastene3aa6592012-12-04 12:22:46 -080097 mSessionId(sessionId),
98 mIsOut(isOut),
Eric Laurentbfb1b832013-01-07 09:53:42 -080099 mId(android_atomic_inc(&nextTrackId)),
Eric Laurent83b88082014-06-20 18:31:16 -0700100 mTerminated(false),
Eric Laurentaaa44472014-09-12 17:41:50 -0700101 mType(type),
Kevin Rocard153f92d2018-12-18 18:33:28 -0800102 mThreadIoHandle(thread ? thread->id() : AUDIO_IO_HANDLE_NONE),
Eric Laurent6acd1d42017-01-04 14:23:29 -0800103 mPortId(portId),
104 mIsInvalid(false)
Eric Laurent81784c32012-11-19 14:55:58 -0800105{
Marco Nelissendcb346b2015-09-09 10:47:29 -0700106 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Andy Hung4ef19fa2018-05-15 19:35:29 -0700107 if (!isAudioServerOrMediaServerUid(callingUid) || clientUid == AUDIO_UID_INVALID) {
Andy Hung1f12a8a2016-11-07 16:10:30 -0800108 ALOGW_IF(clientUid != AUDIO_UID_INVALID && clientUid != callingUid,
Andy Hung9d84af52018-09-12 18:03:44 -0700109 "%s(%d): uid %d tried to pass itself off as %d",
110 __func__, mId, callingUid, clientUid);
Andy Hung1f12a8a2016-11-07 16:10:30 -0800111 clientUid = callingUid;
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800112 }
113 // clientUid contains the uid of the app that is responsible for this track, so we can blame
114 // battery usage on it.
115 mUid = clientUid;
116
Eric Laurent81784c32012-11-19 14:55:58 -0800117 // ALOGD("Creating track with %d buffers @ %d bytes", bufferCount, bufferSize);
Andy Hung1883f692017-02-13 18:48:39 -0800118
Andy Hung8fe68032017-06-05 16:17:51 -0700119 size_t minBufferSize = buffer == NULL ? roundup(frameCount) : frameCount;
Andy Hung1883f692017-02-13 18:48:39 -0800120 // check overflow when computing bufferSize due to multiplication by mFrameSize.
Andy Hung8fe68032017-06-05 16:17:51 -0700121 if (minBufferSize < frameCount // roundup rounds down for values above UINT_MAX / 2
Andy Hung1883f692017-02-13 18:48:39 -0800122 || mFrameSize == 0 // format needs to be correct
Andy Hung8fe68032017-06-05 16:17:51 -0700123 || minBufferSize > SIZE_MAX / mFrameSize) {
Andy Hung1883f692017-02-13 18:48:39 -0800124 android_errorWriteLog(0x534e4554, "34749571");
125 return;
126 }
Andy Hung8fe68032017-06-05 16:17:51 -0700127 minBufferSize *= mFrameSize;
128
129 if (buffer == nullptr) {
130 bufferSize = minBufferSize; // allocated here.
131 } else if (minBufferSize > bufferSize) {
132 android_errorWriteLog(0x534e4554, "38340117");
133 return;
134 }
Andy Hung1883f692017-02-13 18:48:39 -0800135
Eric Laurent81784c32012-11-19 14:55:58 -0800136 size_t size = sizeof(audio_track_cblk_t);
Eric Laurent83b88082014-06-20 18:31:16 -0700137 if (buffer == NULL && alloc == ALLOC_CBLK) {
Andy Hung1883f692017-02-13 18:48:39 -0800138 // check overflow when computing allocation size for streaming tracks.
139 if (size > SIZE_MAX - bufferSize) {
140 android_errorWriteLog(0x534e4554, "34749571");
141 return;
142 }
Eric Laurent81784c32012-11-19 14:55:58 -0800143 size += bufferSize;
144 }
145
146 if (client != 0) {
147 mCblkMemory = client->heap()->allocate(size);
Glenn Kasten663c2242013-09-24 11:52:37 -0700148 if (mCblkMemory == 0 ||
149 (mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->pointer())) == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700150 ALOGE("%s(%d): not enough memory for AudioTrack size=%zu", __func__, mId, size);
Eric Laurent81784c32012-11-19 14:55:58 -0800151 client->heap()->dump("AudioTrack");
Glenn Kasten663c2242013-09-24 11:52:37 -0700152 mCblkMemory.clear();
Eric Laurent81784c32012-11-19 14:55:58 -0800153 return;
154 }
155 } else {
Andy Hungafb31482017-02-13 18:50:48 -0800156 mCblk = (audio_track_cblk_t *) malloc(size);
157 if (mCblk == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700158 ALOGE("%s(%d): not enough memory for AudioTrack size=%zu", __func__, mId, size);
Andy Hungafb31482017-02-13 18:50:48 -0800159 return;
160 }
Eric Laurent81784c32012-11-19 14:55:58 -0800161 }
162
163 // construct the shared structure in-place.
164 if (mCblk != NULL) {
165 new(mCblk) audio_track_cblk_t();
Glenn Kastenc263ca02014-06-04 20:31:46 -0700166 switch (alloc) {
167 case ALLOC_READONLY: {
Glenn Kastend776ac62014-05-07 09:16:09 -0700168 const sp<MemoryDealer> roHeap(thread->readOnlyHeap());
169 if (roHeap == 0 ||
170 (mBufferMemory = roHeap->allocate(bufferSize)) == 0 ||
171 (mBuffer = mBufferMemory->pointer()) == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700172 ALOGE("%s(%d): not enough memory for read-only buffer size=%zu",
173 __func__, mId, bufferSize);
Glenn Kastend776ac62014-05-07 09:16:09 -0700174 if (roHeap != 0) {
175 roHeap->dump("buffer");
176 }
177 mCblkMemory.clear();
178 mBufferMemory.clear();
179 return;
180 }
Eric Laurent81784c32012-11-19 14:55:58 -0800181 memset(mBuffer, 0, bufferSize);
Glenn Kastenc263ca02014-06-04 20:31:46 -0700182 } break;
183 case ALLOC_PIPE:
184 mBufferMemory = thread->pipeMemory();
185 // mBuffer is the virtual address as seen from current process (mediaserver),
186 // and should normally be coming from mBufferMemory->pointer().
187 // However in this case the TrackBase does not reference the buffer directly.
188 // It should references the buffer via the pipe.
189 // Therefore, to detect incorrect usage of the buffer, we set mBuffer to NULL.
190 mBuffer = NULL;
Andy Hung8fe68032017-06-05 16:17:51 -0700191 bufferSize = 0;
Glenn Kastenc263ca02014-06-04 20:31:46 -0700192 break;
193 case ALLOC_CBLK:
Glenn Kastend776ac62014-05-07 09:16:09 -0700194 // clear all buffers
Eric Laurent83b88082014-06-20 18:31:16 -0700195 if (buffer == NULL) {
Glenn Kastend776ac62014-05-07 09:16:09 -0700196 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);
197 memset(mBuffer, 0, bufferSize);
198 } else {
Eric Laurent83b88082014-06-20 18:31:16 -0700199 mBuffer = buffer;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800200#if 0
Glenn Kastend776ac62014-05-07 09:16:09 -0700201 mCblk->mFlags = CBLK_FORCEREADY; // FIXME hack, need to fix the track ready logic
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800202#endif
Glenn Kastend776ac62014-05-07 09:16:09 -0700203 }
Glenn Kastenc263ca02014-06-04 20:31:46 -0700204 break;
Eric Laurent83b88082014-06-20 18:31:16 -0700205 case ALLOC_LOCAL:
206 mBuffer = calloc(1, bufferSize);
207 break;
208 case ALLOC_NONE:
209 mBuffer = buffer;
210 break;
Andy Hung8fe68032017-06-05 16:17:51 -0700211 default:
Andy Hung9d84af52018-09-12 18:03:44 -0700212 LOG_ALWAYS_FATAL("%s(%d): invalid allocation type: %d", __func__, mId, (int)alloc);
Eric Laurent81784c32012-11-19 14:55:58 -0800213 }
Andy Hung8fe68032017-06-05 16:17:51 -0700214 mBufferSize = bufferSize;
Glenn Kastenda6ef132013-01-10 12:31:01 -0800215
Glenn Kasten46909e72013-02-26 09:20:22 -0800216#ifdef TEE_SINK
Andy Hung8946a282018-04-19 20:04:56 -0700217 mTee.set(sampleRate, mChannelCount, format, NBAIO_Tee::TEE_FLAG_TRACK);
Glenn Kasten46909e72013-02-26 09:20:22 -0800218#endif
Glenn Kastenda6ef132013-01-10 12:31:01 -0800219
Eric Laurent81784c32012-11-19 14:55:58 -0800220 }
221}
222
Eric Laurent83b88082014-06-20 18:31:16 -0700223status_t AudioFlinger::ThreadBase::TrackBase::initCheck() const
224{
225 status_t status;
226 if (mType == TYPE_OUTPUT || mType == TYPE_PATCH) {
227 status = cblk() != NULL ? NO_ERROR : NO_MEMORY;
228 } else {
229 status = getCblk() != 0 ? NO_ERROR : NO_MEMORY;
230 }
231 return status;
232}
233
Eric Laurent81784c32012-11-19 14:55:58 -0800234AudioFlinger::ThreadBase::TrackBase::~TrackBase()
235{
Glenn Kastene3aa6592012-12-04 12:22:46 -0800236 // delete the proxy before deleting the shared memory it refers to, to avoid dangling reference
Eric Laurent5bba2f62016-03-18 11:14:14 -0700237 mServerProxy.clear();
Eric Laurent81784c32012-11-19 14:55:58 -0800238 if (mCblk != NULL) {
Andy Hungafb31482017-02-13 18:50:48 -0800239 mCblk->~audio_track_cblk_t(); // destroy our shared-structure.
Eric Laurent81784c32012-11-19 14:55:58 -0800240 if (mClient == 0) {
Andy Hungafb31482017-02-13 18:50:48 -0800241 free(mCblk);
Eric Laurent81784c32012-11-19 14:55:58 -0800242 }
243 }
244 mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to
245 if (mClient != 0) {
Eric Laurent021cf962014-05-13 10:18:14 -0700246 // Client destructor must run with AudioFlinger client mutex locked
247 Mutex::Autolock _l(mClient->audioFlinger()->mClientLock);
Eric Laurent81784c32012-11-19 14:55:58 -0800248 // If the client's reference count drops to zero, the associated destructor
249 // must run with AudioFlinger lock held. Thus the explicit clear() rather than
250 // relying on the automatic clear() at end of scope.
251 mClient.clear();
252 }
Eric Laurent3bcffa12014-06-12 18:38:45 -0700253 // flush the binder command buffer
254 IPCThreadState::self()->flushCommands();
Eric Laurent81784c32012-11-19 14:55:58 -0800255}
256
257// AudioBufferProvider interface
258// getNextBuffer() = 0;
Glenn Kastend79072e2016-01-06 08:41:20 -0800259// This implementation of releaseBuffer() is used by Track and RecordTrack
Eric Laurent81784c32012-11-19 14:55:58 -0800260void AudioFlinger::ThreadBase::TrackBase::releaseBuffer(AudioBufferProvider::Buffer* buffer)
261{
Glenn Kasten46909e72013-02-26 09:20:22 -0800262#ifdef TEE_SINK
Andy Hung8946a282018-04-19 20:04:56 -0700263 mTee.write(buffer->raw, buffer->frameCount);
Glenn Kasten46909e72013-02-26 09:20:22 -0800264#endif
Glenn Kastenda6ef132013-01-10 12:31:01 -0800265
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800266 ServerProxy::Buffer buf;
267 buf.mFrameCount = buffer->frameCount;
268 buf.mRaw = buffer->raw;
Eric Laurent81784c32012-11-19 14:55:58 -0800269 buffer->frameCount = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800270 buffer->raw = NULL;
271 mServerProxy->releaseBuffer(&buf);
Eric Laurent81784c32012-11-19 14:55:58 -0800272}
273
Eric Laurent81784c32012-11-19 14:55:58 -0800274status_t AudioFlinger::ThreadBase::TrackBase::setSyncEvent(const sp<SyncEvent>& event)
275{
276 mSyncEvents.add(event);
277 return NO_ERROR;
278}
279
Kevin Rocard45986c72018-12-18 18:22:59 -0800280AudioFlinger::ThreadBase::PatchTrackBase::PatchTrackBase(sp<ClientProxy> proxy,
281 const ThreadBase& thread,
282 const Timeout& timeout)
283 : mProxy(proxy)
284{
285 if (timeout) {
286 setPeerTimeout(*timeout);
287 } else {
288 // Double buffer mixer
289 uint64_t mixBufferNs = ((uint64_t)2 * thread.frameCount() * 1000000000) /
290 thread.sampleRate();
291 setPeerTimeout(std::chrono::nanoseconds{mixBufferNs});
292 }
293}
294
295void AudioFlinger::ThreadBase::PatchTrackBase::setPeerTimeout(std::chrono::nanoseconds timeout) {
296 mPeerTimeout.tv_sec = timeout.count() / std::nano::den;
297 mPeerTimeout.tv_nsec = timeout.count() % std::nano::den;
298}
299
300
Eric Laurent81784c32012-11-19 14:55:58 -0800301// ----------------------------------------------------------------------------
302// Playback
303// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -0700304#undef LOG_TAG
305#define LOG_TAG "AF::TrackHandle"
Eric Laurent81784c32012-11-19 14:55:58 -0800306
307AudioFlinger::TrackHandle::TrackHandle(const sp<AudioFlinger::PlaybackThread::Track>& track)
308 : BnAudioTrack(),
309 mTrack(track)
310{
311}
312
313AudioFlinger::TrackHandle::~TrackHandle() {
314 // just stop the track on deletion, associated resources
315 // will be freed from the main thread once all pending buffers have
316 // been played. Unless it's not in the active track list, in which
317 // case we free everything now...
318 mTrack->destroy();
319}
320
321sp<IMemory> AudioFlinger::TrackHandle::getCblk() const {
322 return mTrack->getCblk();
323}
324
325status_t AudioFlinger::TrackHandle::start() {
326 return mTrack->start();
327}
328
329void AudioFlinger::TrackHandle::stop() {
330 mTrack->stop();
331}
332
333void AudioFlinger::TrackHandle::flush() {
334 mTrack->flush();
335}
336
Eric Laurent81784c32012-11-19 14:55:58 -0800337void AudioFlinger::TrackHandle::pause() {
338 mTrack->pause();
339}
340
341status_t AudioFlinger::TrackHandle::attachAuxEffect(int EffectId)
342{
343 return mTrack->attachAuxEffect(EffectId);
344}
345
Glenn Kasten3dcd00d2013-07-17 10:10:23 -0700346status_t AudioFlinger::TrackHandle::setParameters(const String8& keyValuePairs) {
347 return mTrack->setParameters(keyValuePairs);
348}
349
Mikhail Naganovac917ac2018-11-28 14:03:52 -0800350status_t AudioFlinger::TrackHandle::selectPresentation(int presentationId, int programId) {
351 return mTrack->selectPresentation(presentationId, programId);
352}
353
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800354VolumeShaper::Status AudioFlinger::TrackHandle::applyVolumeShaper(
355 const sp<VolumeShaper::Configuration>& configuration,
356 const sp<VolumeShaper::Operation>& operation) {
357 return mTrack->applyVolumeShaper(configuration, operation);
358}
359
360sp<VolumeShaper::State> AudioFlinger::TrackHandle::getVolumeShaperState(int id) {
361 return mTrack->getVolumeShaperState(id);
362}
363
Glenn Kasten53cec222013-08-29 09:01:02 -0700364status_t AudioFlinger::TrackHandle::getTimestamp(AudioTimestamp& timestamp)
365{
Glenn Kasten573d80a2013-08-26 09:36:23 -0700366 return mTrack->getTimestamp(timestamp);
Glenn Kasten53cec222013-08-29 09:01:02 -0700367}
368
Eric Laurent59fe0102013-09-27 18:48:26 -0700369
370void AudioFlinger::TrackHandle::signal()
371{
372 return mTrack->signal();
373}
374
Eric Laurent81784c32012-11-19 14:55:58 -0800375status_t AudioFlinger::TrackHandle::onTransact(
376 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
377{
378 return BnAudioTrack::onTransact(code, data, reply, flags);
379}
380
381// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -0700382#undef LOG_TAG
383#define LOG_TAG "AF::Track"
Eric Laurent81784c32012-11-19 14:55:58 -0800384
385// Track constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
386AudioFlinger::PlaybackThread::Track::Track(
387 PlaybackThread *thread,
388 const sp<Client>& client,
389 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700390 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -0800391 uint32_t sampleRate,
392 audio_format_t format,
393 audio_channel_mask_t channelMask,
394 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700395 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700396 size_t bufferSize,
Eric Laurent81784c32012-11-19 14:55:58 -0800397 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -0800398 audio_session_t sessionId,
Andy Hung1f12a8a2016-11-07 16:10:30 -0800399 uid_t uid,
Eric Laurent05067782016-06-01 18:27:28 -0700400 audio_output_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800401 track_type type,
402 audio_port_handle_t portId)
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700403 : TrackBase(thread, client, attr, sampleRate, format, channelMask, frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700404 (sharedBuffer != 0) ? sharedBuffer->pointer() : buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700405 (sharedBuffer != 0) ? sharedBuffer->size() : bufferSize,
Eric Laurent05067782016-06-01 18:27:28 -0700406 sessionId, uid, true /*isOut*/,
Eric Laurent83b88082014-06-20 18:31:16 -0700407 (type == TYPE_PATCH) ? ( buffer == NULL ? ALLOC_LOCAL : ALLOC_NONE) : ALLOC_CBLK,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800408 type, portId),
Eric Laurent81784c32012-11-19 14:55:58 -0800409 mFillingUpStatus(FS_INVALID),
410 // mRetryCount initialized later when needed
411 mSharedBuffer(sharedBuffer),
412 mStreamType(streamType),
rago94a1ee82017-07-21 15:11:02 -0700413 mMainBuffer(thread->sinkBuffer()),
Eric Laurent81784c32012-11-19 14:55:58 -0800414 mAuxBuffer(NULL),
415 mAuxEffectId(0), mHasVolumeController(false),
416 mPresentationCompleteFrames(0),
Andy Hunge10393e2015-06-12 13:59:33 -0700417 mFrameMap(16 /* sink-frame-to-track-frame map memory */),
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700418 mVolumeHandler(new media::VolumeHandler(sampleRate)),
Andy Hunge10393e2015-06-12 13:59:33 -0700419 // mSinkTimestamp
Eric Laurent81784c32012-11-19 14:55:58 -0800420 mFastIndex(-1),
Glenn Kasten5736c352012-12-04 12:12:34 -0800421 mCachedVolume(1.0),
Kevin Rocard12381092018-04-11 09:19:59 -0700422 /* The track might not play immediately after being active, similarly as if its volume was 0.
423 * When the track starts playing, its volume will be computed. */
424 mFinalVolume(0.f),
Haynes Mathew George7844f672014-01-15 12:32:55 -0800425 mResumeToStopping(false),
Eric Laurent05067782016-06-01 18:27:28 -0700426 mFlushHwPending(false),
427 mFlags(flags)
Eric Laurent81784c32012-11-19 14:55:58 -0800428{
Eric Laurent83b88082014-06-20 18:31:16 -0700429 // client == 0 implies sharedBuffer == 0
430 ALOG_ASSERT(!(client == 0 && sharedBuffer != 0));
431
Andy Hung9d84af52018-09-12 18:03:44 -0700432 ALOGV_IF(sharedBuffer != 0, "%s(%d): sharedBuffer: %p, size: %zu",
433 __func__, mId, sharedBuffer->pointer(), sharedBuffer->size());
Eric Laurent83b88082014-06-20 18:31:16 -0700434
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700435 if (mCblk == NULL) {
436 return;
Eric Laurent81784c32012-11-19 14:55:58 -0800437 }
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700438
439 if (sharedBuffer == 0) {
440 mAudioTrackServerProxy = new AudioTrackServerProxy(mCblk, mBuffer, frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700441 mFrameSize, !isExternalTrack(), sampleRate);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700442 } else {
443 mAudioTrackServerProxy = new StaticAudioTrackServerProxy(mCblk, mBuffer, frameCount,
444 mFrameSize);
445 }
446 mServerProxy = mAudioTrackServerProxy;
447
Andy Hung1bc088a2018-02-09 15:57:31 -0800448 if (!thread->isTrackAllowed_l(channelMask, format, sessionId, uid)) {
Andy Hung9d84af52018-09-12 18:03:44 -0700449 ALOGE("%s(%d): no more tracks available", __func__, mId);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700450 return;
451 }
452 // only allocate a fast track index if we were able to allocate a normal track name
Eric Laurent05067782016-06-01 18:27:28 -0700453 if (flags & AUDIO_OUTPUT_FLAG_FAST) {
Andy Hunga5427822015-09-11 16:15:35 -0700454 // FIXME: Not calling framesReadyIsCalledByMultipleThreads() exposes a potential
455 // race with setSyncEvent(). However, if we call it, we cannot properly start
456 // static fast tracks (SoundPool) immediately after stopping.
457 //mAudioTrackServerProxy->framesReadyIsCalledByMultipleThreads();
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700458 ALOG_ASSERT(thread->mFastTrackAvailMask != 0);
459 int i = __builtin_ctz(thread->mFastTrackAvailMask);
Glenn Kastendc2c50b2016-04-21 08:13:14 -0700460 ALOG_ASSERT(0 < i && i < (int)FastMixerState::sMaxFastTracks);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700461 // FIXME This is too eager. We allocate a fast track index before the
462 // fast track becomes active. Since fast tracks are a scarce resource,
463 // this means we are potentially denying other more important fast tracks from
464 // being created. It would be better to allocate the index dynamically.
465 mFastIndex = i;
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700466 thread->mFastTrackAvailMask &= ~(1 << i);
467 }
Andy Hung8946a282018-04-19 20:04:56 -0700468
Andy Hung1c86ebe2018-05-29 20:29:08 -0700469 mServerLatencySupported = thread->type() == ThreadBase::MIXER
470 || thread->type() == ThreadBase::DUPLICATING;
Andy Hung8946a282018-04-19 20:04:56 -0700471#ifdef TEE_SINK
472 mTee.setId(std::string("_") + std::to_string(mThreadIoHandle)
Kevin Rocard51f0e982019-02-01 19:19:11 -0800473 + "_" + std::to_string(mId) + "_T");
Andy Hung8946a282018-04-19 20:04:56 -0700474#endif
jiabin57303cc2018-12-18 15:45:57 -0800475
476 if (channelMask & AUDIO_CHANNEL_HAPTIC_ALL) {
477 mAudioVibrationController = new AudioVibrationController(this);
478 mExternalVibration = new os::ExternalVibration(
479 mUid, "" /* pkg */, mAttr, mAudioVibrationController);
480 }
Eric Laurent81784c32012-11-19 14:55:58 -0800481}
482
483AudioFlinger::PlaybackThread::Track::~Track()
484{
Andy Hung9d84af52018-09-12 18:03:44 -0700485 ALOGV("%s(%d)", __func__, mId);
Glenn Kasten0c72b242013-09-11 09:14:16 -0700486
487 // The destructor would clear mSharedBuffer,
488 // but it will not push the decremented reference count,
489 // leaving the client's IMemory dangling indefinitely.
490 // This prevents that leak.
491 if (mSharedBuffer != 0) {
492 mSharedBuffer.clear();
Glenn Kasten0c72b242013-09-11 09:14:16 -0700493 }
Eric Laurent81784c32012-11-19 14:55:58 -0800494}
495
Glenn Kasten03003332013-08-06 15:40:54 -0700496status_t AudioFlinger::PlaybackThread::Track::initCheck() const
497{
498 status_t status = TrackBase::initCheck();
Andy Hungc0691382018-09-12 18:01:57 -0700499 if (status == NO_ERROR && mCblk == nullptr) {
Glenn Kasten03003332013-08-06 15:40:54 -0700500 status = NO_MEMORY;
501 }
502 return status;
503}
504
Eric Laurent81784c32012-11-19 14:55:58 -0800505void AudioFlinger::PlaybackThread::Track::destroy()
506{
507 // NOTE: destroyTrack_l() can remove a strong reference to this Track
508 // by removing it from mTracks vector, so there is a risk that this Tracks's
509 // destructor is called. As the destructor needs to lock mLock,
510 // we must acquire a strong reference on this Track before locking mLock
511 // here so that the destructor is called only when exiting this function.
512 // On the other hand, as long as Track::destroy() is only called by
513 // TrackHandle destructor, the TrackHandle still holds a strong ref on
514 // this Track with its member mTrack.
515 sp<Track> keep(this);
516 { // scope for mLock
Eric Laurentaaa44472014-09-12 17:41:50 -0700517 bool wasActive = false;
Eric Laurent81784c32012-11-19 14:55:58 -0800518 sp<ThreadBase> thread = mThread.promote();
519 if (thread != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -0800520 Mutex::Autolock _l(thread->mLock);
521 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Eric Laurentaaa44472014-09-12 17:41:50 -0700522 wasActive = playbackThread->destroyTrack_l(this);
523 }
524 if (isExternalTrack() && !wasActive) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700525 AudioSystem::releaseOutput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -0800526 }
527 }
528}
529
Andy Hungf6ab58d2018-05-25 12:50:39 -0700530void AudioFlinger::PlaybackThread::Track::appendDumpHeader(String8& result)
Eric Laurent81784c32012-11-19 14:55:58 -0800531{
Eric Laurent973db022018-11-20 14:54:31 -0800532 result.appendFormat("Type Id Active Client Session Port Id S Flags "
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700533 " Format Chn mask SRate "
534 "ST Usg CT "
535 " G db L dB R dB VS dB "
536 " Server FrmCnt FrmRdy F Underruns Flushed"
537 "%s\n",
538 isServerLatencySupported() ? " Latency" : "");
Eric Laurent81784c32012-11-19 14:55:58 -0800539}
540
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700541void AudioFlinger::PlaybackThread::Track::appendDump(String8& result, bool active)
Eric Laurent81784c32012-11-19 14:55:58 -0800542{
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700543 char trackType;
544 switch (mType) {
545 case TYPE_DEFAULT:
546 case TYPE_OUTPUT:
Andy Hungf6ab58d2018-05-25 12:50:39 -0700547 if (isStatic()) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700548 trackType = 'S'; // static
549 } else {
550 trackType = ' '; // normal
Eric Laurentbfb1b832013-01-07 09:53:42 -0800551 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700552 break;
553 case TYPE_PATCH:
554 trackType = 'P';
555 break;
556 default:
557 trackType = '?';
Eric Laurent81784c32012-11-19 14:55:58 -0800558 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700559
560 if (isFastTrack()) {
Andy Hungc0691382018-09-12 18:01:57 -0700561 result.appendFormat("F%d %c %6d", mFastIndex, trackType, mId);
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700562 } else {
Andy Hungc0691382018-09-12 18:01:57 -0700563 result.appendFormat(" %c %6d", trackType, mId);
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700564 }
565
Eric Laurent81784c32012-11-19 14:55:58 -0800566 char nowInUnderrun;
567 switch (mObservedUnderruns.mBitFields.mMostRecent) {
568 case UNDERRUN_FULL:
569 nowInUnderrun = ' ';
570 break;
571 case UNDERRUN_PARTIAL:
572 nowInUnderrun = '<';
573 break;
574 case UNDERRUN_EMPTY:
575 nowInUnderrun = '*';
576 break;
577 default:
578 nowInUnderrun = '?';
579 break;
580 }
Andy Hungda540db2017-04-20 14:06:17 -0700581
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700582 char fillingStatus;
583 switch (mFillingUpStatus) {
584 case FS_INVALID:
585 fillingStatus = 'I';
586 break;
587 case FS_FILLING:
588 fillingStatus = 'f';
589 break;
590 case FS_FILLED:
591 fillingStatus = 'F';
592 break;
593 case FS_ACTIVE:
594 fillingStatus = 'A';
595 break;
596 default:
597 fillingStatus = '?';
598 break;
599 }
600
601 // clip framesReadySafe to max representation in dump
602 const size_t framesReadySafe =
603 std::min(mAudioTrackServerProxy->framesReadySafe(), (size_t)99999999);
604
605 // obtain volumes
606 const gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR();
607 const std::pair<float /* volume */, bool /* active */> vsVolume =
608 mVolumeHandler->getLastVolume();
609
610 // Our effective frame count is obtained by ServerProxy::getBufferSizeInFrames()
611 // as it may be reduced by the application.
612 const size_t bufferSizeInFrames = (size_t)mAudioTrackServerProxy->getBufferSizeInFrames();
613 // Check whether the buffer size has been modified by the app.
614 const char modifiedBufferChar = bufferSizeInFrames < mFrameCount
615 ? 'r' /* buffer reduced */: bufferSizeInFrames > mFrameCount
616 ? 'e' /* error */ : ' ' /* identical */;
617
Eric Laurent973db022018-11-20 14:54:31 -0800618 result.appendFormat("%7s %6u %7u %7u %2s 0x%03X "
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700619 "%08X %08X %6u "
620 "%2u %3x %2x "
621 "%5.2g %5.2g %5.2g %5.2g%c "
622 "%08X %6zu%c %6zu %c %9u%c %7u",
Marco Nelissenb2208842014-02-07 14:00:50 -0800623 active ? "yes" : "no",
Andy Hung4ef19fa2018-05-15 19:35:29 -0700624 (mClient == 0) ? getpid() : mClient->pid(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700625 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -0800626 mPortId,
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700627 getTrackStateString(),
628 mCblk->mFlags,
629
Eric Laurent81784c32012-11-19 14:55:58 -0800630 mFormat,
631 mChannelMask,
Andy Hungcef2daa2018-06-01 15:31:49 -0700632 sampleRate(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700633
634 mStreamType,
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700635 mAttr.usage,
636 mAttr.content_type,
637
638 20.0 * log10(mFinalVolume),
Glenn Kastenc56f3422014-03-21 17:53:17 -0700639 20.0 * log10(float_from_gain(gain_minifloat_unpack_left(vlr))),
640 20.0 * log10(float_from_gain(gain_minifloat_unpack_right(vlr))),
Andy Hungda540db2017-04-20 14:06:17 -0700641 20.0 * log10(vsVolume.first), // VolumeShaper(s) total volume
642 vsVolume.second ? 'A' : ' ', // if any VolumeShapers active
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700643
Glenn Kastenf20e1d82013-07-12 09:45:18 -0700644 mCblk->mServer,
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700645 bufferSizeInFrames,
646 modifiedBufferChar,
647 framesReadySafe,
648 fillingStatus,
Glenn Kasten82aaf942013-07-17 16:05:07 -0700649 mAudioTrackServerProxy->getUnderrunFrames(),
Andy Hung2148bf02016-11-28 19:01:02 -0800650 nowInUnderrun,
Andy Hungf6ab58d2018-05-25 12:50:39 -0700651 (unsigned)mAudioTrackServerProxy->framesFlushed() % 10000000
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700652 );
Andy Hungcef2daa2018-06-01 15:31:49 -0700653
654 if (isServerLatencySupported()) {
655 double latencyMs;
656 bool fromTrack;
657 if (getTrackLatencyMs(&latencyMs, &fromTrack) == OK) {
658 // Show latency in msec, followed by 't' if from track timestamp (the most accurate)
659 // or 'k' if estimated from kernel because track frames haven't been presented yet.
660 result.appendFormat(" %7.2lf %c", latencyMs, fromTrack ? 't' : 'k');
Andy Hungf6ab58d2018-05-25 12:50:39 -0700661 } else {
Andy Hungcef2daa2018-06-01 15:31:49 -0700662 result.appendFormat("%10s", mCblk->mServer != 0 ? "unavail" : "new");
Andy Hungf6ab58d2018-05-25 12:50:39 -0700663 }
664 }
665 result.append("\n");
Eric Laurent81784c32012-11-19 14:55:58 -0800666}
667
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800668uint32_t AudioFlinger::PlaybackThread::Track::sampleRate() const {
669 return mAudioTrackServerProxy->getSampleRate();
670}
671
Eric Laurent81784c32012-11-19 14:55:58 -0800672// AudioBufferProvider interface
Kevin Rocard153f92d2018-12-18 18:33:28 -0800673status_t AudioFlinger::PlaybackThread::Track::getNextBuffer(AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -0800674{
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800675 ServerProxy::Buffer buf;
676 size_t desiredFrames = buffer->frameCount;
677 buf.mFrameCount = desiredFrames;
678 status_t status = mServerProxy->obtainBuffer(&buf);
679 buffer->frameCount = buf.mFrameCount;
680 buffer->raw = buf.mRaw;
Mikhail Naganova66d3892017-05-03 16:50:56 -0700681 if (buf.mFrameCount == 0 && !isStopping() && !isStopped() && !isPaused()) {
Andy Hung9d84af52018-09-12 18:03:44 -0700682 ALOGV("%s(%d): underrun, framesReady(%zu) < framesDesired(%zd), state: %d",
683 __func__, mId, buf.mFrameCount, desiredFrames, mState);
Glenn Kasten82aaf942013-07-17 16:05:07 -0700684 mAudioTrackServerProxy->tallyUnderrunFrames(desiredFrames);
Phil Burk2812d9e2016-01-04 10:34:30 -0800685 } else {
686 mAudioTrackServerProxy->tallyUnderrunFrames(0);
Eric Laurent81784c32012-11-19 14:55:58 -0800687 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800688 return status;
Eric Laurent81784c32012-11-19 14:55:58 -0800689}
690
Kevin Rocard153f92d2018-12-18 18:33:28 -0800691void AudioFlinger::PlaybackThread::Track::releaseBuffer(AudioBufferProvider::Buffer* buffer)
692{
693 interceptBuffer(*buffer);
694 TrackBase::releaseBuffer(buffer);
695}
696
697// TODO: compensate for time shift between HW modules.
698void AudioFlinger::PlaybackThread::Track::interceptBuffer(
699 const AudioBufferProvider::Buffer& buffer) {
700 for (auto& sink : mTeePatches) {
701 RecordThread::PatchRecord& patchRecord = *sink.patchRecord;
702 AudioBufferProvider::Buffer patchBuffer;
703 patchBuffer.frameCount = buffer.frameCount;
704 auto status = patchRecord.getNextBuffer(&patchBuffer);
705 if (status != NO_ERROR) {
706 ALOGW("%s PathRecord getNextBuffer failed with error %d: %s",
707 __func__, status, strerror(-status));
708 continue;
709 }
710 // FIXME: On buffer wrap, the frame count will be less then requested,
711 // retry to write the rest. (unlikely due to lcm buffer sizing)
712 ALOGW_IF(patchBuffer.frameCount != buffer.frameCount,
713 "%s PatchRecord can not provide big enough buffer %zu/%zu, dropping %zu frames",
714 __func__, patchBuffer.frameCount, buffer.frameCount,
715 buffer.frameCount - patchBuffer.frameCount);
716 memcpy(patchBuffer.raw, buffer.raw, patchBuffer.frameCount * mFrameSize);
717 patchRecord.releaseBuffer(&patchBuffer);
718 }
719}
720
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700721// releaseBuffer() is not overridden
722
723// ExtendedAudioBufferProvider interface
724
Andy Hung27876c02014-09-09 18:07:55 -0700725// framesReady() may return an approximation of the number of frames if called
726// from a different thread than the one calling Proxy->obtainBuffer() and
727// Proxy->releaseBuffer(). Also note there is no mutual exclusion in the
728// AudioTrackServerProxy so be especially careful calling with FastTracks.
Eric Laurent81784c32012-11-19 14:55:58 -0800729size_t AudioFlinger::PlaybackThread::Track::framesReady() const {
Andy Hung27876c02014-09-09 18:07:55 -0700730 if (mSharedBuffer != 0 && (isStopped() || isStopping())) {
731 // Static tracks return zero frames immediately upon stopping (for FastTracks).
732 // The remainder of the buffer is not drained.
733 return 0;
734 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800735 return mAudioTrackServerProxy->framesReady();
Eric Laurent81784c32012-11-19 14:55:58 -0800736}
737
Andy Hung818e7a32016-02-16 18:08:07 -0800738int64_t AudioFlinger::PlaybackThread::Track::framesReleased() const
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700739{
740 return mAudioTrackServerProxy->framesReleased();
741}
742
Andy Hung818e7a32016-02-16 18:08:07 -0800743void AudioFlinger::PlaybackThread::Track::onTimestamp(const ExtendedTimestamp &timestamp)
Andy Hung6ae58432016-02-16 18:32:24 -0800744{
745 // This call comes from a FastTrack and should be kept lockless.
746 // The server side frames are already translated to client frames.
Andy Hung818e7a32016-02-16 18:08:07 -0800747 mAudioTrackServerProxy->setTimestamp(timestamp);
Andy Hung6ae58432016-02-16 18:32:24 -0800748
Andy Hung818e7a32016-02-16 18:08:07 -0800749 // We do not set drained here, as FastTrack timestamp may not go to very last frame.
Andy Hungcef2daa2018-06-01 15:31:49 -0700750
751 // Compute latency.
752 // TODO: Consider whether the server latency may be passed in by FastMixer
753 // as a constant for all active FastTracks.
754 const double latencyMs = timestamp.getOutputServerLatencyMs(sampleRate());
755 mServerLatencyFromTrack.store(true);
756 mServerLatencyMs.store(latencyMs);
Andy Hung6ae58432016-02-16 18:32:24 -0800757}
758
Eric Laurent81784c32012-11-19 14:55:58 -0800759// Don't call for fast tracks; the framesReady() could result in priority inversion
760bool AudioFlinger::PlaybackThread::Track::isReady() const {
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -0800761 if (mFillingUpStatus != FS_FILLING || isStopped() || isPausing()) {
762 return true;
763 }
764
Eric Laurent16498512014-03-17 17:22:08 -0700765 if (isStopping()) {
766 if (framesReady() > 0) {
767 mFillingUpStatus = FS_FILLED;
768 }
Eric Laurent81784c32012-11-19 14:55:58 -0800769 return true;
770 }
771
Phil Burke8972b02016-03-04 11:29:57 -0800772 if (framesReady() >= mServerProxy->getBufferSizeInFrames() ||
Glenn Kasten96f60d82013-07-12 10:21:18 -0700773 (mCblk->mFlags & CBLK_FORCEREADY)) {
Eric Laurent81784c32012-11-19 14:55:58 -0800774 mFillingUpStatus = FS_FILLED;
Glenn Kasten96f60d82013-07-12 10:21:18 -0700775 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -0800776 return true;
777 }
778 return false;
779}
780
Glenn Kasten0f11b512014-01-31 16:18:54 -0800781status_t AudioFlinger::PlaybackThread::Track::start(AudioSystem::sync_event_t event __unused,
Glenn Kastend848eb42016-03-08 13:42:11 -0800782 audio_session_t triggerSession __unused)
Eric Laurent81784c32012-11-19 14:55:58 -0800783{
784 status_t status = NO_ERROR;
Andy Hungc0691382018-09-12 18:01:57 -0700785 ALOGV("%s(%d): calling pid %d session %d",
786 __func__, mId, IPCThreadState::self()->getCallingPid(), mSessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800787
788 sp<ThreadBase> thread = mThread.promote();
789 if (thread != 0) {
Eric Laurent813e2a72013-08-31 12:59:48 -0700790 if (isOffloaded()) {
791 Mutex::Autolock _laf(thread->mAudioFlinger->mLock);
792 Mutex::Autolock _lth(thread->mLock);
793 sp<EffectChain> ec = thread->getEffectChain_l(mSessionId);
Eric Laurent5baf2af2013-09-12 17:37:00 -0700794 if (thread->mAudioFlinger->isNonOffloadableGlobalEffectEnabled_l() ||
795 (ec != 0 && ec->isNonOffloadableEnabled())) {
Eric Laurent813e2a72013-08-31 12:59:48 -0700796 invalidate();
797 return PERMISSION_DENIED;
798 }
799 }
800 Mutex::Autolock _lth(thread->mLock);
Eric Laurent81784c32012-11-19 14:55:58 -0800801 track_state state = mState;
802 // here the track could be either new, or restarted
803 // in both cases "unstop" the track
Eric Laurentbfb1b832013-01-07 09:53:42 -0800804
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -0800805 // initial state-stopping. next state-pausing.
806 // What if resume is called ?
807
808 if (state == PAUSED || state == PAUSING) {
Eric Laurentbfb1b832013-01-07 09:53:42 -0800809 if (mResumeToStopping) {
810 // happened we need to resume to STOPPING_1
811 mState = TrackBase::STOPPING_1;
Andy Hungc0691382018-09-12 18:01:57 -0700812 ALOGV("%s(%d): PAUSED => STOPPING_1 on thread %d",
813 __func__, mId, (int)mThreadIoHandle);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800814 } else {
815 mState = TrackBase::RESUMING;
Andy Hungc0691382018-09-12 18:01:57 -0700816 ALOGV("%s(%d): PAUSED => RESUMING on thread %d",
817 __func__, mId, (int)mThreadIoHandle);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800818 }
Eric Laurent81784c32012-11-19 14:55:58 -0800819 } else {
820 mState = TrackBase::ACTIVE;
Andy Hungc0691382018-09-12 18:01:57 -0700821 ALOGV("%s(%d): ? => ACTIVE on thread %d",
822 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -0800823 }
824
Andy Hunge10393e2015-06-12 13:59:33 -0700825 // states to reset position info for non-offloaded/direct tracks
826 if (!isOffloaded() && !isDirect()
827 && (state == IDLE || state == STOPPED || state == FLUSHED)) {
828 mFrameMap.reset();
829 }
Eric Laurentbfb1b832013-01-07 09:53:42 -0800830 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Haynes Mathew George240934b2015-03-11 18:25:50 -0700831 if (isFastTrack()) {
832 // refresh fast track underruns on start because that field is never cleared
833 // by the fast mixer; furthermore, the same track can be recycled, i.e. start
834 // after stop.
835 mObservedUnderruns = playbackThread->getFastTrackUnderruns(mFastIndex);
836 }
Eric Laurentbfb1b832013-01-07 09:53:42 -0800837 status = playbackThread->addTrack_l(this);
838 if (status == INVALID_OPERATION || status == PERMISSION_DENIED) {
Eric Laurent81784c32012-11-19 14:55:58 -0800839 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800840 // restore previous state if start was rejected by policy manager
841 if (status == PERMISSION_DENIED) {
842 mState = state;
843 }
844 }
Andy Hung1d3556d2018-03-29 16:30:14 -0700845
846 if (status == NO_ERROR || status == ALREADY_EXISTS) {
847 // for streaming tracks, remove the buffer read stop limit.
848 mAudioTrackServerProxy->start();
849 }
850
Eric Laurentbfb1b832013-01-07 09:53:42 -0800851 // track was already in the active list, not a problem
852 if (status == ALREADY_EXISTS) {
853 status = NO_ERROR;
Glenn Kasten12022ff2013-10-17 11:32:39 -0700854 } else {
855 // Acknowledge any pending flush(), so that subsequent new data isn't discarded.
856 // It is usually unsafe to access the server proxy from a binder thread.
857 // But in this case we know the mixer thread (whether normal mixer or fast mixer)
858 // isn't looking at this track yet: we still hold the normal mixer thread lock,
859 // and for fast tracks the track is not yet in the fast mixer thread's active set.
Andy Hunge6fb82a2015-09-09 14:39:02 -0700860 // For static tracks, this is used to acknowledge change in position or loop.
Eric Laurent564d1442015-09-09 12:26:52 -0700861 ServerProxy::Buffer buffer;
862 buffer.mFrameCount = 1;
863 (void) mAudioTrackServerProxy->obtainBuffer(&buffer, true /*ackFlush*/);
Eric Laurent81784c32012-11-19 14:55:58 -0800864 }
865 } else {
866 status = BAD_VALUE;
867 }
868 return status;
869}
870
871void AudioFlinger::PlaybackThread::Track::stop()
872{
Andy Hungc0691382018-09-12 18:01:57 -0700873 ALOGV("%s(%d): calling pid %d", __func__, mId, IPCThreadState::self()->getCallingPid());
Eric Laurent81784c32012-11-19 14:55:58 -0800874 sp<ThreadBase> thread = mThread.promote();
875 if (thread != 0) {
876 Mutex::Autolock _l(thread->mLock);
877 track_state state = mState;
878 if (state == RESUMING || state == ACTIVE || state == PAUSING || state == PAUSED) {
879 // If the track is not active (PAUSED and buffers full), flush buffers
880 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
881 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
882 reset();
883 mState = STOPPED;
Eric Laurentab5cdba2014-06-09 17:22:27 -0700884 } else if (!isFastTrack() && !isOffloaded() && !isDirect()) {
Eric Laurent81784c32012-11-19 14:55:58 -0800885 mState = STOPPED;
886 } else {
Eric Laurentbfb1b832013-01-07 09:53:42 -0800887 // For fast tracks prepareTracks_l() will set state to STOPPING_2
888 // presentation is complete
889 // For an offloaded track this starts a drain and state will
890 // move to STOPPING_2 when drain completes and then STOPPED
Eric Laurent81784c32012-11-19 14:55:58 -0800891 mState = STOPPING_1;
Eric Laurente93cc032016-05-05 10:15:10 -0700892 if (isOffloaded()) {
893 mRetryCount = PlaybackThread::kMaxTrackStopRetriesOffload;
894 }
Eric Laurent81784c32012-11-19 14:55:58 -0800895 }
Eric Laurentb369caf2015-03-30 20:51:47 -0700896 playbackThread->broadcast_l();
Andy Hungc0691382018-09-12 18:01:57 -0700897 ALOGV("%s(%d): not stopping/stopped => stopping/stopped on thread %d",
898 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -0800899 }
Eric Laurent81784c32012-11-19 14:55:58 -0800900 }
901}
902
903void AudioFlinger::PlaybackThread::Track::pause()
904{
Andy Hungc0691382018-09-12 18:01:57 -0700905 ALOGV("%s(%d): calling pid %d", __func__, mId, IPCThreadState::self()->getCallingPid());
Eric Laurent81784c32012-11-19 14:55:58 -0800906 sp<ThreadBase> thread = mThread.promote();
907 if (thread != 0) {
908 Mutex::Autolock _l(thread->mLock);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800909 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
910 switch (mState) {
911 case STOPPING_1:
912 case STOPPING_2:
913 if (!isOffloaded()) {
914 /* nothing to do if track is not offloaded */
915 break;
916 }
917
918 // Offloaded track was draining, we need to carry on draining when resumed
919 mResumeToStopping = true;
Chih-Hung Hsieh2b487032018-09-13 14:16:02 -0700920 FALLTHROUGH_INTENDED;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800921 case ACTIVE:
922 case RESUMING:
Eric Laurent81784c32012-11-19 14:55:58 -0800923 mState = PAUSING;
Andy Hungc0691382018-09-12 18:01:57 -0700924 ALOGV("%s(%d): ACTIVE/RESUMING => PAUSING on thread %d",
925 __func__, mId, (int)mThreadIoHandle);
Eric Laurentede6c3b2013-09-19 14:37:46 -0700926 playbackThread->broadcast_l();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800927 break;
Eric Laurent81784c32012-11-19 14:55:58 -0800928
Eric Laurentbfb1b832013-01-07 09:53:42 -0800929 default:
930 break;
Eric Laurent81784c32012-11-19 14:55:58 -0800931 }
932 }
933}
934
935void AudioFlinger::PlaybackThread::Track::flush()
936{
Andy Hungc0691382018-09-12 18:01:57 -0700937 ALOGV("%s(%d)", __func__, mId);
Eric Laurent81784c32012-11-19 14:55:58 -0800938 sp<ThreadBase> thread = mThread.promote();
939 if (thread != 0) {
940 Mutex::Autolock _l(thread->mLock);
Eric Laurent81784c32012-11-19 14:55:58 -0800941 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800942
Phil Burk4bb650b2016-09-09 12:11:17 -0700943 // Flush the ring buffer now if the track is not active in the PlaybackThread.
944 // Otherwise the flush would not be done until the track is resumed.
945 // Requires FastTrack removal be BLOCK_UNTIL_ACKED
946 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
947 (void)mServerProxy->flushBufferIfNeeded();
948 }
949
Eric Laurentbfb1b832013-01-07 09:53:42 -0800950 if (isOffloaded()) {
951 // If offloaded we allow flush during any state except terminated
952 // and keep the track active to avoid problems if user is seeking
953 // rapidly and underlying hardware has a significant delay handling
954 // a pause
955 if (isTerminated()) {
956 return;
957 }
958
Andy Hung9d84af52018-09-12 18:03:44 -0700959 ALOGV("%s(%d): offload flush", __func__, mId);
Eric Laurent81784c32012-11-19 14:55:58 -0800960 reset();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800961
962 if (mState == STOPPING_1 || mState == STOPPING_2) {
Andy Hung9d84af52018-09-12 18:03:44 -0700963 ALOGV("%s(%d): flushed in STOPPING_1 or 2 state, change state to ACTIVE",
964 __func__, mId);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800965 mState = ACTIVE;
966 }
967
Haynes Mathew George7844f672014-01-15 12:32:55 -0800968 mFlushHwPending = true;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800969 mResumeToStopping = false;
970 } else {
971 if (mState != STOPPING_1 && mState != STOPPING_2 && mState != STOPPED &&
972 mState != PAUSED && mState != PAUSING && mState != IDLE && mState != FLUSHED) {
973 return;
974 }
975 // No point remaining in PAUSED state after a flush => go to
976 // FLUSHED state
977 mState = FLUSHED;
978 // do not reset the track if it is still in the process of being stopped or paused.
979 // this will be done by prepareTracks_l() when the track is stopped.
980 // prepareTracks_l() will see mState == FLUSHED, then
981 // remove from active track list, reset(), and trigger presentation complete
Eric Laurentd1f69b02014-12-15 14:33:13 -0800982 if (isDirect()) {
983 mFlushHwPending = true;
984 }
Eric Laurentbfb1b832013-01-07 09:53:42 -0800985 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
986 reset();
987 }
Eric Laurent81784c32012-11-19 14:55:58 -0800988 }
Eric Laurentbfb1b832013-01-07 09:53:42 -0800989 // Prevent flush being lost if the track is flushed and then resumed
990 // before mixer thread can run. This is important when offloading
991 // because the hardware buffer could hold a large amount of audio
Eric Laurentede6c3b2013-09-19 14:37:46 -0700992 playbackThread->broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800993 }
994}
995
Haynes Mathew George7844f672014-01-15 12:32:55 -0800996// must be called with thread lock held
997void AudioFlinger::PlaybackThread::Track::flushAck()
998{
Eric Laurentd1f69b02014-12-15 14:33:13 -0800999 if (!isOffloaded() && !isDirect())
Haynes Mathew George7844f672014-01-15 12:32:55 -08001000 return;
1001
Phil Burk4bb650b2016-09-09 12:11:17 -07001002 // Clear the client ring buffer so that the app can prime the buffer while paused.
1003 // Otherwise it might not get cleared until playback is resumed and obtainBuffer() is called.
1004 mServerProxy->flushBufferIfNeeded();
1005
Haynes Mathew George7844f672014-01-15 12:32:55 -08001006 mFlushHwPending = false;
1007}
1008
Eric Laurent81784c32012-11-19 14:55:58 -08001009void AudioFlinger::PlaybackThread::Track::reset()
1010{
1011 // Do not reset twice to avoid discarding data written just after a flush and before
1012 // the audioflinger thread detects the track is stopped.
1013 if (!mResetDone) {
Eric Laurent81784c32012-11-19 14:55:58 -08001014 // Force underrun condition to avoid false underrun callback until first data is
1015 // written to buffer
Glenn Kasten96f60d82013-07-12 10:21:18 -07001016 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08001017 mFillingUpStatus = FS_FILLING;
1018 mResetDone = true;
1019 if (mState == FLUSHED) {
1020 mState = IDLE;
1021 }
1022 }
1023}
1024
Eric Laurentbfb1b832013-01-07 09:53:42 -08001025status_t AudioFlinger::PlaybackThread::Track::setParameters(const String8& keyValuePairs)
1026{
1027 sp<ThreadBase> thread = mThread.promote();
1028 if (thread == 0) {
Andy Hung9d84af52018-09-12 18:03:44 -07001029 ALOGE("%s(%d): thread is dead", __func__, mId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001030 return FAILED_TRANSACTION;
1031 } else if ((thread->type() == ThreadBase::DIRECT) ||
1032 (thread->type() == ThreadBase::OFFLOAD)) {
1033 return thread->setParameters(keyValuePairs);
1034 } else {
1035 return PERMISSION_DENIED;
1036 }
1037}
1038
Mikhail Naganovac917ac2018-11-28 14:03:52 -08001039status_t AudioFlinger::PlaybackThread::Track::selectPresentation(int presentationId,
1040 int programId) {
1041 sp<ThreadBase> thread = mThread.promote();
1042 if (thread == 0) {
1043 ALOGE("thread is dead");
1044 return FAILED_TRANSACTION;
1045 } else if ((thread->type() == ThreadBase::DIRECT) || (thread->type() == ThreadBase::OFFLOAD)) {
1046 DirectOutputThread *directOutputThread = static_cast<DirectOutputThread*>(thread.get());
1047 return directOutputThread->selectPresentation(presentationId, programId);
1048 }
1049 return INVALID_OPERATION;
1050}
1051
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001052VolumeShaper::Status AudioFlinger::PlaybackThread::Track::applyVolumeShaper(
1053 const sp<VolumeShaper::Configuration>& configuration,
1054 const sp<VolumeShaper::Operation>& operation)
1055{
Andy Hung10cbff12017-02-21 17:30:14 -08001056 sp<VolumeShaper::Configuration> newConfiguration;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001057
Andy Hung10cbff12017-02-21 17:30:14 -08001058 if (isOffloadedOrDirect()) {
1059 const VolumeShaper::Configuration::OptionFlag optionFlag
1060 = configuration->getOptionFlags();
1061 if ((optionFlag & VolumeShaper::Configuration::OPTION_FLAG_CLOCK_TIME) == 0) {
Andy Hung9d84af52018-09-12 18:03:44 -07001062 ALOGW("%s(%d): %s tracks do not support frame counted VolumeShaper,"
1063 " using clock time instead",
1064 __func__, mId,
1065 isOffloaded() ? "Offload" : "Direct");
Andy Hung10cbff12017-02-21 17:30:14 -08001066 newConfiguration = new VolumeShaper::Configuration(*configuration);
1067 newConfiguration->setOptionFlags(
1068 VolumeShaper::Configuration::OptionFlag(optionFlag
1069 | VolumeShaper::Configuration::OPTION_FLAG_CLOCK_TIME));
1070 }
1071 }
1072
1073 VolumeShaper::Status status = mVolumeHandler->applyVolumeShaper(
1074 (newConfiguration.get() != nullptr ? newConfiguration : configuration), operation);
1075
1076 if (isOffloadedOrDirect()) {
1077 // Signal thread to fetch new volume.
1078 sp<ThreadBase> thread = mThread.promote();
1079 if (thread != 0) {
Kevin Rocard5f2136e2018-05-11 22:03:00 -07001080 Mutex::Autolock _l(thread->mLock);
Andy Hung10cbff12017-02-21 17:30:14 -08001081 thread->broadcast_l();
1082 }
1083 }
1084 return status;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001085}
1086
1087sp<VolumeShaper::State> AudioFlinger::PlaybackThread::Track::getVolumeShaperState(int id)
1088{
1089 // Note: We don't check if Thread exists.
1090
1091 // mVolumeHandler is thread safe.
1092 return mVolumeHandler->getVolumeShaperState(id);
1093}
1094
Kevin Rocard12381092018-04-11 09:19:59 -07001095void AudioFlinger::PlaybackThread::Track::setFinalVolume(float volume)
1096{
1097 if (mFinalVolume != volume) { // Compare to an epsilon if too many meaningless updates
1098 mFinalVolume = volume;
1099 setMetadataHasChanged();
1100 }
1101}
1102
1103void AudioFlinger::PlaybackThread::Track::copyMetadataTo(MetadataInserter& backInserter) const
1104{
1105 *backInserter++ = {
1106 .usage = mAttr.usage,
1107 .content_type = mAttr.content_type,
1108 .gain = mFinalVolume,
1109 };
1110}
1111
Kevin Rocard153f92d2018-12-18 18:33:28 -08001112void AudioFlinger::PlaybackThread::Track::setTeePatches(TeePatches teePatches) {
1113 mTeePatches = std::move(teePatches);
1114}
1115
Glenn Kasten573d80a2013-08-26 09:36:23 -07001116status_t AudioFlinger::PlaybackThread::Track::getTimestamp(AudioTimestamp& timestamp)
1117{
Andy Hung818e7a32016-02-16 18:08:07 -08001118 if (!isOffloaded() && !isDirect()) {
1119 return INVALID_OPERATION; // normal tracks handled through SSQ
Glenn Kastenfe346c72013-08-30 13:28:22 -07001120 }
Glenn Kasten573d80a2013-08-26 09:36:23 -07001121 sp<ThreadBase> thread = mThread.promote();
1122 if (thread == 0) {
Glenn Kastenfe346c72013-08-30 13:28:22 -07001123 return INVALID_OPERATION;
Glenn Kasten573d80a2013-08-26 09:36:23 -07001124 }
Phil Burk6140c792015-03-19 14:30:21 -07001125
Glenn Kasten573d80a2013-08-26 09:36:23 -07001126 Mutex::Autolock _l(thread->mLock);
1127 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Andy Hung818e7a32016-02-16 18:08:07 -08001128 return playbackThread->getTimestamp_l(timestamp);
Glenn Kasten573d80a2013-08-26 09:36:23 -07001129}
1130
Eric Laurent81784c32012-11-19 14:55:58 -08001131status_t AudioFlinger::PlaybackThread::Track::attachAuxEffect(int EffectId)
1132{
1133 status_t status = DEAD_OBJECT;
1134 sp<ThreadBase> thread = mThread.promote();
1135 if (thread != 0) {
1136 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1137 sp<AudioFlinger> af = mClient->audioFlinger();
1138
1139 Mutex::Autolock _l(af->mLock);
1140
1141 sp<PlaybackThread> srcThread = af->getEffectThread_l(AUDIO_SESSION_OUTPUT_MIX, EffectId);
1142
1143 if (EffectId != 0 && srcThread != 0 && playbackThread != srcThread.get()) {
1144 Mutex::Autolock _dl(playbackThread->mLock);
1145 Mutex::Autolock _sl(srcThread->mLock);
1146 sp<EffectChain> chain = srcThread->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
1147 if (chain == 0) {
1148 return INVALID_OPERATION;
1149 }
1150
1151 sp<EffectModule> effect = chain->getEffectFromId_l(EffectId);
1152 if (effect == 0) {
1153 return INVALID_OPERATION;
1154 }
1155 srcThread->removeEffect_l(effect);
Eric Laurent5baf2af2013-09-12 17:37:00 -07001156 status = playbackThread->addEffect_l(effect);
1157 if (status != NO_ERROR) {
1158 srcThread->addEffect_l(effect);
1159 return INVALID_OPERATION;
1160 }
Eric Laurent81784c32012-11-19 14:55:58 -08001161 // removeEffect_l() has stopped the effect if it was active so it must be restarted
1162 if (effect->state() == EffectModule::ACTIVE ||
1163 effect->state() == EffectModule::STOPPING) {
1164 effect->start();
1165 }
1166
1167 sp<EffectChain> dstChain = effect->chain().promote();
1168 if (dstChain == 0) {
1169 srcThread->addEffect_l(effect);
1170 return INVALID_OPERATION;
1171 }
1172 AudioSystem::unregisterEffect(effect->id());
1173 AudioSystem::registerEffect(&effect->desc(),
1174 srcThread->id(),
1175 dstChain->strategy(),
1176 AUDIO_SESSION_OUTPUT_MIX,
1177 effect->id());
Eric Laurentd72b7c02013-10-12 16:17:46 -07001178 AudioSystem::setEffectEnabled(effect->id(), effect->isEnabled());
Eric Laurent81784c32012-11-19 14:55:58 -08001179 }
1180 status = playbackThread->attachAuxEffect(this, EffectId);
1181 }
1182 return status;
1183}
1184
1185void AudioFlinger::PlaybackThread::Track::setAuxBuffer(int EffectId, int32_t *buffer)
1186{
1187 mAuxEffectId = EffectId;
1188 mAuxBuffer = buffer;
1189}
1190
Andy Hung818e7a32016-02-16 18:08:07 -08001191bool AudioFlinger::PlaybackThread::Track::presentationComplete(
1192 int64_t framesWritten, size_t audioHalFrames)
Eric Laurent81784c32012-11-19 14:55:58 -08001193{
Andy Hung818e7a32016-02-16 18:08:07 -08001194 // TODO: improve this based on FrameMap if it exists, to ensure full drain.
1195 // This assists in proper timestamp computation as well as wakelock management.
1196
Eric Laurent81784c32012-11-19 14:55:58 -08001197 // a track is considered presented when the total number of frames written to audio HAL
1198 // corresponds to the number of frames written when presentationComplete() is called for the
1199 // first time (mPresentationCompleteFrames == 0) plus the buffer filling status at that time.
Eric Laurentbfb1b832013-01-07 09:53:42 -08001200 // For an offloaded track the HAL+h/w delay is variable so a HAL drain() is used
1201 // to detect when all frames have been played. In this case framesWritten isn't
1202 // useful because it doesn't always reflect whether there is data in the h/w
1203 // buffers, particularly if a track has been paused and resumed during draining
Andy Hung9d84af52018-09-12 18:03:44 -07001204 ALOGV("%s(%d): presentationComplete() mPresentationCompleteFrames %lld framesWritten %lld",
1205 __func__, mId,
Andy Hung818e7a32016-02-16 18:08:07 -08001206 (long long)mPresentationCompleteFrames, (long long)framesWritten);
Eric Laurent81784c32012-11-19 14:55:58 -08001207 if (mPresentationCompleteFrames == 0) {
1208 mPresentationCompleteFrames = framesWritten + audioHalFrames;
Andy Hung9d84af52018-09-12 18:03:44 -07001209 ALOGV("%s(%d): presentationComplete() reset:"
1210 " mPresentationCompleteFrames %lld audioHalFrames %zu",
1211 __func__, mId,
Andy Hung818e7a32016-02-16 18:08:07 -08001212 (long long)mPresentationCompleteFrames, audioHalFrames);
Eric Laurent81784c32012-11-19 14:55:58 -08001213 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001214
Andy Hungc54b1ff2016-02-23 14:07:07 -08001215 bool complete;
1216 if (isOffloaded()) {
1217 complete = true;
1218 } else if (isDirect() || isFastTrack()) { // these do not go through linear map
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001219 complete = framesWritten >= (int64_t) mPresentationCompleteFrames;
Andy Hungc54b1ff2016-02-23 14:07:07 -08001220 } else { // Normal tracks, OutputTracks, and PatchTracks
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001221 complete = framesWritten >= (int64_t) mPresentationCompleteFrames
Andy Hungc54b1ff2016-02-23 14:07:07 -08001222 && mAudioTrackServerProxy->isDrained();
1223 }
1224
1225 if (complete) {
Eric Laurent81784c32012-11-19 14:55:58 -08001226 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001227 mAudioTrackServerProxy->setStreamEndDone();
Eric Laurent81784c32012-11-19 14:55:58 -08001228 return true;
1229 }
1230 return false;
1231}
1232
1233void AudioFlinger::PlaybackThread::Track::triggerEvents(AudioSystem::sync_event_t type)
1234{
Ivan Lozano5ec161b2017-12-06 10:00:28 -08001235 for (size_t i = 0; i < mSyncEvents.size();) {
Eric Laurent81784c32012-11-19 14:55:58 -08001236 if (mSyncEvents[i]->type() == type) {
1237 mSyncEvents[i]->trigger();
1238 mSyncEvents.removeAt(i);
Ivan Lozano5ec161b2017-12-06 10:00:28 -08001239 } else {
1240 ++i;
Eric Laurent81784c32012-11-19 14:55:58 -08001241 }
1242 }
1243}
1244
1245// implement VolumeBufferProvider interface
1246
Glenn Kastenc56f3422014-03-21 17:53:17 -07001247gain_minifloat_packed_t AudioFlinger::PlaybackThread::Track::getVolumeLR()
Eric Laurent81784c32012-11-19 14:55:58 -08001248{
1249 // called by FastMixer, so not allowed to take any locks, block, or do I/O including logs
1250 ALOG_ASSERT(isFastTrack() && (mCblk != NULL));
Glenn Kastenc56f3422014-03-21 17:53:17 -07001251 gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR();
1252 float vl = float_from_gain(gain_minifloat_unpack_left(vlr));
1253 float vr = float_from_gain(gain_minifloat_unpack_right(vlr));
Eric Laurent81784c32012-11-19 14:55:58 -08001254 // track volumes come from shared memory, so can't be trusted and must be clamped
Glenn Kastenc56f3422014-03-21 17:53:17 -07001255 if (vl > GAIN_FLOAT_UNITY) {
1256 vl = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08001257 }
Glenn Kastenc56f3422014-03-21 17:53:17 -07001258 if (vr > GAIN_FLOAT_UNITY) {
1259 vr = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08001260 }
1261 // now apply the cached master volume and stream type volume;
1262 // this is trusted but lacks any synchronization or barrier so may be stale
1263 float v = mCachedVolume;
1264 vl *= v;
1265 vr *= v;
Glenn Kastenc56f3422014-03-21 17:53:17 -07001266 // re-combine into packed minifloat
1267 vlr = gain_minifloat_pack(gain_from_float(vl), gain_from_float(vr));
Eric Laurent81784c32012-11-19 14:55:58 -08001268 // FIXME look at mute, pause, and stop flags
1269 return vlr;
1270}
1271
1272status_t AudioFlinger::PlaybackThread::Track::setSyncEvent(const sp<SyncEvent>& event)
1273{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001274 if (isTerminated() || mState == PAUSED ||
Eric Laurent81784c32012-11-19 14:55:58 -08001275 ((framesReady() == 0) && ((mSharedBuffer != 0) ||
1276 (mState == STOPPED)))) {
Andy Hung9d84af52018-09-12 18:03:44 -07001277 ALOGW("%s(%d): in invalid state %d on session %d %s mode, framesReady %zu",
1278 __func__, mId,
Eric Laurent81784c32012-11-19 14:55:58 -08001279 mState, mSessionId, (mSharedBuffer != 0) ? "static" : "stream", framesReady());
1280 event->cancel();
1281 return INVALID_OPERATION;
1282 }
1283 (void) TrackBase::setSyncEvent(event);
1284 return NO_ERROR;
1285}
1286
Glenn Kasten5736c352012-12-04 12:12:34 -08001287void AudioFlinger::PlaybackThread::Track::invalidate()
1288{
Eric Laurent6acd1d42017-01-04 14:23:29 -08001289 TrackBase::invalidate();
Eric Laurent4d231dc2016-03-11 18:38:23 -08001290 signalClientFlag(CBLK_INVALID);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001291}
1292
1293void AudioFlinger::PlaybackThread::Track::disable()
1294{
1295 signalClientFlag(CBLK_DISABLED);
1296}
1297
1298void AudioFlinger::PlaybackThread::Track::signalClientFlag(int32_t flag)
1299{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001300 // FIXME should use proxy, and needs work
1301 audio_track_cblk_t* cblk = mCblk;
Eric Laurent4d231dc2016-03-11 18:38:23 -08001302 android_atomic_or(flag, &cblk->mFlags);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001303 android_atomic_release_store(0x40000000, &cblk->mFutex);
1304 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE
Elliott Hughesee499292014-05-21 17:55:51 -07001305 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX);
Glenn Kasten5736c352012-12-04 12:12:34 -08001306}
1307
Eric Laurent59fe0102013-09-27 18:48:26 -07001308void AudioFlinger::PlaybackThread::Track::signal()
1309{
1310 sp<ThreadBase> thread = mThread.promote();
1311 if (thread != 0) {
1312 PlaybackThread *t = (PlaybackThread *)thread.get();
1313 Mutex::Autolock _l(t->mLock);
1314 t->broadcast_l();
1315 }
1316}
1317
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001318//To be called with thread lock held
1319bool AudioFlinger::PlaybackThread::Track::isResumePending() {
1320
1321 if (mState == RESUMING)
1322 return true;
1323 /* Resume is pending if track was stopping before pause was called */
1324 if (mState == STOPPING_1 &&
1325 mResumeToStopping)
1326 return true;
1327
1328 return false;
1329}
1330
1331//To be called with thread lock held
1332void AudioFlinger::PlaybackThread::Track::resumeAck() {
1333
1334
1335 if (mState == RESUMING)
1336 mState = ACTIVE;
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08001337
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001338 // Other possibility of pending resume is stopping_1 state
1339 // Do not update the state from stopping as this prevents
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08001340 // drain being called.
1341 if (mState == STOPPING_1) {
1342 mResumeToStopping = false;
1343 }
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001344}
Andy Hunge10393e2015-06-12 13:59:33 -07001345
1346//To be called with thread lock held
1347void AudioFlinger::PlaybackThread::Track::updateTrackFrameInfo(
Andy Hung818e7a32016-02-16 18:08:07 -08001348 int64_t trackFramesReleased, int64_t sinkFramesWritten,
Andy Hungcef2daa2018-06-01 15:31:49 -07001349 uint32_t halSampleRate, const ExtendedTimestamp &timeStamp) {
Andy Hung30282562018-08-08 18:27:03 -07001350 // Make the kernel frametime available.
1351 const FrameTime ft{
1352 timeStamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
1353 timeStamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]};
1354 // ALOGD("FrameTime: %lld %lld", (long long)ft.frames, (long long)ft.timeNs);
1355 mKernelFrameTime.store(ft);
1356 if (!audio_is_linear_pcm(mFormat)) {
1357 return;
1358 }
1359
Andy Hung818e7a32016-02-16 18:08:07 -08001360 //update frame map
Andy Hunge10393e2015-06-12 13:59:33 -07001361 mFrameMap.push(trackFramesReleased, sinkFramesWritten);
Andy Hung818e7a32016-02-16 18:08:07 -08001362
1363 // adjust server times and set drained state.
1364 //
1365 // Our timestamps are only updated when the track is on the Thread active list.
1366 // We need to ensure that tracks are not removed before full drain.
1367 ExtendedTimestamp local = timeStamp;
Andy Hungcef2daa2018-06-01 15:31:49 -07001368 bool drained = true; // default assume drained, if no server info found
Andy Hung818e7a32016-02-16 18:08:07 -08001369 bool checked = false;
1370 for (int i = ExtendedTimestamp::LOCATION_MAX - 1;
1371 i >= ExtendedTimestamp::LOCATION_SERVER; --i) {
1372 // Lookup the track frame corresponding to the sink frame position.
1373 if (local.mTimeNs[i] > 0) {
1374 local.mPosition[i] = mFrameMap.findX(local.mPosition[i]);
1375 // check drain state from the latest stage in the pipeline.
Andy Hung6d7b1192016-05-07 22:59:48 -07001376 if (!checked && i <= ExtendedTimestamp::LOCATION_KERNEL) {
Andy Hungcef2daa2018-06-01 15:31:49 -07001377 drained = local.mPosition[i] >= mAudioTrackServerProxy->framesReleased();
Andy Hung818e7a32016-02-16 18:08:07 -08001378 checked = true;
1379 }
1380 }
Andy Hunge10393e2015-06-12 13:59:33 -07001381 }
Andy Hungcef2daa2018-06-01 15:31:49 -07001382
1383 mAudioTrackServerProxy->setDrained(drained);
Andy Hungea2b9c02016-02-12 17:06:53 -08001384 // Set correction for flushed frames that are not accounted for in released.
Andy Hungea2b9c02016-02-12 17:06:53 -08001385 local.mFlushed = mAudioTrackServerProxy->framesFlushed();
Andy Hung818e7a32016-02-16 18:08:07 -08001386 mServerProxy->setTimestamp(local);
Andy Hungcef2daa2018-06-01 15:31:49 -07001387
1388 // Compute latency info.
1389 const bool useTrackTimestamp = !drained;
1390 const double latencyMs = useTrackTimestamp
1391 ? local.getOutputServerLatencyMs(sampleRate())
1392 : timeStamp.getOutputServerLatencyMs(halSampleRate);
1393
1394 mServerLatencyFromTrack.store(useTrackTimestamp);
1395 mServerLatencyMs.store(latencyMs);
Andy Hunge10393e2015-06-12 13:59:33 -07001396}
1397
jiabin57303cc2018-12-18 15:45:57 -08001398binder::Status AudioFlinger::PlaybackThread::Track::AudioVibrationController::mute(
1399 /*out*/ bool *ret) {
1400 *ret = false;
1401 sp<ThreadBase> thread = mTrack->mThread.promote();
1402 if (thread != 0) {
1403 // Lock for updating mHapticPlaybackEnabled.
1404 Mutex::Autolock _l(thread->mLock);
1405 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1406 if ((mTrack->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
1407 && playbackThread->mHapticChannelCount > 0) {
1408 mTrack->setHapticPlaybackEnabled(false);
1409 *ret = true;
1410 }
1411 }
1412 return binder::Status::ok();
1413}
1414
1415binder::Status AudioFlinger::PlaybackThread::Track::AudioVibrationController::unmute(
1416 /*out*/ bool *ret) {
1417 *ret = false;
1418 sp<ThreadBase> thread = mTrack->mThread.promote();
1419 if (thread != 0) {
1420 // Lock for updating mHapticPlaybackEnabled.
1421 Mutex::Autolock _l(thread->mLock);
1422 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1423 if ((mTrack->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
1424 && playbackThread->mHapticChannelCount > 0) {
1425 mTrack->setHapticPlaybackEnabled(true);
1426 *ret = true;
1427 }
1428 }
1429 return binder::Status::ok();
1430}
1431
Eric Laurent81784c32012-11-19 14:55:58 -08001432// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -07001433#undef LOG_TAG
1434#define LOG_TAG "AF::OutputTrack"
Eric Laurent81784c32012-11-19 14:55:58 -08001435
Eric Laurent81784c32012-11-19 14:55:58 -08001436AudioFlinger::PlaybackThread::OutputTrack::OutputTrack(
1437 PlaybackThread *playbackThread,
1438 DuplicatingThread *sourceThread,
1439 uint32_t sampleRate,
1440 audio_format_t format,
1441 audio_channel_mask_t channelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001442 size_t frameCount,
Andy Hung1f12a8a2016-11-07 16:10:30 -08001443 uid_t uid)
Eric Laurent223fd5c2014-11-11 13:43:36 -08001444 : Track(playbackThread, NULL, AUDIO_STREAM_PATCH,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001445 audio_attributes_t{} /* currently unused for output track */,
Eric Laurent223fd5c2014-11-11 13:43:36 -08001446 sampleRate, format, channelMask, frameCount,
Andy Hung8fe68032017-06-05 16:17:51 -07001447 nullptr /* buffer */, (size_t)0 /* bufferSize */, nullptr /* sharedBuffer */,
1448 AUDIO_SESSION_NONE, uid, AUDIO_OUTPUT_FLAG_NONE,
Glenn Kastend848eb42016-03-08 13:42:11 -08001449 TYPE_OUTPUT),
Eric Laurent5bba2f62016-03-18 11:14:14 -07001450 mActive(false), mSourceThread(sourceThread)
Eric Laurent81784c32012-11-19 14:55:58 -08001451{
1452
1453 if (mCblk != NULL) {
Eric Laurent81784c32012-11-19 14:55:58 -08001454 mOutBuffer.frameCount = 0;
1455 playbackThread->mTracks.add(this);
Andy Hung9d84af52018-09-12 18:03:44 -07001456 ALOGV("%s(): mCblk %p, mBuffer %p, "
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001457 "frameCount %zu, mChannelMask 0x%08x",
Andy Hung9d84af52018-09-12 18:03:44 -07001458 __func__, mCblk, mBuffer,
Glenn Kasten74935e42013-12-19 08:56:45 -08001459 frameCount, mChannelMask);
Glenn Kastene3aa6592012-12-04 12:22:46 -08001460 // since client and server are in the same process,
1461 // the buffer has the same virtual address on both sides
Glenn Kasten529c61b2014-07-18 15:31:02 -07001462 mClientProxy = new AudioTrackClientProxy(mCblk, mBuffer, mFrameCount, mFrameSize,
1463 true /*clientInServer*/);
Glenn Kastenc56f3422014-03-21 17:53:17 -07001464 mClientProxy->setVolumeLR(GAIN_MINIFLOAT_PACKED_UNITY);
Eric Laurent8d2d4932013-04-25 12:56:18 -07001465 mClientProxy->setSendLevel(0.0);
1466 mClientProxy->setSampleRate(sampleRate);
Eric Laurent81784c32012-11-19 14:55:58 -08001467 } else {
Andy Hung9d84af52018-09-12 18:03:44 -07001468 ALOGW("%s(%d): Error creating output track on thread %d",
1469 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -08001470 }
1471}
1472
1473AudioFlinger::PlaybackThread::OutputTrack::~OutputTrack()
1474{
1475 clearBufferQueue();
Glenn Kastene3aa6592012-12-04 12:22:46 -08001476 // superclass destructor will now delete the server proxy and shared memory both refer to
Eric Laurent81784c32012-11-19 14:55:58 -08001477}
1478
1479status_t AudioFlinger::PlaybackThread::OutputTrack::start(AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08001480 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08001481{
1482 status_t status = Track::start(event, triggerSession);
1483 if (status != NO_ERROR) {
1484 return status;
1485 }
1486
1487 mActive = true;
1488 mRetryCount = 127;
1489 return status;
1490}
1491
1492void AudioFlinger::PlaybackThread::OutputTrack::stop()
1493{
1494 Track::stop();
1495 clearBufferQueue();
1496 mOutBuffer.frameCount = 0;
1497 mActive = false;
1498}
1499
Andy Hung1c86ebe2018-05-29 20:29:08 -07001500ssize_t AudioFlinger::PlaybackThread::OutputTrack::write(void* data, uint32_t frames)
Eric Laurent81784c32012-11-19 14:55:58 -08001501{
1502 Buffer *pInBuffer;
1503 Buffer inBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -08001504 bool outputBufferFull = false;
1505 inBuffer.frameCount = frames;
Andy Hungc25b84a2015-01-14 19:04:10 -08001506 inBuffer.raw = data;
Eric Laurent81784c32012-11-19 14:55:58 -08001507
1508 uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs();
1509
1510 if (!mActive && frames != 0) {
Andy Hung5bedff62015-01-16 11:05:32 -08001511 (void) start();
Eric Laurent81784c32012-11-19 14:55:58 -08001512 }
1513
1514 while (waitTimeLeftMs) {
1515 // First write pending buffers, then new data
1516 if (mBufferQueue.size()) {
1517 pInBuffer = mBufferQueue.itemAt(0);
1518 } else {
1519 pInBuffer = &inBuffer;
1520 }
1521
1522 if (pInBuffer->frameCount == 0) {
1523 break;
1524 }
1525
1526 if (mOutBuffer.frameCount == 0) {
1527 mOutBuffer.frameCount = pInBuffer->frameCount;
1528 nsecs_t startTime = systemTime();
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001529 status_t status = obtainBuffer(&mOutBuffer, waitTimeLeftMs);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001530 if (status != NO_ERROR && status != NOT_ENOUGH_DATA) {
Andy Hung9d84af52018-09-12 18:03:44 -07001531 ALOGV("%s(%d): thread %d no more output buffers; status %d",
1532 __func__, mId,
1533 (int)mThreadIoHandle, status);
Eric Laurent81784c32012-11-19 14:55:58 -08001534 outputBufferFull = true;
1535 break;
1536 }
1537 uint32_t waitTimeMs = (uint32_t)ns2ms(systemTime() - startTime);
1538 if (waitTimeLeftMs >= waitTimeMs) {
1539 waitTimeLeftMs -= waitTimeMs;
1540 } else {
1541 waitTimeLeftMs = 0;
1542 }
Eric Laurent4d231dc2016-03-11 18:38:23 -08001543 if (status == NOT_ENOUGH_DATA) {
1544 restartIfDisabled();
1545 continue;
1546 }
Eric Laurent81784c32012-11-19 14:55:58 -08001547 }
1548
1549 uint32_t outFrames = pInBuffer->frameCount > mOutBuffer.frameCount ? mOutBuffer.frameCount :
1550 pInBuffer->frameCount;
Andy Hungc25b84a2015-01-14 19:04:10 -08001551 memcpy(mOutBuffer.raw, pInBuffer->raw, outFrames * mFrameSize);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001552 Proxy::Buffer buf;
1553 buf.mFrameCount = outFrames;
1554 buf.mRaw = NULL;
1555 mClientProxy->releaseBuffer(&buf);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001556 restartIfDisabled();
Eric Laurent81784c32012-11-19 14:55:58 -08001557 pInBuffer->frameCount -= outFrames;
Andy Hungc25b84a2015-01-14 19:04:10 -08001558 pInBuffer->raw = (int8_t *)pInBuffer->raw + outFrames * mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08001559 mOutBuffer.frameCount -= outFrames;
Andy Hungc25b84a2015-01-14 19:04:10 -08001560 mOutBuffer.raw = (int8_t *)mOutBuffer.raw + outFrames * mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08001561
1562 if (pInBuffer->frameCount == 0) {
1563 if (mBufferQueue.size()) {
1564 mBufferQueue.removeAt(0);
Andy Hungc25b84a2015-01-14 19:04:10 -08001565 free(pInBuffer->mBuffer);
Yunlian Jiang8adc8082017-06-06 15:59:44 -07001566 if (pInBuffer != &inBuffer) {
1567 delete pInBuffer;
1568 }
Andy Hung9d84af52018-09-12 18:03:44 -07001569 ALOGV("%s(%d): thread %d released overflow buffer %zu",
1570 __func__, mId,
1571 (int)mThreadIoHandle, mBufferQueue.size());
Eric Laurent81784c32012-11-19 14:55:58 -08001572 } else {
1573 break;
1574 }
1575 }
1576 }
1577
1578 // If we could not write all frames, allocate a buffer and queue it for next time.
1579 if (inBuffer.frameCount) {
1580 sp<ThreadBase> thread = mThread.promote();
1581 if (thread != 0 && !thread->standby()) {
1582 if (mBufferQueue.size() < kMaxOverFlowBuffers) {
1583 pInBuffer = new Buffer;
Andy Hungc25b84a2015-01-14 19:04:10 -08001584 pInBuffer->mBuffer = malloc(inBuffer.frameCount * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08001585 pInBuffer->frameCount = inBuffer.frameCount;
Andy Hungc25b84a2015-01-14 19:04:10 -08001586 pInBuffer->raw = pInBuffer->mBuffer;
1587 memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08001588 mBufferQueue.add(pInBuffer);
Andy Hung9d84af52018-09-12 18:03:44 -07001589 ALOGV("%s(%d): thread %d adding overflow buffer %zu", __func__, mId,
1590 (int)mThreadIoHandle, mBufferQueue.size());
Andy Hung1c86ebe2018-05-29 20:29:08 -07001591 // audio data is consumed (stored locally); set frameCount to 0.
1592 inBuffer.frameCount = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08001593 } else {
Andy Hung9d84af52018-09-12 18:03:44 -07001594 ALOGW("%s(%d): thread %d no more overflow buffers",
1595 __func__, mId, (int)mThreadIoHandle);
Andy Hung1c86ebe2018-05-29 20:29:08 -07001596 // TODO: return error for this.
Eric Laurent81784c32012-11-19 14:55:58 -08001597 }
1598 }
1599 }
1600
Andy Hungc25b84a2015-01-14 19:04:10 -08001601 // Calling write() with a 0 length buffer means that no more data will be written:
1602 // We rely on stop() to set the appropriate flags to allow the remaining frames to play out.
1603 if (frames == 0 && mBufferQueue.size() == 0 && mActive) {
1604 stop();
Eric Laurent81784c32012-11-19 14:55:58 -08001605 }
1606
Andy Hung1c86ebe2018-05-29 20:29:08 -07001607 return frames - inBuffer.frameCount; // number of frames consumed.
Eric Laurent81784c32012-11-19 14:55:58 -08001608}
1609
Kevin Rocard12381092018-04-11 09:19:59 -07001610void AudioFlinger::PlaybackThread::OutputTrack::copyMetadataTo(MetadataInserter& backInserter) const
1611{
1612 std::lock_guard<std::mutex> lock(mTrackMetadatasMutex);
1613 backInserter = std::copy(mTrackMetadatas.begin(), mTrackMetadatas.end(), backInserter);
1614}
1615
1616void AudioFlinger::PlaybackThread::OutputTrack::setMetadatas(const SourceMetadatas& metadatas) {
1617 {
1618 std::lock_guard<std::mutex> lock(mTrackMetadatasMutex);
1619 mTrackMetadatas = metadatas;
1620 }
1621 // No need to adjust metadata track volumes as OutputTrack volumes are always 0dBFS.
1622 setMetadataHasChanged();
1623}
1624
Eric Laurent81784c32012-11-19 14:55:58 -08001625status_t AudioFlinger::PlaybackThread::OutputTrack::obtainBuffer(
1626 AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs)
1627{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001628 ClientProxy::Buffer buf;
1629 buf.mFrameCount = buffer->frameCount;
1630 struct timespec timeout;
1631 timeout.tv_sec = waitTimeMs / 1000;
1632 timeout.tv_nsec = (int) (waitTimeMs % 1000) * 1000000;
1633 status_t status = mClientProxy->obtainBuffer(&buf, &timeout);
1634 buffer->frameCount = buf.mFrameCount;
1635 buffer->raw = buf.mRaw;
1636 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08001637}
1638
Eric Laurent81784c32012-11-19 14:55:58 -08001639void AudioFlinger::PlaybackThread::OutputTrack::clearBufferQueue()
1640{
1641 size_t size = mBufferQueue.size();
1642
1643 for (size_t i = 0; i < size; i++) {
1644 Buffer *pBuffer = mBufferQueue.itemAt(i);
Andy Hungc25b84a2015-01-14 19:04:10 -08001645 free(pBuffer->mBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08001646 delete pBuffer;
1647 }
1648 mBufferQueue.clear();
1649}
1650
Eric Laurent4d231dc2016-03-11 18:38:23 -08001651void AudioFlinger::PlaybackThread::OutputTrack::restartIfDisabled()
1652{
1653 int32_t flags = android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
1654 if (mActive && (flags & CBLK_DISABLED)) {
1655 start();
1656 }
1657}
Eric Laurent81784c32012-11-19 14:55:58 -08001658
Andy Hung9d84af52018-09-12 18:03:44 -07001659// ----------------------------------------------------------------------------
1660#undef LOG_TAG
1661#define LOG_TAG "AF::PatchTrack"
1662
Eric Laurent83b88082014-06-20 18:31:16 -07001663AudioFlinger::PlaybackThread::PatchTrack::PatchTrack(PlaybackThread *playbackThread,
Eric Laurent3bcf8592015-04-03 12:13:24 -07001664 audio_stream_type_t streamType,
Eric Laurent83b88082014-06-20 18:31:16 -07001665 uint32_t sampleRate,
1666 audio_channel_mask_t channelMask,
1667 audio_format_t format,
1668 size_t frameCount,
1669 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07001670 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -08001671 audio_output_flags_t flags,
1672 const Timeout& timeout)
Eric Laurent3bcf8592015-04-03 12:13:24 -07001673 : Track(playbackThread, NULL, streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001674 audio_attributes_t{} /* currently unused for patch track */,
Eric Laurent223fd5c2014-11-11 13:43:36 -08001675 sampleRate, format, channelMask, frameCount,
Andy Hung8fe68032017-06-05 16:17:51 -07001676 buffer, bufferSize, nullptr /* sharedBuffer */,
Andy Hung4ef19fa2018-05-15 19:35:29 -07001677 AUDIO_SESSION_NONE, AID_AUDIOSERVER, flags, TYPE_PATCH),
Kevin Rocard45986c72018-12-18 18:22:59 -08001678 PatchTrackBase(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, true, true),
1679 *playbackThread, timeout)
Eric Laurent83b88082014-06-20 18:31:16 -07001680{
Andy Hung9d84af52018-09-12 18:03:44 -07001681 ALOGV("%s(%d): sampleRate %d mPeerTimeout %d.%03d sec",
1682 __func__, mId, sampleRate,
Eric Laurent83b88082014-06-20 18:31:16 -07001683 (int)mPeerTimeout.tv_sec,
1684 (int)(mPeerTimeout.tv_nsec / 1000000));
1685}
1686
1687AudioFlinger::PlaybackThread::PatchTrack::~PatchTrack()
1688{
1689}
1690
Eric Laurent4d231dc2016-03-11 18:38:23 -08001691status_t AudioFlinger::PlaybackThread::PatchTrack::start(AudioSystem::sync_event_t event,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07001692 audio_session_t triggerSession)
Eric Laurent4d231dc2016-03-11 18:38:23 -08001693{
1694 status_t status = Track::start(event, triggerSession);
1695 if (status != NO_ERROR) {
1696 return status;
1697 }
1698 android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
1699 return status;
1700}
1701
Eric Laurent83b88082014-06-20 18:31:16 -07001702// AudioBufferProvider interface
1703status_t AudioFlinger::PlaybackThread::PatchTrack::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08001704 AudioBufferProvider::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07001705{
Andy Hung9d84af52018-09-12 18:03:44 -07001706 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07001707 Proxy::Buffer buf;
1708 buf.mFrameCount = buffer->frameCount;
1709 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout);
Andy Hung9d84af52018-09-12 18:03:44 -07001710 ALOGV_IF(status != NO_ERROR, "%s(%d): getNextBuffer status %d", __func__, mId, status);
Eric Laurentc2730ba2014-07-20 15:47:07 -07001711 buffer->frameCount = buf.mFrameCount;
Eric Laurent83b88082014-06-20 18:31:16 -07001712 if (buf.mFrameCount == 0) {
1713 return WOULD_BLOCK;
1714 }
Glenn Kastend79072e2016-01-06 08:41:20 -08001715 status = Track::getNextBuffer(buffer);
Eric Laurent83b88082014-06-20 18:31:16 -07001716 return status;
1717}
1718
1719void AudioFlinger::PlaybackThread::PatchTrack::releaseBuffer(AudioBufferProvider::Buffer* buffer)
1720{
Andy Hung9d84af52018-09-12 18:03:44 -07001721 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07001722 Proxy::Buffer buf;
1723 buf.mFrameCount = buffer->frameCount;
1724 buf.mRaw = buffer->raw;
1725 mPeerProxy->releaseBuffer(&buf);
1726 TrackBase::releaseBuffer(buffer);
1727}
1728
1729status_t AudioFlinger::PlaybackThread::PatchTrack::obtainBuffer(Proxy::Buffer* buffer,
1730 const struct timespec *timeOut)
1731{
Eric Laurent4d231dc2016-03-11 18:38:23 -08001732 status_t status = NO_ERROR;
1733 static const int32_t kMaxTries = 5;
1734 int32_t tryCounter = kMaxTries;
Andy Hungf62e1a22018-05-08 18:32:11 -07001735 const size_t originalFrameCount = buffer->mFrameCount;
Eric Laurent4d231dc2016-03-11 18:38:23 -08001736 do {
1737 if (status == NOT_ENOUGH_DATA) {
1738 restartIfDisabled();
Andy Hungf62e1a22018-05-08 18:32:11 -07001739 buffer->mFrameCount = originalFrameCount; // cleared on error, must be restored.
Eric Laurent4d231dc2016-03-11 18:38:23 -08001740 }
1741 status = mProxy->obtainBuffer(buffer, timeOut);
1742 } while ((status == NOT_ENOUGH_DATA) && (tryCounter-- > 0));
1743 return status;
Eric Laurent83b88082014-06-20 18:31:16 -07001744}
1745
1746void AudioFlinger::PlaybackThread::PatchTrack::releaseBuffer(Proxy::Buffer* buffer)
1747{
1748 mProxy->releaseBuffer(buffer);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001749 restartIfDisabled();
1750 android_atomic_or(CBLK_FORCEREADY, &mCblk->mFlags);
1751}
1752
1753void AudioFlinger::PlaybackThread::PatchTrack::restartIfDisabled()
1754{
Eric Laurent83b88082014-06-20 18:31:16 -07001755 if (android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags) & CBLK_DISABLED) {
Andy Hung9d84af52018-09-12 18:03:44 -07001756 ALOGW("%s(%d): disabled due to previous underrun, restarting", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07001757 start();
1758 }
Eric Laurent83b88082014-06-20 18:31:16 -07001759}
1760
Eric Laurent81784c32012-11-19 14:55:58 -08001761// ----------------------------------------------------------------------------
1762// Record
1763// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -07001764#undef LOG_TAG
1765#define LOG_TAG "AF::RecordHandle"
Eric Laurent81784c32012-11-19 14:55:58 -08001766
1767AudioFlinger::RecordHandle::RecordHandle(
1768 const sp<AudioFlinger::RecordThread::RecordTrack>& recordTrack)
1769 : BnAudioRecord(),
1770 mRecordTrack(recordTrack)
1771{
1772}
1773
1774AudioFlinger::RecordHandle::~RecordHandle() {
1775 stop_nonvirtual();
1776 mRecordTrack->destroy();
1777}
1778
Ivan Lozanoff6900d2017-08-01 15:47:38 -07001779binder::Status AudioFlinger::RecordHandle::start(int /*AudioSystem::sync_event_t*/ event,
1780 int /*audio_session_t*/ triggerSession) {
Andy Hung9d84af52018-09-12 18:03:44 -07001781 ALOGV("%s()", __func__);
Ivan Lozanoff6900d2017-08-01 15:47:38 -07001782 return binder::Status::fromStatusT(
1783 mRecordTrack->start((AudioSystem::sync_event_t)event, (audio_session_t) triggerSession));
Eric Laurent81784c32012-11-19 14:55:58 -08001784}
1785
Ivan Lozanoff6900d2017-08-01 15:47:38 -07001786binder::Status AudioFlinger::RecordHandle::stop() {
Eric Laurent81784c32012-11-19 14:55:58 -08001787 stop_nonvirtual();
Ivan Lozanoff6900d2017-08-01 15:47:38 -07001788 return binder::Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -08001789}
1790
1791void AudioFlinger::RecordHandle::stop_nonvirtual() {
Andy Hung9d84af52018-09-12 18:03:44 -07001792 ALOGV("%s()", __func__);
Eric Laurent81784c32012-11-19 14:55:58 -08001793 mRecordTrack->stop();
1794}
1795
jiabin653cc0a2018-01-17 17:54:10 -08001796binder::Status AudioFlinger::RecordHandle::getActiveMicrophones(
1797 std::vector<media::MicrophoneInfo>* activeMicrophones) {
Andy Hung9d84af52018-09-12 18:03:44 -07001798 ALOGV("%s()", __func__);
jiabin653cc0a2018-01-17 17:54:10 -08001799 return binder::Status::fromStatusT(
1800 mRecordTrack->getActiveMicrophones(activeMicrophones));
1801}
1802
Paul McLean03a6e6a2018-12-04 10:54:13 -07001803binder::Status AudioFlinger::RecordHandle::setMicrophoneDirection(
1804 int /*audio_microphone_direction_t*/ direction) {
1805 ALOGV("%s()", __func__);
1806 return binder::Status::fromStatusT(mRecordTrack->setMicrophoneDirection(
1807 static_cast<audio_microphone_direction_t>(direction)));
1808}
1809
1810binder::Status AudioFlinger::RecordHandle::setMicrophoneFieldDimension(float zoom) {
1811 ALOGV("%s()", __func__);
1812 return binder::Status::fromStatusT(mRecordTrack->setMicrophoneFieldDimension(zoom));
1813}
1814
Eric Laurent81784c32012-11-19 14:55:58 -08001815// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -07001816#undef LOG_TAG
1817#define LOG_TAG "AF::RecordTrack"
Eric Laurent81784c32012-11-19 14:55:58 -08001818
Glenn Kasten05997e22014-03-13 15:08:33 -07001819// RecordTrack constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
Eric Laurent81784c32012-11-19 14:55:58 -08001820AudioFlinger::RecordThread::RecordTrack::RecordTrack(
1821 RecordThread *thread,
1822 const sp<Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001823 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -08001824 uint32_t sampleRate,
1825 audio_format_t format,
1826 audio_channel_mask_t channelMask,
1827 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -07001828 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07001829 size_t bufferSize,
Glenn Kastend848eb42016-03-08 13:42:11 -08001830 audio_session_t sessionId,
Andy Hung1f12a8a2016-11-07 16:10:30 -08001831 uid_t uid,
Eric Laurent05067782016-06-01 18:27:28 -07001832 audio_input_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -08001833 track_type type,
1834 audio_port_handle_t portId)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001835 : TrackBase(thread, client, attr, sampleRate, format,
Andy Hung8fe68032017-06-05 16:17:51 -07001836 channelMask, frameCount, buffer, bufferSize, sessionId, uid, false /*isOut*/,
Eric Laurent83b88082014-06-20 18:31:16 -07001837 (type == TYPE_DEFAULT) ?
Eric Laurent05067782016-06-01 18:27:28 -07001838 ((flags & AUDIO_INPUT_FLAG_FAST) ? ALLOC_PIPE : ALLOC_CBLK) :
Eric Laurent83b88082014-06-20 18:31:16 -07001839 ((buffer == NULL) ? ALLOC_LOCAL : ALLOC_NONE),
Eric Laurent20b9ef02016-12-05 11:03:16 -08001840 type, portId),
Andy Hung97a893e2015-03-29 01:03:07 -07001841 mOverflow(false),
Andy Hung4c6afaf2015-06-12 18:23:35 -07001842 mFramesToDrop(0),
1843 mResamplerBufferProvider(NULL), // initialize in case of early constructor exit
Eric Laurent05067782016-06-01 18:27:28 -07001844 mRecordBufferConverter(NULL),
jiabin9378eb92018-05-02 15:26:35 -07001845 mFlags(flags),
1846 mSilenced(false)
Eric Laurent81784c32012-11-19 14:55:58 -08001847{
Glenn Kasten3ef14ef2014-03-13 15:08:51 -07001848 if (mCblk == NULL) {
1849 return;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001850 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001851
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07001852 if (!isDirect()) {
1853 mRecordBufferConverter = new RecordBufferConverter(
1854 thread->mChannelMask, thread->mFormat, thread->mSampleRate,
1855 channelMask, format, sampleRate);
1856 // Check if the RecordBufferConverter construction was successful.
1857 // If not, don't continue with construction.
1858 //
1859 // NOTE: It would be extremely rare that the record track cannot be created
1860 // for the current device, but a pending or future device change would make
1861 // the record track configuration valid.
1862 if (mRecordBufferConverter->initCheck() != NO_ERROR) {
Andy Hung9d84af52018-09-12 18:03:44 -07001863 ALOGE("%s(%d): RecordTrack unable to create record buffer converter", __func__, mId);
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07001864 return;
1865 }
Andy Hung97a893e2015-03-29 01:03:07 -07001866 }
1867
Andy Hung6ae58432016-02-16 18:32:24 -08001868 mServerProxy = new AudioRecordServerProxy(mCblk, mBuffer, frameCount,
Andy Hung3f0c9022016-01-15 17:49:46 -08001869 mFrameSize, !isExternalTrack());
Andy Hung3f0c9022016-01-15 17:49:46 -08001870
Andy Hung97a893e2015-03-29 01:03:07 -07001871 mResamplerBufferProvider = new ResamplerBufferProvider(this);
Glenn Kastenc263ca02014-06-04 20:31:46 -07001872
Eric Laurent05067782016-06-01 18:27:28 -07001873 if (flags & AUDIO_INPUT_FLAG_FAST) {
Glenn Kastenc263ca02014-06-04 20:31:46 -07001874 ALOG_ASSERT(thread->mFastTrackAvail);
1875 thread->mFastTrackAvail = false;
Andy Hung000adb52018-06-01 15:43:26 -07001876 } else {
1877 // TODO: only Normal Record has timestamps (Fast Record does not).
Andy Hung5d3d9562018-10-04 19:27:26 -07001878 mServerLatencySupported = checkServerLatencySupported(mFormat, flags);
Glenn Kastenc263ca02014-06-04 20:31:46 -07001879 }
Andy Hung8946a282018-04-19 20:04:56 -07001880#ifdef TEE_SINK
1881 mTee.setId(std::string("_") + std::to_string(mThreadIoHandle)
1882 + "_" + std::to_string(mId)
1883 + "_R");
1884#endif
Eric Laurent81784c32012-11-19 14:55:58 -08001885}
1886
1887AudioFlinger::RecordThread::RecordTrack::~RecordTrack()
1888{
Andy Hung9d84af52018-09-12 18:03:44 -07001889 ALOGV("%s()", __func__);
Andy Hung97a893e2015-03-29 01:03:07 -07001890 delete mRecordBufferConverter;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001891 delete mResamplerBufferProvider;
Eric Laurent81784c32012-11-19 14:55:58 -08001892}
1893
Andy Hung97a893e2015-03-29 01:03:07 -07001894status_t AudioFlinger::RecordThread::RecordTrack::initCheck() const
1895{
1896 status_t status = TrackBase::initCheck();
1897 if (status == NO_ERROR && mServerProxy == 0) {
1898 status = BAD_VALUE;
1899 }
1900 return status;
1901}
1902
Eric Laurent81784c32012-11-19 14:55:58 -08001903// AudioBufferProvider interface
Glenn Kastend79072e2016-01-06 08:41:20 -08001904status_t AudioFlinger::RecordThread::RecordTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08001905{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001906 ServerProxy::Buffer buf;
1907 buf.mFrameCount = buffer->frameCount;
1908 status_t status = mServerProxy->obtainBuffer(&buf);
1909 buffer->frameCount = buf.mFrameCount;
1910 buffer->raw = buf.mRaw;
1911 if (buf.mFrameCount == 0) {
1912 // FIXME also wake futex so that overrun is noticed more quickly
Glenn Kasten96f60d82013-07-12 10:21:18 -07001913 (void) android_atomic_or(CBLK_OVERRUN, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08001914 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001915 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08001916}
1917
1918status_t AudioFlinger::RecordThread::RecordTrack::start(AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08001919 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08001920{
1921 sp<ThreadBase> thread = mThread.promote();
1922 if (thread != 0) {
1923 RecordThread *recordThread = (RecordThread *)thread.get();
1924 return recordThread->start(this, event, triggerSession);
1925 } else {
1926 return BAD_VALUE;
1927 }
1928}
1929
1930void AudioFlinger::RecordThread::RecordTrack::stop()
1931{
1932 sp<ThreadBase> thread = mThread.promote();
1933 if (thread != 0) {
1934 RecordThread *recordThread = (RecordThread *)thread.get();
Eric Laurent83b88082014-06-20 18:31:16 -07001935 if (recordThread->stop(this) && isExternalTrack()) {
Eric Laurentfee19762018-01-29 18:44:13 -08001936 AudioSystem::stopInput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -08001937 }
1938 }
1939}
1940
1941void AudioFlinger::RecordThread::RecordTrack::destroy()
1942{
1943 // see comments at AudioFlinger::PlaybackThread::Track::destroy()
1944 sp<RecordTrack> keep(this);
1945 {
Andy Hungce685402018-10-05 17:23:27 -07001946 track_state priorState = mState;
Eric Laurent81784c32012-11-19 14:55:58 -08001947 sp<ThreadBase> thread = mThread.promote();
1948 if (thread != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08001949 Mutex::Autolock _l(thread->mLock);
1950 RecordThread *recordThread = (RecordThread *) thread.get();
Andy Hungce685402018-10-05 17:23:27 -07001951 priorState = mState;
1952 recordThread->destroyTrack_l(this); // move mState to STOPPED, terminate
1953 }
1954 // APM portid/client management done outside of lock.
1955 // NOTE: if thread doesn't exist, the input descriptor probably doesn't either.
1956 if (isExternalTrack()) {
1957 switch (priorState) {
1958 case ACTIVE: // invalidated while still active
1959 case STARTING_2: // invalidated/start-aborted after startInput successfully called
1960 case PAUSING: // invalidated while in the middle of stop() pausing (still active)
1961 AudioSystem::stopInput(mPortId);
1962 break;
1963
1964 case STARTING_1: // invalidated/start-aborted and startInput not successful
1965 case PAUSED: // OK, not active
1966 case IDLE: // OK, not active
1967 break;
1968
1969 case STOPPED: // unexpected (destroyed)
1970 default:
1971 LOG_ALWAYS_FATAL("%s(%d): invalid prior state: %d", __func__, mId, priorState);
1972 }
1973 AudioSystem::releaseInput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -08001974 }
1975 }
1976}
1977
Eric Laurent9a54bc22013-09-09 09:08:44 -07001978void AudioFlinger::RecordThread::RecordTrack::invalidate()
1979{
Eric Laurent6acd1d42017-01-04 14:23:29 -08001980 TrackBase::invalidate();
Eric Laurent9a54bc22013-09-09 09:08:44 -07001981 // FIXME should use proxy, and needs work
1982 audio_track_cblk_t* cblk = mCblk;
1983 android_atomic_or(CBLK_INVALID, &cblk->mFlags);
1984 android_atomic_release_store(0x40000000, &cblk->mFutex);
1985 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE
Elliott Hughesee499292014-05-21 17:55:51 -07001986 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX);
Eric Laurent9a54bc22013-09-09 09:08:44 -07001987}
1988
Eric Laurent81784c32012-11-19 14:55:58 -08001989
Andy Hung000adb52018-06-01 15:43:26 -07001990void AudioFlinger::RecordThread::RecordTrack::appendDumpHeader(String8& result)
Eric Laurent81784c32012-11-19 14:55:58 -08001991{
Eric Laurent973db022018-11-20 14:54:31 -08001992 result.appendFormat("Active Id Client Session Port Id S Flags "
Andy Hung9d84af52018-09-12 18:03:44 -07001993 " Format Chn mask SRate Source "
Kevin Rocard5f2136e2018-05-11 22:03:00 -07001994 " Server FrmCnt FrmRdy Sil%s\n",
1995 isServerLatencySupported() ? " Latency" : "");
Eric Laurent81784c32012-11-19 14:55:58 -08001996}
1997
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001998void AudioFlinger::RecordThread::RecordTrack::appendDump(String8& result, bool active)
Eric Laurent81784c32012-11-19 14:55:58 -08001999{
Eric Laurent973db022018-11-20 14:54:31 -08002000 result.appendFormat("%c%5s %6d %6u %7u %7u %2s 0x%03X "
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002001 "%08X %08X %6u %6X "
Andy Hung000adb52018-06-01 15:43:26 -07002002 "%08X %6zu %6zu %3c",
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002003 isFastTrack() ? 'F' : ' ',
Marco Nelissenb2208842014-02-07 14:00:50 -08002004 active ? "yes" : "no",
Andy Hung9d84af52018-09-12 18:03:44 -07002005 mId,
Andy Hung4ef19fa2018-05-15 19:35:29 -07002006 (mClient == 0) ? getpid() : mClient->pid(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002007 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -08002008 mPortId,
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002009 getTrackStateString(),
2010 mCblk->mFlags,
2011
Eric Laurent81784c32012-11-19 14:55:58 -08002012 mFormat,
2013 mChannelMask,
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002014 mSampleRate,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002015 mAttr.source,
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002016
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002017 mCblk->mServer,
Jean-Michel Trivi7d665ab2018-04-11 17:26:51 -07002018 mFrameCount,
Andy Hung000adb52018-06-01 15:43:26 -07002019 mServerProxy->framesReadySafe(),
Jean-Michel Trivi7d665ab2018-04-11 17:26:51 -07002020 isSilenced() ? 's' : 'n'
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002021 );
Andy Hung000adb52018-06-01 15:43:26 -07002022 if (isServerLatencySupported()) {
2023 double latencyMs;
2024 bool fromTrack;
2025 if (getTrackLatencyMs(&latencyMs, &fromTrack) == OK) {
2026 // Show latency in msec, followed by 't' if from track timestamp (the most accurate)
2027 // or 'k' if estimated from kernel (usually for debugging).
2028 result.appendFormat(" %7.2lf %c", latencyMs, fromTrack ? 't' : 'k');
2029 } else {
2030 result.appendFormat("%10s", mCblk->mServer != 0 ? "unavail" : "new");
2031 }
2032 }
2033 result.append("\n");
Eric Laurent81784c32012-11-19 14:55:58 -08002034}
2035
Glenn Kasten25f4aa82014-02-07 10:50:43 -08002036void AudioFlinger::RecordThread::RecordTrack::handleSyncStartEvent(const sp<SyncEvent>& event)
2037{
2038 if (event == mSyncStartEvent) {
2039 ssize_t framesToDrop = 0;
2040 sp<ThreadBase> threadBase = mThread.promote();
2041 if (threadBase != 0) {
2042 // TODO: use actual buffer filling status instead of 2 buffers when info is available
2043 // from audio HAL
2044 framesToDrop = threadBase->mFrameCount * 2;
2045 }
2046 mFramesToDrop = framesToDrop;
2047 }
2048}
2049
2050void AudioFlinger::RecordThread::RecordTrack::clearSyncStartEvent()
2051{
2052 if (mSyncStartEvent != 0) {
2053 mSyncStartEvent->cancel();
2054 mSyncStartEvent.clear();
2055 }
2056 mFramesToDrop = 0;
2057}
2058
Andy Hung3f0c9022016-01-15 17:49:46 -08002059void AudioFlinger::RecordThread::RecordTrack::updateTrackFrameInfo(
2060 int64_t trackFramesReleased, int64_t sourceFramesRead,
2061 uint32_t halSampleRate, const ExtendedTimestamp &timestamp)
2062{
Andy Hung30282562018-08-08 18:27:03 -07002063 // Make the kernel frametime available.
2064 const FrameTime ft{
2065 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
2066 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]};
2067 // ALOGD("FrameTime: %lld %lld", (long long)ft.frames, (long long)ft.timeNs);
2068 mKernelFrameTime.store(ft);
2069 if (!audio_is_linear_pcm(mFormat)) {
2070 return;
2071 }
2072
Andy Hung3f0c9022016-01-15 17:49:46 -08002073 ExtendedTimestamp local = timestamp;
2074
2075 // Convert HAL frames to server-side track frames at track sample rate.
2076 // We use trackFramesReleased and sourceFramesRead as an anchor point.
2077 for (int i = ExtendedTimestamp::LOCATION_SERVER; i < ExtendedTimestamp::LOCATION_MAX; ++i) {
2078 if (local.mTimeNs[i] != 0) {
2079 const int64_t relativeServerFrames = local.mPosition[i] - sourceFramesRead;
2080 const int64_t relativeTrackFrames = relativeServerFrames
2081 * mSampleRate / halSampleRate; // TODO: potential computation overflow
2082 local.mPosition[i] = relativeTrackFrames + trackFramesReleased;
2083 }
2084 }
Andy Hung6ae58432016-02-16 18:32:24 -08002085 mServerProxy->setTimestamp(local);
Andy Hung000adb52018-06-01 15:43:26 -07002086
2087 // Compute latency info.
2088 const bool useTrackTimestamp = true; // use track unless debugging.
2089 const double latencyMs = - (useTrackTimestamp
2090 ? local.getOutputServerLatencyMs(sampleRate())
2091 : timestamp.getOutputServerLatencyMs(halSampleRate));
2092
2093 mServerLatencyFromTrack.store(useTrackTimestamp);
2094 mServerLatencyMs.store(latencyMs);
Andy Hung3f0c9022016-01-15 17:49:46 -08002095}
Eric Laurent83b88082014-06-20 18:31:16 -07002096
jiabin653cc0a2018-01-17 17:54:10 -08002097status_t AudioFlinger::RecordThread::RecordTrack::getActiveMicrophones(
2098 std::vector<media::MicrophoneInfo>* activeMicrophones)
2099{
2100 sp<ThreadBase> thread = mThread.promote();
2101 if (thread != 0) {
2102 RecordThread *recordThread = (RecordThread *)thread.get();
2103 return recordThread->getActiveMicrophones(activeMicrophones);
2104 } else {
2105 return BAD_VALUE;
2106 }
2107}
2108
Paul McLean03a6e6a2018-12-04 10:54:13 -07002109status_t AudioFlinger::RecordThread::RecordTrack::setMicrophoneDirection(
2110 audio_microphone_direction_t direction) {
2111 sp<ThreadBase> thread = mThread.promote();
2112 if (thread != 0) {
2113 RecordThread *recordThread = (RecordThread *)thread.get();
2114 return recordThread->setMicrophoneDirection(direction);
2115 } else {
2116 return BAD_VALUE;
2117 }
2118}
2119
2120status_t AudioFlinger::RecordThread::RecordTrack::setMicrophoneFieldDimension(float zoom) {
2121 sp<ThreadBase> thread = mThread.promote();
2122 if (thread != 0) {
2123 RecordThread *recordThread = (RecordThread *)thread.get();
2124 return recordThread->setMicrophoneFieldDimension(zoom);
2125 } else {
2126 return BAD_VALUE;
2127 }
2128}
2129
Andy Hung9d84af52018-09-12 18:03:44 -07002130// ----------------------------------------------------------------------------
2131#undef LOG_TAG
2132#define LOG_TAG "AF::PatchRecord"
2133
Eric Laurent83b88082014-06-20 18:31:16 -07002134AudioFlinger::RecordThread::PatchRecord::PatchRecord(RecordThread *recordThread,
2135 uint32_t sampleRate,
2136 audio_channel_mask_t channelMask,
2137 audio_format_t format,
2138 size_t frameCount,
2139 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07002140 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -08002141 audio_input_flags_t flags,
2142 const Timeout& timeout)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002143 : RecordTrack(recordThread, NULL,
2144 audio_attributes_t{} /* currently unused for patch track */,
2145 sampleRate, format, channelMask, frameCount,
Andy Hung4ef19fa2018-05-15 19:35:29 -07002146 buffer, bufferSize, AUDIO_SESSION_NONE, AID_AUDIOSERVER,
2147 flags, TYPE_PATCH),
Kevin Rocard45986c72018-12-18 18:22:59 -08002148 PatchTrackBase(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, false, true),
2149 *recordThread, timeout)
Eric Laurent83b88082014-06-20 18:31:16 -07002150{
Andy Hung9d84af52018-09-12 18:03:44 -07002151 ALOGV("%s(%d): sampleRate %d mPeerTimeout %d.%03d sec",
2152 __func__, mId, sampleRate,
Eric Laurent83b88082014-06-20 18:31:16 -07002153 (int)mPeerTimeout.tv_sec,
2154 (int)(mPeerTimeout.tv_nsec / 1000000));
2155}
2156
2157AudioFlinger::RecordThread::PatchRecord::~PatchRecord()
2158{
2159}
2160
2161// AudioBufferProvider interface
2162status_t AudioFlinger::RecordThread::PatchRecord::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08002163 AudioBufferProvider::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07002164{
Andy Hung9d84af52018-09-12 18:03:44 -07002165 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002166 Proxy::Buffer buf;
2167 buf.mFrameCount = buffer->frameCount;
2168 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout);
2169 ALOGV_IF(status != NO_ERROR,
Andy Hung9d84af52018-09-12 18:03:44 -07002170 "%s(%d): mPeerProxy->obtainBuffer status %d", __func__, mId, status);
Eric Laurentc2730ba2014-07-20 15:47:07 -07002171 buffer->frameCount = buf.mFrameCount;
Eric Laurent83b88082014-06-20 18:31:16 -07002172 if (buf.mFrameCount == 0) {
2173 return WOULD_BLOCK;
2174 }
Glenn Kastend79072e2016-01-06 08:41:20 -08002175 status = RecordTrack::getNextBuffer(buffer);
Eric Laurent83b88082014-06-20 18:31:16 -07002176 return status;
2177}
2178
2179void AudioFlinger::RecordThread::PatchRecord::releaseBuffer(AudioBufferProvider::Buffer* buffer)
2180{
Andy Hung9d84af52018-09-12 18:03:44 -07002181 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002182 Proxy::Buffer buf;
2183 buf.mFrameCount = buffer->frameCount;
2184 buf.mRaw = buffer->raw;
2185 mPeerProxy->releaseBuffer(&buf);
2186 TrackBase::releaseBuffer(buffer);
2187}
2188
2189status_t AudioFlinger::RecordThread::PatchRecord::obtainBuffer(Proxy::Buffer* buffer,
2190 const struct timespec *timeOut)
2191{
2192 return mProxy->obtainBuffer(buffer, timeOut);
2193}
2194
2195void AudioFlinger::RecordThread::PatchRecord::releaseBuffer(Proxy::Buffer* buffer)
2196{
2197 mProxy->releaseBuffer(buffer);
2198}
2199
Andy Hung9d84af52018-09-12 18:03:44 -07002200// ----------------------------------------------------------------------------
2201#undef LOG_TAG
2202#define LOG_TAG "AF::MmapTrack"
Eric Laurent6acd1d42017-01-04 14:23:29 -08002203
2204AudioFlinger::MmapThread::MmapTrack::MmapTrack(ThreadBase *thread,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002205 const audio_attributes_t& attr,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002206 uint32_t sampleRate,
2207 audio_format_t format,
2208 audio_channel_mask_t channelMask,
2209 audio_session_t sessionId,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002210 bool isOut,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002211 uid_t uid,
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002212 pid_t pid,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002213 audio_port_handle_t portId)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002214 : TrackBase(thread, NULL, attr, sampleRate, format,
Andy Hung8fe68032017-06-05 16:17:51 -07002215 channelMask, (size_t)0 /* frameCount */,
2216 nullptr /* buffer */, (size_t)0 /* bufferSize */,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002217 sessionId, uid, isOut,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002218 ALLOC_NONE,
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002219 TYPE_DEFAULT, portId),
Eric Laurent331679c2018-04-16 17:03:16 -07002220 mPid(pid), mSilenced(false), mSilencedNotified(false)
Eric Laurent6acd1d42017-01-04 14:23:29 -08002221{
2222}
2223
2224AudioFlinger::MmapThread::MmapTrack::~MmapTrack()
2225{
2226}
2227
2228status_t AudioFlinger::MmapThread::MmapTrack::initCheck() const
2229{
2230 return NO_ERROR;
2231}
2232
2233status_t AudioFlinger::MmapThread::MmapTrack::start(AudioSystem::sync_event_t event __unused,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002234 audio_session_t triggerSession __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08002235{
2236 return NO_ERROR;
2237}
2238
2239void AudioFlinger::MmapThread::MmapTrack::stop()
2240{
2241}
2242
2243// AudioBufferProvider interface
2244status_t AudioFlinger::MmapThread::MmapTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer)
2245{
2246 buffer->frameCount = 0;
2247 buffer->raw = nullptr;
2248 return INVALID_OPERATION;
2249}
2250
2251// ExtendedAudioBufferProvider interface
2252size_t AudioFlinger::MmapThread::MmapTrack::framesReady() const {
2253 return 0;
2254}
2255
2256int64_t AudioFlinger::MmapThread::MmapTrack::framesReleased() const
2257{
2258 return 0;
2259}
2260
2261void AudioFlinger::MmapThread::MmapTrack::onTimestamp(const ExtendedTimestamp &timestamp __unused)
2262{
2263}
2264
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002265void AudioFlinger::MmapThread::MmapTrack::appendDumpHeader(String8& result)
Eric Laurent6acd1d42017-01-04 14:23:29 -08002266{
Eric Laurent973db022018-11-20 14:54:31 -08002267 result.appendFormat("Client Session Port Id Format Chn mask SRate Flags %s\n",
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002268 isOut() ? "Usg CT": "Source");
Eric Laurent6acd1d42017-01-04 14:23:29 -08002269}
2270
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002271void AudioFlinger::MmapThread::MmapTrack::appendDump(String8& result, bool active __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08002272{
Eric Laurent973db022018-11-20 14:54:31 -08002273 result.appendFormat("%6u %7u %7u %08X %08X %6u 0x%03X ",
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002274 mPid,
2275 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -08002276 mPortId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002277 mFormat,
2278 mChannelMask,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002279 mSampleRate,
2280 mAttr.flags);
2281 if (isOut()) {
2282 result.appendFormat("%3x %2x", mAttr.usage, mAttr.content_type);
2283 } else {
2284 result.appendFormat("%6x", mAttr.source);
2285 }
2286 result.append("\n");
Eric Laurent6acd1d42017-01-04 14:23:29 -08002287}
2288
Glenn Kasten63238ef2015-03-02 15:50:29 -08002289} // namespace android