blob: 30301a872ee18eaf728270cbf703a18b935d211e [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
Mikhail Naganov938be412019-09-04 11:38:47 -070021#define ATRACE_TAG ATRACE_TAG_AUDIO
Eric Laurent81784c32012-11-19 14:55:58 -080022
Glenn Kasten153b9fe2013-07-15 11:23:36 -070023#include "Configuration.h"
Glenn Kastenad8510a2015-02-17 16:24:07 -080024#include <linux/futex.h>
Eric Laurent81784c32012-11-19 14:55:58 -080025#include <math.h>
Elliott Hughesee499292014-05-21 17:55:51 -070026#include <sys/syscall.h>
Eric Laurent81784c32012-11-19 14:55:58 -080027#include <utils/Log.h>
Mikhail Naganov938be412019-09-04 11:38:47 -070028#include <utils/Trace.h>
Eric Laurent81784c32012-11-19 14:55:58 -080029
30#include <private/media/AudioTrackShared.h>
31
Eric Laurent81784c32012-11-19 14:55:58 -080032#include "AudioFlinger.h"
Eric Laurent81784c32012-11-19 14:55:58 -080033
Glenn Kastenda6ef132013-01-10 12:31:01 -080034#include <media/nbaio/Pipe.h>
35#include <media/nbaio/PipeReader.h>
Kuowei Lid4adbdb2020-08-13 14:44:25 +080036#include <media/AudioValidator.h>
Andy Hung89816052017-01-11 17:08:23 -080037#include <media/RecordBufferConverter.h>
Andy Hungab7ef302018-05-15 19:35:29 -070038#include <mediautils/ServiceUtilities.h>
Glenn Kastenc56f3422014-03-21 17:53:17 -070039#include <audio_utils/minifloat.h>
Glenn Kastenda6ef132013-01-10 12:31:01 -080040
Eric Laurent81784c32012-11-19 14:55:58 -080041// ----------------------------------------------------------------------------
42
43// Note: the following macro is used for extremely verbose logging message. In
44// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
45// 0; but one side effect of this is to turn all LOGV's as well. Some messages
46// are so verbose that we want to suppress them even when we have ALOG_ASSERT
47// turned on. Do not uncomment the #def below unless you really know what you
48// are doing and want to see all of the extremely verbose messages.
49//#define VERY_VERY_VERBOSE_LOGGING
50#ifdef VERY_VERY_VERBOSE_LOGGING
51#define ALOGVV ALOGV
52#else
53#define ALOGVV(a...) do { } while(0)
54#endif
55
Kuowei Lid4adbdb2020-08-13 14:44:25 +080056// TODO: Remove when this is put into AidlConversionUtil.h
57#define VALUE_OR_RETURN_BINDER_STATUS(x) \
58 ({ \
59 auto _tmp = (x); \
60 if (!_tmp.ok()) return ::android::aidl_utils::binderStatusFromStatusT(_tmp.error()); \
61 std::move(_tmp.value()); \
62 })
63
Eric Laurent81784c32012-11-19 14:55:58 -080064namespace android {
65
Kuowei Lid4adbdb2020-08-13 14:44:25 +080066using ::android::aidl_utils::binderStatusFromStatusT;
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -080067using binder::Status;
Svet Ganov33761132021-05-13 22:51:08 +000068using content::AttributionSourceState;
Ivan Lozano8cf3a072017-08-09 09:01:33 -070069using media::VolumeShaper;
Eric Laurent81784c32012-11-19 14:55:58 -080070// ----------------------------------------------------------------------------
71// TrackBase
72// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -070073#undef LOG_TAG
74#define LOG_TAG "AF::TrackBase"
Eric Laurent81784c32012-11-19 14:55:58 -080075
Glenn Kastenda6ef132013-01-10 12:31:01 -080076static volatile int32_t nextTrackId = 55;
77
Eric Laurent81784c32012-11-19 14:55:58 -080078// TrackBase constructor must be called with AudioFlinger::mLock held
79AudioFlinger::ThreadBase::TrackBase::TrackBase(
80 ThreadBase *thread,
81 const sp<Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -070082 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -080083 uint32_t sampleRate,
84 audio_format_t format,
85 audio_channel_mask_t channelMask,
86 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -070087 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -070088 size_t bufferSize,
Glenn Kastend848eb42016-03-08 13:42:11 -080089 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -070090 pid_t creatorPid,
Andy Hung1f12a8a2016-11-07 16:10:30 -080091 uid_t clientUid,
Glenn Kastend776ac62014-05-07 09:16:09 -070092 bool isOut,
Eric Laurent83b88082014-06-20 18:31:16 -070093 alloc_type alloc,
Eric Laurent20b9ef02016-12-05 11:03:16 -080094 track_type type,
Andy Hungb68f5eb2019-12-03 16:49:17 -080095 audio_port_handle_t portId,
96 std::string metricsId)
Eric Laurent81784c32012-11-19 14:55:58 -080097 : RefBase(),
98 mThread(thread),
99 mClient(client),
100 mCblk(NULL),
Andy Hung8fe68032017-06-05 16:17:51 -0700101 // mBuffer, mBufferSize
Eric Laurent81784c32012-11-19 14:55:58 -0800102 mState(IDLE),
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700103 mAttr(attr),
Eric Laurent81784c32012-11-19 14:55:58 -0800104 mSampleRate(sampleRate),
105 mFormat(format),
106 mChannelMask(channelMask),
Andy Hunge5412692014-05-16 11:25:07 -0700107 mChannelCount(isOut ?
108 audio_channel_count_from_out_mask(channelMask) :
109 audio_channel_count_from_in_mask(channelMask)),
Phil Burkfdb3c072016-02-09 10:47:02 -0800110 mFrameSize(audio_has_proportional_frames(format) ?
Eric Laurent81784c32012-11-19 14:55:58 -0800111 mChannelCount * audio_bytes_per_sample(format) : sizeof(int8_t)),
112 mFrameCount(frameCount),
Glenn Kastene3aa6592012-12-04 12:22:46 -0800113 mSessionId(sessionId),
114 mIsOut(isOut),
Eric Laurentbfb1b832013-01-07 09:53:42 -0800115 mId(android_atomic_inc(&nextTrackId)),
Eric Laurent83b88082014-06-20 18:31:16 -0700116 mTerminated(false),
Eric Laurentaaa44472014-09-12 17:41:50 -0700117 mType(type),
Kevin Rocard153f92d2018-12-18 18:33:28 -0800118 mThreadIoHandle(thread ? thread->id() : AUDIO_IO_HANDLE_NONE),
Eric Laurent6acd1d42017-01-04 14:23:29 -0800119 mPortId(portId),
Eric Laurent09f1ed22019-04-24 17:45:17 -0700120 mIsInvalid(false),
Andy Hungc2b11cb2020-04-22 09:04:01 -0700121 mTrackMetrics(std::move(metricsId), isOut),
Eric Laurent09f1ed22019-04-24 17:45:17 -0700122 mCreatorPid(creatorPid)
Eric Laurent81784c32012-11-19 14:55:58 -0800123{
Marco Nelissendcb346b2015-09-09 10:47:29 -0700124 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Andy Hung4ef19fa2018-05-15 19:35:29 -0700125 if (!isAudioServerOrMediaServerUid(callingUid) || clientUid == AUDIO_UID_INVALID) {
Andy Hung1f12a8a2016-11-07 16:10:30 -0800126 ALOGW_IF(clientUid != AUDIO_UID_INVALID && clientUid != callingUid,
Andy Hung9d84af52018-09-12 18:03:44 -0700127 "%s(%d): uid %d tried to pass itself off as %d",
128 __func__, mId, callingUid, clientUid);
Andy Hung1f12a8a2016-11-07 16:10:30 -0800129 clientUid = callingUid;
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800130 }
131 // clientUid contains the uid of the app that is responsible for this track, so we can blame
132 // battery usage on it.
133 mUid = clientUid;
134
Eric Laurent81784c32012-11-19 14:55:58 -0800135 // ALOGD("Creating track with %d buffers @ %d bytes", bufferCount, bufferSize);
Andy Hung1883f692017-02-13 18:48:39 -0800136
Andy Hung8fe68032017-06-05 16:17:51 -0700137 size_t minBufferSize = buffer == NULL ? roundup(frameCount) : frameCount;
Andy Hung1883f692017-02-13 18:48:39 -0800138 // check overflow when computing bufferSize due to multiplication by mFrameSize.
Andy Hung8fe68032017-06-05 16:17:51 -0700139 if (minBufferSize < frameCount // roundup rounds down for values above UINT_MAX / 2
Andy Hung1883f692017-02-13 18:48:39 -0800140 || mFrameSize == 0 // format needs to be correct
Andy Hung8fe68032017-06-05 16:17:51 -0700141 || minBufferSize > SIZE_MAX / mFrameSize) {
Andy Hung1883f692017-02-13 18:48:39 -0800142 android_errorWriteLog(0x534e4554, "34749571");
143 return;
144 }
Andy Hung8fe68032017-06-05 16:17:51 -0700145 minBufferSize *= mFrameSize;
146
147 if (buffer == nullptr) {
148 bufferSize = minBufferSize; // allocated here.
149 } else if (minBufferSize > bufferSize) {
150 android_errorWriteLog(0x534e4554, "38340117");
151 return;
152 }
Andy Hung1883f692017-02-13 18:48:39 -0800153
Eric Laurent81784c32012-11-19 14:55:58 -0800154 size_t size = sizeof(audio_track_cblk_t);
Eric Laurent83b88082014-06-20 18:31:16 -0700155 if (buffer == NULL && alloc == ALLOC_CBLK) {
Andy Hung1883f692017-02-13 18:48:39 -0800156 // check overflow when computing allocation size for streaming tracks.
157 if (size > SIZE_MAX - bufferSize) {
158 android_errorWriteLog(0x534e4554, "34749571");
159 return;
160 }
Eric Laurent81784c32012-11-19 14:55:58 -0800161 size += bufferSize;
162 }
163
164 if (client != 0) {
165 mCblkMemory = client->heap()->allocate(size);
Glenn Kasten663c2242013-09-24 11:52:37 -0700166 if (mCblkMemory == 0 ||
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700167 (mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->unsecurePointer())) == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700168 ALOGE("%s(%d): not enough memory for AudioTrack size=%zu", __func__, mId, size);
Eric Laurent81784c32012-11-19 14:55:58 -0800169 client->heap()->dump("AudioTrack");
Glenn Kasten663c2242013-09-24 11:52:37 -0700170 mCblkMemory.clear();
Eric Laurent81784c32012-11-19 14:55:58 -0800171 return;
172 }
173 } else {
Andy Hungafb31482017-02-13 18:50:48 -0800174 mCblk = (audio_track_cblk_t *) malloc(size);
175 if (mCblk == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700176 ALOGE("%s(%d): not enough memory for AudioTrack size=%zu", __func__, mId, size);
Andy Hungafb31482017-02-13 18:50:48 -0800177 return;
178 }
Eric Laurent81784c32012-11-19 14:55:58 -0800179 }
180
181 // construct the shared structure in-place.
182 if (mCblk != NULL) {
183 new(mCblk) audio_track_cblk_t();
Glenn Kastenc263ca02014-06-04 20:31:46 -0700184 switch (alloc) {
185 case ALLOC_READONLY: {
Glenn Kastend776ac62014-05-07 09:16:09 -0700186 const sp<MemoryDealer> roHeap(thread->readOnlyHeap());
187 if (roHeap == 0 ||
188 (mBufferMemory = roHeap->allocate(bufferSize)) == 0 ||
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700189 (mBuffer = mBufferMemory->unsecurePointer()) == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700190 ALOGE("%s(%d): not enough memory for read-only buffer size=%zu",
191 __func__, mId, bufferSize);
Glenn Kastend776ac62014-05-07 09:16:09 -0700192 if (roHeap != 0) {
193 roHeap->dump("buffer");
194 }
195 mCblkMemory.clear();
196 mBufferMemory.clear();
197 return;
198 }
Eric Laurent81784c32012-11-19 14:55:58 -0800199 memset(mBuffer, 0, bufferSize);
Glenn Kastenc263ca02014-06-04 20:31:46 -0700200 } break;
201 case ALLOC_PIPE:
202 mBufferMemory = thread->pipeMemory();
203 // mBuffer is the virtual address as seen from current process (mediaserver),
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700204 // and should normally be coming from mBufferMemory->unsecurePointer().
Glenn Kastenc263ca02014-06-04 20:31:46 -0700205 // However in this case the TrackBase does not reference the buffer directly.
206 // It should references the buffer via the pipe.
207 // Therefore, to detect incorrect usage of the buffer, we set mBuffer to NULL.
208 mBuffer = NULL;
Andy Hung8fe68032017-06-05 16:17:51 -0700209 bufferSize = 0;
Glenn Kastenc263ca02014-06-04 20:31:46 -0700210 break;
211 case ALLOC_CBLK:
Glenn Kastend776ac62014-05-07 09:16:09 -0700212 // clear all buffers
Eric Laurent83b88082014-06-20 18:31:16 -0700213 if (buffer == NULL) {
Glenn Kastend776ac62014-05-07 09:16:09 -0700214 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);
215 memset(mBuffer, 0, bufferSize);
216 } else {
Eric Laurent83b88082014-06-20 18:31:16 -0700217 mBuffer = buffer;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800218#if 0
Glenn Kastend776ac62014-05-07 09:16:09 -0700219 mCblk->mFlags = CBLK_FORCEREADY; // FIXME hack, need to fix the track ready logic
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800220#endif
Glenn Kastend776ac62014-05-07 09:16:09 -0700221 }
Glenn Kastenc263ca02014-06-04 20:31:46 -0700222 break;
Eric Laurent83b88082014-06-20 18:31:16 -0700223 case ALLOC_LOCAL:
224 mBuffer = calloc(1, bufferSize);
225 break;
226 case ALLOC_NONE:
227 mBuffer = buffer;
228 break;
Andy Hung8fe68032017-06-05 16:17:51 -0700229 default:
Andy Hung9d84af52018-09-12 18:03:44 -0700230 LOG_ALWAYS_FATAL("%s(%d): invalid allocation type: %d", __func__, mId, (int)alloc);
Eric Laurent81784c32012-11-19 14:55:58 -0800231 }
Andy Hung8fe68032017-06-05 16:17:51 -0700232 mBufferSize = bufferSize;
Glenn Kastenda6ef132013-01-10 12:31:01 -0800233
Glenn Kasten46909e72013-02-26 09:20:22 -0800234#ifdef TEE_SINK
Andy Hung8946a282018-04-19 20:04:56 -0700235 mTee.set(sampleRate, mChannelCount, format, NBAIO_Tee::TEE_FLAG_TRACK);
Glenn Kasten46909e72013-02-26 09:20:22 -0800236#endif
Andy Hung959b5b82021-09-24 10:46:20 -0700237 // mState is mirrored for the client to read.
238 mState.setMirror(&mCblk->mState);
239 // ensure our state matches up until we consolidate the enumeration.
240 static_assert(CBLK_STATE_IDLE == IDLE);
241 static_assert(CBLK_STATE_PAUSING == PAUSING);
Eric Laurent81784c32012-11-19 14:55:58 -0800242 }
243}
244
Svet Ganov33761132021-05-13 22:51:08 +0000245// TODO b/182392769: use attribution source util
246static AttributionSourceState audioServerAttributionSource(pid_t pid) {
247 AttributionSourceState attributionSource{};
248 attributionSource.uid = AID_AUDIOSERVER;
249 attributionSource.pid = pid;
250 attributionSource.token = sp<BBinder>::make();
251 return attributionSource;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700252}
253
Eric Laurent83b88082014-06-20 18:31:16 -0700254status_t AudioFlinger::ThreadBase::TrackBase::initCheck() const
255{
256 status_t status;
257 if (mType == TYPE_OUTPUT || mType == TYPE_PATCH) {
258 status = cblk() != NULL ? NO_ERROR : NO_MEMORY;
259 } else {
260 status = getCblk() != 0 ? NO_ERROR : NO_MEMORY;
261 }
262 return status;
263}
264
Eric Laurent81784c32012-11-19 14:55:58 -0800265AudioFlinger::ThreadBase::TrackBase::~TrackBase()
266{
Glenn Kastene3aa6592012-12-04 12:22:46 -0800267 // delete the proxy before deleting the shared memory it refers to, to avoid dangling reference
Eric Laurent5bba2f62016-03-18 11:14:14 -0700268 mServerProxy.clear();
Andy Hung689e82c2019-08-21 17:53:17 -0700269 releaseCblk();
Eric Laurent81784c32012-11-19 14:55:58 -0800270 mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to
271 if (mClient != 0) {
Eric Laurent021cf962014-05-13 10:18:14 -0700272 // Client destructor must run with AudioFlinger client mutex locked
273 Mutex::Autolock _l(mClient->audioFlinger()->mClientLock);
Eric Laurent81784c32012-11-19 14:55:58 -0800274 // If the client's reference count drops to zero, the associated destructor
275 // must run with AudioFlinger lock held. Thus the explicit clear() rather than
276 // relying on the automatic clear() at end of scope.
277 mClient.clear();
278 }
Eric Laurent3bcffa12014-06-12 18:38:45 -0700279 // flush the binder command buffer
280 IPCThreadState::self()->flushCommands();
Eric Laurent81784c32012-11-19 14:55:58 -0800281}
282
283// AudioBufferProvider interface
284// getNextBuffer() = 0;
Glenn Kastend79072e2016-01-06 08:41:20 -0800285// This implementation of releaseBuffer() is used by Track and RecordTrack
Eric Laurent81784c32012-11-19 14:55:58 -0800286void AudioFlinger::ThreadBase::TrackBase::releaseBuffer(AudioBufferProvider::Buffer* buffer)
287{
Glenn Kasten46909e72013-02-26 09:20:22 -0800288#ifdef TEE_SINK
Andy Hung8946a282018-04-19 20:04:56 -0700289 mTee.write(buffer->raw, buffer->frameCount);
Glenn Kasten46909e72013-02-26 09:20:22 -0800290#endif
Glenn Kastenda6ef132013-01-10 12:31:01 -0800291
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800292 ServerProxy::Buffer buf;
293 buf.mFrameCount = buffer->frameCount;
294 buf.mRaw = buffer->raw;
Eric Laurent81784c32012-11-19 14:55:58 -0800295 buffer->frameCount = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800296 buffer->raw = NULL;
297 mServerProxy->releaseBuffer(&buf);
Eric Laurent81784c32012-11-19 14:55:58 -0800298}
299
Eric Laurent81784c32012-11-19 14:55:58 -0800300status_t AudioFlinger::ThreadBase::TrackBase::setSyncEvent(const sp<SyncEvent>& event)
301{
302 mSyncEvents.add(event);
303 return NO_ERROR;
304}
305
Kevin Rocard45986c72018-12-18 18:22:59 -0800306AudioFlinger::ThreadBase::PatchTrackBase::PatchTrackBase(sp<ClientProxy> proxy,
307 const ThreadBase& thread,
308 const Timeout& timeout)
309 : mProxy(proxy)
310{
311 if (timeout) {
312 setPeerTimeout(*timeout);
313 } else {
314 // Double buffer mixer
315 uint64_t mixBufferNs = ((uint64_t)2 * thread.frameCount() * 1000000000) /
316 thread.sampleRate();
317 setPeerTimeout(std::chrono::nanoseconds{mixBufferNs});
318 }
319}
320
321void AudioFlinger::ThreadBase::PatchTrackBase::setPeerTimeout(std::chrono::nanoseconds timeout) {
322 mPeerTimeout.tv_sec = timeout.count() / std::nano::den;
323 mPeerTimeout.tv_nsec = timeout.count() % std::nano::den;
324}
325
326
Eric Laurent81784c32012-11-19 14:55:58 -0800327// ----------------------------------------------------------------------------
328// Playback
329// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -0700330#undef LOG_TAG
331#define LOG_TAG "AF::TrackHandle"
Eric Laurent81784c32012-11-19 14:55:58 -0800332
333AudioFlinger::TrackHandle::TrackHandle(const sp<AudioFlinger::PlaybackThread::Track>& track)
334 : BnAudioTrack(),
335 mTrack(track)
336{
337}
338
339AudioFlinger::TrackHandle::~TrackHandle() {
340 // just stop the track on deletion, associated resources
341 // will be freed from the main thread once all pending buffers have
342 // been played. Unless it's not in the active track list, in which
343 // case we free everything now...
344 mTrack->destroy();
345}
346
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800347Status AudioFlinger::TrackHandle::getCblk(
348 std::optional<media::SharedFileRegion>* _aidl_return) {
349 *_aidl_return = legacy2aidl_NullableIMemory_SharedFileRegion(mTrack->getCblk()).value();
350 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800351}
352
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800353Status AudioFlinger::TrackHandle::start(int32_t* _aidl_return) {
354 *_aidl_return = mTrack->start();
355 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800356}
357
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800358Status AudioFlinger::TrackHandle::stop() {
Eric Laurent81784c32012-11-19 14:55:58 -0800359 mTrack->stop();
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800360 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800361}
362
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800363Status AudioFlinger::TrackHandle::flush() {
Eric Laurent81784c32012-11-19 14:55:58 -0800364 mTrack->flush();
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800365 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800366}
367
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800368Status AudioFlinger::TrackHandle::pause() {
Eric Laurent81784c32012-11-19 14:55:58 -0800369 mTrack->pause();
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800370 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800371}
372
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800373Status AudioFlinger::TrackHandle::attachAuxEffect(int32_t effectId,
374 int32_t* _aidl_return) {
375 *_aidl_return = mTrack->attachAuxEffect(effectId);
376 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800377}
378
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800379Status AudioFlinger::TrackHandle::setParameters(const std::string& keyValuePairs,
380 int32_t* _aidl_return) {
381 *_aidl_return = mTrack->setParameters(String8(keyValuePairs.c_str()));
382 return Status::ok();
Glenn Kasten3dcd00d2013-07-17 10:10:23 -0700383}
384
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800385Status AudioFlinger::TrackHandle::selectPresentation(int32_t presentationId, int32_t programId,
386 int32_t* _aidl_return) {
387 *_aidl_return = mTrack->selectPresentation(presentationId, programId);
388 return Status::ok();
Mikhail Naganovac917ac2018-11-28 14:03:52 -0800389}
390
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800391Status AudioFlinger::TrackHandle::getTimestamp(media::AudioTimestampInternal* timestamp,
392 int32_t* _aidl_return) {
393 AudioTimestamp legacy;
394 *_aidl_return = mTrack->getTimestamp(legacy);
395 if (*_aidl_return != OK) {
396 return Status::ok();
397 }
Andy Hung973638a2020-12-08 20:47:45 -0800398 *timestamp = legacy2aidl_AudioTimestamp_AudioTimestampInternal(legacy).value();
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800399 return Status::ok();
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800400}
401
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800402Status AudioFlinger::TrackHandle::signal() {
403 mTrack->signal();
404 return Status::ok();
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800405}
406
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800407Status AudioFlinger::TrackHandle::applyVolumeShaper(
408 const media::VolumeShaperConfiguration& configuration,
409 const media::VolumeShaperOperation& operation,
410 int32_t* _aidl_return) {
411 sp<VolumeShaper::Configuration> conf = new VolumeShaper::Configuration();
412 *_aidl_return = conf->readFromParcelable(configuration);
413 if (*_aidl_return != OK) {
414 return Status::ok();
415 }
416
417 sp<VolumeShaper::Operation> op = new VolumeShaper::Operation();
418 *_aidl_return = op->readFromParcelable(operation);
419 if (*_aidl_return != OK) {
420 return Status::ok();
421 }
422
423 *_aidl_return = mTrack->applyVolumeShaper(conf, op);
424 return Status::ok();
Glenn Kasten53cec222013-08-29 09:01:02 -0700425}
426
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800427Status AudioFlinger::TrackHandle::getVolumeShaperState(
428 int32_t id,
429 std::optional<media::VolumeShaperState>* _aidl_return) {
430 sp<VolumeShaper::State> legacy = mTrack->getVolumeShaperState(id);
431 if (legacy == nullptr) {
432 _aidl_return->reset();
433 return Status::ok();
434 }
435 media::VolumeShaperState aidl;
436 legacy->writeToParcelable(&aidl);
437 *_aidl_return = aidl;
438 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800439}
440
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800441Status AudioFlinger::TrackHandle::getDualMonoMode(media::AudioDualMonoMode* _aidl_return)
442{
443 audio_dual_mono_mode_t mode = AUDIO_DUAL_MONO_MODE_OFF;
444 const status_t status = mTrack->getDualMonoMode(&mode)
445 ?: AudioValidator::validateDualMonoMode(mode);
446 if (status == OK) {
447 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
448 legacy2aidl_audio_dual_mono_mode_t_AudioDualMonoMode(mode));
449 }
450 return binderStatusFromStatusT(status);
451}
452
453Status AudioFlinger::TrackHandle::setDualMonoMode(
454 media::AudioDualMonoMode mode)
455{
456 const auto localMonoMode = VALUE_OR_RETURN_BINDER_STATUS(
457 aidl2legacy_AudioDualMonoMode_audio_dual_mono_mode_t(mode));
458 return binderStatusFromStatusT(AudioValidator::validateDualMonoMode(localMonoMode)
459 ?: mTrack->setDualMonoMode(localMonoMode));
460}
461
462Status AudioFlinger::TrackHandle::getAudioDescriptionMixLevel(float* _aidl_return)
463{
464 float leveldB = -std::numeric_limits<float>::infinity();
465 const status_t status = mTrack->getAudioDescriptionMixLevel(&leveldB)
466 ?: AudioValidator::validateAudioDescriptionMixLevel(leveldB);
467 if (status == OK) *_aidl_return = leveldB;
468 return binderStatusFromStatusT(status);
469}
470
471Status AudioFlinger::TrackHandle::setAudioDescriptionMixLevel(float leveldB)
472{
473 return binderStatusFromStatusT(AudioValidator::validateAudioDescriptionMixLevel(leveldB)
474 ?: mTrack->setAudioDescriptionMixLevel(leveldB));
475}
476
477Status AudioFlinger::TrackHandle::getPlaybackRateParameters(
478 media::AudioPlaybackRate* _aidl_return)
479{
480 audio_playback_rate_t localPlaybackRate{};
481 status_t status = mTrack->getPlaybackRateParameters(&localPlaybackRate)
482 ?: AudioValidator::validatePlaybackRate(localPlaybackRate);
483 if (status == NO_ERROR) {
484 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
485 legacy2aidl_audio_playback_rate_t_AudioPlaybackRate(localPlaybackRate));
486 }
487 return binderStatusFromStatusT(status);
488}
489
490Status AudioFlinger::TrackHandle::setPlaybackRateParameters(
491 const media::AudioPlaybackRate& playbackRate)
492{
493 const audio_playback_rate_t localPlaybackRate = VALUE_OR_RETURN_BINDER_STATUS(
494 aidl2legacy_AudioPlaybackRate_audio_playback_rate_t(playbackRate));
495 return binderStatusFromStatusT(AudioValidator::validatePlaybackRate(localPlaybackRate)
496 ?: mTrack->setPlaybackRateParameters(localPlaybackRate));
497}
498
Eric Laurent81784c32012-11-19 14:55:58 -0800499// ----------------------------------------------------------------------------
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800500// AppOp for audio playback
501// -------------------------------
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700502
503// static
504sp<AudioFlinger::PlaybackThread::OpPlayAudioMonitor>
505AudioFlinger::PlaybackThread::OpPlayAudioMonitor::createIfNeeded(
Svet Ganov33761132021-05-13 22:51:08 +0000506 const AttributionSourceState& attributionSource, const audio_attributes_t& attr, int id,
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700507 audio_stream_type_t streamType)
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800508{
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000509 Vector <String16> packages;
Svet Ganov33761132021-05-13 22:51:08 +0000510 uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid));
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000511 getPackagesForUid(uid, packages);
Eric Laurent9066ad32019-05-20 14:40:10 -0700512 if (isServiceUid(uid)) {
Eric Laurent9066ad32019-05-20 14:40:10 -0700513 if (packages.isEmpty()) {
514 ALOGD("OpPlayAudio: not muting track:%d usage:%d for service UID %d",
515 id,
516 attr.usage,
517 uid);
518 return nullptr;
519 }
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800520 }
521 // stream type has been filtered by audio policy to indicate whether it can be muted
522 if (streamType == AUDIO_STREAM_ENFORCED_AUDIBLE) {
Eric Laurent2dab0302019-05-08 18:15:55 -0700523 ALOGD("OpPlayAudio: not muting track:%d usage:%d ENFORCED_AUDIBLE", id, attr.usage);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700524 return nullptr;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800525 }
Eric Laurent2dab0302019-05-08 18:15:55 -0700526 if ((attr.flags & AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY)
527 == AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY) {
528 ALOGD("OpPlayAudio: not muting track:%d flags %#x have FLAG_BYPASS_INTERRUPTION_POLICY",
529 id, attr.flags);
530 return nullptr;
531 }
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000532
Svet Ganov33761132021-05-13 22:51:08 +0000533 AttributionSourceState checkedAttributionSource = AudioFlinger::checkAttributionSourcePackage(
534 attributionSource);
535 return new OpPlayAudioMonitor(checkedAttributionSource, attr.usage, id);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700536}
537
538AudioFlinger::PlaybackThread::OpPlayAudioMonitor::OpPlayAudioMonitor(
Svet Ganov33761132021-05-13 22:51:08 +0000539 const AttributionSourceState& attributionSource, audio_usage_t usage, int id)
540 : mHasOpPlayAudio(true), mAttributionSource(attributionSource), mUsage((int32_t) usage),
541 mId(id)
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700542{
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800543}
544
545AudioFlinger::PlaybackThread::OpPlayAudioMonitor::~OpPlayAudioMonitor()
546{
547 if (mOpCallback != 0) {
548 mAppOpsManager.stopWatchingMode(mOpCallback);
549 }
550 mOpCallback.clear();
551}
552
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700553void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::onFirstRef()
554{
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700555 checkPlayAudioForUsage();
Svet Ganov33761132021-05-13 22:51:08 +0000556 if (mAttributionSource.packageName.has_value()) {
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700557 mOpCallback = new PlayAudioOpCallback(this);
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700558 mAppOpsManager.startWatchingMode(AppOpsManager::OP_PLAY_AUDIO,
Svet Ganov33761132021-05-13 22:51:08 +0000559 VALUE_OR_FATAL(aidl2legacy_string_view_String16(
560 mAttributionSource.packageName.value_or("")))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700561 , mOpCallback);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700562 }
563}
564
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800565bool AudioFlinger::PlaybackThread::OpPlayAudioMonitor::hasOpPlayAudio() const {
566 return mHasOpPlayAudio.load();
567}
568
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -0700569// Note this method is never called (and never to be) for audio server / patch record track
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800570// - not called from constructor due to check on UID,
571// - not called from PlayAudioOpCallback because the callback is not installed in this case
572void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::checkPlayAudioForUsage()
573{
Svet Ganov33761132021-05-13 22:51:08 +0000574 if (!mAttributionSource.packageName.has_value()) {
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800575 mHasOpPlayAudio.store(false);
576 } else {
Svet Ganov33761132021-05-13 22:51:08 +0000577 uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(mAttributionSource.uid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700578 String16 packageName = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +0000579 aidl2legacy_string_view_String16(mAttributionSource.packageName.value_or("")));
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000580 bool hasIt = mAppOpsManager.checkAudioOpNoThrow(AppOpsManager::OP_PLAY_AUDIO,
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700581 mUsage, uid, packageName) == AppOpsManager::MODE_ALLOWED;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800582 ALOGD("OpPlayAudio: track:%d usage:%d %smuted", mId, mUsage, hasIt ? "not " : "");
583 mHasOpPlayAudio.store(hasIt);
584 }
585}
586
587AudioFlinger::PlaybackThread::OpPlayAudioMonitor::PlayAudioOpCallback::PlayAudioOpCallback(
588 const wp<OpPlayAudioMonitor>& monitor) : mMonitor(monitor)
589{ }
590
591void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::PlayAudioOpCallback::opChanged(int32_t op,
592 const String16& packageName) {
593 // we only have uid, so we need to check all package names anyway
594 UNUSED(packageName);
595 if (op != AppOpsManager::OP_PLAY_AUDIO) {
596 return;
597 }
598 sp<OpPlayAudioMonitor> monitor = mMonitor.promote();
599 if (monitor != NULL) {
600 monitor->checkPlayAudioForUsage();
601 }
602}
603
Eric Laurent9066ad32019-05-20 14:40:10 -0700604// static
605void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::getPackagesForUid(
606 uid_t uid, Vector<String16>& packages)
607{
608 PermissionController permissionController;
609 permissionController.getPackagesForUid(uid, packages);
610}
611
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800612// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -0700613#undef LOG_TAG
614#define LOG_TAG "AF::Track"
Eric Laurent81784c32012-11-19 14:55:58 -0800615
616// Track constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
617AudioFlinger::PlaybackThread::Track::Track(
618 PlaybackThread *thread,
619 const sp<Client>& client,
620 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700621 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -0800622 uint32_t sampleRate,
623 audio_format_t format,
624 audio_channel_mask_t channelMask,
625 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700626 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700627 size_t bufferSize,
Eric Laurent81784c32012-11-19 14:55:58 -0800628 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -0800629 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700630 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +0000631 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -0700632 audio_output_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800633 track_type type,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +0100634 audio_port_handle_t portId,
jiabinf042b9b2021-05-07 23:46:28 +0000635 size_t frameCountToBeReady,
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200636 float speed,
637 bool isSpatialized)
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700638 : TrackBase(thread, client, attr, sampleRate, format, channelMask, frameCount,
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700639 // TODO: Using unsecurePointer() has some associated security pitfalls
640 // (see declaration for details).
641 // Either document why it is safe in this case or address the
642 // issue (e.g. by copying).
643 (sharedBuffer != 0) ? sharedBuffer->unsecurePointer() : buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700644 (sharedBuffer != 0) ? sharedBuffer->size() : bufferSize,
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700645 sessionId, creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +0000646 VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid)), true /*isOut*/,
Eric Laurent83b88082014-06-20 18:31:16 -0700647 (type == TYPE_PATCH) ? ( buffer == NULL ? ALLOC_LOCAL : ALLOC_NONE) : ALLOC_CBLK,
Andy Hungb68f5eb2019-12-03 16:49:17 -0800648 type,
649 portId,
650 std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_TRACK) + std::to_string(portId)),
Eric Laurent81784c32012-11-19 14:55:58 -0800651 mFillingUpStatus(FS_INVALID),
652 // mRetryCount initialized later when needed
653 mSharedBuffer(sharedBuffer),
654 mStreamType(streamType),
rago94a1ee82017-07-21 15:11:02 -0700655 mMainBuffer(thread->sinkBuffer()),
Eric Laurent81784c32012-11-19 14:55:58 -0800656 mAuxBuffer(NULL),
657 mAuxEffectId(0), mHasVolumeController(false),
Andy Hunge10393e2015-06-12 13:59:33 -0700658 mFrameMap(16 /* sink-frame-to-track-frame map memory */),
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700659 mVolumeHandler(new media::VolumeHandler(sampleRate)),
Svet Ganov33761132021-05-13 22:51:08 +0000660 mOpPlayAudioMonitor(OpPlayAudioMonitor::createIfNeeded(attributionSource, attr, id(),
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700661 streamType)),
Andy Hunge10393e2015-06-12 13:59:33 -0700662 // mSinkTimestamp
Eric Laurent81784c32012-11-19 14:55:58 -0800663 mFastIndex(-1),
Glenn Kasten5736c352012-12-04 12:12:34 -0800664 mCachedVolume(1.0),
Kevin Rocard12381092018-04-11 09:19:59 -0700665 /* The track might not play immediately after being active, similarly as if its volume was 0.
666 * When the track starts playing, its volume will be computed. */
667 mFinalVolume(0.f),
Haynes Mathew George7844f672014-01-15 12:32:55 -0800668 mResumeToStopping(false),
Eric Laurent05067782016-06-01 18:27:28 -0700669 mFlushHwPending(false),
jiabinf042b9b2021-05-07 23:46:28 +0000670 mFlags(flags),
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200671 mSpeed(speed),
672 mIsSpatialized(isSpatialized)
Eric Laurent81784c32012-11-19 14:55:58 -0800673{
Eric Laurent83b88082014-06-20 18:31:16 -0700674 // client == 0 implies sharedBuffer == 0
675 ALOG_ASSERT(!(client == 0 && sharedBuffer != 0));
676
Andy Hung9d84af52018-09-12 18:03:44 -0700677 ALOGV_IF(sharedBuffer != 0, "%s(%d): sharedBuffer: %p, size: %zu",
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700678 __func__, mId, sharedBuffer->unsecurePointer(), sharedBuffer->size());
Eric Laurent83b88082014-06-20 18:31:16 -0700679
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700680 if (mCblk == NULL) {
681 return;
Eric Laurent81784c32012-11-19 14:55:58 -0800682 }
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700683
Svet Ganov33761132021-05-13 22:51:08 +0000684 uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid));
Andy Hung689e82c2019-08-21 17:53:17 -0700685 if (!thread->isTrackAllowed_l(channelMask, format, sessionId, uid)) {
686 ALOGE("%s(%d): no more tracks available", __func__, mId);
687 releaseCblk(); // this makes the track invalid.
688 return;
689 }
690
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700691 if (sharedBuffer == 0) {
692 mAudioTrackServerProxy = new AudioTrackServerProxy(mCblk, mBuffer, frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700693 mFrameSize, !isExternalTrack(), sampleRate);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700694 } else {
695 mAudioTrackServerProxy = new StaticAudioTrackServerProxy(mCblk, mBuffer, frameCount,
Kevin Rocard36862032019-10-10 10:52:19 +0100696 mFrameSize, sampleRate);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700697 }
698 mServerProxy = mAudioTrackServerProxy;
Andy Hung3c7f47a2021-03-16 17:30:09 -0700699 mServerProxy->setStartThresholdInFrames(frameCountToBeReady); // update the Cblk value
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700700
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700701 // only allocate a fast track index if we were able to allocate a normal track name
Eric Laurent05067782016-06-01 18:27:28 -0700702 if (flags & AUDIO_OUTPUT_FLAG_FAST) {
Andy Hunga5427822015-09-11 16:15:35 -0700703 // FIXME: Not calling framesReadyIsCalledByMultipleThreads() exposes a potential
704 // race with setSyncEvent(). However, if we call it, we cannot properly start
705 // static fast tracks (SoundPool) immediately after stopping.
706 //mAudioTrackServerProxy->framesReadyIsCalledByMultipleThreads();
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700707 ALOG_ASSERT(thread->mFastTrackAvailMask != 0);
708 int i = __builtin_ctz(thread->mFastTrackAvailMask);
Glenn Kastendc2c50b2016-04-21 08:13:14 -0700709 ALOG_ASSERT(0 < i && i < (int)FastMixerState::sMaxFastTracks);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700710 // FIXME This is too eager. We allocate a fast track index before the
711 // fast track becomes active. Since fast tracks are a scarce resource,
712 // this means we are potentially denying other more important fast tracks from
713 // being created. It would be better to allocate the index dynamically.
714 mFastIndex = i;
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700715 thread->mFastTrackAvailMask &= ~(1 << i);
716 }
Andy Hung8946a282018-04-19 20:04:56 -0700717
Dean Wheatley7b036912020-06-18 16:22:11 +1000718 mServerLatencySupported = checkServerLatencySupported(format, flags);
Andy Hung8946a282018-04-19 20:04:56 -0700719#ifdef TEE_SINK
720 mTee.setId(std::string("_") + std::to_string(mThreadIoHandle)
Kevin Rocard51f0e982019-02-01 19:19:11 -0800721 + "_" + std::to_string(mId) + "_T");
Andy Hung8946a282018-04-19 20:04:56 -0700722#endif
jiabin57303cc2018-12-18 15:45:57 -0800723
jiabineb3bda02020-06-30 14:07:03 -0700724 if (thread->supportsHapticPlayback()) {
725 // If the track is attached to haptic playback thread, it is potentially to have
726 // HapticGenerator effect, which will generate haptic data, on the track. In that case,
727 // external vibration is always created for all tracks attached to haptic playback thread.
jiabin57303cc2018-12-18 15:45:57 -0800728 mAudioVibrationController = new AudioVibrationController(this);
Svet Ganov33761132021-05-13 22:51:08 +0000729 std::string packageName = attributionSource.packageName.has_value() ?
730 attributionSource.packageName.value() : "";
jiabin57303cc2018-12-18 15:45:57 -0800731 mExternalVibration = new os::ExternalVibration(
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700732 mUid, packageName, mAttr, mAudioVibrationController);
jiabin57303cc2018-12-18 15:45:57 -0800733 }
Andy Hungb68f5eb2019-12-03 16:49:17 -0800734
735 // Once this item is logged by the server, the client can add properties.
Andy Hunga629bd12020-06-05 16:03:53 -0700736 const char * const traits = sharedBuffer == 0 ? "" : "static";
Andy Hung5837c7f2021-02-25 10:48:24 -0800737 mTrackMetrics.logConstructor(creatorPid, uid, id(), traits, streamType);
Eric Laurent81784c32012-11-19 14:55:58 -0800738}
739
740AudioFlinger::PlaybackThread::Track::~Track()
741{
Andy Hung9d84af52018-09-12 18:03:44 -0700742 ALOGV("%s(%d)", __func__, mId);
Glenn Kasten0c72b242013-09-11 09:14:16 -0700743
744 // The destructor would clear mSharedBuffer,
745 // but it will not push the decremented reference count,
746 // leaving the client's IMemory dangling indefinitely.
747 // This prevents that leak.
748 if (mSharedBuffer != 0) {
749 mSharedBuffer.clear();
Glenn Kasten0c72b242013-09-11 09:14:16 -0700750 }
Eric Laurent81784c32012-11-19 14:55:58 -0800751}
752
Glenn Kasten03003332013-08-06 15:40:54 -0700753status_t AudioFlinger::PlaybackThread::Track::initCheck() const
754{
755 status_t status = TrackBase::initCheck();
Andy Hungc0691382018-09-12 18:01:57 -0700756 if (status == NO_ERROR && mCblk == nullptr) {
Glenn Kasten03003332013-08-06 15:40:54 -0700757 status = NO_MEMORY;
758 }
759 return status;
760}
761
Eric Laurent81784c32012-11-19 14:55:58 -0800762void AudioFlinger::PlaybackThread::Track::destroy()
763{
764 // NOTE: destroyTrack_l() can remove a strong reference to this Track
765 // by removing it from mTracks vector, so there is a risk that this Tracks's
766 // destructor is called. As the destructor needs to lock mLock,
767 // we must acquire a strong reference on this Track before locking mLock
768 // here so that the destructor is called only when exiting this function.
769 // On the other hand, as long as Track::destroy() is only called by
770 // TrackHandle destructor, the TrackHandle still holds a strong ref on
771 // this Track with its member mTrack.
772 sp<Track> keep(this);
773 { // scope for mLock
Eric Laurentaaa44472014-09-12 17:41:50 -0700774 bool wasActive = false;
Eric Laurent81784c32012-11-19 14:55:58 -0800775 sp<ThreadBase> thread = mThread.promote();
776 if (thread != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -0800777 Mutex::Autolock _l(thread->mLock);
778 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Eric Laurentaaa44472014-09-12 17:41:50 -0700779 wasActive = playbackThread->destroyTrack_l(this);
780 }
781 if (isExternalTrack() && !wasActive) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700782 AudioSystem::releaseOutput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -0800783 }
784 }
Kevin Rocardc43ea142019-01-31 18:17:37 -0800785 forEachTeePatchTrack([](auto patchTrack) { patchTrack->destroy(); });
Eric Laurent81784c32012-11-19 14:55:58 -0800786}
787
Andy Hungf6ab58d2018-05-25 12:50:39 -0700788void AudioFlinger::PlaybackThread::Track::appendDumpHeader(String8& result)
Eric Laurent81784c32012-11-19 14:55:58 -0800789{
Eric Laurent973db022018-11-20 14:54:31 -0800790 result.appendFormat("Type Id Active Client Session Port Id S Flags "
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700791 " Format Chn mask SRate "
792 "ST Usg CT "
793 " G db L dB R dB VS dB "
794 " Server FrmCnt FrmRdy F Underruns Flushed"
795 "%s\n",
796 isServerLatencySupported() ? " Latency" : "");
Eric Laurent81784c32012-11-19 14:55:58 -0800797}
798
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700799void AudioFlinger::PlaybackThread::Track::appendDump(String8& result, bool active)
Eric Laurent81784c32012-11-19 14:55:58 -0800800{
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700801 char trackType;
802 switch (mType) {
803 case TYPE_DEFAULT:
804 case TYPE_OUTPUT:
Andy Hungf6ab58d2018-05-25 12:50:39 -0700805 if (isStatic()) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700806 trackType = 'S'; // static
807 } else {
808 trackType = ' '; // normal
Eric Laurentbfb1b832013-01-07 09:53:42 -0800809 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700810 break;
811 case TYPE_PATCH:
812 trackType = 'P';
813 break;
814 default:
815 trackType = '?';
Eric Laurent81784c32012-11-19 14:55:58 -0800816 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700817
818 if (isFastTrack()) {
Andy Hungc0691382018-09-12 18:01:57 -0700819 result.appendFormat("F%d %c %6d", mFastIndex, trackType, mId);
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700820 } else {
Andy Hungc0691382018-09-12 18:01:57 -0700821 result.appendFormat(" %c %6d", trackType, mId);
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700822 }
823
Eric Laurent81784c32012-11-19 14:55:58 -0800824 char nowInUnderrun;
825 switch (mObservedUnderruns.mBitFields.mMostRecent) {
826 case UNDERRUN_FULL:
827 nowInUnderrun = ' ';
828 break;
829 case UNDERRUN_PARTIAL:
830 nowInUnderrun = '<';
831 break;
832 case UNDERRUN_EMPTY:
833 nowInUnderrun = '*';
834 break;
835 default:
836 nowInUnderrun = '?';
837 break;
838 }
Andy Hungda540db2017-04-20 14:06:17 -0700839
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700840 char fillingStatus;
841 switch (mFillingUpStatus) {
842 case FS_INVALID:
843 fillingStatus = 'I';
844 break;
845 case FS_FILLING:
846 fillingStatus = 'f';
847 break;
848 case FS_FILLED:
849 fillingStatus = 'F';
850 break;
851 case FS_ACTIVE:
852 fillingStatus = 'A';
853 break;
854 default:
855 fillingStatus = '?';
856 break;
857 }
858
859 // clip framesReadySafe to max representation in dump
860 const size_t framesReadySafe =
861 std::min(mAudioTrackServerProxy->framesReadySafe(), (size_t)99999999);
862
863 // obtain volumes
864 const gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR();
865 const std::pair<float /* volume */, bool /* active */> vsVolume =
866 mVolumeHandler->getLastVolume();
867
868 // Our effective frame count is obtained by ServerProxy::getBufferSizeInFrames()
869 // as it may be reduced by the application.
870 const size_t bufferSizeInFrames = (size_t)mAudioTrackServerProxy->getBufferSizeInFrames();
871 // Check whether the buffer size has been modified by the app.
872 const char modifiedBufferChar = bufferSizeInFrames < mFrameCount
873 ? 'r' /* buffer reduced */: bufferSizeInFrames > mFrameCount
874 ? 'e' /* error */ : ' ' /* identical */;
875
Eric Laurent973db022018-11-20 14:54:31 -0800876 result.appendFormat("%7s %6u %7u %7u %2s 0x%03X "
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700877 "%08X %08X %6u "
878 "%2u %3x %2x "
879 "%5.2g %5.2g %5.2g %5.2g%c "
880 "%08X %6zu%c %6zu %c %9u%c %7u",
Marco Nelissenb2208842014-02-07 14:00:50 -0800881 active ? "yes" : "no",
Andy Hung4ef19fa2018-05-15 19:35:29 -0700882 (mClient == 0) ? getpid() : mClient->pid(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700883 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -0800884 mPortId,
Andy Hunge2e830f2019-12-03 12:54:46 -0800885 getTrackStateAsCodedString(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700886 mCblk->mFlags,
887
Eric Laurent81784c32012-11-19 14:55:58 -0800888 mFormat,
889 mChannelMask,
Andy Hungcef2daa2018-06-01 15:31:49 -0700890 sampleRate(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700891
892 mStreamType,
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700893 mAttr.usage,
894 mAttr.content_type,
895
896 20.0 * log10(mFinalVolume),
Glenn Kastenc56f3422014-03-21 17:53:17 -0700897 20.0 * log10(float_from_gain(gain_minifloat_unpack_left(vlr))),
898 20.0 * log10(float_from_gain(gain_minifloat_unpack_right(vlr))),
Andy Hungda540db2017-04-20 14:06:17 -0700899 20.0 * log10(vsVolume.first), // VolumeShaper(s) total volume
900 vsVolume.second ? 'A' : ' ', // if any VolumeShapers active
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700901
Glenn Kastenf20e1d82013-07-12 09:45:18 -0700902 mCblk->mServer,
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700903 bufferSizeInFrames,
904 modifiedBufferChar,
905 framesReadySafe,
906 fillingStatus,
Glenn Kasten82aaf942013-07-17 16:05:07 -0700907 mAudioTrackServerProxy->getUnderrunFrames(),
Andy Hung2148bf02016-11-28 19:01:02 -0800908 nowInUnderrun,
Andy Hungf6ab58d2018-05-25 12:50:39 -0700909 (unsigned)mAudioTrackServerProxy->framesFlushed() % 10000000
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700910 );
Andy Hungcef2daa2018-06-01 15:31:49 -0700911
912 if (isServerLatencySupported()) {
913 double latencyMs;
914 bool fromTrack;
915 if (getTrackLatencyMs(&latencyMs, &fromTrack) == OK) {
916 // Show latency in msec, followed by 't' if from track timestamp (the most accurate)
917 // or 'k' if estimated from kernel because track frames haven't been presented yet.
918 result.appendFormat(" %7.2lf %c", latencyMs, fromTrack ? 't' : 'k');
Andy Hungf6ab58d2018-05-25 12:50:39 -0700919 } else {
Andy Hungcef2daa2018-06-01 15:31:49 -0700920 result.appendFormat("%10s", mCblk->mServer != 0 ? "unavail" : "new");
Andy Hungf6ab58d2018-05-25 12:50:39 -0700921 }
922 }
923 result.append("\n");
Eric Laurent81784c32012-11-19 14:55:58 -0800924}
925
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800926uint32_t AudioFlinger::PlaybackThread::Track::sampleRate() const {
927 return mAudioTrackServerProxy->getSampleRate();
928}
929
Eric Laurent81784c32012-11-19 14:55:58 -0800930// AudioBufferProvider interface
Kevin Rocard153f92d2018-12-18 18:33:28 -0800931status_t AudioFlinger::PlaybackThread::Track::getNextBuffer(AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -0800932{
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800933 ServerProxy::Buffer buf;
934 size_t desiredFrames = buffer->frameCount;
935 buf.mFrameCount = desiredFrames;
936 status_t status = mServerProxy->obtainBuffer(&buf);
937 buffer->frameCount = buf.mFrameCount;
938 buffer->raw = buf.mRaw;
Andy Hungfc629172020-06-22 10:06:23 -0700939 if (buf.mFrameCount == 0 && !isStopping() && !isStopped() && !isPaused() && !isOffloaded()) {
Andy Hung9d84af52018-09-12 18:03:44 -0700940 ALOGV("%s(%d): underrun, framesReady(%zu) < framesDesired(%zd), state: %d",
Andy Hung959b5b82021-09-24 10:46:20 -0700941 __func__, mId, buf.mFrameCount, desiredFrames, (int)mState);
Glenn Kasten82aaf942013-07-17 16:05:07 -0700942 mAudioTrackServerProxy->tallyUnderrunFrames(desiredFrames);
Phil Burk2812d9e2016-01-04 10:34:30 -0800943 } else {
944 mAudioTrackServerProxy->tallyUnderrunFrames(0);
Eric Laurent81784c32012-11-19 14:55:58 -0800945 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800946 return status;
Eric Laurent81784c32012-11-19 14:55:58 -0800947}
948
Kevin Rocard153f92d2018-12-18 18:33:28 -0800949void AudioFlinger::PlaybackThread::Track::releaseBuffer(AudioBufferProvider::Buffer* buffer)
950{
951 interceptBuffer(*buffer);
952 TrackBase::releaseBuffer(buffer);
953}
954
955// TODO: compensate for time shift between HW modules.
956void AudioFlinger::PlaybackThread::Track::interceptBuffer(
Kevin Rocarda134b002019-02-07 18:05:31 -0800957 const AudioBufferProvider::Buffer& sourceBuffer) {
Kevin Rocard6057fa22019-02-08 14:08:07 -0800958 auto start = std::chrono::steady_clock::now();
Kevin Rocarda134b002019-02-07 18:05:31 -0800959 const size_t frameCount = sourceBuffer.frameCount;
Kevin Rocardd83b08a2019-02-27 15:05:54 -0800960 if (frameCount == 0) {
961 return; // No audio to intercept.
962 // Additionally PatchProxyBufferProvider::obtainBuffer (called by PathTrack::getNextBuffer)
963 // does not allow 0 frame size request contrary to getNextBuffer
964 }
965 for (auto& teePatch : mTeePatches) {
966 RecordThread::PatchRecord* patchRecord = teePatch.patchRecord.get();
Mikhail Naganov8296c252019-09-25 14:59:54 -0700967 const size_t framesWritten = patchRecord->writeFrames(
968 sourceBuffer.i8, frameCount, mFrameSize);
969 const size_t framesLeft = frameCount - framesWritten;
Kevin Rocarda134b002019-02-07 18:05:31 -0800970 ALOGW_IF(framesLeft != 0, "%s(%d) PatchRecord %d can not provide big enough "
971 "buffer %zu/%zu, dropping %zu frames", __func__, mId, patchRecord->mId,
972 framesWritten, frameCount, framesLeft);
Kevin Rocard153f92d2018-12-18 18:33:28 -0800973 }
Kevin Rocard6057fa22019-02-08 14:08:07 -0800974 auto spent = ceil<std::chrono::microseconds>(std::chrono::steady_clock::now() - start);
975 using namespace std::chrono_literals;
976 // Average is ~20us per track, this should virtually never be logged (Logging takes >200us)
Kevin Rocard01c7d9e2019-09-18 11:24:52 +0100977 ALOGD_IF(spent > 500us, "%s: took %lldus to intercept %zu tracks", __func__,
Kevin Rocard6057fa22019-02-08 14:08:07 -0800978 spent.count(), mTeePatches.size());
Kevin Rocard153f92d2018-12-18 18:33:28 -0800979}
980
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700981// ExtendedAudioBufferProvider interface
982
Andy Hung27876c02014-09-09 18:07:55 -0700983// framesReady() may return an approximation of the number of frames if called
984// from a different thread than the one calling Proxy->obtainBuffer() and
985// Proxy->releaseBuffer(). Also note there is no mutual exclusion in the
986// AudioTrackServerProxy so be especially careful calling with FastTracks.
Eric Laurent81784c32012-11-19 14:55:58 -0800987size_t AudioFlinger::PlaybackThread::Track::framesReady() const {
Andy Hung27876c02014-09-09 18:07:55 -0700988 if (mSharedBuffer != 0 && (isStopped() || isStopping())) {
989 // Static tracks return zero frames immediately upon stopping (for FastTracks).
990 // The remainder of the buffer is not drained.
991 return 0;
992 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800993 return mAudioTrackServerProxy->framesReady();
Eric Laurent81784c32012-11-19 14:55:58 -0800994}
995
Andy Hung818e7a32016-02-16 18:08:07 -0800996int64_t AudioFlinger::PlaybackThread::Track::framesReleased() const
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700997{
998 return mAudioTrackServerProxy->framesReleased();
999}
1000
Andy Hung818e7a32016-02-16 18:08:07 -08001001void AudioFlinger::PlaybackThread::Track::onTimestamp(const ExtendedTimestamp &timestamp)
Andy Hung6ae58432016-02-16 18:32:24 -08001002{
1003 // This call comes from a FastTrack and should be kept lockless.
1004 // The server side frames are already translated to client frames.
Andy Hung818e7a32016-02-16 18:08:07 -08001005 mAudioTrackServerProxy->setTimestamp(timestamp);
Andy Hung6ae58432016-02-16 18:32:24 -08001006
Andy Hung818e7a32016-02-16 18:08:07 -08001007 // We do not set drained here, as FastTrack timestamp may not go to very last frame.
Andy Hungcef2daa2018-06-01 15:31:49 -07001008
1009 // Compute latency.
1010 // TODO: Consider whether the server latency may be passed in by FastMixer
1011 // as a constant for all active FastTracks.
1012 const double latencyMs = timestamp.getOutputServerLatencyMs(sampleRate());
1013 mServerLatencyFromTrack.store(true);
1014 mServerLatencyMs.store(latencyMs);
Andy Hung6ae58432016-02-16 18:32:24 -08001015}
1016
Eric Laurent81784c32012-11-19 14:55:58 -08001017// Don't call for fast tracks; the framesReady() could result in priority inversion
1018bool AudioFlinger::PlaybackThread::Track::isReady() const {
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001019 if (mFillingUpStatus != FS_FILLING || isStopped() || isPausing()) {
1020 return true;
1021 }
1022
Eric Laurent16498512014-03-17 17:22:08 -07001023 if (isStopping()) {
1024 if (framesReady() > 0) {
1025 mFillingUpStatus = FS_FILLED;
1026 }
Eric Laurent81784c32012-11-19 14:55:58 -08001027 return true;
1028 }
1029
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01001030 size_t bufferSizeInFrames = mServerProxy->getBufferSizeInFrames();
Andy Hung3c7f47a2021-03-16 17:30:09 -07001031 // Note: mServerProxy->getStartThresholdInFrames() is clamped.
1032 const size_t startThresholdInFrames = mServerProxy->getStartThresholdInFrames();
1033 const size_t framesToBeReady = std::clamp( // clamp again to validate client values.
1034 std::min(startThresholdInFrames, bufferSizeInFrames), size_t(1), mFrameCount);
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01001035
1036 if (framesReady() >= framesToBeReady || (mCblk->mFlags & CBLK_FORCEREADY)) {
1037 ALOGV("%s(%d): consider track ready with %zu/%zu, target was %zu)",
1038 __func__, mId, framesReady(), bufferSizeInFrames, framesToBeReady);
Eric Laurent81784c32012-11-19 14:55:58 -08001039 mFillingUpStatus = FS_FILLED;
Glenn Kasten96f60d82013-07-12 10:21:18 -07001040 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08001041 return true;
1042 }
1043 return false;
1044}
1045
Glenn Kasten0f11b512014-01-31 16:18:54 -08001046status_t AudioFlinger::PlaybackThread::Track::start(AudioSystem::sync_event_t event __unused,
Glenn Kastend848eb42016-03-08 13:42:11 -08001047 audio_session_t triggerSession __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08001048{
1049 status_t status = NO_ERROR;
Andy Hungc0691382018-09-12 18:01:57 -07001050 ALOGV("%s(%d): calling pid %d session %d",
1051 __func__, mId, IPCThreadState::self()->getCallingPid(), mSessionId);
Eric Laurent81784c32012-11-19 14:55:58 -08001052
1053 sp<ThreadBase> thread = mThread.promote();
1054 if (thread != 0) {
Eric Laurent813e2a72013-08-31 12:59:48 -07001055 if (isOffloaded()) {
1056 Mutex::Autolock _laf(thread->mAudioFlinger->mLock);
1057 Mutex::Autolock _lth(thread->mLock);
1058 sp<EffectChain> ec = thread->getEffectChain_l(mSessionId);
Eric Laurent5baf2af2013-09-12 17:37:00 -07001059 if (thread->mAudioFlinger->isNonOffloadableGlobalEffectEnabled_l() ||
1060 (ec != 0 && ec->isNonOffloadableEnabled())) {
Eric Laurent813e2a72013-08-31 12:59:48 -07001061 invalidate();
1062 return PERMISSION_DENIED;
1063 }
1064 }
1065 Mutex::Autolock _lth(thread->mLock);
Eric Laurent81784c32012-11-19 14:55:58 -08001066 track_state state = mState;
1067 // here the track could be either new, or restarted
1068 // in both cases "unstop" the track
Eric Laurentbfb1b832013-01-07 09:53:42 -08001069
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001070 // initial state-stopping. next state-pausing.
1071 // What if resume is called ?
1072
Zhou Song1ed46a22020-08-17 15:36:56 +08001073 if (state == FLUSHED) {
1074 // avoid underrun glitches when starting after flush
1075 reset();
1076 }
1077
kuowei.li576f1362021-05-11 18:02:32 +08001078 // clear mPauseHwPending because of pause (and possibly flush) during underrun.
1079 mPauseHwPending = false;
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001080 if (state == PAUSED || state == PAUSING) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08001081 if (mResumeToStopping) {
1082 // happened we need to resume to STOPPING_1
1083 mState = TrackBase::STOPPING_1;
Andy Hungc0691382018-09-12 18:01:57 -07001084 ALOGV("%s(%d): PAUSED => STOPPING_1 on thread %d",
1085 __func__, mId, (int)mThreadIoHandle);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001086 } else {
1087 mState = TrackBase::RESUMING;
Andy Hungc0691382018-09-12 18:01:57 -07001088 ALOGV("%s(%d): PAUSED => RESUMING on thread %d",
1089 __func__, mId, (int)mThreadIoHandle);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001090 }
Eric Laurent81784c32012-11-19 14:55:58 -08001091 } else {
1092 mState = TrackBase::ACTIVE;
Andy Hungc0691382018-09-12 18:01:57 -07001093 ALOGV("%s(%d): ? => ACTIVE on thread %d",
1094 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -08001095 }
1096
Andy Hunge10393e2015-06-12 13:59:33 -07001097 // states to reset position info for non-offloaded/direct tracks
1098 if (!isOffloaded() && !isDirect()
1099 && (state == IDLE || state == STOPPED || state == FLUSHED)) {
1100 mFrameMap.reset();
1101 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001102 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Haynes Mathew George240934b2015-03-11 18:25:50 -07001103 if (isFastTrack()) {
1104 // refresh fast track underruns on start because that field is never cleared
1105 // by the fast mixer; furthermore, the same track can be recycled, i.e. start
1106 // after stop.
1107 mObservedUnderruns = playbackThread->getFastTrackUnderruns(mFastIndex);
1108 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001109 status = playbackThread->addTrack_l(this);
1110 if (status == INVALID_OPERATION || status == PERMISSION_DENIED) {
Eric Laurent81784c32012-11-19 14:55:58 -08001111 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001112 // restore previous state if start was rejected by policy manager
1113 if (status == PERMISSION_DENIED) {
1114 mState = state;
1115 }
1116 }
Andy Hung1d3556d2018-03-29 16:30:14 -07001117
Andy Hungb68f5eb2019-12-03 16:49:17 -08001118 // Audio timing metrics are computed a few mix cycles after starting.
1119 {
1120 mLogStartCountdown = LOG_START_COUNTDOWN;
1121 mLogStartTimeNs = systemTime();
1122 mLogStartFrames = mAudioTrackServerProxy->getTimestamp()
Andy Hung62921122020-05-18 10:47:31 -07001123 .mPosition[ExtendedTimestamp::LOCATION_KERNEL];
1124 mLogLatencyMs = 0.;
Andy Hungb68f5eb2019-12-03 16:49:17 -08001125 }
Andy Hunga81a4b42022-05-19 19:24:51 -07001126 mLogForceVolumeUpdate = true; // at least one volume logged for metrics when starting.
Andy Hungb68f5eb2019-12-03 16:49:17 -08001127
Andy Hung1d3556d2018-03-29 16:30:14 -07001128 if (status == NO_ERROR || status == ALREADY_EXISTS) {
1129 // for streaming tracks, remove the buffer read stop limit.
1130 mAudioTrackServerProxy->start();
1131 }
1132
Eric Laurentbfb1b832013-01-07 09:53:42 -08001133 // track was already in the active list, not a problem
1134 if (status == ALREADY_EXISTS) {
1135 status = NO_ERROR;
Glenn Kasten12022ff2013-10-17 11:32:39 -07001136 } else {
1137 // Acknowledge any pending flush(), so that subsequent new data isn't discarded.
1138 // It is usually unsafe to access the server proxy from a binder thread.
1139 // But in this case we know the mixer thread (whether normal mixer or fast mixer)
1140 // isn't looking at this track yet: we still hold the normal mixer thread lock,
1141 // and for fast tracks the track is not yet in the fast mixer thread's active set.
Andy Hunge6fb82a2015-09-09 14:39:02 -07001142 // For static tracks, this is used to acknowledge change in position or loop.
Eric Laurent564d1442015-09-09 12:26:52 -07001143 ServerProxy::Buffer buffer;
1144 buffer.mFrameCount = 1;
1145 (void) mAudioTrackServerProxy->obtainBuffer(&buffer, true /*ackFlush*/);
Eric Laurent81784c32012-11-19 14:55:58 -08001146 }
1147 } else {
1148 status = BAD_VALUE;
1149 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001150 if (status == NO_ERROR) {
1151 forEachTeePatchTrack([](auto patchTrack) { patchTrack->start(); });
1152 }
Eric Laurent81784c32012-11-19 14:55:58 -08001153 return status;
1154}
1155
1156void AudioFlinger::PlaybackThread::Track::stop()
1157{
Andy Hungc0691382018-09-12 18:01:57 -07001158 ALOGV("%s(%d): calling pid %d", __func__, mId, IPCThreadState::self()->getCallingPid());
Eric Laurent81784c32012-11-19 14:55:58 -08001159 sp<ThreadBase> thread = mThread.promote();
1160 if (thread != 0) {
1161 Mutex::Autolock _l(thread->mLock);
1162 track_state state = mState;
1163 if (state == RESUMING || state == ACTIVE || state == PAUSING || state == PAUSED) {
1164 // If the track is not active (PAUSED and buffers full), flush buffers
1165 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1166 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
1167 reset();
1168 mState = STOPPED;
Eric Laurentab5cdba2014-06-09 17:22:27 -07001169 } else if (!isFastTrack() && !isOffloaded() && !isDirect()) {
Eric Laurent81784c32012-11-19 14:55:58 -08001170 mState = STOPPED;
1171 } else {
Eric Laurentbfb1b832013-01-07 09:53:42 -08001172 // For fast tracks prepareTracks_l() will set state to STOPPING_2
1173 // presentation is complete
1174 // For an offloaded track this starts a drain and state will
1175 // move to STOPPING_2 when drain completes and then STOPPED
Eric Laurent81784c32012-11-19 14:55:58 -08001176 mState = STOPPING_1;
Eric Laurente93cc032016-05-05 10:15:10 -07001177 if (isOffloaded()) {
1178 mRetryCount = PlaybackThread::kMaxTrackStopRetriesOffload;
1179 }
Eric Laurent81784c32012-11-19 14:55:58 -08001180 }
Eric Laurentb369caf2015-03-30 20:51:47 -07001181 playbackThread->broadcast_l();
Andy Hungc0691382018-09-12 18:01:57 -07001182 ALOGV("%s(%d): not stopping/stopped => stopping/stopped on thread %d",
1183 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -08001184 }
Eric Laurent81784c32012-11-19 14:55:58 -08001185 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001186 forEachTeePatchTrack([](auto patchTrack) { patchTrack->stop(); });
Eric Laurent81784c32012-11-19 14:55:58 -08001187}
1188
1189void AudioFlinger::PlaybackThread::Track::pause()
1190{
Andy Hungc0691382018-09-12 18:01:57 -07001191 ALOGV("%s(%d): calling pid %d", __func__, mId, IPCThreadState::self()->getCallingPid());
Eric Laurent81784c32012-11-19 14:55:58 -08001192 sp<ThreadBase> thread = mThread.promote();
1193 if (thread != 0) {
1194 Mutex::Autolock _l(thread->mLock);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001195 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1196 switch (mState) {
1197 case STOPPING_1:
1198 case STOPPING_2:
1199 if (!isOffloaded()) {
1200 /* nothing to do if track is not offloaded */
1201 break;
1202 }
1203
1204 // Offloaded track was draining, we need to carry on draining when resumed
1205 mResumeToStopping = true;
Chih-Hung Hsieh2b487032018-09-13 14:16:02 -07001206 FALLTHROUGH_INTENDED;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001207 case ACTIVE:
1208 case RESUMING:
Eric Laurent81784c32012-11-19 14:55:58 -08001209 mState = PAUSING;
Andy Hungc0691382018-09-12 18:01:57 -07001210 ALOGV("%s(%d): ACTIVE/RESUMING => PAUSING on thread %d",
1211 __func__, mId, (int)mThreadIoHandle);
Kuowei Li23666472021-01-20 10:23:25 +08001212 if (isOffloadedOrDirect()) {
1213 mPauseHwPending = true;
1214 }
Eric Laurentede6c3b2013-09-19 14:37:46 -07001215 playbackThread->broadcast_l();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001216 break;
Eric Laurent81784c32012-11-19 14:55:58 -08001217
Eric Laurentbfb1b832013-01-07 09:53:42 -08001218 default:
1219 break;
Eric Laurent81784c32012-11-19 14:55:58 -08001220 }
1221 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001222 // Pausing the TeePatch to avoid a glitch on underrun, at the cost of buffered audio loss.
1223 forEachTeePatchTrack([](auto patchTrack) { patchTrack->pause(); });
Eric Laurent81784c32012-11-19 14:55:58 -08001224}
1225
1226void AudioFlinger::PlaybackThread::Track::flush()
1227{
Andy Hungc0691382018-09-12 18:01:57 -07001228 ALOGV("%s(%d)", __func__, mId);
Eric Laurent81784c32012-11-19 14:55:58 -08001229 sp<ThreadBase> thread = mThread.promote();
1230 if (thread != 0) {
1231 Mutex::Autolock _l(thread->mLock);
Eric Laurent81784c32012-11-19 14:55:58 -08001232 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001233
Phil Burk4bb650b2016-09-09 12:11:17 -07001234 // Flush the ring buffer now if the track is not active in the PlaybackThread.
1235 // Otherwise the flush would not be done until the track is resumed.
1236 // Requires FastTrack removal be BLOCK_UNTIL_ACKED
1237 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
1238 (void)mServerProxy->flushBufferIfNeeded();
1239 }
1240
Eric Laurentbfb1b832013-01-07 09:53:42 -08001241 if (isOffloaded()) {
1242 // If offloaded we allow flush during any state except terminated
1243 // and keep the track active to avoid problems if user is seeking
1244 // rapidly and underlying hardware has a significant delay handling
1245 // a pause
1246 if (isTerminated()) {
1247 return;
1248 }
1249
Andy Hung9d84af52018-09-12 18:03:44 -07001250 ALOGV("%s(%d): offload flush", __func__, mId);
Eric Laurent81784c32012-11-19 14:55:58 -08001251 reset();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001252
1253 if (mState == STOPPING_1 || mState == STOPPING_2) {
Andy Hung9d84af52018-09-12 18:03:44 -07001254 ALOGV("%s(%d): flushed in STOPPING_1 or 2 state, change state to ACTIVE",
1255 __func__, mId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001256 mState = ACTIVE;
1257 }
1258
Haynes Mathew George7844f672014-01-15 12:32:55 -08001259 mFlushHwPending = true;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001260 mResumeToStopping = false;
1261 } else {
1262 if (mState != STOPPING_1 && mState != STOPPING_2 && mState != STOPPED &&
1263 mState != PAUSED && mState != PAUSING && mState != IDLE && mState != FLUSHED) {
1264 return;
1265 }
1266 // No point remaining in PAUSED state after a flush => go to
1267 // FLUSHED state
1268 mState = FLUSHED;
1269 // do not reset the track if it is still in the process of being stopped or paused.
1270 // this will be done by prepareTracks_l() when the track is stopped.
1271 // prepareTracks_l() will see mState == FLUSHED, then
1272 // remove from active track list, reset(), and trigger presentation complete
Eric Laurentd1f69b02014-12-15 14:33:13 -08001273 if (isDirect()) {
1274 mFlushHwPending = true;
1275 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001276 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
1277 reset();
1278 }
Eric Laurent81784c32012-11-19 14:55:58 -08001279 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001280 // Prevent flush being lost if the track is flushed and then resumed
1281 // before mixer thread can run. This is important when offloading
1282 // because the hardware buffer could hold a large amount of audio
Eric Laurentede6c3b2013-09-19 14:37:46 -07001283 playbackThread->broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001284 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001285 // Flush the Tee to avoid on resume playing old data and glitching on the transition to new data
1286 forEachTeePatchTrack([](auto patchTrack) { patchTrack->flush(); });
Eric Laurent81784c32012-11-19 14:55:58 -08001287}
1288
Haynes Mathew George7844f672014-01-15 12:32:55 -08001289// must be called with thread lock held
1290void AudioFlinger::PlaybackThread::Track::flushAck()
1291{
Eric Laurentd1f69b02014-12-15 14:33:13 -08001292 if (!isOffloaded() && !isDirect())
Haynes Mathew George7844f672014-01-15 12:32:55 -08001293 return;
1294
Phil Burk4bb650b2016-09-09 12:11:17 -07001295 // Clear the client ring buffer so that the app can prime the buffer while paused.
1296 // Otherwise it might not get cleared until playback is resumed and obtainBuffer() is called.
1297 mServerProxy->flushBufferIfNeeded();
1298
Haynes Mathew George7844f672014-01-15 12:32:55 -08001299 mFlushHwPending = false;
1300}
1301
Kuowei Li23666472021-01-20 10:23:25 +08001302void AudioFlinger::PlaybackThread::Track::pauseAck()
1303{
1304 mPauseHwPending = false;
1305}
1306
Eric Laurent81784c32012-11-19 14:55:58 -08001307void AudioFlinger::PlaybackThread::Track::reset()
1308{
1309 // Do not reset twice to avoid discarding data written just after a flush and before
1310 // the audioflinger thread detects the track is stopped.
1311 if (!mResetDone) {
Eric Laurent81784c32012-11-19 14:55:58 -08001312 // Force underrun condition to avoid false underrun callback until first data is
1313 // written to buffer
Glenn Kasten96f60d82013-07-12 10:21:18 -07001314 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08001315 mFillingUpStatus = FS_FILLING;
1316 mResetDone = true;
1317 if (mState == FLUSHED) {
1318 mState = IDLE;
1319 }
1320 }
1321}
1322
Eric Laurentbfb1b832013-01-07 09:53:42 -08001323status_t AudioFlinger::PlaybackThread::Track::setParameters(const String8& keyValuePairs)
1324{
1325 sp<ThreadBase> thread = mThread.promote();
1326 if (thread == 0) {
Andy Hung9d84af52018-09-12 18:03:44 -07001327 ALOGE("%s(%d): thread is dead", __func__, mId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001328 return FAILED_TRANSACTION;
1329 } else if ((thread->type() == ThreadBase::DIRECT) ||
1330 (thread->type() == ThreadBase::OFFLOAD)) {
1331 return thread->setParameters(keyValuePairs);
1332 } else {
1333 return PERMISSION_DENIED;
1334 }
1335}
1336
Mikhail Naganovac917ac2018-11-28 14:03:52 -08001337status_t AudioFlinger::PlaybackThread::Track::selectPresentation(int presentationId,
1338 int programId) {
1339 sp<ThreadBase> thread = mThread.promote();
1340 if (thread == 0) {
1341 ALOGE("thread is dead");
1342 return FAILED_TRANSACTION;
1343 } else if ((thread->type() == ThreadBase::DIRECT) || (thread->type() == ThreadBase::OFFLOAD)) {
1344 DirectOutputThread *directOutputThread = static_cast<DirectOutputThread*>(thread.get());
1345 return directOutputThread->selectPresentation(presentationId, programId);
1346 }
1347 return INVALID_OPERATION;
1348}
1349
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001350VolumeShaper::Status AudioFlinger::PlaybackThread::Track::applyVolumeShaper(
1351 const sp<VolumeShaper::Configuration>& configuration,
1352 const sp<VolumeShaper::Operation>& operation)
1353{
Andy Hung10cbff12017-02-21 17:30:14 -08001354 sp<VolumeShaper::Configuration> newConfiguration;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001355
Andy Hung10cbff12017-02-21 17:30:14 -08001356 if (isOffloadedOrDirect()) {
1357 const VolumeShaper::Configuration::OptionFlag optionFlag
1358 = configuration->getOptionFlags();
1359 if ((optionFlag & VolumeShaper::Configuration::OPTION_FLAG_CLOCK_TIME) == 0) {
Andy Hung9d84af52018-09-12 18:03:44 -07001360 ALOGW("%s(%d): %s tracks do not support frame counted VolumeShaper,"
1361 " using clock time instead",
1362 __func__, mId,
1363 isOffloaded() ? "Offload" : "Direct");
Andy Hung10cbff12017-02-21 17:30:14 -08001364 newConfiguration = new VolumeShaper::Configuration(*configuration);
1365 newConfiguration->setOptionFlags(
1366 VolumeShaper::Configuration::OptionFlag(optionFlag
1367 | VolumeShaper::Configuration::OPTION_FLAG_CLOCK_TIME));
1368 }
1369 }
1370
1371 VolumeShaper::Status status = mVolumeHandler->applyVolumeShaper(
1372 (newConfiguration.get() != nullptr ? newConfiguration : configuration), operation);
1373
1374 if (isOffloadedOrDirect()) {
1375 // Signal thread to fetch new volume.
1376 sp<ThreadBase> thread = mThread.promote();
1377 if (thread != 0) {
Kevin Rocard5f2136e2018-05-11 22:03:00 -07001378 Mutex::Autolock _l(thread->mLock);
Andy Hung10cbff12017-02-21 17:30:14 -08001379 thread->broadcast_l();
1380 }
1381 }
1382 return status;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001383}
1384
1385sp<VolumeShaper::State> AudioFlinger::PlaybackThread::Track::getVolumeShaperState(int id)
1386{
1387 // Note: We don't check if Thread exists.
1388
1389 // mVolumeHandler is thread safe.
1390 return mVolumeHandler->getVolumeShaperState(id);
1391}
1392
Kevin Rocard12381092018-04-11 09:19:59 -07001393void AudioFlinger::PlaybackThread::Track::setFinalVolume(float volume)
1394{
1395 if (mFinalVolume != volume) { // Compare to an epsilon if too many meaningless updates
1396 mFinalVolume = volume;
1397 setMetadataHasChanged();
Andy Hunga81a4b42022-05-19 19:24:51 -07001398 mLogForceVolumeUpdate = true;
1399 }
1400 if (mLogForceVolumeUpdate) {
1401 mLogForceVolumeUpdate = false;
1402 mTrackMetrics.logVolume(mFinalVolume);
Kevin Rocard12381092018-04-11 09:19:59 -07001403 }
1404}
1405
1406void AudioFlinger::PlaybackThread::Track::copyMetadataTo(MetadataInserter& backInserter) const
1407{
Eric Laurent94579172020-11-20 18:41:04 +01001408 playback_track_metadata_v7_t metadata;
1409 metadata.base = {
Kevin Rocard12381092018-04-11 09:19:59 -07001410 .usage = mAttr.usage,
1411 .content_type = mAttr.content_type,
1412 .gain = mFinalVolume,
1413 };
Eric Laurentfdf99502021-11-26 19:05:02 +01001414
1415 // When attributes are undefined, derive default values from stream type.
1416 // See AudioAttributes.java, usageForStreamType() and Builder.setInternalLegacyStreamType()
1417 if (mAttr.usage == AUDIO_USAGE_UNKNOWN) {
1418 switch (mStreamType) {
1419 case AUDIO_STREAM_VOICE_CALL:
1420 metadata.base.usage = AUDIO_USAGE_VOICE_COMMUNICATION;
1421 metadata.base.content_type = AUDIO_CONTENT_TYPE_SPEECH;
1422 break;
1423 case AUDIO_STREAM_SYSTEM:
1424 metadata.base.usage = AUDIO_USAGE_ASSISTANCE_SONIFICATION;
1425 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1426 break;
1427 case AUDIO_STREAM_RING:
1428 metadata.base.usage = AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE;
1429 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1430 break;
1431 case AUDIO_STREAM_MUSIC:
1432 metadata.base.usage = AUDIO_USAGE_MEDIA;
1433 metadata.base.content_type = AUDIO_CONTENT_TYPE_MUSIC;
1434 break;
1435 case AUDIO_STREAM_ALARM:
1436 metadata.base.usage = AUDIO_USAGE_ALARM;
1437 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1438 break;
1439 case AUDIO_STREAM_NOTIFICATION:
1440 metadata.base.usage = AUDIO_USAGE_NOTIFICATION;
1441 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1442 break;
1443 case AUDIO_STREAM_DTMF:
1444 metadata.base.usage = AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING;
1445 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1446 break;
1447 case AUDIO_STREAM_ACCESSIBILITY:
1448 metadata.base.usage = AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY;
1449 metadata.base.content_type = AUDIO_CONTENT_TYPE_SPEECH;
1450 break;
1451 case AUDIO_STREAM_ASSISTANT:
1452 metadata.base.usage = AUDIO_USAGE_ASSISTANT;
1453 metadata.base.content_type = AUDIO_CONTENT_TYPE_SPEECH;
1454 break;
1455 case AUDIO_STREAM_REROUTING:
1456 metadata.base.usage = AUDIO_USAGE_VIRTUAL_SOURCE;
1457 // unknown content type
1458 break;
1459 case AUDIO_STREAM_CALL_ASSISTANT:
1460 metadata.base.usage = AUDIO_USAGE_CALL_ASSISTANT;
1461 metadata.base.content_type = AUDIO_CONTENT_TYPE_SPEECH;
1462 break;
1463 default:
1464 break;
1465 }
1466 }
1467
Eric Laurent94579172020-11-20 18:41:04 +01001468 metadata.channel_mask = mChannelMask,
1469 strncpy(metadata.tags, mAttr.tags, AUDIO_ATTRIBUTES_TAGS_MAX_SIZE);
1470 *backInserter++ = metadata;
Kevin Rocard12381092018-04-11 09:19:59 -07001471}
1472
Kevin Rocard153f92d2018-12-18 18:33:28 -08001473void AudioFlinger::PlaybackThread::Track::setTeePatches(TeePatches teePatches) {
Kevin Rocardc43ea142019-01-31 18:17:37 -08001474 forEachTeePatchTrack([](auto patchTrack) { patchTrack->destroy(); });
Kevin Rocard153f92d2018-12-18 18:33:28 -08001475 mTeePatches = std::move(teePatches);
jiabinf042b9b2021-05-07 23:46:28 +00001476 if (mState == TrackBase::ACTIVE || mState == TrackBase::RESUMING ||
1477 mState == TrackBase::STOPPING_1) {
1478 forEachTeePatchTrack([](auto patchTrack) { patchTrack->start(); });
1479 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08001480}
1481
Glenn Kasten573d80a2013-08-26 09:36:23 -07001482status_t AudioFlinger::PlaybackThread::Track::getTimestamp(AudioTimestamp& timestamp)
1483{
Andy Hung818e7a32016-02-16 18:08:07 -08001484 if (!isOffloaded() && !isDirect()) {
1485 return INVALID_OPERATION; // normal tracks handled through SSQ
Glenn Kastenfe346c72013-08-30 13:28:22 -07001486 }
Glenn Kasten573d80a2013-08-26 09:36:23 -07001487 sp<ThreadBase> thread = mThread.promote();
1488 if (thread == 0) {
Glenn Kastenfe346c72013-08-30 13:28:22 -07001489 return INVALID_OPERATION;
Glenn Kasten573d80a2013-08-26 09:36:23 -07001490 }
Phil Burk6140c792015-03-19 14:30:21 -07001491
Glenn Kasten573d80a2013-08-26 09:36:23 -07001492 Mutex::Autolock _l(thread->mLock);
1493 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Andy Hung818e7a32016-02-16 18:08:07 -08001494 return playbackThread->getTimestamp_l(timestamp);
Glenn Kasten573d80a2013-08-26 09:36:23 -07001495}
1496
Eric Laurent81784c32012-11-19 14:55:58 -08001497status_t AudioFlinger::PlaybackThread::Track::attachAuxEffect(int EffectId)
1498{
Eric Laurent81784c32012-11-19 14:55:58 -08001499 sp<ThreadBase> thread = mThread.promote();
Eric Laurent6c796322019-04-09 14:13:17 -07001500 if (thread == nullptr) {
1501 return DEAD_OBJECT;
1502 }
Eric Laurent81784c32012-11-19 14:55:58 -08001503
Eric Laurent6c796322019-04-09 14:13:17 -07001504 sp<PlaybackThread> dstThread = (PlaybackThread *)thread.get();
1505 sp<PlaybackThread> srcThread; // srcThread is initialized by call to moveAuxEffectToIo()
1506 sp<AudioFlinger> af = mClient->audioFlinger();
1507 status_t status = af->moveAuxEffectToIo(EffectId, dstThread, &srcThread);
Eric Laurent81784c32012-11-19 14:55:58 -08001508
Eric Laurent6c796322019-04-09 14:13:17 -07001509 if (EffectId != 0 && status == NO_ERROR) {
1510 status = dstThread->attachAuxEffect(this, EffectId);
1511 if (status == NO_ERROR) {
1512 AudioSystem::moveEffectsToIo(std::vector<int>(EffectId), dstThread->id());
Eric Laurent81784c32012-11-19 14:55:58 -08001513 }
Eric Laurent6c796322019-04-09 14:13:17 -07001514 }
1515
1516 if (status != NO_ERROR && srcThread != nullptr) {
1517 af->moveAuxEffectToIo(EffectId, srcThread, &dstThread);
Eric Laurent81784c32012-11-19 14:55:58 -08001518 }
1519 return status;
1520}
1521
1522void AudioFlinger::PlaybackThread::Track::setAuxBuffer(int EffectId, int32_t *buffer)
1523{
1524 mAuxEffectId = EffectId;
1525 mAuxBuffer = buffer;
1526}
1527
Andy Hung59de4262021-06-14 10:53:54 -07001528// presentationComplete verified by frames, used by Mixed tracks.
Andy Hung818e7a32016-02-16 18:08:07 -08001529bool AudioFlinger::PlaybackThread::Track::presentationComplete(
1530 int64_t framesWritten, size_t audioHalFrames)
Eric Laurent81784c32012-11-19 14:55:58 -08001531{
Andy Hung818e7a32016-02-16 18:08:07 -08001532 // TODO: improve this based on FrameMap if it exists, to ensure full drain.
1533 // This assists in proper timestamp computation as well as wakelock management.
1534
Eric Laurent81784c32012-11-19 14:55:58 -08001535 // a track is considered presented when the total number of frames written to audio HAL
1536 // corresponds to the number of frames written when presentationComplete() is called for the
1537 // first time (mPresentationCompleteFrames == 0) plus the buffer filling status at that time.
Eric Laurentbfb1b832013-01-07 09:53:42 -08001538 // For an offloaded track the HAL+h/w delay is variable so a HAL drain() is used
1539 // to detect when all frames have been played. In this case framesWritten isn't
1540 // useful because it doesn't always reflect whether there is data in the h/w
1541 // buffers, particularly if a track has been paused and resumed during draining
Andy Hung9d84af52018-09-12 18:03:44 -07001542 ALOGV("%s(%d): presentationComplete() mPresentationCompleteFrames %lld framesWritten %lld",
1543 __func__, mId,
Andy Hung818e7a32016-02-16 18:08:07 -08001544 (long long)mPresentationCompleteFrames, (long long)framesWritten);
Eric Laurent81784c32012-11-19 14:55:58 -08001545 if (mPresentationCompleteFrames == 0) {
1546 mPresentationCompleteFrames = framesWritten + audioHalFrames;
Andy Hung59de4262021-06-14 10:53:54 -07001547 ALOGV("%s(%d): set:"
Andy Hung9d84af52018-09-12 18:03:44 -07001548 " mPresentationCompleteFrames %lld audioHalFrames %zu",
1549 __func__, mId,
Andy Hung818e7a32016-02-16 18:08:07 -08001550 (long long)mPresentationCompleteFrames, audioHalFrames);
Eric Laurent81784c32012-11-19 14:55:58 -08001551 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001552
Andy Hungc54b1ff2016-02-23 14:07:07 -08001553 bool complete;
Andy Hung59de4262021-06-14 10:53:54 -07001554 if (isFastTrack()) { // does not go through linear map
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001555 complete = framesWritten >= (int64_t) mPresentationCompleteFrames;
Andy Hung59de4262021-06-14 10:53:54 -07001556 ALOGV("%s(%d): %s framesWritten:%lld mPresentationCompleteFrames:%lld",
1557 __func__, mId, (complete ? "complete" : "waiting"),
1558 (long long) framesWritten, (long long) mPresentationCompleteFrames);
Andy Hungc54b1ff2016-02-23 14:07:07 -08001559 } else { // Normal tracks, OutputTracks, and PatchTracks
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001560 complete = framesWritten >= (int64_t) mPresentationCompleteFrames
Andy Hungc54b1ff2016-02-23 14:07:07 -08001561 && mAudioTrackServerProxy->isDrained();
1562 }
1563
1564 if (complete) {
Andy Hung59de4262021-06-14 10:53:54 -07001565 notifyPresentationComplete();
Eric Laurent81784c32012-11-19 14:55:58 -08001566 return true;
1567 }
1568 return false;
1569}
1570
Andy Hung59de4262021-06-14 10:53:54 -07001571// presentationComplete checked by time, used by DirectTracks.
1572bool AudioFlinger::PlaybackThread::Track::presentationComplete(uint32_t latencyMs)
1573{
1574 // For Offloaded or Direct tracks.
1575
1576 // For a direct track, we incorporated time based testing for presentationComplete.
1577
1578 // For an offloaded track the HAL+h/w delay is variable so a HAL drain() is used
1579 // to detect when all frames have been played. In this case latencyMs isn't
1580 // useful because it doesn't always reflect whether there is data in the h/w
1581 // buffers, particularly if a track has been paused and resumed during draining
1582
1583 constexpr float MIN_SPEED = 0.125f; // min speed scaling allowed for timely response.
1584 if (mPresentationCompleteTimeNs == 0) {
1585 mPresentationCompleteTimeNs = systemTime() + latencyMs * 1e6 / fmax(mSpeed, MIN_SPEED);
1586 ALOGV("%s(%d): set: latencyMs %u mPresentationCompleteTimeNs:%lld",
1587 __func__, mId, latencyMs, (long long) mPresentationCompleteTimeNs);
1588 }
1589
1590 bool complete;
1591 if (isOffloaded()) {
1592 complete = true;
1593 } else { // Direct
1594 complete = systemTime() >= mPresentationCompleteTimeNs;
1595 ALOGV("%s(%d): %s", __func__, mId, (complete ? "complete" : "waiting"));
1596 }
1597 if (complete) {
1598 notifyPresentationComplete();
1599 return true;
1600 }
1601 return false;
1602}
1603
1604void AudioFlinger::PlaybackThread::Track::notifyPresentationComplete()
1605{
1606 // This only triggers once. TODO: should we enforce this?
1607 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
1608 mAudioTrackServerProxy->setStreamEndDone();
1609}
1610
Eric Laurent81784c32012-11-19 14:55:58 -08001611void AudioFlinger::PlaybackThread::Track::triggerEvents(AudioSystem::sync_event_t type)
1612{
Ivan Lozano5ec161b2017-12-06 10:00:28 -08001613 for (size_t i = 0; i < mSyncEvents.size();) {
Eric Laurent81784c32012-11-19 14:55:58 -08001614 if (mSyncEvents[i]->type() == type) {
1615 mSyncEvents[i]->trigger();
1616 mSyncEvents.removeAt(i);
Ivan Lozano5ec161b2017-12-06 10:00:28 -08001617 } else {
1618 ++i;
Eric Laurent81784c32012-11-19 14:55:58 -08001619 }
1620 }
1621}
1622
1623// implement VolumeBufferProvider interface
1624
Glenn Kastenc56f3422014-03-21 17:53:17 -07001625gain_minifloat_packed_t AudioFlinger::PlaybackThread::Track::getVolumeLR()
Eric Laurent81784c32012-11-19 14:55:58 -08001626{
1627 // called by FastMixer, so not allowed to take any locks, block, or do I/O including logs
1628 ALOG_ASSERT(isFastTrack() && (mCblk != NULL));
Glenn Kastenc56f3422014-03-21 17:53:17 -07001629 gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR();
1630 float vl = float_from_gain(gain_minifloat_unpack_left(vlr));
1631 float vr = float_from_gain(gain_minifloat_unpack_right(vlr));
Eric Laurent81784c32012-11-19 14:55:58 -08001632 // track volumes come from shared memory, so can't be trusted and must be clamped
Glenn Kastenc56f3422014-03-21 17:53:17 -07001633 if (vl > GAIN_FLOAT_UNITY) {
1634 vl = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08001635 }
Glenn Kastenc56f3422014-03-21 17:53:17 -07001636 if (vr > GAIN_FLOAT_UNITY) {
1637 vr = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08001638 }
1639 // now apply the cached master volume and stream type volume;
1640 // this is trusted but lacks any synchronization or barrier so may be stale
1641 float v = mCachedVolume;
1642 vl *= v;
1643 vr *= v;
Glenn Kastenc56f3422014-03-21 17:53:17 -07001644 // re-combine into packed minifloat
1645 vlr = gain_minifloat_pack(gain_from_float(vl), gain_from_float(vr));
Eric Laurent81784c32012-11-19 14:55:58 -08001646 // FIXME look at mute, pause, and stop flags
1647 return vlr;
1648}
1649
1650status_t AudioFlinger::PlaybackThread::Track::setSyncEvent(const sp<SyncEvent>& event)
1651{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001652 if (isTerminated() || mState == PAUSED ||
Eric Laurent81784c32012-11-19 14:55:58 -08001653 ((framesReady() == 0) && ((mSharedBuffer != 0) ||
1654 (mState == STOPPED)))) {
Andy Hung9d84af52018-09-12 18:03:44 -07001655 ALOGW("%s(%d): in invalid state %d on session %d %s mode, framesReady %zu",
1656 __func__, mId,
Andy Hung959b5b82021-09-24 10:46:20 -07001657 (int)mState, mSessionId, (mSharedBuffer != 0) ? "static" : "stream", framesReady());
Eric Laurent81784c32012-11-19 14:55:58 -08001658 event->cancel();
1659 return INVALID_OPERATION;
1660 }
1661 (void) TrackBase::setSyncEvent(event);
1662 return NO_ERROR;
1663}
1664
Glenn Kasten5736c352012-12-04 12:12:34 -08001665void AudioFlinger::PlaybackThread::Track::invalidate()
1666{
Eric Laurent6acd1d42017-01-04 14:23:29 -08001667 TrackBase::invalidate();
Eric Laurent4d231dc2016-03-11 18:38:23 -08001668 signalClientFlag(CBLK_INVALID);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001669}
1670
1671void AudioFlinger::PlaybackThread::Track::disable()
1672{
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01001673 // TODO(b/142394888): the filling status should also be reset to filling
Eric Laurent4d231dc2016-03-11 18:38:23 -08001674 signalClientFlag(CBLK_DISABLED);
1675}
1676
1677void AudioFlinger::PlaybackThread::Track::signalClientFlag(int32_t flag)
1678{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001679 // FIXME should use proxy, and needs work
1680 audio_track_cblk_t* cblk = mCblk;
Eric Laurent4d231dc2016-03-11 18:38:23 -08001681 android_atomic_or(flag, &cblk->mFlags);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001682 android_atomic_release_store(0x40000000, &cblk->mFutex);
1683 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE
Elliott Hughesee499292014-05-21 17:55:51 -07001684 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX);
Glenn Kasten5736c352012-12-04 12:12:34 -08001685}
1686
Eric Laurent59fe0102013-09-27 18:48:26 -07001687void AudioFlinger::PlaybackThread::Track::signal()
1688{
1689 sp<ThreadBase> thread = mThread.promote();
1690 if (thread != 0) {
1691 PlaybackThread *t = (PlaybackThread *)thread.get();
1692 Mutex::Autolock _l(t->mLock);
1693 t->broadcast_l();
1694 }
1695}
1696
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001697status_t AudioFlinger::PlaybackThread::Track::getDualMonoMode(audio_dual_mono_mode_t* mode)
1698{
1699 status_t status = INVALID_OPERATION;
1700 if (isOffloadedOrDirect()) {
1701 sp<ThreadBase> thread = mThread.promote();
1702 if (thread != nullptr) {
1703 PlaybackThread *t = (PlaybackThread *)thread.get();
1704 Mutex::Autolock _l(t->mLock);
1705 status = t->mOutput->stream->getDualMonoMode(mode);
1706 ALOGD_IF((status == NO_ERROR) && (mDualMonoMode != *mode),
1707 "%s: mode %d inconsistent", __func__, mDualMonoMode);
1708 }
1709 }
1710 return status;
1711}
1712
1713status_t AudioFlinger::PlaybackThread::Track::setDualMonoMode(audio_dual_mono_mode_t mode)
1714{
1715 status_t status = INVALID_OPERATION;
1716 if (isOffloadedOrDirect()) {
1717 sp<ThreadBase> thread = mThread.promote();
1718 if (thread != nullptr) {
1719 auto t = static_cast<PlaybackThread *>(thread.get());
1720 Mutex::Autolock lock(t->mLock);
1721 status = t->mOutput->stream->setDualMonoMode(mode);
1722 if (status == NO_ERROR) {
1723 mDualMonoMode = mode;
1724 }
1725 }
1726 }
1727 return status;
1728}
1729
1730status_t AudioFlinger::PlaybackThread::Track::getAudioDescriptionMixLevel(float* leveldB)
1731{
1732 status_t status = INVALID_OPERATION;
1733 if (isOffloadedOrDirect()) {
1734 sp<ThreadBase> thread = mThread.promote();
1735 if (thread != nullptr) {
1736 auto t = static_cast<PlaybackThread *>(thread.get());
1737 Mutex::Autolock lock(t->mLock);
1738 status = t->mOutput->stream->getAudioDescriptionMixLevel(leveldB);
1739 ALOGD_IF((status == NO_ERROR) && (mAudioDescriptionMixLevel != *leveldB),
1740 "%s: level %.3f inconsistent", __func__, mAudioDescriptionMixLevel);
1741 }
1742 }
1743 return status;
1744}
1745
1746status_t AudioFlinger::PlaybackThread::Track::setAudioDescriptionMixLevel(float leveldB)
1747{
1748 status_t status = INVALID_OPERATION;
1749 if (isOffloadedOrDirect()) {
1750 sp<ThreadBase> thread = mThread.promote();
1751 if (thread != nullptr) {
1752 auto t = static_cast<PlaybackThread *>(thread.get());
1753 Mutex::Autolock lock(t->mLock);
1754 status = t->mOutput->stream->setAudioDescriptionMixLevel(leveldB);
1755 if (status == NO_ERROR) {
1756 mAudioDescriptionMixLevel = leveldB;
1757 }
1758 }
1759 }
1760 return status;
1761}
1762
1763status_t AudioFlinger::PlaybackThread::Track::getPlaybackRateParameters(
1764 audio_playback_rate_t* playbackRate)
1765{
1766 status_t status = INVALID_OPERATION;
1767 if (isOffloadedOrDirect()) {
1768 sp<ThreadBase> thread = mThread.promote();
1769 if (thread != nullptr) {
1770 auto t = static_cast<PlaybackThread *>(thread.get());
1771 Mutex::Autolock lock(t->mLock);
1772 status = t->mOutput->stream->getPlaybackRateParameters(playbackRate);
1773 ALOGD_IF((status == NO_ERROR) &&
1774 !isAudioPlaybackRateEqual(mPlaybackRateParameters, *playbackRate),
1775 "%s: playbackRate inconsistent", __func__);
1776 }
1777 }
1778 return status;
1779}
1780
1781status_t AudioFlinger::PlaybackThread::Track::setPlaybackRateParameters(
1782 const audio_playback_rate_t& playbackRate)
1783{
1784 status_t status = INVALID_OPERATION;
1785 if (isOffloadedOrDirect()) {
1786 sp<ThreadBase> thread = mThread.promote();
1787 if (thread != nullptr) {
1788 auto t = static_cast<PlaybackThread *>(thread.get());
1789 Mutex::Autolock lock(t->mLock);
1790 status = t->mOutput->stream->setPlaybackRateParameters(playbackRate);
1791 if (status == NO_ERROR) {
1792 mPlaybackRateParameters = playbackRate;
1793 }
1794 }
1795 }
1796 return status;
1797}
1798
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001799//To be called with thread lock held
1800bool AudioFlinger::PlaybackThread::Track::isResumePending() {
1801
1802 if (mState == RESUMING)
1803 return true;
1804 /* Resume is pending if track was stopping before pause was called */
1805 if (mState == STOPPING_1 &&
1806 mResumeToStopping)
1807 return true;
1808
1809 return false;
1810}
1811
1812//To be called with thread lock held
1813void AudioFlinger::PlaybackThread::Track::resumeAck() {
1814
1815
1816 if (mState == RESUMING)
1817 mState = ACTIVE;
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08001818
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001819 // Other possibility of pending resume is stopping_1 state
1820 // Do not update the state from stopping as this prevents
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08001821 // drain being called.
1822 if (mState == STOPPING_1) {
1823 mResumeToStopping = false;
1824 }
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001825}
Andy Hunge10393e2015-06-12 13:59:33 -07001826
1827//To be called with thread lock held
1828void AudioFlinger::PlaybackThread::Track::updateTrackFrameInfo(
Andy Hung818e7a32016-02-16 18:08:07 -08001829 int64_t trackFramesReleased, int64_t sinkFramesWritten,
Andy Hungcef2daa2018-06-01 15:31:49 -07001830 uint32_t halSampleRate, const ExtendedTimestamp &timeStamp) {
Andy Hung30282562018-08-08 18:27:03 -07001831 // Make the kernel frametime available.
1832 const FrameTime ft{
1833 timeStamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
1834 timeStamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]};
1835 // ALOGD("FrameTime: %lld %lld", (long long)ft.frames, (long long)ft.timeNs);
1836 mKernelFrameTime.store(ft);
1837 if (!audio_is_linear_pcm(mFormat)) {
1838 return;
1839 }
1840
Andy Hung818e7a32016-02-16 18:08:07 -08001841 //update frame map
Andy Hunge10393e2015-06-12 13:59:33 -07001842 mFrameMap.push(trackFramesReleased, sinkFramesWritten);
Andy Hung818e7a32016-02-16 18:08:07 -08001843
1844 // adjust server times and set drained state.
1845 //
1846 // Our timestamps are only updated when the track is on the Thread active list.
1847 // We need to ensure that tracks are not removed before full drain.
1848 ExtendedTimestamp local = timeStamp;
Andy Hungcef2daa2018-06-01 15:31:49 -07001849 bool drained = true; // default assume drained, if no server info found
Andy Hung818e7a32016-02-16 18:08:07 -08001850 bool checked = false;
1851 for (int i = ExtendedTimestamp::LOCATION_MAX - 1;
1852 i >= ExtendedTimestamp::LOCATION_SERVER; --i) {
1853 // Lookup the track frame corresponding to the sink frame position.
1854 if (local.mTimeNs[i] > 0) {
1855 local.mPosition[i] = mFrameMap.findX(local.mPosition[i]);
1856 // check drain state from the latest stage in the pipeline.
Andy Hung6d7b1192016-05-07 22:59:48 -07001857 if (!checked && i <= ExtendedTimestamp::LOCATION_KERNEL) {
Andy Hungcef2daa2018-06-01 15:31:49 -07001858 drained = local.mPosition[i] >= mAudioTrackServerProxy->framesReleased();
Andy Hung818e7a32016-02-16 18:08:07 -08001859 checked = true;
1860 }
1861 }
Andy Hunge10393e2015-06-12 13:59:33 -07001862 }
Andy Hungcef2daa2018-06-01 15:31:49 -07001863
1864 mAudioTrackServerProxy->setDrained(drained);
Andy Hungea2b9c02016-02-12 17:06:53 -08001865 // Set correction for flushed frames that are not accounted for in released.
Andy Hungea2b9c02016-02-12 17:06:53 -08001866 local.mFlushed = mAudioTrackServerProxy->framesFlushed();
Andy Hung818e7a32016-02-16 18:08:07 -08001867 mServerProxy->setTimestamp(local);
Andy Hungcef2daa2018-06-01 15:31:49 -07001868
1869 // Compute latency info.
1870 const bool useTrackTimestamp = !drained;
1871 const double latencyMs = useTrackTimestamp
1872 ? local.getOutputServerLatencyMs(sampleRate())
1873 : timeStamp.getOutputServerLatencyMs(halSampleRate);
1874
1875 mServerLatencyFromTrack.store(useTrackTimestamp);
1876 mServerLatencyMs.store(latencyMs);
Andy Hungb68f5eb2019-12-03 16:49:17 -08001877
Andy Hung62921122020-05-18 10:47:31 -07001878 if (mLogStartCountdown > 0
1879 && local.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] > 0
1880 && local.mPosition[ExtendedTimestamp::LOCATION_KERNEL] > 0)
1881 {
1882 if (mLogStartCountdown > 1) {
1883 --mLogStartCountdown;
1884 } else if (latencyMs < mLogLatencyMs) { // wait for latency to stabilize (dip)
1885 mLogStartCountdown = 0;
Andy Hungb68f5eb2019-12-03 16:49:17 -08001886 // startup is the difference in times for the current timestamp and our start
1887 double startUpMs =
Andy Hung62921122020-05-18 10:47:31 -07001888 (local.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] - mLogStartTimeNs) * 1e-6;
Andy Hungb68f5eb2019-12-03 16:49:17 -08001889 // adjust for frames played.
Andy Hung62921122020-05-18 10:47:31 -07001890 startUpMs -= (local.mPosition[ExtendedTimestamp::LOCATION_KERNEL] - mLogStartFrames)
1891 * 1e3 / mSampleRate;
1892 ALOGV("%s: latencyMs:%lf startUpMs:%lf"
1893 " localTime:%lld startTime:%lld"
1894 " localPosition:%lld startPosition:%lld",
1895 __func__, latencyMs, startUpMs,
1896 (long long)local.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL],
Andy Hungb68f5eb2019-12-03 16:49:17 -08001897 (long long)mLogStartTimeNs,
Andy Hung62921122020-05-18 10:47:31 -07001898 (long long)local.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
Andy Hungb68f5eb2019-12-03 16:49:17 -08001899 (long long)mLogStartFrames);
Andy Hungc2b11cb2020-04-22 09:04:01 -07001900 mTrackMetrics.logLatencyAndStartup(latencyMs, startUpMs);
Andy Hungb68f5eb2019-12-03 16:49:17 -08001901 }
Andy Hung62921122020-05-18 10:47:31 -07001902 mLogLatencyMs = latencyMs;
Andy Hungb68f5eb2019-12-03 16:49:17 -08001903 }
Andy Hunge10393e2015-06-12 13:59:33 -07001904}
1905
jiabin57303cc2018-12-18 15:45:57 -08001906binder::Status AudioFlinger::PlaybackThread::Track::AudioVibrationController::mute(
1907 /*out*/ bool *ret) {
1908 *ret = false;
1909 sp<ThreadBase> thread = mTrack->mThread.promote();
1910 if (thread != 0) {
1911 // Lock for updating mHapticPlaybackEnabled.
1912 Mutex::Autolock _l(thread->mLock);
1913 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1914 if ((mTrack->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
1915 && playbackThread->mHapticChannelCount > 0) {
jiabinc47acf22022-04-01 23:47:52 +00001916 ALOGD("%s, haptic playback was muted for track %d", __func__, mTrack->id());
jiabin57303cc2018-12-18 15:45:57 -08001917 mTrack->setHapticPlaybackEnabled(false);
1918 *ret = true;
1919 }
1920 }
1921 return binder::Status::ok();
1922}
1923
1924binder::Status AudioFlinger::PlaybackThread::Track::AudioVibrationController::unmute(
1925 /*out*/ bool *ret) {
1926 *ret = false;
1927 sp<ThreadBase> thread = mTrack->mThread.promote();
1928 if (thread != 0) {
1929 // Lock for updating mHapticPlaybackEnabled.
1930 Mutex::Autolock _l(thread->mLock);
1931 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1932 if ((mTrack->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
1933 && playbackThread->mHapticChannelCount > 0) {
jiabinc47acf22022-04-01 23:47:52 +00001934 ALOGD("%s, haptic playback was unmuted for track %d", __func__, mTrack->id());
jiabin57303cc2018-12-18 15:45:57 -08001935 mTrack->setHapticPlaybackEnabled(true);
1936 *ret = true;
1937 }
1938 }
1939 return binder::Status::ok();
1940}
1941
Eric Laurent81784c32012-11-19 14:55:58 -08001942// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -07001943#undef LOG_TAG
1944#define LOG_TAG "AF::OutputTrack"
Eric Laurent81784c32012-11-19 14:55:58 -08001945
Eric Laurent81784c32012-11-19 14:55:58 -08001946AudioFlinger::PlaybackThread::OutputTrack::OutputTrack(
1947 PlaybackThread *playbackThread,
1948 DuplicatingThread *sourceThread,
1949 uint32_t sampleRate,
1950 audio_format_t format,
1951 audio_channel_mask_t channelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001952 size_t frameCount,
Svet Ganov33761132021-05-13 22:51:08 +00001953 const AttributionSourceState& attributionSource)
Eric Laurent223fd5c2014-11-11 13:43:36 -08001954 : Track(playbackThread, NULL, AUDIO_STREAM_PATCH,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001955 audio_attributes_t{} /* currently unused for output track */,
Eric Laurent223fd5c2014-11-11 13:43:36 -08001956 sampleRate, format, channelMask, frameCount,
Andy Hung8fe68032017-06-05 16:17:51 -07001957 nullptr /* buffer */, (size_t)0 /* bufferSize */, nullptr /* sharedBuffer */,
Svet Ganov33761132021-05-13 22:51:08 +00001958 AUDIO_SESSION_NONE, getpid(), attributionSource, AUDIO_OUTPUT_FLAG_NONE,
Glenn Kastend848eb42016-03-08 13:42:11 -08001959 TYPE_OUTPUT),
Eric Laurent5bba2f62016-03-18 11:14:14 -07001960 mActive(false), mSourceThread(sourceThread)
Eric Laurent81784c32012-11-19 14:55:58 -08001961{
1962
1963 if (mCblk != NULL) {
Eric Laurent81784c32012-11-19 14:55:58 -08001964 mOutBuffer.frameCount = 0;
1965 playbackThread->mTracks.add(this);
Andy Hung9d84af52018-09-12 18:03:44 -07001966 ALOGV("%s(): mCblk %p, mBuffer %p, "
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001967 "frameCount %zu, mChannelMask 0x%08x",
Andy Hung9d84af52018-09-12 18:03:44 -07001968 __func__, mCblk, mBuffer,
Glenn Kasten74935e42013-12-19 08:56:45 -08001969 frameCount, mChannelMask);
Glenn Kastene3aa6592012-12-04 12:22:46 -08001970 // since client and server are in the same process,
1971 // the buffer has the same virtual address on both sides
Glenn Kasten529c61b2014-07-18 15:31:02 -07001972 mClientProxy = new AudioTrackClientProxy(mCblk, mBuffer, mFrameCount, mFrameSize,
1973 true /*clientInServer*/);
Glenn Kastenc56f3422014-03-21 17:53:17 -07001974 mClientProxy->setVolumeLR(GAIN_MINIFLOAT_PACKED_UNITY);
Eric Laurent8d2d4932013-04-25 12:56:18 -07001975 mClientProxy->setSendLevel(0.0);
1976 mClientProxy->setSampleRate(sampleRate);
Eric Laurent81784c32012-11-19 14:55:58 -08001977 } else {
Andy Hung9d84af52018-09-12 18:03:44 -07001978 ALOGW("%s(%d): Error creating output track on thread %d",
1979 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -08001980 }
1981}
1982
1983AudioFlinger::PlaybackThread::OutputTrack::~OutputTrack()
1984{
1985 clearBufferQueue();
Glenn Kastene3aa6592012-12-04 12:22:46 -08001986 // superclass destructor will now delete the server proxy and shared memory both refer to
Eric Laurent81784c32012-11-19 14:55:58 -08001987}
1988
1989status_t AudioFlinger::PlaybackThread::OutputTrack::start(AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08001990 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08001991{
1992 status_t status = Track::start(event, triggerSession);
1993 if (status != NO_ERROR) {
1994 return status;
1995 }
1996
1997 mActive = true;
1998 mRetryCount = 127;
1999 return status;
2000}
2001
2002void AudioFlinger::PlaybackThread::OutputTrack::stop()
2003{
2004 Track::stop();
2005 clearBufferQueue();
2006 mOutBuffer.frameCount = 0;
2007 mActive = false;
2008}
2009
Andy Hung1c86ebe2018-05-29 20:29:08 -07002010ssize_t AudioFlinger::PlaybackThread::OutputTrack::write(void* data, uint32_t frames)
Eric Laurent81784c32012-11-19 14:55:58 -08002011{
2012 Buffer *pInBuffer;
2013 Buffer inBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -08002014 bool outputBufferFull = false;
2015 inBuffer.frameCount = frames;
Andy Hungc25b84a2015-01-14 19:04:10 -08002016 inBuffer.raw = data;
Eric Laurent81784c32012-11-19 14:55:58 -08002017
2018 uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs();
2019
2020 if (!mActive && frames != 0) {
Andy Hung5bedff62015-01-16 11:05:32 -08002021 (void) start();
Eric Laurent81784c32012-11-19 14:55:58 -08002022 }
2023
2024 while (waitTimeLeftMs) {
2025 // First write pending buffers, then new data
2026 if (mBufferQueue.size()) {
2027 pInBuffer = mBufferQueue.itemAt(0);
2028 } else {
2029 pInBuffer = &inBuffer;
2030 }
2031
2032 if (pInBuffer->frameCount == 0) {
2033 break;
2034 }
2035
2036 if (mOutBuffer.frameCount == 0) {
2037 mOutBuffer.frameCount = pInBuffer->frameCount;
2038 nsecs_t startTime = systemTime();
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002039 status_t status = obtainBuffer(&mOutBuffer, waitTimeLeftMs);
Eric Laurent4d231dc2016-03-11 18:38:23 -08002040 if (status != NO_ERROR && status != NOT_ENOUGH_DATA) {
Andy Hung9d84af52018-09-12 18:03:44 -07002041 ALOGV("%s(%d): thread %d no more output buffers; status %d",
2042 __func__, mId,
2043 (int)mThreadIoHandle, status);
Eric Laurent81784c32012-11-19 14:55:58 -08002044 outputBufferFull = true;
2045 break;
2046 }
2047 uint32_t waitTimeMs = (uint32_t)ns2ms(systemTime() - startTime);
2048 if (waitTimeLeftMs >= waitTimeMs) {
2049 waitTimeLeftMs -= waitTimeMs;
2050 } else {
2051 waitTimeLeftMs = 0;
2052 }
Eric Laurent4d231dc2016-03-11 18:38:23 -08002053 if (status == NOT_ENOUGH_DATA) {
2054 restartIfDisabled();
2055 continue;
2056 }
Eric Laurent81784c32012-11-19 14:55:58 -08002057 }
2058
2059 uint32_t outFrames = pInBuffer->frameCount > mOutBuffer.frameCount ? mOutBuffer.frameCount :
2060 pInBuffer->frameCount;
Andy Hungc25b84a2015-01-14 19:04:10 -08002061 memcpy(mOutBuffer.raw, pInBuffer->raw, outFrames * mFrameSize);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002062 Proxy::Buffer buf;
2063 buf.mFrameCount = outFrames;
2064 buf.mRaw = NULL;
2065 mClientProxy->releaseBuffer(&buf);
Eric Laurent4d231dc2016-03-11 18:38:23 -08002066 restartIfDisabled();
Eric Laurent81784c32012-11-19 14:55:58 -08002067 pInBuffer->frameCount -= outFrames;
Andy Hungc25b84a2015-01-14 19:04:10 -08002068 pInBuffer->raw = (int8_t *)pInBuffer->raw + outFrames * mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08002069 mOutBuffer.frameCount -= outFrames;
Andy Hungc25b84a2015-01-14 19:04:10 -08002070 mOutBuffer.raw = (int8_t *)mOutBuffer.raw + outFrames * mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08002071
2072 if (pInBuffer->frameCount == 0) {
2073 if (mBufferQueue.size()) {
2074 mBufferQueue.removeAt(0);
Andy Hungc25b84a2015-01-14 19:04:10 -08002075 free(pInBuffer->mBuffer);
Yunlian Jiang8adc8082017-06-06 15:59:44 -07002076 if (pInBuffer != &inBuffer) {
2077 delete pInBuffer;
2078 }
Andy Hung9d84af52018-09-12 18:03:44 -07002079 ALOGV("%s(%d): thread %d released overflow buffer %zu",
2080 __func__, mId,
2081 (int)mThreadIoHandle, mBufferQueue.size());
Eric Laurent81784c32012-11-19 14:55:58 -08002082 } else {
2083 break;
2084 }
2085 }
2086 }
2087
2088 // If we could not write all frames, allocate a buffer and queue it for next time.
2089 if (inBuffer.frameCount) {
2090 sp<ThreadBase> thread = mThread.promote();
2091 if (thread != 0 && !thread->standby()) {
2092 if (mBufferQueue.size() < kMaxOverFlowBuffers) {
2093 pInBuffer = new Buffer;
Andy Hungc25b84a2015-01-14 19:04:10 -08002094 pInBuffer->mBuffer = malloc(inBuffer.frameCount * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08002095 pInBuffer->frameCount = inBuffer.frameCount;
Andy Hungc25b84a2015-01-14 19:04:10 -08002096 pInBuffer->raw = pInBuffer->mBuffer;
2097 memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08002098 mBufferQueue.add(pInBuffer);
Andy Hung9d84af52018-09-12 18:03:44 -07002099 ALOGV("%s(%d): thread %d adding overflow buffer %zu", __func__, mId,
2100 (int)mThreadIoHandle, mBufferQueue.size());
Andy Hung1c86ebe2018-05-29 20:29:08 -07002101 // audio data is consumed (stored locally); set frameCount to 0.
2102 inBuffer.frameCount = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08002103 } else {
Andy Hung9d84af52018-09-12 18:03:44 -07002104 ALOGW("%s(%d): thread %d no more overflow buffers",
2105 __func__, mId, (int)mThreadIoHandle);
Andy Hung1c86ebe2018-05-29 20:29:08 -07002106 // TODO: return error for this.
Eric Laurent81784c32012-11-19 14:55:58 -08002107 }
2108 }
2109 }
2110
Andy Hungc25b84a2015-01-14 19:04:10 -08002111 // Calling write() with a 0 length buffer means that no more data will be written:
2112 // We rely on stop() to set the appropriate flags to allow the remaining frames to play out.
2113 if (frames == 0 && mBufferQueue.size() == 0 && mActive) {
2114 stop();
Eric Laurent81784c32012-11-19 14:55:58 -08002115 }
2116
Andy Hung1c86ebe2018-05-29 20:29:08 -07002117 return frames - inBuffer.frameCount; // number of frames consumed.
Eric Laurent81784c32012-11-19 14:55:58 -08002118}
2119
Kevin Rocard12381092018-04-11 09:19:59 -07002120void AudioFlinger::PlaybackThread::OutputTrack::copyMetadataTo(MetadataInserter& backInserter) const
2121{
2122 std::lock_guard<std::mutex> lock(mTrackMetadatasMutex);
2123 backInserter = std::copy(mTrackMetadatas.begin(), mTrackMetadatas.end(), backInserter);
2124}
2125
2126void AudioFlinger::PlaybackThread::OutputTrack::setMetadatas(const SourceMetadatas& metadatas) {
2127 {
2128 std::lock_guard<std::mutex> lock(mTrackMetadatasMutex);
2129 mTrackMetadatas = metadatas;
2130 }
2131 // No need to adjust metadata track volumes as OutputTrack volumes are always 0dBFS.
2132 setMetadataHasChanged();
2133}
2134
Eric Laurent81784c32012-11-19 14:55:58 -08002135status_t AudioFlinger::PlaybackThread::OutputTrack::obtainBuffer(
2136 AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs)
2137{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002138 ClientProxy::Buffer buf;
2139 buf.mFrameCount = buffer->frameCount;
2140 struct timespec timeout;
2141 timeout.tv_sec = waitTimeMs / 1000;
2142 timeout.tv_nsec = (int) (waitTimeMs % 1000) * 1000000;
2143 status_t status = mClientProxy->obtainBuffer(&buf, &timeout);
2144 buffer->frameCount = buf.mFrameCount;
2145 buffer->raw = buf.mRaw;
2146 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08002147}
2148
Eric Laurent81784c32012-11-19 14:55:58 -08002149void AudioFlinger::PlaybackThread::OutputTrack::clearBufferQueue()
2150{
2151 size_t size = mBufferQueue.size();
2152
2153 for (size_t i = 0; i < size; i++) {
2154 Buffer *pBuffer = mBufferQueue.itemAt(i);
Andy Hungc25b84a2015-01-14 19:04:10 -08002155 free(pBuffer->mBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08002156 delete pBuffer;
2157 }
2158 mBufferQueue.clear();
2159}
2160
Eric Laurent4d231dc2016-03-11 18:38:23 -08002161void AudioFlinger::PlaybackThread::OutputTrack::restartIfDisabled()
2162{
2163 int32_t flags = android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
2164 if (mActive && (flags & CBLK_DISABLED)) {
2165 start();
2166 }
2167}
Eric Laurent81784c32012-11-19 14:55:58 -08002168
Andy Hung9d84af52018-09-12 18:03:44 -07002169// ----------------------------------------------------------------------------
2170#undef LOG_TAG
2171#define LOG_TAG "AF::PatchTrack"
2172
Eric Laurent83b88082014-06-20 18:31:16 -07002173AudioFlinger::PlaybackThread::PatchTrack::PatchTrack(PlaybackThread *playbackThread,
Eric Laurent3bcf8592015-04-03 12:13:24 -07002174 audio_stream_type_t streamType,
Eric Laurent83b88082014-06-20 18:31:16 -07002175 uint32_t sampleRate,
2176 audio_channel_mask_t channelMask,
2177 audio_format_t format,
2178 size_t frameCount,
2179 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07002180 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -08002181 audio_output_flags_t flags,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01002182 const Timeout& timeout,
2183 size_t frameCountToBeReady)
Eric Laurent3bcf8592015-04-03 12:13:24 -07002184 : Track(playbackThread, NULL, streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002185 audio_attributes_t{} /* currently unused for patch track */,
Eric Laurent223fd5c2014-11-11 13:43:36 -08002186 sampleRate, format, channelMask, frameCount,
Andy Hung8fe68032017-06-05 16:17:51 -07002187 buffer, bufferSize, nullptr /* sharedBuffer */,
Svet Ganov33761132021-05-13 22:51:08 +00002188 AUDIO_SESSION_NONE, getpid(), audioServerAttributionSource(getpid()), flags,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002189 TYPE_PATCH, AUDIO_PORT_HANDLE_NONE, frameCountToBeReady),
Kevin Rocard45986c72018-12-18 18:22:59 -08002190 PatchTrackBase(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, true, true),
2191 *playbackThread, timeout)
Eric Laurent83b88082014-06-20 18:31:16 -07002192{
Andy Hung9d84af52018-09-12 18:03:44 -07002193 ALOGV("%s(%d): sampleRate %d mPeerTimeout %d.%03d sec",
2194 __func__, mId, sampleRate,
Eric Laurent83b88082014-06-20 18:31:16 -07002195 (int)mPeerTimeout.tv_sec,
2196 (int)(mPeerTimeout.tv_nsec / 1000000));
2197}
2198
2199AudioFlinger::PlaybackThread::PatchTrack::~PatchTrack()
2200{
Andy Hungabfab202019-03-07 19:45:54 -08002201 ALOGV("%s(%d)", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002202}
2203
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002204size_t AudioFlinger::PlaybackThread::PatchTrack::framesReady() const
2205{
2206 if (mPeerProxy && mPeerProxy->producesBufferOnDemand()) {
2207 return std::numeric_limits<size_t>::max();
2208 } else {
2209 return Track::framesReady();
2210 }
2211}
2212
Eric Laurent4d231dc2016-03-11 18:38:23 -08002213status_t AudioFlinger::PlaybackThread::PatchTrack::start(AudioSystem::sync_event_t event,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002214 audio_session_t triggerSession)
Eric Laurent4d231dc2016-03-11 18:38:23 -08002215{
2216 status_t status = Track::start(event, triggerSession);
2217 if (status != NO_ERROR) {
2218 return status;
2219 }
2220 android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
2221 return status;
2222}
2223
Eric Laurent83b88082014-06-20 18:31:16 -07002224// AudioBufferProvider interface
2225status_t AudioFlinger::PlaybackThread::PatchTrack::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08002226 AudioBufferProvider::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07002227{
Andy Hung9d84af52018-09-12 18:03:44 -07002228 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002229 Proxy::Buffer buf;
2230 buf.mFrameCount = buffer->frameCount;
Mikhail Naganov938be412019-09-04 11:38:47 -07002231 if (ATRACE_ENABLED()) {
2232 std::string traceName("PTnReq");
2233 traceName += std::to_string(id());
2234 ATRACE_INT(traceName.c_str(), buf.mFrameCount);
2235 }
Eric Laurent83b88082014-06-20 18:31:16 -07002236 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout);
Andy Hung9d84af52018-09-12 18:03:44 -07002237 ALOGV_IF(status != NO_ERROR, "%s(%d): getNextBuffer status %d", __func__, mId, status);
Eric Laurentc2730ba2014-07-20 15:47:07 -07002238 buffer->frameCount = buf.mFrameCount;
Mikhail Naganov938be412019-09-04 11:38:47 -07002239 if (ATRACE_ENABLED()) {
2240 std::string traceName("PTnObt");
2241 traceName += std::to_string(id());
2242 ATRACE_INT(traceName.c_str(), buf.mFrameCount);
2243 }
Eric Laurent83b88082014-06-20 18:31:16 -07002244 if (buf.mFrameCount == 0) {
2245 return WOULD_BLOCK;
2246 }
Glenn Kastend79072e2016-01-06 08:41:20 -08002247 status = Track::getNextBuffer(buffer);
Eric Laurent83b88082014-06-20 18:31:16 -07002248 return status;
2249}
2250
2251void AudioFlinger::PlaybackThread::PatchTrack::releaseBuffer(AudioBufferProvider::Buffer* buffer)
2252{
Andy Hung9d84af52018-09-12 18:03:44 -07002253 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002254 Proxy::Buffer buf;
2255 buf.mFrameCount = buffer->frameCount;
2256 buf.mRaw = buffer->raw;
2257 mPeerProxy->releaseBuffer(&buf);
2258 TrackBase::releaseBuffer(buffer);
2259}
2260
2261status_t AudioFlinger::PlaybackThread::PatchTrack::obtainBuffer(Proxy::Buffer* buffer,
2262 const struct timespec *timeOut)
2263{
Eric Laurent4d231dc2016-03-11 18:38:23 -08002264 status_t status = NO_ERROR;
2265 static const int32_t kMaxTries = 5;
2266 int32_t tryCounter = kMaxTries;
Andy Hungf62e1a22018-05-08 18:32:11 -07002267 const size_t originalFrameCount = buffer->mFrameCount;
Eric Laurent4d231dc2016-03-11 18:38:23 -08002268 do {
2269 if (status == NOT_ENOUGH_DATA) {
2270 restartIfDisabled();
Andy Hungf62e1a22018-05-08 18:32:11 -07002271 buffer->mFrameCount = originalFrameCount; // cleared on error, must be restored.
Eric Laurent4d231dc2016-03-11 18:38:23 -08002272 }
2273 status = mProxy->obtainBuffer(buffer, timeOut);
2274 } while ((status == NOT_ENOUGH_DATA) && (tryCounter-- > 0));
2275 return status;
Eric Laurent83b88082014-06-20 18:31:16 -07002276}
2277
2278void AudioFlinger::PlaybackThread::PatchTrack::releaseBuffer(Proxy::Buffer* buffer)
2279{
2280 mProxy->releaseBuffer(buffer);
Eric Laurent4d231dc2016-03-11 18:38:23 -08002281 restartIfDisabled();
naoki miyazuf37f9982019-11-28 11:18:18 +09002282
2283 // Check if the PatchTrack has enough data to write once in releaseBuffer().
2284 // If not, prevent an underrun from occurring by moving the track into FS_FILLING;
2285 // this logic avoids glitches when suspending A2DP with AudioPlaybackCapture.
2286 // TODO: perhaps underrun avoidance could be a track property checked in isReady() instead.
2287 if (mFillingUpStatus == FS_ACTIVE
2288 && audio_is_linear_pcm(mFormat)
2289 && !isOffloadedOrDirect()) {
2290 if (sp<ThreadBase> thread = mThread.promote();
2291 thread != 0) {
2292 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
2293 const size_t frameCount = playbackThread->frameCount() * sampleRate()
2294 / playbackThread->sampleRate();
2295 if (framesReady() < frameCount) {
2296 ALOGD("%s(%d) Not enough data, wait for buffer to fill", __func__, mId);
2297 mFillingUpStatus = FS_FILLING;
2298 }
2299 }
2300 }
Eric Laurent4d231dc2016-03-11 18:38:23 -08002301}
2302
2303void AudioFlinger::PlaybackThread::PatchTrack::restartIfDisabled()
2304{
Eric Laurent83b88082014-06-20 18:31:16 -07002305 if (android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags) & CBLK_DISABLED) {
Andy Hung9d84af52018-09-12 18:03:44 -07002306 ALOGW("%s(%d): disabled due to previous underrun, restarting", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002307 start();
2308 }
Eric Laurent83b88082014-06-20 18:31:16 -07002309}
2310
Eric Laurent81784c32012-11-19 14:55:58 -08002311// ----------------------------------------------------------------------------
2312// Record
2313// ----------------------------------------------------------------------------
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -07002314
2315
Andy Hung9d84af52018-09-12 18:03:44 -07002316#undef LOG_TAG
2317#define LOG_TAG "AF::RecordHandle"
Eric Laurent81784c32012-11-19 14:55:58 -08002318
2319AudioFlinger::RecordHandle::RecordHandle(
2320 const sp<AudioFlinger::RecordThread::RecordTrack>& recordTrack)
2321 : BnAudioRecord(),
2322 mRecordTrack(recordTrack)
2323{
2324}
2325
2326AudioFlinger::RecordHandle::~RecordHandle() {
2327 stop_nonvirtual();
2328 mRecordTrack->destroy();
2329}
2330
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002331binder::Status AudioFlinger::RecordHandle::start(int /*AudioSystem::sync_event_t*/ event,
2332 int /*audio_session_t*/ triggerSession) {
Andy Hung9d84af52018-09-12 18:03:44 -07002333 ALOGV("%s()", __func__);
Andy Hung1131b6e2020-12-08 20:47:45 -08002334 return binderStatusFromStatusT(
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002335 mRecordTrack->start((AudioSystem::sync_event_t)event, (audio_session_t) triggerSession));
Eric Laurent81784c32012-11-19 14:55:58 -08002336}
2337
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002338binder::Status AudioFlinger::RecordHandle::stop() {
Eric Laurent81784c32012-11-19 14:55:58 -08002339 stop_nonvirtual();
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002340 return binder::Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -08002341}
2342
2343void AudioFlinger::RecordHandle::stop_nonvirtual() {
Andy Hung9d84af52018-09-12 18:03:44 -07002344 ALOGV("%s()", __func__);
Eric Laurent81784c32012-11-19 14:55:58 -08002345 mRecordTrack->stop();
2346}
2347
jiabin653cc0a2018-01-17 17:54:10 -08002348binder::Status AudioFlinger::RecordHandle::getActiveMicrophones(
Ytai Ben-Tsvi71109da2020-11-03 15:11:13 -08002349 std::vector<media::MicrophoneInfoData>* activeMicrophones) {
Andy Hung9d84af52018-09-12 18:03:44 -07002350 ALOGV("%s()", __func__);
Ytai Ben-Tsvi71109da2020-11-03 15:11:13 -08002351 std::vector<media::MicrophoneInfo> mics;
2352 status_t status = mRecordTrack->getActiveMicrophones(&mics);
2353 activeMicrophones->resize(mics.size());
2354 for (size_t i = 0; status == OK && i < mics.size(); ++i) {
2355 status = mics[i].writeToParcelable(&activeMicrophones->at(i));
2356 }
Andy Hung1131b6e2020-12-08 20:47:45 -08002357 return binderStatusFromStatusT(status);
jiabin653cc0a2018-01-17 17:54:10 -08002358}
2359
Paul McLean12340082019-03-19 09:35:05 -06002360binder::Status AudioFlinger::RecordHandle::setPreferredMicrophoneDirection(
Paul McLean03a6e6a2018-12-04 10:54:13 -07002361 int /*audio_microphone_direction_t*/ direction) {
2362 ALOGV("%s()", __func__);
Andy Hung1131b6e2020-12-08 20:47:45 -08002363 return binderStatusFromStatusT(mRecordTrack->setPreferredMicrophoneDirection(
Paul McLean03a6e6a2018-12-04 10:54:13 -07002364 static_cast<audio_microphone_direction_t>(direction)));
2365}
2366
Paul McLean12340082019-03-19 09:35:05 -06002367binder::Status AudioFlinger::RecordHandle::setPreferredMicrophoneFieldDimension(float zoom) {
Paul McLean03a6e6a2018-12-04 10:54:13 -07002368 ALOGV("%s()", __func__);
Andy Hung1131b6e2020-12-08 20:47:45 -08002369 return binderStatusFromStatusT(mRecordTrack->setPreferredMicrophoneFieldDimension(zoom));
Paul McLean03a6e6a2018-12-04 10:54:13 -07002370}
2371
Eric Laurentec376dc2021-04-08 20:41:22 +02002372binder::Status AudioFlinger::RecordHandle::shareAudioHistory(
2373 const std::string& sharedAudioPackageName, int64_t sharedAudioStartMs) {
2374 return binderStatusFromStatusT(
2375 mRecordTrack->shareAudioHistory(sharedAudioPackageName, sharedAudioStartMs));
2376}
2377
Eric Laurent81784c32012-11-19 14:55:58 -08002378// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -07002379#undef LOG_TAG
2380#define LOG_TAG "AF::RecordTrack"
Eric Laurent81784c32012-11-19 14:55:58 -08002381
Glenn Kasten05997e22014-03-13 15:08:33 -07002382// RecordTrack constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
Eric Laurent81784c32012-11-19 14:55:58 -08002383AudioFlinger::RecordThread::RecordTrack::RecordTrack(
2384 RecordThread *thread,
2385 const sp<Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002386 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -08002387 uint32_t sampleRate,
2388 audio_format_t format,
2389 audio_channel_mask_t channelMask,
2390 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -07002391 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07002392 size_t bufferSize,
Glenn Kastend848eb42016-03-08 13:42:11 -08002393 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002394 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00002395 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -07002396 audio_input_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -08002397 track_type type,
Eric Laurentec376dc2021-04-08 20:41:22 +02002398 audio_port_handle_t portId,
Eric Laurent2407ce32021-04-26 14:56:03 +02002399 int32_t startFrames)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002400 : TrackBase(thread, client, attr, sampleRate, format,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002401 channelMask, frameCount, buffer, bufferSize, sessionId,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002402 creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00002403 VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid)),
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002404 false /*isOut*/,
Eric Laurent83b88082014-06-20 18:31:16 -07002405 (type == TYPE_DEFAULT) ?
Eric Laurent05067782016-06-01 18:27:28 -07002406 ((flags & AUDIO_INPUT_FLAG_FAST) ? ALLOC_PIPE : ALLOC_CBLK) :
Eric Laurent83b88082014-06-20 18:31:16 -07002407 ((buffer == NULL) ? ALLOC_LOCAL : ALLOC_NONE),
Andy Hungb68f5eb2019-12-03 16:49:17 -08002408 type, portId,
2409 std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_RECORD) + std::to_string(portId)),
Andy Hung97a893e2015-03-29 01:03:07 -07002410 mOverflow(false),
Andy Hung4c6afaf2015-06-12 18:23:35 -07002411 mFramesToDrop(0),
2412 mResamplerBufferProvider(NULL), // initialize in case of early constructor exit
Eric Laurent05067782016-06-01 18:27:28 -07002413 mRecordBufferConverter(NULL),
jiabin9378eb92018-05-02 15:26:35 -07002414 mFlags(flags),
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -07002415 mSilenced(false),
Eric Laurent2407ce32021-04-26 14:56:03 +02002416 mStartFrames(startFrames)
Eric Laurent81784c32012-11-19 14:55:58 -08002417{
Glenn Kasten3ef14ef2014-03-13 15:08:51 -07002418 if (mCblk == NULL) {
2419 return;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002420 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002421
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07002422 if (!isDirect()) {
2423 mRecordBufferConverter = new RecordBufferConverter(
2424 thread->mChannelMask, thread->mFormat, thread->mSampleRate,
2425 channelMask, format, sampleRate);
2426 // Check if the RecordBufferConverter construction was successful.
2427 // If not, don't continue with construction.
2428 //
2429 // NOTE: It would be extremely rare that the record track cannot be created
2430 // for the current device, but a pending or future device change would make
2431 // the record track configuration valid.
2432 if (mRecordBufferConverter->initCheck() != NO_ERROR) {
Andy Hung9d84af52018-09-12 18:03:44 -07002433 ALOGE("%s(%d): RecordTrack unable to create record buffer converter", __func__, mId);
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07002434 return;
2435 }
Andy Hung97a893e2015-03-29 01:03:07 -07002436 }
2437
Andy Hung6ae58432016-02-16 18:32:24 -08002438 mServerProxy = new AudioRecordServerProxy(mCblk, mBuffer, frameCount,
Andy Hung3f0c9022016-01-15 17:49:46 -08002439 mFrameSize, !isExternalTrack());
Andy Hung3f0c9022016-01-15 17:49:46 -08002440
Andy Hung97a893e2015-03-29 01:03:07 -07002441 mResamplerBufferProvider = new ResamplerBufferProvider(this);
Glenn Kastenc263ca02014-06-04 20:31:46 -07002442
Eric Laurent05067782016-06-01 18:27:28 -07002443 if (flags & AUDIO_INPUT_FLAG_FAST) {
Glenn Kastenc263ca02014-06-04 20:31:46 -07002444 ALOG_ASSERT(thread->mFastTrackAvail);
2445 thread->mFastTrackAvail = false;
Andy Hung000adb52018-06-01 15:43:26 -07002446 } else {
2447 // TODO: only Normal Record has timestamps (Fast Record does not).
Andy Hung5d3d9562018-10-04 19:27:26 -07002448 mServerLatencySupported = checkServerLatencySupported(mFormat, flags);
Glenn Kastenc263ca02014-06-04 20:31:46 -07002449 }
Andy Hung8946a282018-04-19 20:04:56 -07002450#ifdef TEE_SINK
2451 mTee.setId(std::string("_") + std::to_string(mThreadIoHandle)
2452 + "_" + std::to_string(mId)
2453 + "_R");
2454#endif
Andy Hungb68f5eb2019-12-03 16:49:17 -08002455
2456 // Once this item is logged by the server, the client can add properties.
Andy Hung94235282021-03-24 15:50:14 -07002457 mTrackMetrics.logConstructor(creatorPid, uid(), id());
Eric Laurent81784c32012-11-19 14:55:58 -08002458}
2459
2460AudioFlinger::RecordThread::RecordTrack::~RecordTrack()
2461{
Andy Hung9d84af52018-09-12 18:03:44 -07002462 ALOGV("%s()", __func__);
Andy Hung97a893e2015-03-29 01:03:07 -07002463 delete mRecordBufferConverter;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002464 delete mResamplerBufferProvider;
Eric Laurent81784c32012-11-19 14:55:58 -08002465}
2466
Andy Hung97a893e2015-03-29 01:03:07 -07002467status_t AudioFlinger::RecordThread::RecordTrack::initCheck() const
2468{
2469 status_t status = TrackBase::initCheck();
2470 if (status == NO_ERROR && mServerProxy == 0) {
2471 status = BAD_VALUE;
2472 }
2473 return status;
2474}
2475
Eric Laurent81784c32012-11-19 14:55:58 -08002476// AudioBufferProvider interface
Glenn Kastend79072e2016-01-06 08:41:20 -08002477status_t AudioFlinger::RecordThread::RecordTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08002478{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002479 ServerProxy::Buffer buf;
2480 buf.mFrameCount = buffer->frameCount;
2481 status_t status = mServerProxy->obtainBuffer(&buf);
2482 buffer->frameCount = buf.mFrameCount;
2483 buffer->raw = buf.mRaw;
2484 if (buf.mFrameCount == 0) {
2485 // FIXME also wake futex so that overrun is noticed more quickly
Glenn Kasten96f60d82013-07-12 10:21:18 -07002486 (void) android_atomic_or(CBLK_OVERRUN, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08002487 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002488 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08002489}
2490
2491status_t AudioFlinger::RecordThread::RecordTrack::start(AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08002492 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08002493{
2494 sp<ThreadBase> thread = mThread.promote();
2495 if (thread != 0) {
2496 RecordThread *recordThread = (RecordThread *)thread.get();
2497 return recordThread->start(this, event, triggerSession);
2498 } else {
Eric Laurentd52a28c2020-08-21 17:10:39 -07002499 ALOGW("%s track %d: thread was destroyed", __func__, portId());
2500 return DEAD_OBJECT;
Eric Laurent81784c32012-11-19 14:55:58 -08002501 }
2502}
2503
2504void AudioFlinger::RecordThread::RecordTrack::stop()
2505{
2506 sp<ThreadBase> thread = mThread.promote();
2507 if (thread != 0) {
2508 RecordThread *recordThread = (RecordThread *)thread.get();
Eric Laurent83b88082014-06-20 18:31:16 -07002509 if (recordThread->stop(this) && isExternalTrack()) {
Eric Laurentfee19762018-01-29 18:44:13 -08002510 AudioSystem::stopInput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -08002511 }
2512 }
2513}
2514
2515void AudioFlinger::RecordThread::RecordTrack::destroy()
2516{
2517 // see comments at AudioFlinger::PlaybackThread::Track::destroy()
2518 sp<RecordTrack> keep(this);
2519 {
Andy Hungce685402018-10-05 17:23:27 -07002520 track_state priorState = mState;
Eric Laurent81784c32012-11-19 14:55:58 -08002521 sp<ThreadBase> thread = mThread.promote();
2522 if (thread != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08002523 Mutex::Autolock _l(thread->mLock);
2524 RecordThread *recordThread = (RecordThread *) thread.get();
Andy Hungce685402018-10-05 17:23:27 -07002525 priorState = mState;
Eric Laurentec376dc2021-04-08 20:41:22 +02002526 if (!mSharedAudioPackageName.empty()) {
Eric Laurent92d0a322021-07-16 15:32:33 +02002527 recordThread->resetAudioHistory_l();
Eric Laurentec376dc2021-04-08 20:41:22 +02002528 }
Andy Hungce685402018-10-05 17:23:27 -07002529 recordThread->destroyTrack_l(this); // move mState to STOPPED, terminate
2530 }
2531 // APM portid/client management done outside of lock.
2532 // NOTE: if thread doesn't exist, the input descriptor probably doesn't either.
2533 if (isExternalTrack()) {
2534 switch (priorState) {
2535 case ACTIVE: // invalidated while still active
2536 case STARTING_2: // invalidated/start-aborted after startInput successfully called
2537 case PAUSING: // invalidated while in the middle of stop() pausing (still active)
2538 AudioSystem::stopInput(mPortId);
2539 break;
2540
2541 case STARTING_1: // invalidated/start-aborted and startInput not successful
2542 case PAUSED: // OK, not active
2543 case IDLE: // OK, not active
2544 break;
2545
2546 case STOPPED: // unexpected (destroyed)
2547 default:
2548 LOG_ALWAYS_FATAL("%s(%d): invalid prior state: %d", __func__, mId, priorState);
2549 }
2550 AudioSystem::releaseInput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -08002551 }
2552 }
2553}
2554
Eric Laurent9a54bc22013-09-09 09:08:44 -07002555void AudioFlinger::RecordThread::RecordTrack::invalidate()
2556{
Eric Laurent6acd1d42017-01-04 14:23:29 -08002557 TrackBase::invalidate();
Eric Laurent9a54bc22013-09-09 09:08:44 -07002558 // FIXME should use proxy, and needs work
2559 audio_track_cblk_t* cblk = mCblk;
2560 android_atomic_or(CBLK_INVALID, &cblk->mFlags);
2561 android_atomic_release_store(0x40000000, &cblk->mFutex);
2562 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE
Elliott Hughesee499292014-05-21 17:55:51 -07002563 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX);
Eric Laurent9a54bc22013-09-09 09:08:44 -07002564}
2565
Eric Laurent81784c32012-11-19 14:55:58 -08002566
Andy Hung000adb52018-06-01 15:43:26 -07002567void AudioFlinger::RecordThread::RecordTrack::appendDumpHeader(String8& result)
Eric Laurent81784c32012-11-19 14:55:58 -08002568{
Eric Laurent973db022018-11-20 14:54:31 -08002569 result.appendFormat("Active Id Client Session Port Id S Flags "
Andy Hung9d84af52018-09-12 18:03:44 -07002570 " Format Chn mask SRate Source "
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002571 " Server FrmCnt FrmRdy Sil%s\n",
2572 isServerLatencySupported() ? " Latency" : "");
Eric Laurent81784c32012-11-19 14:55:58 -08002573}
2574
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002575void AudioFlinger::RecordThread::RecordTrack::appendDump(String8& result, bool active)
Eric Laurent81784c32012-11-19 14:55:58 -08002576{
Eric Laurent973db022018-11-20 14:54:31 -08002577 result.appendFormat("%c%5s %6d %6u %7u %7u %2s 0x%03X "
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002578 "%08X %08X %6u %6X "
Andy Hung000adb52018-06-01 15:43:26 -07002579 "%08X %6zu %6zu %3c",
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002580 isFastTrack() ? 'F' : ' ',
Marco Nelissenb2208842014-02-07 14:00:50 -08002581 active ? "yes" : "no",
Andy Hung9d84af52018-09-12 18:03:44 -07002582 mId,
Andy Hung4ef19fa2018-05-15 19:35:29 -07002583 (mClient == 0) ? getpid() : mClient->pid(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002584 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -08002585 mPortId,
Andy Hunge2e830f2019-12-03 12:54:46 -08002586 getTrackStateAsCodedString(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002587 mCblk->mFlags,
2588
Eric Laurent81784c32012-11-19 14:55:58 -08002589 mFormat,
2590 mChannelMask,
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002591 mSampleRate,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002592 mAttr.source,
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002593
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002594 mCblk->mServer,
Jean-Michel Trivi7d665ab2018-04-11 17:26:51 -07002595 mFrameCount,
Andy Hung000adb52018-06-01 15:43:26 -07002596 mServerProxy->framesReadySafe(),
Jean-Michel Trivi7d665ab2018-04-11 17:26:51 -07002597 isSilenced() ? 's' : 'n'
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002598 );
Andy Hung000adb52018-06-01 15:43:26 -07002599 if (isServerLatencySupported()) {
2600 double latencyMs;
2601 bool fromTrack;
2602 if (getTrackLatencyMs(&latencyMs, &fromTrack) == OK) {
2603 // Show latency in msec, followed by 't' if from track timestamp (the most accurate)
2604 // or 'k' if estimated from kernel (usually for debugging).
2605 result.appendFormat(" %7.2lf %c", latencyMs, fromTrack ? 't' : 'k');
2606 } else {
2607 result.appendFormat("%10s", mCblk->mServer != 0 ? "unavail" : "new");
2608 }
2609 }
2610 result.append("\n");
Eric Laurent81784c32012-11-19 14:55:58 -08002611}
2612
Glenn Kasten25f4aa82014-02-07 10:50:43 -08002613void AudioFlinger::RecordThread::RecordTrack::handleSyncStartEvent(const sp<SyncEvent>& event)
2614{
2615 if (event == mSyncStartEvent) {
2616 ssize_t framesToDrop = 0;
2617 sp<ThreadBase> threadBase = mThread.promote();
2618 if (threadBase != 0) {
2619 // TODO: use actual buffer filling status instead of 2 buffers when info is available
2620 // from audio HAL
2621 framesToDrop = threadBase->mFrameCount * 2;
2622 }
2623 mFramesToDrop = framesToDrop;
2624 }
2625}
2626
2627void AudioFlinger::RecordThread::RecordTrack::clearSyncStartEvent()
2628{
2629 if (mSyncStartEvent != 0) {
2630 mSyncStartEvent->cancel();
2631 mSyncStartEvent.clear();
2632 }
2633 mFramesToDrop = 0;
2634}
2635
Andy Hung3f0c9022016-01-15 17:49:46 -08002636void AudioFlinger::RecordThread::RecordTrack::updateTrackFrameInfo(
2637 int64_t trackFramesReleased, int64_t sourceFramesRead,
2638 uint32_t halSampleRate, const ExtendedTimestamp &timestamp)
2639{
Andy Hung30282562018-08-08 18:27:03 -07002640 // Make the kernel frametime available.
2641 const FrameTime ft{
2642 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
2643 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]};
2644 // ALOGD("FrameTime: %lld %lld", (long long)ft.frames, (long long)ft.timeNs);
2645 mKernelFrameTime.store(ft);
2646 if (!audio_is_linear_pcm(mFormat)) {
Atneya Nair497fff12022-01-18 16:23:04 -05002647 // Stream is direct, return provided timestamp with no conversion
2648 mServerProxy->setTimestamp(timestamp);
Andy Hung30282562018-08-08 18:27:03 -07002649 return;
2650 }
2651
Andy Hung3f0c9022016-01-15 17:49:46 -08002652 ExtendedTimestamp local = timestamp;
2653
2654 // Convert HAL frames to server-side track frames at track sample rate.
2655 // We use trackFramesReleased and sourceFramesRead as an anchor point.
2656 for (int i = ExtendedTimestamp::LOCATION_SERVER; i < ExtendedTimestamp::LOCATION_MAX; ++i) {
2657 if (local.mTimeNs[i] != 0) {
2658 const int64_t relativeServerFrames = local.mPosition[i] - sourceFramesRead;
2659 const int64_t relativeTrackFrames = relativeServerFrames
2660 * mSampleRate / halSampleRate; // TODO: potential computation overflow
2661 local.mPosition[i] = relativeTrackFrames + trackFramesReleased;
2662 }
2663 }
Andy Hung6ae58432016-02-16 18:32:24 -08002664 mServerProxy->setTimestamp(local);
Andy Hung000adb52018-06-01 15:43:26 -07002665
2666 // Compute latency info.
2667 const bool useTrackTimestamp = true; // use track unless debugging.
2668 const double latencyMs = - (useTrackTimestamp
2669 ? local.getOutputServerLatencyMs(sampleRate())
2670 : timestamp.getOutputServerLatencyMs(halSampleRate));
2671
2672 mServerLatencyFromTrack.store(useTrackTimestamp);
2673 mServerLatencyMs.store(latencyMs);
Andy Hung3f0c9022016-01-15 17:49:46 -08002674}
Eric Laurent83b88082014-06-20 18:31:16 -07002675
jiabin653cc0a2018-01-17 17:54:10 -08002676status_t AudioFlinger::RecordThread::RecordTrack::getActiveMicrophones(
2677 std::vector<media::MicrophoneInfo>* activeMicrophones)
2678{
2679 sp<ThreadBase> thread = mThread.promote();
2680 if (thread != 0) {
2681 RecordThread *recordThread = (RecordThread *)thread.get();
2682 return recordThread->getActiveMicrophones(activeMicrophones);
2683 } else {
2684 return BAD_VALUE;
2685 }
2686}
2687
Paul McLean12340082019-03-19 09:35:05 -06002688status_t AudioFlinger::RecordThread::RecordTrack::setPreferredMicrophoneDirection(
Paul McLean03a6e6a2018-12-04 10:54:13 -07002689 audio_microphone_direction_t direction) {
2690 sp<ThreadBase> thread = mThread.promote();
2691 if (thread != 0) {
2692 RecordThread *recordThread = (RecordThread *)thread.get();
Paul McLean12340082019-03-19 09:35:05 -06002693 return recordThread->setPreferredMicrophoneDirection(direction);
Paul McLean03a6e6a2018-12-04 10:54:13 -07002694 } else {
2695 return BAD_VALUE;
2696 }
2697}
2698
Paul McLean12340082019-03-19 09:35:05 -06002699status_t AudioFlinger::RecordThread::RecordTrack::setPreferredMicrophoneFieldDimension(float zoom) {
Paul McLean03a6e6a2018-12-04 10:54:13 -07002700 sp<ThreadBase> thread = mThread.promote();
2701 if (thread != 0) {
2702 RecordThread *recordThread = (RecordThread *)thread.get();
Paul McLean12340082019-03-19 09:35:05 -06002703 return recordThread->setPreferredMicrophoneFieldDimension(zoom);
Paul McLean03a6e6a2018-12-04 10:54:13 -07002704 } else {
2705 return BAD_VALUE;
2706 }
2707}
2708
Eric Laurentec376dc2021-04-08 20:41:22 +02002709status_t AudioFlinger::RecordThread::RecordTrack::shareAudioHistory(
2710 const std::string& sharedAudioPackageName, int64_t sharedAudioStartMs) {
2711
2712 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
2713 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
2714 if (callingUid != mUid || callingPid != mCreatorPid) {
2715 return PERMISSION_DENIED;
2716 }
2717
Svet Ganov33761132021-05-13 22:51:08 +00002718 AttributionSourceState attributionSource{};
2719 attributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
2720 attributionSource.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingPid));
2721 attributionSource.token = sp<BBinder>::make();
2722 if (!captureHotwordAllowed(attributionSource)) {
Eric Laurentec376dc2021-04-08 20:41:22 +02002723 return PERMISSION_DENIED;
2724 }
2725
2726 sp<ThreadBase> thread = mThread.promote();
2727 if (thread != 0) {
2728 RecordThread *recordThread = (RecordThread *)thread.get();
2729 status_t status = recordThread->shareAudioHistory(
2730 sharedAudioPackageName, mSessionId, sharedAudioStartMs);
2731 if (status == NO_ERROR) {
2732 mSharedAudioPackageName = sharedAudioPackageName;
2733 }
2734 return status;
2735 } else {
2736 return BAD_VALUE;
2737 }
2738}
2739
2740
Andy Hung9d84af52018-09-12 18:03:44 -07002741// ----------------------------------------------------------------------------
2742#undef LOG_TAG
2743#define LOG_TAG "AF::PatchRecord"
2744
Eric Laurent83b88082014-06-20 18:31:16 -07002745AudioFlinger::RecordThread::PatchRecord::PatchRecord(RecordThread *recordThread,
2746 uint32_t sampleRate,
2747 audio_channel_mask_t channelMask,
2748 audio_format_t format,
2749 size_t frameCount,
2750 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07002751 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -08002752 audio_input_flags_t flags,
2753 const Timeout& timeout)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002754 : RecordTrack(recordThread, NULL,
2755 audio_attributes_t{} /* currently unused for patch track */,
2756 sampleRate, format, channelMask, frameCount,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002757 buffer, bufferSize, AUDIO_SESSION_NONE, getpid(),
Svet Ganov33761132021-05-13 22:51:08 +00002758 audioServerAttributionSource(getpid()), flags, TYPE_PATCH),
Kevin Rocard45986c72018-12-18 18:22:59 -08002759 PatchTrackBase(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, false, true),
2760 *recordThread, timeout)
Eric Laurent83b88082014-06-20 18:31:16 -07002761{
Andy Hung9d84af52018-09-12 18:03:44 -07002762 ALOGV("%s(%d): sampleRate %d mPeerTimeout %d.%03d sec",
2763 __func__, mId, sampleRate,
Eric Laurent83b88082014-06-20 18:31:16 -07002764 (int)mPeerTimeout.tv_sec,
2765 (int)(mPeerTimeout.tv_nsec / 1000000));
2766}
2767
2768AudioFlinger::RecordThread::PatchRecord::~PatchRecord()
2769{
Andy Hungabfab202019-03-07 19:45:54 -08002770 ALOGV("%s(%d)", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002771}
2772
Mikhail Naganov8296c252019-09-25 14:59:54 -07002773static size_t writeFramesHelper(
2774 AudioBufferProvider* dest, const void* src, size_t frameCount, size_t frameSize)
2775{
2776 AudioBufferProvider::Buffer patchBuffer;
2777 patchBuffer.frameCount = frameCount;
2778 auto status = dest->getNextBuffer(&patchBuffer);
2779 if (status != NO_ERROR) {
2780 ALOGW("%s PathRecord getNextBuffer failed with error %d: %s",
2781 __func__, status, strerror(-status));
2782 return 0;
2783 }
2784 ALOG_ASSERT(patchBuffer.frameCount <= frameCount);
2785 memcpy(patchBuffer.raw, src, patchBuffer.frameCount * frameSize);
2786 size_t framesWritten = patchBuffer.frameCount;
2787 dest->releaseBuffer(&patchBuffer);
2788 return framesWritten;
2789}
2790
2791// static
2792size_t AudioFlinger::RecordThread::PatchRecord::writeFrames(
2793 AudioBufferProvider* dest, const void* src, size_t frameCount, size_t frameSize)
2794{
2795 size_t framesWritten = writeFramesHelper(dest, src, frameCount, frameSize);
2796 // On buffer wrap, the buffer frame count will be less than requested,
2797 // when this happens a second buffer needs to be used to write the leftover audio
2798 const size_t framesLeft = frameCount - framesWritten;
2799 if (framesWritten != 0 && framesLeft != 0) {
2800 framesWritten += writeFramesHelper(dest, (const char*)src + framesWritten * frameSize,
2801 framesLeft, frameSize);
2802 }
2803 return framesWritten;
2804}
2805
Eric Laurent83b88082014-06-20 18:31:16 -07002806// AudioBufferProvider interface
2807status_t AudioFlinger::RecordThread::PatchRecord::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08002808 AudioBufferProvider::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07002809{
Andy Hung9d84af52018-09-12 18:03:44 -07002810 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002811 Proxy::Buffer buf;
2812 buf.mFrameCount = buffer->frameCount;
2813 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout);
2814 ALOGV_IF(status != NO_ERROR,
Andy Hung9d84af52018-09-12 18:03:44 -07002815 "%s(%d): mPeerProxy->obtainBuffer status %d", __func__, mId, status);
Eric Laurentc2730ba2014-07-20 15:47:07 -07002816 buffer->frameCount = buf.mFrameCount;
Mikhail Naganov938be412019-09-04 11:38:47 -07002817 if (ATRACE_ENABLED()) {
2818 std::string traceName("PRnObt");
2819 traceName += std::to_string(id());
2820 ATRACE_INT(traceName.c_str(), buf.mFrameCount);
2821 }
Eric Laurent83b88082014-06-20 18:31:16 -07002822 if (buf.mFrameCount == 0) {
2823 return WOULD_BLOCK;
2824 }
Glenn Kastend79072e2016-01-06 08:41:20 -08002825 status = RecordTrack::getNextBuffer(buffer);
Eric Laurent83b88082014-06-20 18:31:16 -07002826 return status;
2827}
2828
2829void AudioFlinger::RecordThread::PatchRecord::releaseBuffer(AudioBufferProvider::Buffer* buffer)
2830{
Andy Hung9d84af52018-09-12 18:03:44 -07002831 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002832 Proxy::Buffer buf;
2833 buf.mFrameCount = buffer->frameCount;
2834 buf.mRaw = buffer->raw;
2835 mPeerProxy->releaseBuffer(&buf);
2836 TrackBase::releaseBuffer(buffer);
2837}
2838
2839status_t AudioFlinger::RecordThread::PatchRecord::obtainBuffer(Proxy::Buffer* buffer,
2840 const struct timespec *timeOut)
2841{
2842 return mProxy->obtainBuffer(buffer, timeOut);
2843}
2844
2845void AudioFlinger::RecordThread::PatchRecord::releaseBuffer(Proxy::Buffer* buffer)
2846{
2847 mProxy->releaseBuffer(buffer);
2848}
2849
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002850#undef LOG_TAG
2851#define LOG_TAG "AF::PthrPatchRecord"
2852
2853static std::unique_ptr<void, decltype(free)*> allocAligned(size_t alignment, size_t size)
2854{
2855 void *ptr = nullptr;
2856 (void)posix_memalign(&ptr, alignment, size);
2857 return std::unique_ptr<void, decltype(free)*>(ptr, free);
2858}
2859
2860AudioFlinger::RecordThread::PassthruPatchRecord::PassthruPatchRecord(
2861 RecordThread *recordThread,
2862 uint32_t sampleRate,
2863 audio_channel_mask_t channelMask,
2864 audio_format_t format,
2865 size_t frameCount,
2866 audio_input_flags_t flags)
2867 : PatchRecord(recordThread, sampleRate, channelMask, format, frameCount,
2868 nullptr /*buffer*/, 0 /*bufferSize*/, flags),
2869 mPatchRecordAudioBufferProvider(*this),
2870 mSinkBuffer(allocAligned(32, mFrameCount * mFrameSize)),
2871 mStubBuffer(allocAligned(32, mFrameCount * mFrameSize))
2872{
2873 memset(mStubBuffer.get(), 0, mFrameCount * mFrameSize);
2874}
2875
2876sp<StreamInHalInterface> AudioFlinger::RecordThread::PassthruPatchRecord::obtainStream(
2877 sp<ThreadBase>* thread)
2878{
2879 *thread = mThread.promote();
2880 if (!*thread) return nullptr;
2881 RecordThread *recordThread = static_cast<RecordThread*>((*thread).get());
2882 Mutex::Autolock _l(recordThread->mLock);
2883 return recordThread->mInput ? recordThread->mInput->stream : nullptr;
2884}
2885
2886// PatchProxyBufferProvider methods are called on DirectOutputThread
2887status_t AudioFlinger::RecordThread::PassthruPatchRecord::obtainBuffer(
2888 Proxy::Buffer* buffer, const struct timespec* timeOut)
2889{
2890 if (mUnconsumedFrames) {
2891 buffer->mFrameCount = std::min(buffer->mFrameCount, mUnconsumedFrames);
2892 // mUnconsumedFrames is decreased in releaseBuffer to use actual frame consumption figure.
2893 return PatchRecord::obtainBuffer(buffer, timeOut);
2894 }
2895
2896 // Otherwise, execute a read from HAL and write into the buffer.
2897 nsecs_t startTimeNs = 0;
2898 if (timeOut && (timeOut->tv_sec != 0 || timeOut->tv_nsec != 0) && timeOut->tv_sec != INT_MAX) {
2899 // Will need to correct timeOut by elapsed time.
2900 startTimeNs = systemTime();
2901 }
2902 const size_t framesToRead = std::min(buffer->mFrameCount, mFrameCount);
2903 buffer->mFrameCount = 0;
2904 buffer->mRaw = nullptr;
2905 sp<ThreadBase> thread;
2906 sp<StreamInHalInterface> stream = obtainStream(&thread);
2907 if (!stream) return NO_INIT; // If there is no stream, RecordThread is not reading.
2908
2909 status_t result = NO_ERROR;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002910 size_t bytesRead = 0;
2911 {
2912 ATRACE_NAME("read");
2913 result = stream->read(mSinkBuffer.get(), framesToRead * mFrameSize, &bytesRead);
2914 if (result != NO_ERROR) goto stream_error;
2915 if (bytesRead == 0) return NO_ERROR;
2916 }
2917
2918 {
2919 std::lock_guard<std::mutex> lock(mReadLock);
2920 mReadBytes += bytesRead;
2921 mReadError = NO_ERROR;
2922 }
2923 mReadCV.notify_one();
2924 // writeFrames handles wraparound and should write all the provided frames.
2925 // If it couldn't, there is something wrong with the client/server buffer of the software patch.
2926 buffer->mFrameCount = writeFrames(
2927 &mPatchRecordAudioBufferProvider,
2928 mSinkBuffer.get(), bytesRead / mFrameSize, mFrameSize);
2929 ALOGW_IF(buffer->mFrameCount < bytesRead / mFrameSize,
2930 "Lost %zu frames obtained from HAL", bytesRead / mFrameSize - buffer->mFrameCount);
2931 mUnconsumedFrames = buffer->mFrameCount;
Mikhail Naganov4de49972019-10-07 09:53:58 -07002932 struct timespec newTimeOut;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002933 if (startTimeNs) {
Mikhail Naganov4de49972019-10-07 09:53:58 -07002934 // Correct the timeout by elapsed time.
2935 nsecs_t newTimeOutNs = audio_utils_ns_from_timespec(timeOut) - (systemTime() - startTimeNs);
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002936 if (newTimeOutNs < 0) newTimeOutNs = 0;
2937 newTimeOut.tv_sec = newTimeOutNs / NANOS_PER_SECOND;
2938 newTimeOut.tv_nsec = newTimeOutNs - newTimeOut.tv_sec * NANOS_PER_SECOND;
Mikhail Naganov4de49972019-10-07 09:53:58 -07002939 timeOut = &newTimeOut;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002940 }
Mikhail Naganov4de49972019-10-07 09:53:58 -07002941 return PatchRecord::obtainBuffer(buffer, timeOut);
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002942
2943stream_error:
2944 stream->standby();
2945 {
2946 std::lock_guard<std::mutex> lock(mReadLock);
2947 mReadError = result;
2948 }
2949 mReadCV.notify_one();
2950 return result;
2951}
2952
2953void AudioFlinger::RecordThread::PassthruPatchRecord::releaseBuffer(Proxy::Buffer* buffer)
2954{
2955 if (buffer->mFrameCount <= mUnconsumedFrames) {
2956 mUnconsumedFrames -= buffer->mFrameCount;
2957 } else {
2958 ALOGW("Write side has consumed more frames than we had: %zu > %zu",
2959 buffer->mFrameCount, mUnconsumedFrames);
2960 mUnconsumedFrames = 0;
2961 }
2962 PatchRecord::releaseBuffer(buffer);
2963}
2964
2965// AudioBufferProvider and Source methods are called on RecordThread
2966// 'read' emulates actual audio data with 0's. This is OK as 'getNextBuffer'
2967// and 'releaseBuffer' are stubbed out and ignore their input.
2968// It's not possible to retrieve actual data here w/o blocking 'obtainBuffer'
2969// until we copy it.
2970status_t AudioFlinger::RecordThread::PassthruPatchRecord::read(
2971 void* buffer, size_t bytes, size_t* read)
2972{
2973 bytes = std::min(bytes, mFrameCount * mFrameSize);
2974 {
2975 std::unique_lock<std::mutex> lock(mReadLock);
2976 mReadCV.wait(lock, [&]{ return mReadError != NO_ERROR || mReadBytes != 0; });
2977 if (mReadError != NO_ERROR) {
2978 mLastReadFrames = 0;
2979 return mReadError;
2980 }
2981 *read = std::min(bytes, mReadBytes);
2982 mReadBytes -= *read;
2983 }
2984 mLastReadFrames = *read / mFrameSize;
2985 memset(buffer, 0, *read);
2986 return 0;
2987}
2988
2989status_t AudioFlinger::RecordThread::PassthruPatchRecord::getCapturePosition(
2990 int64_t* frames, int64_t* time)
2991{
2992 sp<ThreadBase> thread;
2993 sp<StreamInHalInterface> stream = obtainStream(&thread);
2994 return stream ? stream->getCapturePosition(frames, time) : NO_INIT;
2995}
2996
2997status_t AudioFlinger::RecordThread::PassthruPatchRecord::standby()
2998{
2999 // RecordThread issues 'standby' command in two major cases:
3000 // 1. Error on read--this case is handled in 'obtainBuffer'.
3001 // 2. Track is stopping--as PassthruPatchRecord assumes continuous
3002 // output, this can only happen when the software patch
3003 // is being torn down. In this case, the RecordThread
3004 // will terminate and close the HAL stream.
3005 return 0;
3006}
3007
3008// As the buffer gets filled in obtainBuffer, here we only simulate data consumption.
3009status_t AudioFlinger::RecordThread::PassthruPatchRecord::getNextBuffer(
3010 AudioBufferProvider::Buffer* buffer)
3011{
3012 buffer->frameCount = mLastReadFrames;
3013 buffer->raw = buffer->frameCount != 0 ? mStubBuffer.get() : nullptr;
3014 return NO_ERROR;
3015}
3016
3017void AudioFlinger::RecordThread::PassthruPatchRecord::releaseBuffer(
3018 AudioBufferProvider::Buffer* buffer)
3019{
3020 buffer->frameCount = 0;
3021 buffer->raw = nullptr;
3022}
3023
Andy Hung9d84af52018-09-12 18:03:44 -07003024// ----------------------------------------------------------------------------
3025#undef LOG_TAG
3026#define LOG_TAG "AF::MmapTrack"
Eric Laurent6acd1d42017-01-04 14:23:29 -08003027
3028AudioFlinger::MmapThread::MmapTrack::MmapTrack(ThreadBase *thread,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07003029 const audio_attributes_t& attr,
Eric Laurent6acd1d42017-01-04 14:23:29 -08003030 uint32_t sampleRate,
3031 audio_format_t format,
3032 audio_channel_mask_t channelMask,
3033 audio_session_t sessionId,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003034 bool isOut,
Svet Ganov33761132021-05-13 22:51:08 +00003035 const AttributionSourceState& attributionSource,
Eric Laurent09f1ed22019-04-24 17:45:17 -07003036 pid_t creatorPid,
Eric Laurent6acd1d42017-01-04 14:23:29 -08003037 audio_port_handle_t portId)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07003038 : TrackBase(thread, NULL, attr, sampleRate, format,
Andy Hung8fe68032017-06-05 16:17:51 -07003039 channelMask, (size_t)0 /* frameCount */,
3040 nullptr /* buffer */, (size_t)0 /* bufferSize */,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003041 sessionId, creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00003042 VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid)),
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003043 isOut,
Eric Laurent6acd1d42017-01-04 14:23:29 -08003044 ALLOC_NONE,
Andy Hungc2b11cb2020-04-22 09:04:01 -07003045 TYPE_DEFAULT, portId,
3046 std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_MMAP) + std::to_string(portId)),
Svet Ganov33761132021-05-13 22:51:08 +00003047 mPid(VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.pid))),
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003048 mSilenced(false), mSilencedNotified(false)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003049{
Andy Hungc2b11cb2020-04-22 09:04:01 -07003050 // Once this item is logged by the server, the client can add properties.
Andy Hung94235282021-03-24 15:50:14 -07003051 mTrackMetrics.logConstructor(creatorPid, uid(), id());
Eric Laurent6acd1d42017-01-04 14:23:29 -08003052}
3053
3054AudioFlinger::MmapThread::MmapTrack::~MmapTrack()
3055{
3056}
3057
3058status_t AudioFlinger::MmapThread::MmapTrack::initCheck() const
3059{
3060 return NO_ERROR;
3061}
3062
3063status_t AudioFlinger::MmapThread::MmapTrack::start(AudioSystem::sync_event_t event __unused,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003064 audio_session_t triggerSession __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003065{
3066 return NO_ERROR;
3067}
3068
3069void AudioFlinger::MmapThread::MmapTrack::stop()
3070{
3071}
3072
3073// AudioBufferProvider interface
3074status_t AudioFlinger::MmapThread::MmapTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer)
3075{
3076 buffer->frameCount = 0;
3077 buffer->raw = nullptr;
3078 return INVALID_OPERATION;
3079}
3080
3081// ExtendedAudioBufferProvider interface
3082size_t AudioFlinger::MmapThread::MmapTrack::framesReady() const {
3083 return 0;
3084}
3085
3086int64_t AudioFlinger::MmapThread::MmapTrack::framesReleased() const
3087{
3088 return 0;
3089}
3090
3091void AudioFlinger::MmapThread::MmapTrack::onTimestamp(const ExtendedTimestamp &timestamp __unused)
3092{
3093}
3094
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003095void AudioFlinger::MmapThread::MmapTrack::appendDumpHeader(String8& result)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003096{
Eric Laurent973db022018-11-20 14:54:31 -08003097 result.appendFormat("Client Session Port Id Format Chn mask SRate Flags %s\n",
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003098 isOut() ? "Usg CT": "Source");
Eric Laurent6acd1d42017-01-04 14:23:29 -08003099}
3100
Andy Hung2c6c3bb2017-06-16 14:01:45 -07003101void AudioFlinger::MmapThread::MmapTrack::appendDump(String8& result, bool active __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003102{
Eric Laurent973db022018-11-20 14:54:31 -08003103 result.appendFormat("%6u %7u %7u %08X %08X %6u 0x%03X ",
Andy Hung2c6c3bb2017-06-16 14:01:45 -07003104 mPid,
3105 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -08003106 mPortId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08003107 mFormat,
3108 mChannelMask,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003109 mSampleRate,
3110 mAttr.flags);
3111 if (isOut()) {
3112 result.appendFormat("%3x %2x", mAttr.usage, mAttr.content_type);
3113 } else {
3114 result.appendFormat("%6x", mAttr.source);
3115 }
3116 result.append("\n");
Eric Laurent6acd1d42017-01-04 14:23:29 -08003117}
3118
Glenn Kasten63238ef2015-03-02 15:50:29 -08003119} // namespace android